149 lines
3.4 KiB
Go
149 lines
3.4 KiB
Go
// Package twitch polls the Twitch Helix API to track whether a channel is live.
|
|
package twitch
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
)
|
|
|
|
// Checker polls Twitch and exposes whether the channel is currently live.
|
|
type Checker struct {
|
|
clientID string
|
|
clientSecret string
|
|
channel string
|
|
live atomic.Bool
|
|
token string
|
|
tokenExpiry time.Time
|
|
mu sync.Mutex
|
|
http *http.Client
|
|
}
|
|
|
|
// New creates a Checker for the given channel.
|
|
func New(clientID, clientSecret, channel string) *Checker {
|
|
return &Checker{
|
|
clientID: clientID,
|
|
clientSecret: clientSecret,
|
|
channel: channel,
|
|
http: &http.Client{Timeout: 10 * time.Second},
|
|
}
|
|
}
|
|
|
|
// Start begins background polling at the given interval.
|
|
func (c *Checker) Start(interval time.Duration) {
|
|
go func() {
|
|
for {
|
|
if err := c.check(); err != nil {
|
|
log.Printf("twitch: %v", err)
|
|
}
|
|
time.Sleep(interval)
|
|
}
|
|
}()
|
|
}
|
|
|
|
// IsLive reports whether the channel is currently streaming.
|
|
func (c *Checker) IsLive() bool {
|
|
return c.live.Load()
|
|
}
|
|
|
|
// Channel returns the configured channel name.
|
|
func (c *Checker) Channel() string {
|
|
return c.channel
|
|
}
|
|
|
|
func (c *Checker) check() error {
|
|
token, err := c.accessToken()
|
|
if err != nil {
|
|
return fmt.Errorf("access token: %w", err)
|
|
}
|
|
|
|
req, err := http.NewRequest("GET",
|
|
"https://api.twitch.tv/helix/streams?user_login="+url.QueryEscape(c.channel), nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
req.Header.Set("Client-Id", c.clientID)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
resp, err := c.http.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("streams request: %w", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode == http.StatusUnauthorized {
|
|
// Token may have been revoked; clear it and retry next tick.
|
|
c.mu.Lock()
|
|
c.token = ""
|
|
c.mu.Unlock()
|
|
return fmt.Errorf("streams: 401 unauthorized, will refresh token")
|
|
}
|
|
if resp.StatusCode != http.StatusOK {
|
|
return fmt.Errorf("streams: %s", resp.Status)
|
|
}
|
|
|
|
var body struct {
|
|
Data []struct {
|
|
Type string `json:"type"`
|
|
} `json:"data"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
|
|
return fmt.Errorf("decode: %w", err)
|
|
}
|
|
|
|
wasLive := c.live.Load()
|
|
isLive := len(body.Data) > 0 && body.Data[0].Type == "live"
|
|
c.live.Store(isLive)
|
|
|
|
if isLive != wasLive {
|
|
if isLive {
|
|
log.Printf("twitch: %s went live", c.channel)
|
|
} else {
|
|
log.Printf("twitch: %s went offline", c.channel)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// accessToken returns a cached app access token, refreshing if expired.
|
|
func (c *Checker) accessToken() (string, error) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
|
|
if c.token != "" && time.Now().Before(c.tokenExpiry) {
|
|
return c.token, nil
|
|
}
|
|
|
|
resp, err := c.http.PostForm("https://id.twitch.tv/oauth2/token", url.Values{
|
|
"client_id": {c.clientID},
|
|
"client_secret": {c.clientSecret},
|
|
"grant_type": {"client_credentials"},
|
|
})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return "", fmt.Errorf("token: %s", resp.Status)
|
|
}
|
|
|
|
var body struct {
|
|
AccessToken string `json:"access_token"`
|
|
ExpiresIn int `json:"expires_in"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
c.token = body.AccessToken
|
|
// Refresh 5 minutes before actual expiry.
|
|
c.tokenExpiry = time.Now().Add(time.Duration(body.ExpiresIn)*time.Second - 5*time.Minute)
|
|
return c.token, nil
|
|
}
|