[ci skip] commit wip

johnstcn · johnstcn · commit a17ca5838ae6 · 2025-02-04T12:11:08.000Z
diff --git a/agent/containers.go b/agent/containers.go
@@ -133,11 +133,12 @@ func (*dockerCLIContainerLister) List(ctx context.Context) ([]codersdk.Workspace
 
 func convertDockerCLIList(in dockerCLIList) codersdk.WorkspaceAgentContainer {
 	out := codersdk.WorkspaceAgentContainer{
-		FriendlyName: in.Names,
-		ID:           in.ID,
-		Image:        in.Image,
-		Labels:       map[string]string{},
+		ID:     in.ID,
+		Image:  in.Image,
+		Labels: map[string]string{},
 	}
+	// Remove the leading slash from the container name
+	out.FriendlyName = strings.TrimPrefix(in.Names, "/")
 
 	createdAt, err := time.Parse(dockerCreatedAtTimeFormat, in.CreatedAt)
 	if err != nil {
diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -1212,6 +1212,7 @@ func New(options *Options) *API {
 				r.Get("/listening-ports", api.workspaceAgentListeningPorts)
 				r.Get("/connection", api.workspaceAgentConnection)
 				r.Get("/coordinate", api.workspaceAgentClientCoordinate)
+				r.Get("/containers", api.workspaceAgentListContainers)
 
 				// PTY is part of workspaceAppServer.
 			})
diff --git a/coderd/workspaceagents.go b/coderd/workspaceagents.go
@@ -678,6 +678,61 @@ func (api *API) workspaceAgentListeningPorts(rw http.ResponseWriter, r *http.Req
 	httpapi.Write(ctx, rw, http.StatusOK, portsResponse)
 }
 
+func (api *API) workspaceAgentListContainers(rw http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	workspaceAgent := httpmw.WorkspaceAgentParam(r)
+
+	// If the agent is unreachable, the request will hang. Assume that if we
+	// don't get a response after 30s that the agent is unreachable.
+	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+	apiAgent, err := db2sdk.WorkspaceAgent(
+		api.DERPMap(),
+		*api.TailnetCoordinator.Load(),
+		workspaceAgent,
+		nil,
+		nil,
+		nil,
+		api.AgentInactiveDisconnectTimeout,
+		api.DeploymentValues.AgentFallbackTroubleshootingURL.String(),
+	)
+	if err != nil {
+		httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
+			Message: "Internal error reading workspace agent.",
+			Detail:  err.Error(),
+		})
+		return
+	}
+	if apiAgent.Status != codersdk.WorkspaceAgentConnected {
+		httpapi.Write(ctx, rw, http.StatusBadRequest, codersdk.Response{
+			Message: fmt.Sprintf("Agent state is %q, it must be in the %q state.", apiAgent.Status, codersdk.WorkspaceAgentConnected),
+		})
+		return
+	}
+
+	agentConn, release, err := api.agentProvider.AgentConn(ctx, workspaceAgent.ID)
+	if err != nil {
+		httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
+			Message: "Internal error dialing workspace agent.",
+			Detail:  err.Error(),
+		})
+		return
+	}
+	defer release()
+
+	// Get a list of containers that the agent is able to detect
+	containers, err := agentConn.ListContainers(ctx)
+	if err != nil {
+		httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
+			Message: "Internal error fetching containers.",
+			Detail:  err.Error(),
+		})
+		return
+	}
+
+	httpapi.Write(ctx, rw, http.StatusOK, containers)
+}
+
 // @Summary Get connection info for workspace agent
 // @ID get-connection-info-for-workspace-agent
 // @Security CoderSessionToken
diff --git a/coderd/workspaceagents_test.go b/coderd/workspaceagents_test.go
@@ -16,6 +16,8 @@ import (
 
 	"github.com/go-jose/go-jose/v4/jwt"
 	"github.com/google/uuid"
+	"github.com/ory/dockertest/v3"
+	"github.com/ory/dockertest/v3/docker"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/xerrors"
@@ -1053,6 +1055,61 @@ func TestWorkspaceAgentListeningPorts(t *testing.T) {
 	})
 }
 
+func TestWorkspaceAgentContainers(t *testing.T) {
+	t.Parallel()
+
+	pool, err := dockertest.NewPool("")
+	require.NoError(t, err, "Could not connect to docker")
+	testLabelValue := uuid.New().String()
+	ct, err := pool.RunWithOptions(&dockertest.RunOptions{
+		Repository: "busybox",
+		Tag:        "latest",
+		Cmd:        []string{"sleep", "infnity"},
+		Labels:     map[string]string{"com.coder.test": testLabelValue},
+	}, func(config *docker.HostConfig) {
+		config.AutoRemove = true
+		config.RestartPolicy = docker.RestartPolicy{Name: "no"}
+	})
+	require.NoError(t, err, "Could not start test docker container")
+	t.Cleanup(func() {
+		assert.NoError(t, pool.Purge(ct), "Could not purge resource")
+	})
+
+	client, db := coderdtest.NewWithDatabase(t, &coderdtest.Options{})
+
+	user := coderdtest.CreateFirstUser(t, client)
+	r := dbfake.WorkspaceBuild(t, db, database.WorkspaceTable{
+		OrganizationID: user.OrganizationID,
+		OwnerID:        user.UserID,
+	}).WithAgent(func(agents []*proto.Agent) []*proto.Agent {
+		return agents
+	}).Do()
+	_ = agenttest.New(t, client.URL, r.AgentToken, func(_ *agent.Options) {})
+	resources := coderdtest.NewWorkspaceAgentWaiter(t, client, r.Workspace.ID).Wait()
+	require.Len(t, resources, 1, "expected one resource")
+	require.Len(t, resources[0].Agents, 1, "expected one agent")
+	agentID := resources[0].Agents[0].ID
+
+	ctx := testutil.Context(t, testutil.WaitLong)
+	res, err := client.WorkspaceAgentListContainers(ctx, agentID)
+	require.NoError(t, err, "failed to list containers")
+	require.NotEmpty(t, res.Containers, "expected to find containers")
+
+	var found bool
+	for _, c := range res.Containers {
+		if c.ID == ct.Container.ID {
+			found = true
+			assert.Equal(t, ct.Container.ID, c.ID)
+			assert.Equal(t, "busybox:latest", c.Image)
+			// The container name is prefixed with a slash.
+			assert.Equal(t, strings.TrimPrefix(ct.Container.Name, "/"), c.FriendlyName)
+			assert.Equal(t, ct.Container.Config.Labels, c.Labels)
+			break
+		}
+	}
+	require.True(t, found, "expected to find container")
+}
+
 func TestWorkspaceAgentAppHealth(t *testing.T) {
 	t.Parallel()
 	client, db := coderdtest.NewWithDatabase(t, nil)
diff --git a/codersdk/workspaceagents.go b/codersdk/workspaceagents.go
@@ -405,9 +405,10 @@ type WorkspaceAgentContainer struct {
 	Labels map[string]string `json:"labels"`
 }
 
+// WorkspaceAgentListContainersResponse is the response to the list containers
+// request.
 type WorkspaceAgentListContainersResponse struct {
 	Containers []WorkspaceAgentContainer `json:"containers"`
-	Mtime      time.Time                 `json:"mtime"`
 }
 
 // WorkspaceAgentListContainers returns a list of containers that are currently
@@ -421,9 +422,9 @@ func (c *Client) WorkspaceAgentListContainers(ctx context.Context, agentID uuid.
 	if res.StatusCode != http.StatusOK {
 		return WorkspaceAgentListContainersResponse{}, ReadBodyAsError(res)
 	}
-	var resp WorkspaceAgentListContainersResponse
+	var cr WorkspaceAgentListContainersResponse
 
-	return resp, json.NewDecoder(res.Body).Decode(&resp.Containers)
+	return cr, json.NewDecoder(res.Body).Decode(&cr)
 }
 
 //nolint:revive // Follow is a control flag on the server as well.
diff --git a/codersdk/workspacesdk/agentconn.go b/codersdk/workspacesdk/agentconn.go
@@ -336,6 +336,22 @@ func (c *AgentConn) PrometheusMetrics(ctx context.Context) ([]byte, error) {
 	return bs, nil
 }
 
+// ListContainers returns a response from the agent's containers endpoint
+func (c *AgentConn) ListContainers(ctx context.Context) (codersdk.WorkspaceAgentListContainersResponse, error) {
+	ctx, span := tracing.StartSpan(ctx)
+	defer span.End()
+	res, err := c.apiRequest(ctx, http.MethodGet, "/api/v0/containers", nil)
+	if err != nil {
+		return codersdk.WorkspaceAgentListContainersResponse{}, xerrors.Errorf("do request: %w", err)
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return codersdk.WorkspaceAgentListContainersResponse{}, codersdk.ReadBodyAsError(res)
+	}
+	var resp codersdk.WorkspaceAgentListContainersResponse
+	return resp, json.NewDecoder(res.Body).Decode(&resp.Containers)
+}
+
 // apiRequest makes a request to the workspace agent's HTTP API server.
 func (c *AgentConn) apiRequest(ctx context.Context, method, path string, body io.Reader) (*http.Response, error) {
 	ctx, span := tracing.StartSpan(ctx)

Original file line number	Diff line number	Diff line change
`@@ -405,9 +405,10 @@ type WorkspaceAgentContainer struct {`
`405`	`405`	Labels map[string]string `json:"labels"`
`406`	`406`	`}`
`407`	`407`
	`408`	`+// WorkspaceAgentListContainersResponse is the response to the list containers`
	`409`	`+// request.`
`408`	`410`	`type WorkspaceAgentListContainersResponse struct {`
`409`	`411`	Containers []WorkspaceAgentContainer `json:"containers"`
`410`		- Mtime time.Time `json:"mtime"`
`411`	`412`	`}`
`412`	`413`
`413`	`414`	`// WorkspaceAgentListContainers returns a list of containers that are currently`
`@@ -421,9 +422,9 @@ func (c *Client) WorkspaceAgentListContainers(ctx context.Context, agentID uuid.`
`421`	`422`	`if res.StatusCode != http.StatusOK {`
`422`	`423`	`return WorkspaceAgentListContainersResponse{}, ReadBodyAsError(res)`
`423`	`424`	`}`
`424`		`- var resp WorkspaceAgentListContainersResponse`
	`425`	`+ var cr WorkspaceAgentListContainersResponse`
`425`	`426`
`426`		`- return resp, json.NewDecoder(res.Body).Decode(&resp.Containers)`
	`427`	`+ return cr, json.NewDecoder(res.Body).Decode(&cr)`
`427`	`428`	`}`
`428`	`429`
`429`	`430`	`//nolint:revive // Follow is a control flag on the server as well.`