refactor: app orchestration into tui
This commit is contained in:
+3
-236
@@ -1,251 +1,18 @@
|
||||
// app.go wires together config loading, auth bootstrap, and the Bubble Tea program.
|
||||
// It decides whether cached Twitch auth can be reused and, when needed,
|
||||
// connects the interactive login flow to the TUI through auth update messages.
|
||||
// app.go owns process-level application bootstrap before handing control to the TUI.
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
tea "github.com/charmbracelet/bubbletea"
|
||||
|
||||
"parasocial/internal/auth"
|
||||
"parasocial/internal/config"
|
||||
"parasocial/internal/gql"
|
||||
"parasocial/internal/irc"
|
||||
"parasocial/internal/tui"
|
||||
"parasocial/internal/twitch"
|
||||
)
|
||||
|
||||
const streamerRefreshInterval = 5 * time.Minute
|
||||
|
||||
// Run loads the application configuration and starts the terminal UI.
|
||||
// Run loads configuration and starts the terminal UI.
|
||||
func Run(ctx context.Context) error {
|
||||
ctx, cancel := context.WithCancel(ctx)
|
||||
defer cancel()
|
||||
|
||||
cfg, err := config.LoadDefault()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
httpClient := &http.Client{Timeout: 30 * time.Second}
|
||||
authClient := auth.NewClient(httpClient)
|
||||
authPath := auth.DefaultPath()
|
||||
|
||||
state, err := authClient.ReuseAuth(ctx, authPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
program := tea.NewProgram(
|
||||
tui.New(tui.Options{
|
||||
Streamers: twitch.LoadingStreamerEntries(cfg.Streamers),
|
||||
AuthState: state,
|
||||
StartAuth: func(ch chan<- tui.AuthUpdate) {
|
||||
go func() {
|
||||
defer close(ch)
|
||||
|
||||
state, err := authClient.EnsureAuth(ctx, authPath, func(line string) {
|
||||
ch <- tui.AuthUpdate{Line: strings.TrimRight(line, "\n")}
|
||||
})
|
||||
if err != nil {
|
||||
ch <- tui.AuthUpdate{
|
||||
Line: fmt.Sprintf("Authentication failed: %v", err),
|
||||
Err: err,
|
||||
Done: true,
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
ch <- tui.AuthUpdate{State: state, Done: true}
|
||||
}()
|
||||
},
|
||||
StartResolve: func(state *auth.State, ch chan<- tui.StreamerUpdate) {
|
||||
go func() {
|
||||
defer close(ch)
|
||||
ircManager := newIRCManager(ch)
|
||||
defer ircManager.Close()
|
||||
|
||||
service, err := newTwitchService(httpClient, state)
|
||||
if err != nil {
|
||||
ch <- tui.StreamerUpdate{Err: err, Done: true}
|
||||
return
|
||||
}
|
||||
if err := resolveStreamerEntries(ctx, service, state, cfg.Streamers, ircManager, func(update tui.StreamerUpdate) {
|
||||
ch <- update
|
||||
}); err != nil {
|
||||
if errors.Is(err, context.Canceled) {
|
||||
return
|
||||
}
|
||||
ch <- tui.StreamerUpdate{Err: err, Done: true}
|
||||
return
|
||||
}
|
||||
ch <- tui.StreamerUpdate{Done: true}
|
||||
}()
|
||||
},
|
||||
}),
|
||||
tea.WithContext(ctx),
|
||||
tea.WithInput(os.Stdin),
|
||||
tea.WithOutput(os.Stdout),
|
||||
)
|
||||
_, err = program.Run()
|
||||
return err
|
||||
}
|
||||
|
||||
// streamerService captures the Twitch lookups the app needs during UI resolution.
|
||||
type streamerService interface {
|
||||
CurrentUser(context.Context) (*twitch.Viewer, error)
|
||||
ResolveStreamer(context.Context, string) (*twitch.Channel, error)
|
||||
StreamInfo(context.Context, string) (*twitch.StreamInfo, error)
|
||||
PlaybackAccessToken(context.Context, string) (*twitch.PlaybackToken, error)
|
||||
}
|
||||
|
||||
type ircSyncer interface {
|
||||
Sync(context.Context, string, string, []irc.Target)
|
||||
}
|
||||
|
||||
// newTwitchService builds a Twitch service from the authenticated session state.
|
||||
func newTwitchService(httpClient *http.Client, state *auth.State) (*twitch.Service, error) {
|
||||
client := &gql.Client{
|
||||
HTTPClient: httpClient,
|
||||
Session: gql.Session{
|
||||
AccessToken: state.AccessToken,
|
||||
ClientID: state.ClientID,
|
||||
DeviceID: state.DeviceID,
|
||||
UserAgent: auth.TVUserAgent(),
|
||||
},
|
||||
}
|
||||
if err := client.Validate(); err != nil {
|
||||
return nil, fmt.Errorf("configure graphql session: %w", err)
|
||||
}
|
||||
return &twitch.Service{GQL: client}, nil
|
||||
}
|
||||
|
||||
func newIRCManager(ch chan<- tui.StreamerUpdate) *irc.Manager {
|
||||
return &irc.Manager{
|
||||
Addr: irc.DefaultAddr,
|
||||
Events: func(event irc.Event) {
|
||||
ch <- tui.StreamerUpdate{
|
||||
IRC: &tui.IRCUpdate{
|
||||
Login: event.Streamer,
|
||||
State: tui.IRCState(event.State),
|
||||
Line: event.Line,
|
||||
},
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// resolveStreamerEntries streams viewer and streamer resolution results into the TUI.
|
||||
func resolveStreamerEntries(ctx context.Context, service streamerService, state *auth.State, logins []string, syncer ircSyncer, send func(tui.StreamerUpdate)) error {
|
||||
return resolveStreamerEntriesWithSleep(ctx, service, state, logins, syncer, send, streamerRefreshInterval, sleepContext)
|
||||
}
|
||||
|
||||
func resolveStreamerEntriesWithSleep(ctx context.Context, service streamerService, state *auth.State, logins []string, syncer ircSyncer, send func(tui.StreamerUpdate), interval time.Duration, sleep func(context.Context, time.Duration) error) error {
|
||||
viewer, err := service.CurrentUser(ctx)
|
||||
if err != nil {
|
||||
return fmt.Errorf("resolve current user: %w", err)
|
||||
}
|
||||
send(tui.StreamerUpdate{Viewer: viewer})
|
||||
|
||||
entries := twitch.LoadingStreamerEntries(logins)
|
||||
syncWatchedChannels(ctx, syncer, state, entries)
|
||||
|
||||
for {
|
||||
for index, login := range logins {
|
||||
entry, err := resolveStreamerEntry(ctx, service, login)
|
||||
if errors.Is(err, context.Canceled) {
|
||||
return err
|
||||
}
|
||||
entries[index] = *entry
|
||||
send(tui.StreamerUpdate{
|
||||
Index: index,
|
||||
Entry: entry,
|
||||
})
|
||||
syncWatchedChannels(ctx, syncer, state, entries)
|
||||
}
|
||||
if err := sleep(ctx, interval); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func resolveStreamerEntry(ctx context.Context, service streamerService, login string) (*twitch.StreamerEntry, error) {
|
||||
entry := &twitch.StreamerEntry{
|
||||
ConfigLogin: login,
|
||||
Status: twitch.StreamerLoading,
|
||||
}
|
||||
|
||||
channel, err := service.ResolveStreamer(ctx, login)
|
||||
switch {
|
||||
case err == nil:
|
||||
entry.Login = channel.Login
|
||||
entry.ChannelID = channel.ID
|
||||
case errors.Is(err, context.Canceled):
|
||||
return nil, err
|
||||
default:
|
||||
entry.Status = twitch.StreamerError
|
||||
entry.Error = err.Error()
|
||||
return entry, nil
|
||||
}
|
||||
|
||||
stream, err := service.StreamInfo(ctx, channel.ID)
|
||||
switch {
|
||||
case err == nil:
|
||||
entry.Status = twitch.StreamerReady
|
||||
entry.Live = stream.Online
|
||||
case errors.Is(err, context.Canceled):
|
||||
return nil, err
|
||||
default:
|
||||
entry.Status = twitch.StreamerError
|
||||
entry.Error = err.Error()
|
||||
return entry, nil
|
||||
}
|
||||
|
||||
if !entry.Live {
|
||||
return entry, nil
|
||||
}
|
||||
if _, err := service.PlaybackAccessToken(ctx, channel.Login); err != nil && errors.Is(err, context.Canceled) {
|
||||
return nil, err
|
||||
}
|
||||
return entry, nil
|
||||
}
|
||||
|
||||
func sleepContext(ctx context.Context, duration time.Duration) error {
|
||||
timer := time.NewTimer(duration)
|
||||
defer timer.Stop()
|
||||
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
case <-timer.C:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
func syncWatchedChannels(ctx context.Context, syncer ircSyncer, state *auth.State, entries []twitch.StreamerEntry) {
|
||||
if syncer == nil || state == nil {
|
||||
return
|
||||
}
|
||||
syncer.Sync(ctx, state.Login, state.AccessToken, watchedIRCTargets(entries))
|
||||
}
|
||||
|
||||
func watchedIRCTargets(entries []twitch.StreamerEntry) []irc.Target {
|
||||
targets := make([]irc.Target, 0, 2)
|
||||
for _, entry := range entries {
|
||||
if entry.Status != twitch.StreamerReady || !entry.Live || entry.Login == "" {
|
||||
continue
|
||||
}
|
||||
targets = append(targets, irc.Target{Login: entry.Login})
|
||||
if len(targets) == 2 {
|
||||
break
|
||||
}
|
||||
}
|
||||
return targets
|
||||
return tui.Run(ctx, tui.Options{Streamers: cfg.Streamers})
|
||||
}
|
||||
|
||||
@@ -1,288 +0,0 @@
|
||||
// app_test.go covers the app-layer orchestration around Twitch viewer and streamer resolution.
|
||||
// It exercises the background resolution loop independently of Bubble Tea startup
|
||||
// so the app wiring can be validated without requiring a full interactive session.
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"parasocial/internal/auth"
|
||||
"parasocial/internal/irc"
|
||||
"parasocial/internal/tui"
|
||||
"parasocial/internal/twitch"
|
||||
)
|
||||
|
||||
// fakeStreamerService is a test double for the app's Twitch resolution dependency.
|
||||
type fakeStreamerService struct {
|
||||
viewer *twitch.Viewer
|
||||
viewerErr error
|
||||
channels map[string]*twitch.Channel
|
||||
resolveErrs map[string]error
|
||||
streams map[string][]streamResult
|
||||
streamCalls map[string]int
|
||||
playbackErr map[string]error
|
||||
}
|
||||
|
||||
type streamResult struct {
|
||||
info *twitch.StreamInfo
|
||||
err error
|
||||
}
|
||||
|
||||
// CurrentUser returns the configured fake viewer or viewer error.
|
||||
func (f *fakeStreamerService) CurrentUser(context.Context) (*twitch.Viewer, error) {
|
||||
if f.viewerErr != nil {
|
||||
return nil, f.viewerErr
|
||||
}
|
||||
return f.viewer, nil
|
||||
}
|
||||
|
||||
// ResolveStreamer returns the configured fake channel or resolution error.
|
||||
func (f *fakeStreamerService) ResolveStreamer(_ context.Context, login string) (*twitch.Channel, error) {
|
||||
if err, ok := f.resolveErrs[login]; ok {
|
||||
return nil, err
|
||||
}
|
||||
return f.channels[login], nil
|
||||
}
|
||||
|
||||
func (f *fakeStreamerService) StreamInfo(_ context.Context, channelID string) (*twitch.StreamInfo, error) {
|
||||
if f.streamCalls == nil {
|
||||
f.streamCalls = map[string]int{}
|
||||
}
|
||||
call := f.streamCalls[channelID]
|
||||
f.streamCalls[channelID] = call + 1
|
||||
|
||||
results := f.streams[channelID]
|
||||
if len(results) == 0 {
|
||||
return &twitch.StreamInfo{Online: false}, nil
|
||||
}
|
||||
if call >= len(results) {
|
||||
call = len(results) - 1
|
||||
}
|
||||
result := results[call]
|
||||
if result.err != nil {
|
||||
return nil, result.err
|
||||
}
|
||||
return result.info, nil
|
||||
}
|
||||
|
||||
func (f *fakeStreamerService) PlaybackAccessToken(_ context.Context, login string) (*twitch.PlaybackToken, error) {
|
||||
if err, ok := f.playbackErr[login]; ok {
|
||||
return nil, err
|
||||
}
|
||||
return &twitch.PlaybackToken{Signature: "sig", Value: "token"}, nil
|
||||
}
|
||||
|
||||
type fakeIRCSyncer struct {
|
||||
calls [][]string
|
||||
}
|
||||
|
||||
func (f *fakeIRCSyncer) Sync(_ context.Context, _, _ string, targets []irc.Target) {
|
||||
logins := make([]string, 0, len(targets))
|
||||
for _, target := range targets {
|
||||
logins = append(logins, target.Login)
|
||||
}
|
||||
f.calls = append(f.calls, logins)
|
||||
}
|
||||
|
||||
// TestResolveStreamerEntries verifies that app resolution emits viewer, success, and error updates.
|
||||
func TestResolveStreamerEntries(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
service := &fakeStreamerService{
|
||||
viewer: &twitch.Viewer{ID: "7", Login: "viewer"},
|
||||
channels: map[string]*twitch.Channel{
|
||||
"alpha": {ID: "1", Login: "alpha_live"},
|
||||
},
|
||||
resolveErrs: map[string]error{
|
||||
"beta": errors.New("lookup failed"),
|
||||
},
|
||||
streams: map[string][]streamResult{
|
||||
"1": {{info: &twitch.StreamInfo{Online: true}}},
|
||||
},
|
||||
}
|
||||
|
||||
var updates []tui.StreamerUpdate
|
||||
err := resolveStreamerEntriesWithSleep(context.Background(), service, &auth.State{Login: "viewer", AccessToken: "token"}, []string{"alpha", "beta"}, nil, func(update tui.StreamerUpdate) {
|
||||
updates = append(updates, update)
|
||||
}, 0, func(context.Context, time.Duration) error {
|
||||
return context.Canceled
|
||||
})
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(updates) != 3 {
|
||||
t.Fatalf("len(updates) = %d", len(updates))
|
||||
}
|
||||
if updates[0].Viewer == nil || updates[0].Viewer.Login != "viewer" {
|
||||
t.Fatalf("viewer update = %#v", updates[0])
|
||||
}
|
||||
if updates[1].Entry == nil || updates[1].Entry.Status != twitch.StreamerReady || updates[1].Entry.Login != "alpha_live" || !updates[1].Entry.Live {
|
||||
t.Fatalf("alpha update = %#v", updates[1])
|
||||
}
|
||||
if updates[2].Entry == nil || updates[2].Entry.Status != twitch.StreamerError {
|
||||
t.Fatalf("beta update = %#v", updates[2])
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveStreamerEntriesPlaybackFailureStillMarksLive(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
service := &fakeStreamerService{
|
||||
viewer: &twitch.Viewer{ID: "7", Login: "viewer"},
|
||||
channels: map[string]*twitch.Channel{
|
||||
"alpha": {ID: "1", Login: "alpha_live"},
|
||||
},
|
||||
streams: map[string][]streamResult{
|
||||
"1": {{info: &twitch.StreamInfo{Online: true}}},
|
||||
},
|
||||
playbackErr: map[string]error{
|
||||
"alpha_live": errors.New("token lookup failed"),
|
||||
},
|
||||
}
|
||||
|
||||
var updates []tui.StreamerUpdate
|
||||
err := resolveStreamerEntriesWithSleep(context.Background(), service, &auth.State{Login: "viewer", AccessToken: "token"}, []string{"alpha"}, nil, func(update tui.StreamerUpdate) {
|
||||
updates = append(updates, update)
|
||||
}, 0, func(context.Context, time.Duration) error {
|
||||
return context.Canceled
|
||||
})
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(updates) != 2 {
|
||||
t.Fatalf("len(updates) = %d", len(updates))
|
||||
}
|
||||
entry := updates[1].Entry
|
||||
if entry == nil || entry.Status != twitch.StreamerReady || !entry.Live {
|
||||
t.Fatalf("entry = %#v", entry)
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveStreamerEntriesRefreshesLiveState(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
service := &fakeStreamerService{
|
||||
viewer: &twitch.Viewer{ID: "7", Login: "viewer"},
|
||||
channels: map[string]*twitch.Channel{
|
||||
"alpha": {ID: "1", Login: "alpha_live"},
|
||||
},
|
||||
streams: map[string][]streamResult{
|
||||
"1": {
|
||||
{info: &twitch.StreamInfo{Online: false}},
|
||||
{info: &twitch.StreamInfo{Online: true}},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
var updates []tui.StreamerUpdate
|
||||
sleepCalls := 0
|
||||
err := resolveStreamerEntriesWithSleep(context.Background(), service, &auth.State{Login: "viewer", AccessToken: "token"}, []string{"alpha"}, nil, func(update tui.StreamerUpdate) {
|
||||
updates = append(updates, update)
|
||||
}, 0, func(context.Context, time.Duration) error {
|
||||
sleepCalls++
|
||||
if sleepCalls == 1 {
|
||||
return nil
|
||||
}
|
||||
return context.Canceled
|
||||
})
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(updates) != 3 {
|
||||
t.Fatalf("len(updates) = %d", len(updates))
|
||||
}
|
||||
if updates[1].Entry == nil || updates[1].Entry.Live {
|
||||
t.Fatalf("first pass = %#v", updates[1])
|
||||
}
|
||||
if updates[2].Entry == nil || !updates[2].Entry.Live {
|
||||
t.Fatalf("second pass = %#v", updates[2])
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveStreamerEntriesSyncsTopTwoLiveChannels(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
service := &fakeStreamerService{
|
||||
viewer: &twitch.Viewer{ID: "7", Login: "viewer"},
|
||||
channels: map[string]*twitch.Channel{
|
||||
"alpha": {ID: "1", Login: "alpha_live"},
|
||||
"beta": {ID: "2", Login: "beta_live"},
|
||||
"gamma": {ID: "3", Login: "gamma_live"},
|
||||
},
|
||||
streams: map[string][]streamResult{
|
||||
"1": {{info: &twitch.StreamInfo{Online: true}}},
|
||||
"2": {{info: &twitch.StreamInfo{Online: true}}},
|
||||
"3": {{info: &twitch.StreamInfo{Online: true}}},
|
||||
},
|
||||
}
|
||||
syncer := &fakeIRCSyncer{}
|
||||
|
||||
err := resolveStreamerEntriesWithSleep(context.Background(), service, &auth.State{Login: "viewer", AccessToken: "token"}, []string{"alpha", "beta", "gamma"}, syncer, func(tui.StreamerUpdate) {
|
||||
}, 0, func(context.Context, time.Duration) error {
|
||||
return context.Canceled
|
||||
})
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
want := [][]string{
|
||||
{},
|
||||
{"alpha_live"},
|
||||
{"alpha_live", "beta_live"},
|
||||
{"alpha_live", "beta_live"},
|
||||
}
|
||||
if !reflect.DeepEqual(syncer.calls, want) {
|
||||
t.Fatalf("sync calls = %#v, want %#v", syncer.calls, want)
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolveStreamerEntriesRefreshUpdatesWatchedChannels(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
service := &fakeStreamerService{
|
||||
viewer: &twitch.Viewer{ID: "7", Login: "viewer"},
|
||||
channels: map[string]*twitch.Channel{
|
||||
"alpha": {ID: "1", Login: "alpha_live"},
|
||||
"beta": {ID: "2", Login: "beta_live"},
|
||||
},
|
||||
streams: map[string][]streamResult{
|
||||
"1": {
|
||||
{info: &twitch.StreamInfo{Online: true}},
|
||||
{info: &twitch.StreamInfo{Online: false}},
|
||||
},
|
||||
"2": {
|
||||
{info: &twitch.StreamInfo{Online: false}},
|
||||
{info: &twitch.StreamInfo{Online: true}},
|
||||
},
|
||||
},
|
||||
}
|
||||
syncer := &fakeIRCSyncer{}
|
||||
|
||||
sleepCalls := 0
|
||||
err := resolveStreamerEntriesWithSleep(context.Background(), service, &auth.State{Login: "viewer", AccessToken: "token"}, []string{"alpha", "beta"}, syncer, func(tui.StreamerUpdate) {
|
||||
}, 0, func(context.Context, time.Duration) error {
|
||||
sleepCalls++
|
||||
if sleepCalls == 1 {
|
||||
return nil
|
||||
}
|
||||
return context.Canceled
|
||||
})
|
||||
if !errors.Is(err, context.Canceled) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
want := [][]string{
|
||||
{},
|
||||
{"alpha_live"},
|
||||
{"alpha_live"},
|
||||
{},
|
||||
{"beta_live"},
|
||||
}
|
||||
if !reflect.DeepEqual(syncer.calls, want) {
|
||||
t.Fatalf("sync calls = %#v, want %#v", syncer.calls, want)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user