hepa: persist cursor state in redis

cmd/hepa/consumer.go

···
 func (s *Server) RunConsumer(ctx context.Context) error {
 
 	// TODO: persist cursor in a database or local disk
-	cur := 0
+	cur, err := s.ReadLastCursor(ctx)
+	if err != nil {
+		return err
+	}
 
 	dialer := websocket.DefaultDialer
 	u, err := url.Parse(s.bgshost)
···
 
 	rsc := &events.RepoStreamCallbacks{
 		RepoCommit: func(evt *comatproto.SyncSubscribeRepos_Commit) error {
+			s.lastSeq = evt.Seq
 			return s.HandleRepoCommit(ctx, evt)
 		},
 		RepoHandle: func(evt *comatproto.SyncSubscribeRepos_Handle) error {
+			s.lastSeq = evt.Seq
 			did, err := syntax.ParseDID(evt.Did)
 			if err != nil {
 				s.logger.Error("bad DID in RepoHandle event", "did", evt.Did, "handle", evt.Handle, "seq", evt.Seq, "err", err)

cmd/hepa/main.go

···
 			}
 		}()
 
+		go func() {
+			if err := srv.RunPersistCursor(ctx); err != nil {
+				slog.Error("cursor routine failed", "err", err)
+			}
+		}()
+
 		// the main service loop
 		if err := srv.RunConsumer(ctx); err != nil {
 			return fmt.Errorf("failure consuming and processing firehose: %w", err)

cmd/hepa/server.go

···
 	"github.com/bluesky-social/indigo/xrpc"
 
 	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/redis/go-redis/v9"
 )
 
 type Server struct {
 	bgshost string
 	logger  *slog.Logger
 	engine  *automod.Engine
+	rdb     *redis.Client
+	lastSeq int64
 }
 
 type Config struct {
···
 	}
 
 	var counters automod.CountStore
+	var cache automod.CacheStore
+	var rdb *redis.Client
 	if config.RedisURL != "" {
-		c, err := automod.NewRedisCountStore(config.RedisURL)
+		// generic client, for cursor state
+		opt, err := redis.ParseURL(config.RedisURL)
 		if err != nil {
 			return nil, err
 		}
-		counters = c
-	} else {
-		counters = automod.NewMemCountStore()
-	}
+		rdb = redis.NewClient(opt)
+		// check redis connection
+		_, err = rdb.Ping(context.TODO()).Result()
+		if err != nil {
+			return nil, err
+		}
 
-	var cache automod.CacheStore
-	if config.RedisURL != "" {
-		c, err := automod.NewRedisCacheStore(config.RedisURL, 30*time.Minute)
+		cnt, err := automod.NewRedisCountStore(config.RedisURL)
 		if err != nil {
 			return nil, err
 		}
-		cache = c
+		counters = cnt
+
+		csh, err := automod.NewRedisCacheStore(config.RedisURL, 30*time.Minute)
+		if err != nil {
+			return nil, err
+		}
+		cache = csh
 	} else {
+		counters = automod.NewMemCountStore()
 		cache = automod.NewMemCacheStore(5_000, 30*time.Minute)
 	}
 
···
 		bgshost: config.BGSHost,
 		logger:  logger,
 		engine:  &engine,
+		rdb:     rdb,
 	}
 
 	return s, nil
···
 	http.Handle("/metrics", promhttp.Handler())
 	return http.ListenAndServe(listen, nil)
 }
+
+var cursorKey = "hepa/seq"
+
+func (s *Server) ReadLastCursor(ctx context.Context) (int64, error) {
+	// if redis isn't configured, just skip
+	if s.rdb == nil {
+		s.logger.Info("redis not configured, skipping cursor read")
+		return 0, nil
+	}
+
+	val, err := s.rdb.Get(ctx, cursorKey).Int64()
+	if err == redis.Nil {
+		s.logger.Info("no pre-existing cursor in redis")
+		return 0, nil
+	}
+	s.logger.Info("successfully found prior subscription cursor seq in redis", "seq", val)
+	return val, err
+}
+
+func (s *Server) PersistCursor(ctx context.Context) error {
+	// if redis isn't configured, just skip
+	if s.rdb == nil {
+		return nil
+	}
+	if s.lastSeq <= 0 {
+		return nil
+	}
+	err := s.rdb.Set(ctx, cursorKey, s.lastSeq, 14*24*time.Hour).Err()
+	return err
+}
+
+// this method runs in a loop, persisting the current cursor state every 5 seconds
+func (s *Server) RunPersistCursor(ctx context.Context) error {
+
+	// if redis isn't configured, just skip
+	if s.rdb == nil {
+		return nil
+	}
+	ticker := time.NewTicker(5 * time.Second)
+	for {
+		select {
+		case <-ctx.Done():
+			if s.lastSeq >= 1 {
+				s.logger.Info("persisting final cursor seq value", "seq", s.lastSeq)
+				err := s.PersistCursor(ctx)
+				if err != nil {
+					s.logger.Error("failed to persist cursor", "err", err, "seq", s.lastSeq)
+				}
+			}
+			return nil
+		case <-ticker.C:
+			if s.lastSeq >= 1 {
+				err := s.PersistCursor(ctx)
+				if err != nil {
+					s.logger.Error("failed to persist cursor", "err", err, "seq", s.lastSeq)
+				}
+			}
+		}
+	}
+}