goat: support both 'Basic' and 'Bearer' relay admin (#1027)

relay_admin.go

···
 
 import (
 	"bytes"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
···
 	Usage: "sub-comands for relay administration",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
-			Name:     "admin-token",
-			Required: true,
-			Usage:    "relay admin auth token",
-			EnvVars:  []string{"ATP_AUTH_ADMIN_PASSWORD", "RELAY_ADMIN_TOKEN"},
+			Name:    "admin-password",
+			Usage:   "relay admin password (for Basic admin auth)",
+			EnvVars: []string{"RELAY_ADMIN_PASSWORD", "ATP_AUTH_ADMIN_PASSWORD"},
+		},
+		&cli.StringFlag{
+			Name:    "admin-bearer-token",
+			Usage:   "relay admin auth token (for Bearer auth)",
+			EnvVars: []string{"RELAY_ADMIN_BEARER_TOKEN"},
 		},
 	},
 	Subcommands: []*cli.Command{
···
 
 type RelayAdminClient struct {
 	Host        string
+	Password    string
 	BearerToken string
 }
 
···
 	if err != nil {
 		return nil, err
 	}
-	req.Header.Set("Authorization", "Bearer "+c.BearerToken)
+	if c.Password != "" {
+		req.Header.Set("Authorization", "Basic "+base64.StdEncoding.EncodeToString([]byte("admin:"+c.Password)))
+	} else if c.BearerToken != "" {
+		req.Header.Set("Authorization", "Bearer "+c.BearerToken)
+	}
 	req.Header.Set("User-Agent", fmt.Sprintf("goat/"+versioninfo.Short()))
 	if buf != nil {
 		req.Header.Set("Content-Type", "application/json")
···
 	return respBytes, nil
 }
 
-func NewRelayAdminClient(cctx *cli.Context) *RelayAdminClient {
-	// TODO: password-style admin auth
-	//headers["Authorization"] = "Basic "+base64.StdEncoding.EncodeToString([]byte("admin:"+*c.AdminToken)))
+func NewRelayAdminClient(cctx *cli.Context) (*RelayAdminClient, error) {
 	client := RelayAdminClient{
 		Host:        cctx.String("relay-host"),
-		BearerToken: cctx.String("admin-token"),
+		Password:    cctx.String("admin-password"),
+		BearerToken: cctx.String("admin-bearer-token"),
 	}
-	return &client
+	if client.Password == "" && client.BearerToken == "" {
+		return nil, fmt.Errorf("either admin password or admin bearer token must be provided")
+	}
+	return &client, nil
 }
 
 func runRelayAdminAccountTakedown(cctx *cli.Context) error {
···
 		return err
 	}
 
-	client := NewRelayAdminClient(cctx)
+	client, err := NewRelayAdminClient(cctx)
+	if err != nil {
+		return err
+	}
 
 	path := "/admin/repo/takeDown"
 	if cctx.Bool("reverse") {
···
 }
 
 func runRelayAdminAccountList(cctx *cli.Context) error {
-	client := NewRelayAdminClient(cctx)
+	client, err := NewRelayAdminClient(cctx)
+	if err != nil {
+		return err
+	}
 	path := "/admin/repo/takedowns"
 	params := map[string]string{
 		"cursor": "",
···
 		return fmt.Errorf("need to provide hostname as an argument")
 	}
 
-	client := NewRelayAdminClient(cctx)
+	client, err := NewRelayAdminClient(cctx)
+	if err != nil {
+		return err
+	}
 	path := "/admin/pds/requestCrawl"
 	body := map[string]any{
 		"hostname": hostname,
 	}
-	_, err := client.Do("POST", path, nil, body)
+	_, err = client.Do("POST", path, nil, body)
 	if err != nil {
 		return err
 	}
···
 		return fmt.Errorf("need to provide hostname as an argument")
 	}
 
-	client := NewRelayAdminClient(cctx)
+	client, err := NewRelayAdminClient(cctx)
+	if err != nil {
+		return err
+	}
 
 	path := "/admin/pds/block"
 	if cctx.Bool("reverse") {
···
 	params := map[string]string{
 		"host": hostname,
 	}
-	_, err := client.Do("POST", path, params, nil)
+	_, err = client.Do("POST", path, params, nil)
 	if err != nil {
 		return err
 	}
···
 }
 
 func runRelayAdminHostList(cctx *cli.Context) error {
-	client := NewRelayAdminClient(cctx)
+	client, err := NewRelayAdminClient(cctx)
+	if err != nil {
+		return err
+	}
 	path := "/admin/pds/list"
 
 	respBytes, err := client.Do("GET", path, nil, nil)
···
 		return fmt.Errorf("need to provide hostname as an argument")
 	}
 
-	client := NewRelayAdminClient(cctx)
+	client, err := NewRelayAdminClient(cctx)
+	if err != nil {
+		return err
+	}
 
 	path := "/admin/pds/changeLimits"
 
···
 		body["repo_limit"] = cctx.Int("repo-limit")
 	}
 
-	_, err := client.Do("POST", path, nil, body)
+	_, err = client.Do("POST", path, nil, body)
 	if err != nil {
 		return err
 	}
···
 		return fmt.Errorf("need to provide domain as an argument")
 	}
 
-	client := NewRelayAdminClient(cctx)
+	client, err := NewRelayAdminClient(cctx)
+	if err != nil {
+		return err
+	}
 
 	path := "/admin/subs/banDomain"
 	if cctx.Bool("reverse") {
···
 	body := map[string]any{
 		"domain": domain,
 	}
-	_, err := client.Do("POST", path, nil, body)
+	_, err = client.Do("POST", path, nil, body)
 	if err != nil {
 		return err
 	}
···
 }
 
 func runRelayAdminDomainList(cctx *cli.Context) error {
-	client := NewRelayAdminClient(cctx)
+	client, err := NewRelayAdminClient(cctx)
+	if err != nil {
+		return err
+	}
 	path := "/admin/subs/listDomainBans"
 
 	respBytes, err := client.Do("GET", path, nil, nil)
···
 }
 
 func runRelayAdminConsumerList(cctx *cli.Context) error {
-	client := NewRelayAdminClient(cctx)
+	client, err := NewRelayAdminClient(cctx)
+	if err != nil {
+		return err
+	}
 	path := "/admin/consumers/list"
 
 	respBytes, err := client.Do("GET", path, nil, nil)