Add replicas endpoint

coder · kylecarbs · Oct 17, 2022 · Sep 22, 2022 · Sep 23, 2022 · Sep 23, 2022
commit abff96b103bcc4d6a72697154d95477bd9b69aed
diff --git a/coderd/rbac/object.go b/coderd/rbac/object.go
@@ -146,6 +146,10 @@ var (
 	ResourceDeploymentFlags = Object{
 		Type: "deployment_flags",
 	}
+
+	ResourceReplicas = Object{
+		Type: "replicas",
+	}
 )
 
 // Object is used to create objects for authz checks when you have none in

diff --git a/codersdk/deployment.go b/codersdk/deployment.go
diff --git a/codersdk/replicas.go b/codersdk/replicas.go
@@ -0,0 +1,42 @@
+package codersdk
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"github.com/google/uuid"
+	"golang.org/x/xerrors"
+)
+
+type Replica struct {
+	// ID is the unique identifier for the replica.
+	ID uuid.UUID `json:"id"`
+	// Hostname is the hostname of the replica.
+	Hostname string `json:"hostname"`
+	// CreatedAt is when the replica was first seen.
+	CreatedAt time.Time `json:"created_at"`
+	// RelayAddress is the accessible address to relay DERP connections.
+	RelayAddress string `json:"relay_address"`
+	// RegionID is the region of the replica.
+	RegionID int32 `json:"region_id"`
+	// Error is the error.
+	Error string `json:"error"`
+}
+
+// Replicas fetches the list of replicas.
+func (c *Client) Replicas(ctx context.Context) ([]Replica, error) {
+	res, err := c.Request(ctx, http.MethodGet, "/api/v2/replicas", nil)
+	if err != nil {
+		return nil, xerrors.Errorf("execute request: %w", err)
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		return nil, readBodyAsError(res)
+	}
+
+	var replicas []Replica
+	return replicas, json.NewDecoder(res.Body).Decode(&replicas)
+}
diff --git a/codersdk/workspaceagents.go b/codersdk/workspaceagents.go
@@ -331,13 +331,17 @@ func (c *Client) ListenWorkspaceAgentTailnet(ctx context.Context) (net.Conn, err
 	return websocket.NetConn(ctx, conn, websocket.MessageBinary), nil
 }
 
+// @typescript-ignore DialWorkspaceAgentOptions
 type DialWorkspaceAgentOptions struct {
 	Logger slog.Logger
 	// BlockEndpoints forced a direct connection through DERP.
 	BlockEndpoints bool
 }
 
 func (c *Client) DialWorkspaceAgent(ctx context.Context, agentID uuid.UUID, options *DialWorkspaceAgentOptions) (*AgentConn, error) {
+	if options == nil {
+		options = &DialWorkspaceAgentOptions{}
+	}
 	res, err := c.Request(ctx, http.MethodGet, fmt.Sprintf("/api/v2/workspaceagents/%s/connection", agentID), nil)
 	if err != nil {
 		return nil, err

diff --git a/enterprise/cli/features_test.go b/enterprise/cli/features_test.go
@@ -57,7 +57,7 @@ func TestFeaturesList(t *testing.T) {
 		var entitlements codersdk.Entitlements
 		err := json.Unmarshal(buf.Bytes(), &entitlements)
 		require.NoError(t, err, "unmarshal JSON output")
-		assert.Len(t, entitlements.Features, 6)
+		assert.Len(t, entitlements.Features, 7)
 		assert.Empty(t, entitlements.Warnings)
 		assert.Equal(t, codersdk.EntitlementNotEntitled,
 			entitlements.Features[codersdk.FeatureUserLimit].Entitlement)

diff --git a/enterprise/coderd/coderd.go b/enterprise/coderd/coderd.go
@@ -59,6 +59,10 @@ func New(ctx context.Context, options *Options) (*API, error) {
 
 	api.AGPL.APIHandler.Group(func(r chi.Router) {
 		r.Get("/entitlements", api.serveEntitlements)
+		r.Route("/replicas", func(r chi.Router) {
+			r.Use(apiKeyMiddleware)
+			r.Get("/", api.replicas)
+		})
 		r.Route("/licenses", func(r chi.Router) {
 			r.Use(apiKeyMiddleware)
 			r.Post("/", api.postLicense)

diff --git a/enterprise/coderd/coderd_test.go b/enterprise/coderd/coderd_test.go
@@ -85,7 +85,7 @@ func TestEntitlements(t *testing.T) {
 		assert.False(t, res.HasLicense)
 		al = res.Features[codersdk.FeatureAuditLog]
 		assert.Equal(t, codersdk.EntitlementNotEntitled, al.Entitlement)
-		assert.True(t, al.Enabled)
+		assert.False(t, al.Enabled)
 	})
 	t.Run("Pubsub", func(t *testing.T) {
 		t.Parallel()

diff --git a/enterprise/coderd/coderdenttest/coderdenttest_test.go b/enterprise/coderd/coderdenttest/coderdenttest_test.go
@@ -58,6 +58,10 @@ func TestAuthorizeAllEndpoints(t *testing.T) {
 		AssertAction: rbac.ActionRead,
 		AssertObject: rbac.ResourceLicense,
 	}
+	assertRoute["GET:/api/v2/replicas"] = coderdtest.RouteCheck{
+		AssertAction: rbac.ActionRead,
+		AssertObject: rbac.ResourceReplicas,
+	}
 	assertRoute["DELETE:/api/v2/licenses/{id}"] = coderdtest.RouteCheck{
 		AssertAction: rbac.ActionDelete,
 		AssertObject: rbac.ResourceLicense,

diff --git a/enterprise/coderd/replicas.go b/enterprise/coderd/replicas.go
@@ -1 +1,36 @@
 package coderd
+
+import (
+	"net/http"
+
+	"github.com/coder/coder/coderd/database"
+	"github.com/coder/coder/coderd/httpapi"
+	"github.com/coder/coder/coderd/rbac"
+	"github.com/coder/coder/codersdk"
+)
+
+// replicas returns the number of replicas that are active in Coder.
+func (api *API) replicas(rw http.ResponseWriter, r *http.Request) {
+	if !api.AGPL.Authorize(r, rbac.ActionRead, rbac.ResourceReplicas) {
+		httpapi.ResourceNotFound(rw)
+		return
+	}
+
+	replicas := api.replicaManager.All()
+	res := make([]codersdk.Replica, 0, len(replicas))
+	for _, replica := range replicas {
+		res = append(res, convertReplica(replica))
+	}
+	httpapi.Write(r.Context(), rw, http.StatusOK, res)
+}
+
+func convertReplica(replica database.Replica) codersdk.Replica {
+	return codersdk.Replica{
+		ID:           replica.ID,
+		Hostname:     replica.Hostname,
+		CreatedAt:    replica.CreatedAt,
+		RelayAddress: replica.RelayAddress,
+		RegionID:     replica.RegionID,
+		Error:        replica.Error.String,
+	}
+}
diff --git a/enterprise/coderd/replicas_test.go b/enterprise/coderd/replicas_test.go
@@ -63,6 +63,10 @@ func TestReplicas(t *testing.T) {
 			},
 		})
 		secondClient.SessionToken = firstClient.SessionToken
+		replicas, err := secondClient.Replicas(context.Background())
+		require.NoError(t, err)
+		require.Len(t, replicas, 2)
+
 		agentID := setupWorkspaceAgent(t, firstClient, firstUser)
 		conn, err := secondClient.DialWorkspaceAgent(context.Background(), agentID, &codersdk.DialWorkspaceAgentOptions{
 			BlockEndpoints: true,
@@ -76,5 +80,6 @@ func TestReplicas(t *testing.T) {
 			return err == nil
 		}, testutil.WaitLong, testutil.IntervalFast)
 		_ = conn.Close()
+
 	})
 }
diff --git a/enterprise/replicasync/replicasync.go b/enterprise/replicasync/replicasync.go
@@ -101,6 +101,14 @@ func New(ctx context.Context, logger slog.Logger, db database.Store, pubsub data
 	if err != nil {
 		return nil, xerrors.Errorf("run replica: %w", err)
 	}
+	peers := server.Regional()
+	if len(peers) > 0 {
+		self := server.Self()
+		if self.RelayAddress == "" {
+			return nil, xerrors.Errorf("a relay address must be specified when running multiple replicas in the same region")
+		}
+	}
+
 	err = server.subscribe(ctx)
 	if err != nil {
 		return nil, xerrors.Errorf("subscribe: %w", err)

diff --git a/enterprise/replicasync/replicasync_test.go b/enterprise/replicasync/replicasync_test.go
@@ -5,7 +5,6 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"sync"
-	"sync/atomic"
 	"testing"
 	"time"
 
@@ -66,6 +65,25 @@ func TestReplica(t *testing.T) {
 		_ = server.Close()
 		require.NoError(t, err)
 	})
+	t.Run("ErrorsWithoutRelayAddress", func(t *testing.T) {
+		// Ensures that the replica reports a successful status for
+		// accessing all of its peers.
+		t.Parallel()
+		db, pubsub := dbtestutil.NewDB(t)
+		_, err := db.InsertReplica(context.Background(), database.InsertReplicaParams{
+			ID:        uuid.New(),
+			CreatedAt: database.Now(),
+			StartedAt: database.Now(),
+			UpdatedAt: database.Now(),
+			Hostname:  "something",
+		})
+		require.NoError(t, err)
+		_, err = replicasync.New(context.Background(), slogtest.Make(t, nil), db, pubsub, replicasync.Options{
+			ID: uuid.New(),
+		})
+		require.Error(t, err)
+		require.Equal(t, "a relay address must be specified when running multiple replicas in the same region", err.Error())
+	})
 	t.Run("ConnectsToPeerReplica", func(t *testing.T) {
 		// Ensures that the replica reports a successful status for
 		// accessing all of its peers.
@@ -85,7 +103,8 @@ func TestReplica(t *testing.T) {
 		})
 		require.NoError(t, err)
 		server, err := replicasync.New(context.Background(), slogtest.Make(t, nil), db, pubsub, replicasync.Options{
-			ID: uuid.New(),
+			ID:           uuid.New(),
+			RelayAddress: "http://169.254.169.254",
 		})
 		require.NoError(t, err)
 		require.Len(t, server.Regional(), 1)
@@ -96,12 +115,6 @@ func TestReplica(t *testing.T) {
 	t.Run("ConnectsToFakePeerWithError", func(t *testing.T) {
 		t.Parallel()
 		db, pubsub := dbtestutil.NewDB(t)
-		var count atomic.Int32
-		cancel, err := pubsub.Subscribe(replicasync.PubsubEvent, func(ctx context.Context, message []byte) {
-			count.Add(1)
-		})
-		require.NoError(t, err)
-		defer cancel()
 		peer, err := db.InsertReplica(context.Background(), database.InsertReplicaParams{
 			ID:        uuid.New(),
 			CreatedAt: database.Now(),
@@ -113,16 +126,15 @@ func TestReplica(t *testing.T) {
 		})
 		require.NoError(t, err)
 		server, err := replicasync.New(context.Background(), slogtest.Make(t, nil), db, pubsub, replicasync.Options{
-			ID:          uuid.New(),
-			PeerTimeout: 1 * time.Millisecond,
+			ID:           uuid.New(),
+			PeerTimeout:  1 * time.Millisecond,
+			RelayAddress: "http://169.254.169.254",
 		})
 		require.NoError(t, err)
 		require.Len(t, server.Regional(), 1)
 		require.Equal(t, peer.ID, server.Regional()[0].ID)
 		require.True(t, server.Self().Error.Valid)
 		require.Contains(t, server.Self().Error.String, "Failed to dial peers")
-		// Once for the initial creation of a replica, and another time for the error.
-		require.Equal(t, int32(2), count.Load())
 		_ = server.Close()
 	})
 	t.Run("RefreshOnPublish", func(t *testing.T) {

diff --git a/site/src/api/typesGenerated.ts b/site/src/api/typesGenerated.ts
@@ -268,6 +268,7 @@ export interface DeploymentFlags {
   readonly derp_server_region_code: StringFlag
   readonly derp_server_region_name: StringFlag
   readonly derp_server_stun_address: StringArrayFlag
+  readonly derp_server_relay_address: StringFlag
   readonly derp_config_url: StringFlag
   readonly derp_config_path: StringFlag
   readonly prom_enabled: BoolFlag
@@ -522,6 +523,16 @@ export interface PutExtendWorkspaceRequest {
   readonly deadline: string
 }
 
+// From codersdk/replicas.go
+export interface Replica {
+  readonly id: string
+  readonly hostname: string
+  readonly created_at: string
+  readonly relay_address: string
+  readonly region_id: number
+  readonly error: string
+}
+
 // From codersdk/error.go
 export interface Response {
   readonly message: string