palomar: replace 'BGS' with 'Relay'

cmd/palomar/README.md

···
 
 Palomar uses environment variables for configuration.
 
-- `ATP_BGS_HOST`: URL of firehose to subscribe to, either global BGS or individual PDS (default: `wss://bsky.social`)
+- `ATP_RELAY_HOST`: URL of firehose to subscribe to, either global Relay or individual PDS (default: `wss://bsky.network`)
 - `ATP_PLC_HOST`: PLC directory for identity lookups (default: `https://plc.directory`)
 - `DATABASE_URL`: connection string for database to persist firehose cursor subscription state
 - `PALOMAR_BIND`: IP/port to have HTTP API listen on (default: `:3999`)

cmd/palomar/main.go

···
 			EnvVars: []string{"ES_PROFILE_INDEX"},
 		},
 		&cli.StringFlag{
-			Name:    "atp-bgs-host",
-			Usage:   "hostname and port of BGS to subscribe to",
-			Value:   "wss://bsky.social",
-			EnvVars: []string{"ATP_BGS_HOST"},
+			Name:    "atp-relay-host",
+			Usage:   "hostname and port of Relay to subscribe to",
+			Value:   "wss://bsky.network",
+			EnvVars: []string{"ATP_RELAY_HOST", "ATP_BGS_HOST"},
 		},
 		&cli.StringFlag{
 			Name:    "atp-plc-host",
···
 			EnvVars: []string{"PALOMAR_METRICS_LISTEN"},
 		},
 		&cli.IntFlag{
-			Name:    "bgs-sync-rate-limit",
-			Usage:   "max repo sync (checkout) requests per second to upstream (BGS)",
+			Name:    "relay-sync-rate-limit",
+			Usage:   "max repo sync (checkout) requests per second to upstream (Relay)",
 			Value:   8,
-			EnvVars: []string{"PALOMAR_BGS_SYNC_RATE_LIMIT"},
+			EnvVars: []string{"PALOMAR_RELAY_SYNC_RATE_LIMIT", "PALOMAR_BGS_SYNC_RATE_LIMIT"},
 		},
 		&cli.IntFlag{
 			Name:    "index-max-concurrency",
···
 			escli,
 			&dir,
 			search.Config{
-				BGSHost:             cctx.String("atp-bgs-host"),
+				RelayHost:           cctx.String("atp-relay-host"),
 				ProfileIndex:        cctx.String("es-profile-index"),
 				PostIndex:           cctx.String("es-post-index"),
 				Logger:              logger,
-				BGSSyncRateLimit:    cctx.Int("bgs-sync-rate-limit"),
+				RelaySyncRateLimit:  cctx.Int("relay-sync-rate-limit"),
 				IndexMaxConcurrency: cctx.Int("index-max-concurrency"),
 			},
 		)

search/firehose.go

···
 	}
 
 	d := websocket.DefaultDialer
-	u, err := url.Parse(s.bgshost)
+	u, err := url.Parse(s.relayHost)
 	if err != nil {
-		return fmt.Errorf("invalid bgshost URI: %w", err)
+		return fmt.Errorf("invalid relayHost URI: %w", err)
 	}
 	u.Path = "xrpc/com.atproto.sync.subscribeRepos"
 	if cur != 0 {
···
 	return events.HandleRepoStream(
 		ctx, con, autoscaling.NewScheduler(
 			autoscaling.DefaultAutoscaleSettings(),
-			s.bgshost,
+			s.relayHost,
 			rsc.EventHandler,
 		),
 	)
···
 	totalErrored := 0
 
 	for {
-		resp, err := comatproto.SyncListRepos(ctx, s.bgsxrpc, cursor, limit)
+		resp, err := comatproto.SyncListRepos(ctx, s.relayClient, cursor, limit)
 		if err != nil {
 			log.Error("failed to list repos", "err", err)
 			time.Sleep(5 * time.Second)
···
 }
 
 func (s *Server) processTooBigCommit(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Commit) error {
-	repodata, err := comatproto.SyncGetRepo(ctx, s.bgsxrpc, evt.Repo, "")
+	repodata, err := comatproto.SyncGetRepo(ctx, s.relayClient, evt.Repo, "")
 	if err != nil {
 		return err
 	}

search/server.go

···
 	postIndex    string
 	profileIndex string
 	db           *gorm.DB
-	bgshost      string
-	bgsxrpc      *xrpc.Client
+	relayHost    string
+	relayClient  *xrpc.Client
 	dir          identity.Directory
 	echo         *echo.Echo
 	logger       *slog.Logger
···
 }
 
 type Config struct {
-	BGSHost             string
+	RelayHost           string
 	ProfileIndex        string
 	PostIndex           string
 	Logger              *slog.Logger
-	BGSSyncRateLimit    int
+	RelaySyncRateLimit  int
 	IndexMaxConcurrency int
 	DiscoverRepos       bool
 }
···
 	db.AutoMigrate(&LastSeq{})
 	db.AutoMigrate(&backfill.GormDBJob{})
 
-	bgsws := config.BGSHost
-	if !strings.HasPrefix(bgsws, "ws") {
-		return nil, fmt.Errorf("specified bgs host must include 'ws://' or 'wss://'")
+	relayws := config.RelayHost
+	if !strings.HasPrefix(relayws, "ws") {
+		return nil, fmt.Errorf("specified relay host must include 'ws://' or 'wss://'")
 	}
 
-	bgshttp := strings.Replace(bgsws, "ws", "http", 1)
-	bgsxrpc := &xrpc.Client{
-		Host: bgshttp,
+	relayhttp := strings.Replace(relayws, "ws", "http", 1)
+	relayClient := &xrpc.Client{
+		Host: relayhttp,
 	}
 
 	s := &Server{
···
 		profileIndex:        config.ProfileIndex,
 		postIndex:           config.PostIndex,
 		db:                  db,
-		bgshost:             config.BGSHost, // NOTE: the original URL, not 'bgshttp'
-		bgsxrpc:             bgsxrpc,
+		relayHost:           config.RelayHost, // NOTE: the original URL, not 'relayhttp'
+		relayClient:         relayClient,
 		dir:                 dir,
 		logger:              logger,
 		enableRepoDiscovery: config.DiscoverRepos,
···
 
 	bfstore := backfill.NewGormstore(db)
 	opts := backfill.DefaultBackfillOptions()
-	if config.BGSSyncRateLimit > 0 {
-		opts.SyncRequestsPerSecond = config.BGSSyncRateLimit
-		opts.ParallelBackfills = 2 * config.BGSSyncRateLimit
+	if config.RelaySyncRateLimit > 0 {
+		opts.SyncRequestsPerSecond = config.RelaySyncRateLimit
+		opts.ParallelBackfills = 2 * config.RelaySyncRateLimit
 	} else {
 		opts.SyncRequestsPerSecond = 8
 	}
-	opts.CheckoutPath = fmt.Sprintf("%s/xrpc/com.atproto.sync.getRepo", bgshttp)
+	opts.CheckoutPath = fmt.Sprintf("%s/xrpc/com.atproto.sync.getRepo", relayhttp)
 	if config.IndexMaxConcurrency > 0 {
 		opts.ParallelRecordCreates = config.IndexMaxConcurrency
 	} else {