drop locks

cmd/monarch/census.go

···
 )
 
 type CensusService struct {
-	cursor   *CursorService
-	backfill *backfill.Backfiller
-
+	cursor    *CursorService
+	backfill  *backfill.Backfiller
 	seenHosts map[string]bool
-	seenLk    sync.Mutex
-
-	storeLk sync.Mutex
 }
 
 type jobMaker interface {
···
 
 		for _, host := range res.Hosts {
 			// don't reprocess hosts already handled
-			cs.seenLk.Lock()
-			_, ok := cs.seenHosts[host.Hostname]
-			cs.seenLk.Unlock()
-			if ok {
+			seen := cs.seenHosts[host.Hostname]
+			if seen {
 				slog.Info("already processed host, skipping", "host", host)
 				continue
 			}
···
 		return
 	}
 
-	cs.storeLk.Lock()
 	hcur, err := cs.cursor.GetHostCursor(host)
 	if err != nil {
 		slog.Error("error fetching host cursor", "err", err)
 	}
-	cs.storeLk.Unlock()
 
 	var added int
 	curs := hcur.Cursor
···
 			continue
 		}
 
-		cs.storeLk.Lock()
 		for _, repo := range res.Repos {
 			_, err := jmstore.GetOrCreateJob(ctx, repo.Did, backfill.StateEnqueued)
 			if err != nil {
···
 				added += 1
 			}
 		}
-		cs.storeLk.Unlock()
 
 		if res.Cursor != nil && *res.Cursor != "" {
 			curs = *res.Cursor
-			cs.storeLk.Lock()
 			if err := cs.cursor.SetHostCursor(host, curs); err != nil {
 				slog.Error("error updating cursor for host", "err", err)
 			}
-			cs.storeLk.Unlock()
 		} else {
 			break
 		}
 	}
 
 	slog.Info("finished listing repos", "host", host)
-
-	cs.seenLk.Lock()
-	defer cs.seenLk.Unlock()
-
 	cs.seenHosts[host] = true
 }
 

cmd/monarch/cursors.go

···
 import (
 	"context"
 	"log/slog"
-	"sync"
 	"time"
 
 	"gorm.io/gorm"
 )
 
 type CursorService struct {
-	store *gorm.DB
-
-	firehoseLk  sync.Mutex
+	store       *gorm.DB
 	firehoseSeq int64
 }
 

cmd/monarch/firehose.go

···
 }
 
 func (cs *CursorService) GetFirehoseCursor() (int64, error) {
-	cs.firehoseLk.Lock()
-	defer cs.firehoseLk.Unlock()
-
 	var fcur firehoseCursor
 	if err := cs.store.Where(firehoseCursor{
 		Key: "firehose",
···
 }
 
 func (cs *CursorService) SetFirehoseCursor(seq int64) {
-	cs.firehoseLk.Lock()
-	defer cs.firehoseLk.Unlock()
-
 	cs.firehoseSeq = seq
 }
 
 func (cs *CursorService) PersistFirehoseCursor() error {
-	cs.firehoseLk.Lock()
-	defer cs.firehoseLk.Unlock()
-
 	if err := cs.store.Model(&firehoseCursor{}).Where(firehoseCursor{Key: "firehose"}).Update("val", cs.firehoseSeq).Error; err != nil {
 		return fmt.Errorf("error persisting firehose seq: %w", err)
 	}