snoobert/reddit/stream.go

94 lines
2.0 KiB
Go
Raw Normal View History

package reddit
import (
"context"
"sync"
"time"
)
// StreamService allows streaming new content from Reddit as it appears.
type StreamService struct {
client *Client
}
// Posts streams posts from the specified subreddit.
// It returns 2 channels and a function:
// - a channel into which new posts will be sent
// - a channel into which any errors will be sent
// - a function that the client can call once to stop the streaming and close the channels
// Because of the 100 post limit imposed by Reddit when fetching posts, some high-traffic
// streams might drop submissions between API requests, such as when streaming r/all.
func (s *StreamService) Posts(subreddit string) (<-chan *Post, <-chan error, func()) {
posts := make(chan *Post)
errs := make(chan error)
ticker := time.NewTicker(time.Second * 5)
// originally used the "before" parameter, but if that post gets deleted, subsequent requests
// would just return empty listings; easier to just keep track of all post ids encountered
ids := set{}
go func() {
for ; ; <-ticker.C {
result, err := s.getPosts(subreddit)
if err != nil {
errs <- err
continue
}
for _, post := range result.Posts {
id := post.FullID
// if this post id is already part of the set, it means that it and the ones
// after it in the list have already been streamed, so break out of the loop
if ids.Exists(id) {
break
}
ids.Add(id)
posts <- post
}
}
}()
var once sync.Once
return posts, errs, func() {
once.Do(func() {
ticker.Stop()
close(posts)
close(errs)
})
}
}
func (s *StreamService) getPosts(subreddit string) (*Posts, error) {
opts := &ListOptions{
Limit: 100,
}
result, _, err := s.client.Subreddit.NewPosts(context.Background(), subreddit, opts)
if err != nil {
return nil, err
}
return result, nil
}
type set map[string]struct{}
func (s set) Add(v string) {
s[v] = struct{}{}
}
func (s set) Delete(v string) {
delete(s, v)
}
func (s set) Len() int {
return len(s)
}
func (s set) Exists(v string) bool {
_, ok := s[v]
return ok
}