update more BGS/Relay terminology (#639)

not very high-priority, but noticed these doing some palomar work and
did a cleanup.

didn't want to touch the actual bgs package and bigsky code base.

the CLI arg parsing stuff makes it easy to keep the old env vars around,
which means this shouldn't impact deploys with old config.

HACKING.md

···
 
 Run with, eg, `go run ./cmd/bigsky`):
 
-- `cmd/bigsky`: BGS+indexer daemon
+- `cmd/bigsky`: Relay+indexer daemon
 - `cmd/palomar`: search indexer and query servcie (OpenSearch)
 - `cmd/gosky`: client CLI for talking to a PDS
 - `cmd/lexgen`: codegen tool for lexicons (Lexicon JSON to Go package)
···
 - `atproto/syntax`: string types and parsers for identifiers, datetimes, etc
 - `atproto/identity`: DID and handle resolution
 - `automod`: moderation and anti-spam rules engine
-- `bgs`: server implementation for crawling, etc
+- `bgs`: relay server implementation for crawling, etc
 - `carstore`: library for storing repo data in CAR files on disk, plus a metadata SQL db
 - `events`: types, codegen CBOR helpers, and persistence for event feeds
 - `indexer`: aggregator, handling like counts etc in SQL database
···
 
 ## Jargon
 
-- BGS: Big Graph Service (or Server), which centrals crawls/consumes content from "all" PDSs and re-broadcasts as a firehose
+- Relay: service which crawls/consumes content from "all" PDSs and re-broadcasts as a firehose
+- BGS: Big Graph Service, previous name for what is now "Relay"
 - PDS: Personal Data Server (or Service), which stores user atproto repositories and acts as a user agent in the network
 - CLI: Command Line Tool
 - CBOR: a binary serialization format, smilar to JSON
···
     # consume repo events from PDS
     websocat ws://localhost:4989/events
 
-    # consume repo events from BGS
+    # consume repo events from Relay
     websocat ws://localhost:2470/events
 
-Send the BGS a ding-dong:
+Send the Relay a ding-dong:
 
-    # tell BGS to consume from PDS
+    # tell Relay to consume from PDS
     http --json post localhost:2470/add-target host="localhost:4989"
 
 Set the log level to be more verbose, using an env variable:
···
 
 ## Integrated Development
 
-Sometimes it is helpful to run a PLC, PDS, BGS, and other components, all locally on your laptop, across languages. This section describes one setup for this.
+Sometimes it is helpful to run a PLC, PDS, Relay, and other components, all locally on your laptop, across languages. This section describes one setup for this.
 
 First, you need PostgreSQL running locally. This could be via docker, or the following commands assume some kind of debian/ubuntu setup with a postgres server package installed and running.
 
···
 
     make run-dev-pds
 
-In this repo (indigo), start a BGS, in two separate terminals:
+In this repo (indigo), start a Relay, in two separate terminals:
 
-    make run-dev-bgs
+    make run-dev-relay
 
 In a final terminal, run fakermaker to inject data into the system:
 

Makefile

···
 run-postgres: .env ## Runs a local postgres instance
 	docker compose -f cmd/bigsky/docker-compose.yml up -d
 
-.PHONY: run-dev-bgs
-run-dev-bgs: .env ## Runs 'bigsky' BGS for local dev
+.PHONY: run-dev-relay
+run-dev-relay: .env ## Runs 'bigsky' Relay for local dev
 	GOLOG_LOG_LEVEL=info go run ./cmd/bigsky --admin-key localdev 
 # --crawl-insecure-ws 
 
-.PHONY: build-bgs-image
-build-bgs-image: ## Builds 'bigsky' BGS docker image
+.PHONY: build-relay-image
+build-relay-image: ## Builds 'bigsky' Relay docker image
 	docker build -t bigsky -f cmd/bigsky/Dockerfile .
 
-.PHONY: run-bgs-image
-run-bgs-image:
+.PHONY: run-relay-image
+run-relay-image:
 	docker run -p 2470:2470 bigsky /bigsky --admin-key localdev
 # --crawl-insecure-ws 
 

cmd/bigsky/Dockerfile

···
 CMD ["/bigsky"]
 
 LABEL org.opencontainers.image.source=https://github.com/bluesky-social/indigo
-LABEL org.opencontainers.image.description="ATP Big Graph Server (BGS)"
+LABEL org.opencontainers.image.description="ATP Relay (aka BGS)"
 LABEL org.opencontainers.image.licenses=MIT

cmd/bigsky/README.md

···
 
-bigsky: A Big Graph Server (BGS)
-================================
+bigsky: Big Graph Server (BGS), aka Relay
+=========================================
 
 ## Database Setup
 

cmd/hepa/consumer.go

···
 	}
 
 	dialer := 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 {
 		u.RawQuery = fmt.Sprintf("cursor=%d", cur)
 	}
-	s.logger.Info("subscribing to repo event stream", "upstream", s.bgshost, "cursor", cur)
+	s.logger.Info("subscribing to repo event stream", "upstream", s.relayHost, "cursor", cur)
 	con, _, err := dialer.Dial(u.String(), http.Header{
 		"User-Agent": []string{fmt.Sprintf("hepa/%s", versioninfo.Short())},
 	})
···
 		scheduler = parallel.NewScheduler(
 			s.firehoseParallelism,
 			1000,
-			s.bgshost,
+			s.relayHost,
 			rsc.EventHandler,
 		)
 		s.logger.Info("hepa scheduler configured", "scheduler", "parallel", "initial", s.firehoseParallelism)
···
 		// start at higher parallelism (somewhat arbitrary)
 		scaleSettings.Concurrency = 4
 		scaleSettings.MaxConcurrency = 200
-		scheduler = autoscaling.NewScheduler(scaleSettings, s.bgshost, rsc.EventHandler)
+		scheduler = autoscaling.NewScheduler(scaleSettings, s.relayHost, rsc.EventHandler)
 		s.logger.Info("hepa scheduler configured", "scheduler", "autoscaling", "initial", scaleSettings.Concurrency, "max", scaleSettings.MaxConcurrency)
 	}
 

cmd/hepa/main.go

···
 
 	app.Flags = []cli.Flag{
 		&cli.StringFlag{
-			Name:    "atp-bgs-host",
-			Usage:   "hostname and port of BGS to subscribe to",
+			Name:    "atp-relay-host",
+			Usage:   "hostname and port of Relay to subscribe to",
 			Value:   "wss://bsky.network",
-			EnvVars: []string{"ATP_BGS_HOST"},
+			EnvVars: []string{"ATP_RELAY_HOST", "ATP_BGS_HOST"},
 		},
 		&cli.StringFlag{
 			Name:    "atp-plc-host",
···
 		srv, err := NewServer(
 			dir,
 			Config{
-				BGSHost:             cctx.String("atp-bgs-host"),
+				RelayHost:           cctx.String("atp-relay-host"),
 				BskyHost:            cctx.String("atp-bsky-host"),
 				Logger:              logger,
 				ModHost:             cctx.String("atp-mod-host"),
···
 	return NewServer(
 		dir,
 		Config{
-			BGSHost:             cctx.String("atp-bgs-host"),
+			RelayHost:           cctx.String("atp-relay-host"),
 			BskyHost:            cctx.String("atp-bsky-host"),
 			Logger:              logger,
 			ModHost:             cctx.String("atp-mod-host"),

cmd/hepa/server.go

···
 )
 
 type Server struct {
-	bgshost             string
+	relayHost           string
 	firehoseParallelism int
 	logger              *slog.Logger
 	engine              *automod.Engine
···
 }
 
 type Config struct {
-	BGSHost             string
+	RelayHost           string
 	BskyHost            string
 	ModHost             string
 	ModAdminToken       string
···
 		}))
 	}
 
-	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://'")
 	}
 
 	// TODO: this isn't a very robust way to handle a persistent client
···
 	}
 
 	s := &Server{
-		bgshost:             config.BGSHost,
+		relayHost:           config.RelayHost,
 		firehoseParallelism: config.FirehoseParallelism,
 		logger:              logger,
 		engine:              &engine,

cmd/supercollider/main.go

···
 
 	app := cli.App{
 		Name:    "supercollider",
-		Usage:   "atproto event noise-maker for BGS load testing",
+		Usage:   "atproto event noise-maker for Relay load testing",
 		Version: versioninfo.Short(),
 	}
 

testing/integ_test.go

···
 	log.SetAllLoggers(log.LevelInfo)
 }
 
-func TestBGSBasic(t *testing.T) {
+func TestRelayBasic(t *testing.T) {
 	if testing.Short() {
-		t.Skip("skipping BGS test in 'short' test mode")
+		t.Skip("skipping Relay test in 'short' test mode")
 	}
 	assert := assert.New(t)
 	didr := TestPLC(t)
 	p1 := MustSetupPDS(t, ".tpds", didr)
 	p1.Run(t)
 
-	b1 := MustSetupBGS(t, didr)
+	b1 := MustSetupRelay(t, didr)
 	b1.Run(t)
 
 	b1.tr.TrialHosts = []string{p1.RawHost()}
···
 	return posts
 }
 
-func TestBGSMultiPDS(t *testing.T) {
+func TestRelayMultiPDS(t *testing.T) {
 	if testing.Short() {
-		t.Skip("skipping BGS test in 'short' test mode")
+		t.Skip("skipping Relay test in 'short' test mode")
 	}
 	//t.Skip("test too sleepy to run in CI for now")
 
···
 	p2 := MustSetupPDS(t, ".pdsdos", didr)
 	p2.Run(t)
 
-	b1 := MustSetupBGS(t, didr)
+	b1 := MustSetupRelay(t, didr)
 	b1.Run(t)
 
 	b1.tr.TrialHosts = []string{p1.RawHost(), p2.RawHost()}
···
 
 	users[0].Reply(t, p2posts[0], p2posts[0], "what a wonderful life")
 
-	// now if we make posts on pds 2, the bgs will not hear about those new posts
+	// now if we make posts on pds 2, the relay will not hear about those new posts
 
 	p2posts2 := socialSim(t, users2, 10, 10)
 
···
 	p2.BumpLimits(t, b1)
 	time.Sleep(time.Millisecond * 50)
 
-	// Now, the bgs will discover a gap, and have to catch up somehow
+	// Now, the relay will discover a gap, and have to catch up somehow
 	socialSim(t, users2, 1, 0)
 
 	time.Sleep(time.Second)
 
-	// we expect the bgs to learn about posts that it did not directly see from
+	// we expect the relay to learn about posts that it did not directly see from
 	// repos its already partially scraped, as long as its seen *something* after the missing post
 	// this is the 'catchup' process
 	ctx := context.Background()
···
 	}
 }
 
-func TestBGSMultiGap(t *testing.T) {
+func TestRelayMultiGap(t *testing.T) {
 	if testing.Short() {
-		t.Skip("skipping BGS test in 'short' test mode")
+		t.Skip("skipping Relay test in 'short' test mode")
 	}
 	//t.Skip("test too sleepy to run in CI for now")
 	assert := assert.New(t)
···
 	p2 := MustSetupPDS(t, ".pdsdos", didr)
 	p2.Run(t)
 
-	b1 := MustSetupBGS(t, didr)
+	b1 := MustSetupRelay(t, didr)
 	b1.Run(t)
 
 	b1.tr.TrialHosts = []string{p1.RawHost(), p2.RawHost()}
···
 		t.Fatal(err)
 	}
 
-	// now if we make posts on pds 2, the bgs will not hear about those new posts
+	// now if we make posts on pds 2, the relay will not hear about those new posts
 
 	p2posts2 := socialSim(t, users2, 10, 0)
 
···
 	p2.BumpLimits(t, b1)
 	time.Sleep(time.Second * 2)
 
-	// Now, the bgs will discover a gap, and have to catch up somehow
+	// Now, the relay will discover a gap, and have to catch up somehow
 	socialSim(t, users2, 1, 0)
 
 	time.Sleep(time.Second * 2)
 
-	// we expect the bgs to learn about posts that it did not directly see from
+	// we expect the relay to learn about posts that it did not directly see from
 	// repos its already partially scraped, as long as its seen *something* after the missing post
 	// this is the 'catchup' process
 	_, err = b1.bgs.Index.GetPost(ctx, p2posts2[4].Uri)
···
 	p1 := MustSetupPDS(t, ".pdsuno", didr)
 	p1.Run(t)
 
-	b1 := MustSetupBGS(t, didr)
+	b1 := MustSetupRelay(t, didr)
 	b1.Run(t)
 
 	b1.tr.TrialHosts = []string{p1.RawHost()}
···
 
 	u := p1.MustNewUser(t, usernames[0]+".pdsuno")
 
-	// if the handle changes before the bgs processes the first event, things
+	// if the handle changes before the relay processes the first event, things
 	// get a little weird
 	time.Sleep(time.Millisecond * 50)
 	//socialSim(t, []*testUser{u}, 10, 0)
···
 	fmt.Println(idevt.RepoIdentity)
 }
 
-func TestBGSTakedown(t *testing.T) {
+func TestRelayTakedown(t *testing.T) {
 	if testing.Short() {
-		t.Skip("skipping BGS test in 'short' test mode")
+		t.Skip("skipping Relay test in 'short' test mode")
 	}
 	assert := assert.New(t)
 	_ = assert
···
 	p1 := MustSetupPDS(t, ".tpds", didr)
 	p1.Run(t)
 
-	b1 := MustSetupBGS(t, didr)
+	b1 := MustSetupRelay(t, didr)
 	b1.Run(t)
 
 	b1.tr.TrialHosts = []string{p1.RawHost()}
···
 
 func TestDomainBans(t *testing.T) {
 	if testing.Short() {
-		t.Skip("skipping BGS test in 'short' test mode")
+		t.Skip("skipping Relay test in 'short' test mode")
 	}
 	didr := TestPLC(t)
 
-	b1 := MustSetupBGS(t, didr)
+	b1 := MustSetupRelay(t, didr)
 	b1.Run(t)
 
 	b1.BanDomain(t, "foo.com")
···
 	}
 }
 
-func TestBGSHandleEmptyEvent(t *testing.T) {
+func TestRelayHandleEmptyEvent(t *testing.T) {
 	if testing.Short() {
-		t.Skip("skipping BGS test in 'short' test mode")
+		t.Skip("skipping Relay test in 'short' test mode")
 	}
 	assert := assert.New(t)
 	didr := TestPLC(t)
 	p1 := MustSetupPDS(t, ".tpds", didr)
 	p1.Run(t)
 
-	b1 := MustSetupBGS(t, didr)
+	b1 := MustSetupRelay(t, didr)
 	b1.Run(t)
 
 	b1.tr.TrialHosts = []string{p1.RawHost()}

testing/utils.go

···
 	}
 }
 
-func (tp *TestPDS) RequestScraping(t *testing.T, b *TestBGS) {
+func (tp *TestPDS) RequestScraping(t *testing.T, b *TestRelay) {
 	t.Helper()
 
 	c := &xrpc.Client{Host: "http://" + b.Host()}
···
 	}
 }
 
-func (tp *TestPDS) BumpLimits(t *testing.T, b *TestBGS) {
+func (tp *TestPDS) BumpLimits(t *testing.T, b *TestRelay) {
 	t.Helper()
 
 	err := b.bgs.CreateAdminToken("test")
···
 	return plc.NewFakeDid(db)
 }
 
-type TestBGS struct {
+type TestRelay struct {
 	bgs *bgs.BGS
 	tr  *api.TestHandleResolver
 	db  *gorm.DB
 
-	// listener is owned by by the BGS structure and should be closed by
-	// shutting down the BGS.
+	// listener is owned by by the Relay structure and should be closed by
+	// shutting down the Relay.
 	listener net.Listener
 }
 
-func (t *TestBGS) Host() string {
+func (t *TestRelay) Host() string {
 	return t.listener.Addr().String()
 }
 
-func MustSetupBGS(t *testing.T, didr plc.PLCClient) *TestBGS {
+func MustSetupRelay(t *testing.T, didr plc.PLCClient) *TestRelay {
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
-	tbgs, err := SetupBGS(ctx, didr)
+	tbgs, err := SetupRelay(ctx, didr)
 	if err != nil {
 		t.Fatal(err)
 	}
···
 	return tbgs
 }
 
-func SetupBGS(ctx context.Context, didr plc.PLCClient) (*TestBGS, error) {
+func SetupRelay(ctx context.Context, didr plc.PLCClient) (*TestRelay, error) {
 	dir, err := os.MkdirTemp("", "integtest")
 	if err != nil {
 		return nil, err
···
 
 	repoman.SetEventHandler(func(ctx context.Context, evt *repomgr.RepoEvent) {
 		if err := ix.HandleRepoEvent(ctx, evt); err != nil {
-			fmt.Println("test bgs failed to handle repo event", err)
+			fmt.Println("test relay failed to handle repo event", err)
 		}
-	}, true) // TODO: actually want this to be false, but some tests use this to confirm the BGS has seen certain records
+	}, true) // TODO: actually want this to be false, but some tests use this to confirm the Relay has seen certain records
 
 	tr := &api.TestHandleResolver{}
 
···
 		return nil, err
 	}
 
-	return &TestBGS{
+	return &TestRelay{
 		db:       maindb,
 		bgs:      b,
 		tr:       tr,
···
 	}, nil
 }
 
-func (b *TestBGS) Run(t *testing.T) {
+func (b *TestRelay) Run(t *testing.T) {
 	go func() {
 		if err := b.bgs.StartWithListener(b.listener); err != nil {
 			fmt.Println(err)
···
 	time.Sleep(time.Millisecond * 10)
 }
 
-func (b *TestBGS) BanDomain(t *testing.T, d string) {
+func (b *TestRelay) BanDomain(t *testing.T, d string) {
 	t.Helper()
 
 	if err := b.db.Create(&models.DomainBan{
···
 	Cur int
 }
 
-func (b *TestBGS) Events(t *testing.T, since int64) *EventStream {
+func (b *TestRelay) Events(t *testing.T, since int64) *EventStream {
 	d := websocket.Dialer{}
 	h := http.Header{}