JHHM

tweed

a Twitch RSS feed generator
git clone https://jhhm.no/repos/tweed.git

tweed/main.go

get raw file: main.go

1package main
2
3import (
4	"context"
5	"flag"
6	"fmt"
7	"io"
8	"net"
9	"net/http"
10	"os"
11	"os/signal"
12	"path/filepath"
13	"strings"
14	"sync"
15	"syscall"
16	"time"
17)
18
19var liveState = map[string]bool{}
20var dataMu sync.Mutex
21
22func monitor(ctx context.Context, cfg *Config) {
23	dataMu.Lock()
24	for _, c := range cfg.Channels {
25		liveState[c] = false
26	}
27	dataMu.Unlock()
28
29	for {
30		for _, c := range cfg.Channels {
31			if ctx.Err() != nil {
32				return
33			}
34
35			online, stream, err := isLive(ctx, cfg, c)
36			if err != nil {
37				logWarn("check %s: %v", c, err)
38				continue
39			}
40
41			dataMu.Lock()
42			prev := liveState[c]
43			liveState[c] = online
44			dataMu.Unlock()
45
46			if !prev && online {
47				logInfo("%s went live, stream id %s, title '%s'", c, stream.StreamID, stream.Title)
48				err = updateRSSWithNewStream(ctx, cfg, &stream)
49				if err != nil {
50					logErr("update feed for %s: %v", c, err)
51				}
52			}
53		}
54		select {
55		case <-ctx.Done():
56			return
57		case <-time.After(time.Duration(cfg.RefreshMinutes) * time.Minute):
58		}
59	}
60}
61
62func rssHandler(cfg *Config) http.HandlerFunc {
63	return func(w http.ResponseWriter, r *http.Request) {
64		parts := strings.Split(r.URL.Path, "/")
65		if len(parts) < 3 {
66			http.Error(w, "invalid feed", http.StatusBadRequest)
67			return
68		}
69		channel := parts[len(parts)-1]
70
71		f, err := os.Open(rssFilePath(channel, cfg))
72		if err != nil {
73			http.Error(w, "found no feed for given channel", http.StatusNotFound)
74			return
75		}
76		defer f.Close()
77
78		w.Header().Set("Content-Type", "application/xml")
79		io.Copy(w, f)
80	}
81}
82
83func sandbox(cfg *Config) error {
84	_ = time.Local.String()
85
86	paths := []struct{ path, perms string }{
87		{filepath.Join(cfg.DataDir, "feeds"), "rwc"},
88		{"/etc/ssl/cert.pem", "r"},
89		{"/etc/resolv.conf", "r"},
90		{"/etc/hosts", "r"},
91		{"/dev/log", "rw"},
92	}
93	for _, p := range paths {
94		if err := unveil(p.path, p.perms); err != nil {
95			return fmt.Errorf("unveil %s: %w", p.path, err)
96		}
97	}
98	if err := unveilBlock(); err != nil {
99		return fmt.Errorf("unveil block: %w", err)
100	}
101	if err := pledge("stdio rpath wpath cpath fattr inet dns unix"); err != nil {
102		return fmt.Errorf("pledge: %w", err)
103	}
104	return nil
105}
106
107func main() {
108	debug := flag.Bool("d", false, "log to stderr instead of syslog")
109	configFlag := flag.String("c", "", "path to config directory")
110	flag.Usage = func() {
111		fmt.Fprintf(flag.CommandLine.Output(), "usage: %s [-d] [-c config]\n", os.Args[0])
112		flag.PrintDefaults()
113	}
114	flag.Parse()
115	if flag.NArg() > 0 {
116		flag.Usage()
117		os.Exit(2)
118	}
119
120	path, err := findConfigDir(*configFlag)
121	if err != nil {
122		fatal("%v", err)
123	}
124
125	cfg, err := loadConfig(path)
126	if err != nil {
127		fatal("config: %v", err)
128	}
129
130	lock, err := lockDataDir(&cfg)
131	if err != nil {
132		fatal("%v", err)
133	}
134	defer lock.Close()
135
136	if err := initEmptyFeeds(&cfg); err != nil {
137		fatal("initialize empty feeds: %v", err)
138	}
139
140	if !*debug {
141		if err := initSyslog(); err != nil {
142			fatal("syslog: %v", err)
143		}
144	}
145
146	logInfo("startup")
147	logInfo("using config directory %s", path)
148	logInfo("using data directory %s", cfg.DataDir)
149	logInfo("monitoring channels: %s", strings.Join(cfg.Channels, ", "))
150	logInfo("using %d CDN candidate domains", len(cfg.CDNDomains))
151
152	srv := &http.Server{Addr: fmt.Sprintf(":%d", cfg.Port)}
153	var ln net.Listener
154	if cfg.ServeFeeds {
155		ln, err = net.Listen("tcp", srv.Addr)
156		if err != nil {
157			fatal("listen: %v", err)
158		}
159	}
160
161	if err := sandbox(&cfg); err != nil {
162		fatal("sandbox: %v", err)
163	}
164
165	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
166	defer stop()
167
168	monitorDone := make(chan struct{})
169	go func() {
170		defer close(monitorDone)
171		monitor(ctx, &cfg)
172	}()
173
174	serveErr := make(chan error, 1)
175	if cfg.ServeFeeds {
176		http.HandleFunc("/feed/", rssHandler(&cfg))
177		go func() { serveErr <- srv.Serve(ln) }()
178		logInfo("listening on %s", srv.Addr)
179	} else {
180		logInfo("not serving feeds")
181	}
182
183	select {
184	case err := <-serveErr:
185		fatal("listen: %v", err)
186	case <-ctx.Done():
187	}
188
189	stop()
190	logInfo("shutting down")
191
192	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
193	defer cancel()
194	if err := srv.Shutdown(shutdownCtx); err != nil {
195		logWarn("http shutdown: %v", err)
196	}
197	<-monitorDone
198	logInfo("exiting")
199}