internal/gomote: implement list swarming bots endpoint

This change adds an endpoint to list the swarming builders which are
available for the gomote user to create and instance from.

Updates golang/go#61773
For golang/go#61772

Change-Id: Ic2bd0bb5d9b5866399370197fa543ea949addc31
Reviewed-on: https://go-review.googlesource.com/c/build/+/518798
Reviewed-by: Dmitri Shuralyov <[email protected]>
Reviewed-by: Dmitri Shuralyov <[email protected]>
Run-TryBot: Carlos Amedee <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: cagedmantis

cmd/coordinator/coordinator.go

@@ -60,6 +60,7 @@ import (
 	"golang.org/x/build/internal/https"
 	"golang.org/x/build/internal/metrics"
 	"golang.org/x/build/internal/secret"
+	"golang.org/x/build/internal/swarmclient"
 	"golang.org/x/build/kubernetes/gke"
 	"golang.org/x/build/maintner/maintnerd/apipb"
 	"golang.org/x/build/repos"
@@ -347,7 +348,7 @@ func main() {
 	dashV2 := &builddash.Handler{Datastore: gce.GoDSClient(), Maintner: maintnerClient}
 	gs := &gRPCServer{dashboardURL: "https://build.golang.org"}
 	setSessionPool(sp)
-	gomoteServer := gomote.New(sp, sched, sshCA, gomoteBucket, mustStorageClient())
+	gomoteServer := gomote.New(sp, sched, sshCA, gomoteBucket, mustStorageClient(), mustLUCIConfigClient())
 	protos.RegisterCoordinatorServer(grpcServer, gs)
 	gomoteprotos.RegisterGomoteServiceServer(grpcServer, gomoteServer)
 	mux.HandleFunc("/", grpcHandlerFunc(grpcServer, handleStatus)) // Serve a status page at farmer.golang.org.
@@ -2254,3 +2255,13 @@ func retrieveSSHKeys(ctx context.Context, sc *secret.Client, m string) (publicKe
 	}
 	return nil, nil, fmt.Errorf("unable to retrieve ssh keys")
 }
+
+func mustLUCIConfigClient() *swarmclient.ConfigClient {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	c, err := swarmclient.NewConfigClient(ctx)
+	if err != nil {
+		log.Fatalf("unable to create LUCI config client: %s", err)
+	}
+	return c
+}

internal/gomote/gomote.go

@@ -30,6 +30,7 @@ import (
 	"golang.org/x/build/internal/coordinator/schedule"
 	"golang.org/x/build/internal/envutil"
 	"golang.org/x/build/internal/gomote/protos"
+	"golang.org/x/build/internal/swarmclient"
 	"golang.org/x/build/types"
 	"golang.org/x/crypto/ssh"
 	"google.golang.org/grpc/codes"
@@ -59,10 +60,11 @@ type Server struct {
 	gceBucketName           string
 	scheduler               scheduler
 	sshCertificateAuthority ssh.Signer
+	luciConfigClient        *swarmclient.ConfigClient
 }
 
 // New creates a gomote server. If the rawCAPriKey is invalid, the program will exit.
-func New(rsp *remote.SessionPool, sched *schedule.Scheduler, rawCAPriKey []byte, gomoteGCSBucket string, storageClient *storage.Client) *Server {
+func New(rsp *remote.SessionPool, sched *schedule.Scheduler, rawCAPriKey []byte, gomoteGCSBucket string, storageClient *storage.Client, configClient *swarmclient.ConfigClient) *Server {
 	signer, err := ssh.ParsePrivateKey(rawCAPriKey)
 	if err != nil {
 		log.Fatalf("unable to parse raw certificate authority private key into signer=%s", err)
@@ -73,6 +75,7 @@ func New(rsp *remote.SessionPool, sched *schedule.Scheduler, rawCAPriKey []byte,
 		gceBucketName:           gomoteGCSBucket,
 		scheduler:               sched,
 		sshCertificateAuthority: signer,
+		luciConfigClient:        configClient,
 	}
 }
 
@@ -273,6 +276,27 @@ func (s *Server) ListInstances(ctx context.Context, req *protos.ListInstancesReq
 	return res, nil
 }
 
+// ListSwarmingBuilders lists all of the swarming builders which run for gotip. The requester must be authenticated.
+func (s Server) ListSwarmingBuilders(ctx context.Context, req *protos.ListSwarmingBuildersRequest) (*protos.ListSwarmingBuildersResponse, error) {
+	_, err := access.IAPFromContext(ctx)
+	if err != nil {
+		log.Printf("ListSwarmingInstances access.IAPFromContext(ctx) = nil, %s", err)
+		return nil, status.Errorf(codes.Unauthenticated, "request does not contain the required authentication")
+	}
+	bots, err := s.luciConfigClient.ListSwarmingBots(ctx)
+	if err != nil {
+		log.Printf("luciConfigClient.ListSwarmingBots(ctx) = %s", err)
+		return nil, status.Errorf(codes.Internal, "unable to query for bots")
+	}
+	builders := []string{}
+	for _, bot := range bots {
+		if bot.BucketName == "ci" && strings.HasPrefix(bot.Name, "gotip") {
+			builders = append(builders, bot.Name)
+		}
+	}
+	return &protos.ListSwarmingBuildersResponse{Builders: builders}, nil
+}
+
 // DestroyInstance will destroy a gomote instance. It will ensure that the caller is authenticated and is the owner of the instance
 // before it destroys the instance.
 func (s *Server) DestroyInstance(ctx context.Context, req *protos.DestroyInstanceRequest) (*protos.DestroyInstanceResponse, error) {

internal/gomote/gomote_test.go

@@ -14,6 +14,7 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"testing"
 	"time"
 
@@ -23,6 +24,7 @@ import (
 	"golang.org/x/build/internal/coordinator/remote"
 	"golang.org/x/build/internal/coordinator/schedule"
 	"golang.org/x/build/internal/gomote/protos"
+	"golang.org/x/build/internal/swarmclient"
 	"golang.org/x/crypto/ssh"
 	"golang.org/x/net/nettest"
 	"google.golang.org/grpc"
@@ -33,7 +35,7 @@ import (
 
 const testBucketName = "unit-testing-bucket"
 
-func fakeGomoteServer(t *testing.T, ctx context.Context) protos.GomoteServiceServer {
+func fakeGomoteServer(t *testing.T, ctx context.Context, configClient *swarmclient.ConfigClient) protos.GomoteServiceServer {
 	signer, err := ssh.ParsePrivateKey([]byte(devCertCAPrivate))
 	if err != nil {
 		t.Fatalf("unable to parse raw certificate authority private key into signer=%s", err)
@@ -44,17 +46,25 @@ func fakeGomoteServer(t *testing.T, ctx context.Context) protos.GomoteServiceSer
 		gceBucketName:           testBucketName,
 		scheduler:               schedule.NewFake(),
 		sshCertificateAuthority: signer,
+		luciConfigClient:        configClient,
 	}
 }
 
 func setupGomoteTest(t *testing.T, ctx context.Context) protos.GomoteServiceClient {
+	contents, err := os.ReadFile("../swarmclient/testdata/bb-sample.cfg")
+	if err != nil {
+		t.Fatalf("unable to read test buildbucket config: %s", err)
+	}
+	configClient := swarmclient.NewMemoryConfigClient(ctx, []*swarmclient.ConfigEntry{
+		&swarmclient.ConfigEntry{"cr-buildbucket.cfg", contents},
+	})
 	lis, err := nettest.NewLocalListener("tcp")
 	if err != nil {
 		t.Fatalf("unable to create net listener: %s", err)
 	}
 	sopts := access.FakeIAPAuthInterceptorOptions()
 	s := grpc.NewServer(sopts...)
-	protos.RegisterGomoteServiceServer(s, fakeGomoteServer(t, ctx))
+	protos.RegisterGomoteServiceServer(s, fakeGomoteServer(t, ctx, configClient))
 	go s.Serve(lis)
 
 	// create GRPC client
@@ -415,6 +425,31 @@ func TestListInstance(t *testing.T) {
 	}
 }
 
+func TestListSwarmingBuilders(t *testing.T) {
+	client := setupGomoteTest(t, context.Background())
+	ctx := access.FakeContextWithOutgoingIAPAuth(context.Background(), fakeIAP())
+	response, err := client.ListSwarmingBuilders(ctx, &protos.ListSwarmingBuildersRequest{})
+	if err != nil {
+		t.Fatalf("client.ListSwarmingBuilders = nil, %s; want no error", err)
+	}
+	got := response.GetBuilders()
+	if diff := cmp.Diff([]string{"gotip-linux-amd64-boringcrypto"}, got); diff != "" {
+		t.Errorf("ListBuilders() mismatch (-want, +got):\n%s", diff)
+	}
+}
+
+func TestListSwarmingBuildersError(t *testing.T) {
+	client := setupGomoteTest(t, context.Background())
+	req := &protos.ListSwarmingBuildersRequest{}
+	got, err := client.ListSwarmingBuilders(context.Background(), req)
+	if err != nil && status.Code(err) != codes.Unauthenticated {
+		t.Fatalf("unexpected error: %s; want %s", err, codes.Unauthenticated)
+	}
+	if err == nil {
+		t.Fatalf("client.ListSwarmingBuilder(ctx, %v) = %v, nil; want error", req, got)
+	}
+}
+
 func TestDestroyInstance(t *testing.T) {
 	ctx := access.FakeContextWithOutgoingIAPAuth(context.Background(), fakeIAP())
 	client := setupGomoteTest(t, context.Background())