2022-04-11 16:06:15 -05:00
package coderd
import (
2026-01-22 22:47:49 -08:00
"bytes"
2022-06-03 12:50:10 +03:00
"context"
2022-04-11 16:06:15 -05:00
"database/sql"
"encoding/json"
2022-10-24 19:46:24 -05:00
"errors"
2022-04-11 16:06:15 -05:00
"fmt"
2023-08-02 01:31:51 -07:00
"io"
2022-04-11 16:06:15 -05:00
"net/http"
2022-10-12 01:10:02 +10:00
"net/url"
2025-03-03 21:46:49 +08:00
"slices"
2023-08-08 22:10:28 -07:00
"sort"
2022-04-18 17:40:25 -05:00
"strconv"
2022-08-31 20:09:44 -05:00
"strings"
2022-04-11 16:06:15 -05:00
"time"
2025-05-19 12:56:10 +03:00
"github.com/go-chi/chi/v5"
2022-04-29 17:30:10 -05:00
"github.com/google/uuid"
2023-10-09 23:02:16 -05:00
"github.com/sqlc-dev/pqtype"
2023-08-24 15:18:42 -05:00
"golang.org/x/exp/maps"
2023-04-27 12:34:00 +02:00
"golang.org/x/sync/errgroup"
2022-04-11 16:06:15 -05:00
"golang.org/x/xerrors"
2022-08-31 20:09:44 -05:00
"tailscale.com/tailcfg"
2022-04-11 16:06:15 -05:00
2026-01-08 10:29:41 +04:00
"cdr.dev/slog/v3"
2026-02-24 13:26:55 +04:00
"github.com/coder/coder/v2/coderd/agentapi"
2026-01-22 22:47:49 -08:00
"github.com/coder/coder/v2/coderd/agentapi/metadatabatcher"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/database"
2023-12-18 04:53:28 -08:00
"github.com/coder/coder/v2/coderd/database/db2sdk"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/database/dbauthz"
2023-09-01 19:50:12 +03:00
"github.com/coder/coder/v2/coderd/database/dbtime"
2023-09-30 14:30:01 -05:00
"github.com/coder/coder/v2/coderd/externalauth"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/httpapi"
"github.com/coder/coder/v2/coderd/httpmw"
2025-04-15 13:27:23 +02:00
"github.com/coder/coder/v2/coderd/httpmw/loggermw"
2024-10-25 17:14:35 +01:00
"github.com/coder/coder/v2/coderd/jwtutils"
2025-05-14 14:15:36 +02:00
"github.com/coder/coder/v2/coderd/prebuilds"
2024-11-01 14:53:53 +11:00
"github.com/coder/coder/v2/coderd/rbac"
2024-05-15 09:46:35 -05:00
"github.com/coder/coder/v2/coderd/rbac/policy"
2025-03-24 16:02:33 +04:00
"github.com/coder/coder/v2/coderd/telemetry"
2025-02-10 11:29:30 +00:00
maputil "github.com/coder/coder/v2/coderd/util/maps"
2024-11-01 14:17:05 +11:00
"github.com/coder/coder/v2/coderd/wspubsub"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/codersdk/agentsdk"
2024-03-26 12:44:31 -05:00
"github.com/coder/coder/v2/codersdk/workspacesdk"
2024-12-03 10:12:30 +04:00
"github.com/coder/coder/v2/codersdk/wsjson"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/tailnet"
2024-01-23 14:27:49 +04:00
"github.com/coder/coder/v2/tailnet/proto"
2026-01-08 15:24:11 +04:00
"github.com/coder/websocket"
2022-04-11 16:06:15 -05:00
)
2023-01-13 12:27:21 +01:00
// @Summary Get workspace agent by ID
// @ID get-workspace-agent-by-id
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
// @Success 200 {object} codersdk.WorkspaceAgent
// @Router /workspaceagents/{workspaceagent} [get]
2022-05-25 22:14:08 -05:00
func ( api * API ) workspaceAgent ( rw http . ResponseWriter , r * http . Request ) {
2023-09-25 16:47:17 -05:00
var (
2026-01-19 12:36:33 +00:00
ctx = r . Context ()
waws = httpmw . WorkspaceAgentAndWorkspaceParam ( r )
2023-09-25 16:47:17 -05:00
dbApps [] database . WorkspaceApp
scripts [] database . WorkspaceAgentScript
logSources [] database . WorkspaceAgentLogSource
)
var eg errgroup . Group
eg . Go ( func () ( err error ) {
2026-01-19 12:36:33 +00:00
dbApps , err = api . Database . GetWorkspaceAppsByAgentID ( ctx , waws . WorkspaceAgent . ID )
2023-09-25 16:47:17 -05:00
return err
})
eg . Go ( func () ( err error ) {
2023-10-04 15:50:51 +01:00
//nolint:gocritic // TODO: can we make this not require system restricted?
2026-01-19 12:36:33 +00:00
scripts , err = api . Database . GetWorkspaceAgentScriptsByAgentIDs ( dbauthz . AsSystemRestricted ( ctx ), [] uuid . UUID { waws . WorkspaceAgent . ID })
2023-09-25 16:47:17 -05:00
return err
})
eg . Go ( func () ( err error ) {
2023-10-04 15:50:51 +01:00
//nolint:gocritic // TODO: can we make this not require system restricted?
2026-01-19 12:36:33 +00:00
logSources , err = api . Database . GetWorkspaceAgentLogSourcesByAgentIDs ( dbauthz . AsSystemRestricted ( ctx ), [] uuid . UUID { waws . WorkspaceAgent . ID })
2023-09-25 16:47:17 -05:00
return err
})
err := eg . Wait ()
2023-12-12 15:14:32 -06:00
if httpapi . Is404Error ( err ) {
httpapi . ResourceNotFound ( rw )
return
}
2023-09-25 16:47:17 -05:00
if err != nil {
2022-09-21 17:07:00 -05:00
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
2023-09-25 16:47:17 -05:00
Message : "Internal error fetching workspace agent." ,
2022-06-07 09:33:06 -05:00
Detail : err . Error (),
2022-06-04 15:13:37 -05:00
})
return
}
2023-09-12 15:25:10 +02:00
2025-03-31 10:55:44 -04:00
appIDs := [] uuid . UUID {}
for _ , app := range dbApps {
appIDs = append ( appIDs , app . ID )
}
// nolint:gocritic // This is a system restricted operation.
statuses , err := api . Database . GetWorkspaceAppStatusesByAppIDs ( dbauthz . AsSystemRestricted ( ctx ), appIDs )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error fetching workspace app statuses." ,
Detail : err . Error (),
})
return
}
2023-12-18 04:53:28 -08:00
apiAgent , err := db2sdk . WorkspaceAgent (
2026-01-19 12:36:33 +00:00
api . DERPMap (), * api . TailnetCoordinator . Load (), waws . WorkspaceAgent , db2sdk . Apps ( dbApps , statuses , waws . WorkspaceAgent , waws . OwnerUsername , waws . WorkspaceTable ), convertScripts ( scripts ), convertLogSources ( logSources ), api . AgentInactiveDisconnectTimeout ,
2023-03-07 15:10:01 -06:00
api . DeploymentValues . AgentFallbackTroubleshootingURL . String (),
)
2022-04-11 16:06:15 -05:00
if err != nil {
2022-09-21 17:07:00 -05:00
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
2022-06-07 09:33:06 -05:00
Message : "Internal error reading workspace agent." ,
2022-06-03 16:48:09 -05:00
Detail : err . Error (),
2022-04-11 16:06:15 -05:00
})
return
}
2022-04-12 10:17:33 -05:00
2022-09-21 17:07:00 -05:00
httpapi . Write ( ctx , rw , http . StatusOK , apiAgent )
2022-04-11 16:06:15 -05:00
}
2023-10-31 10:08:43 +04:00
const AgentAPIVersionREST = "1.0"
2023-07-28 09:57:23 -06:00
// @Summary Patch workspace agent logs
// @ID patch-workspace-agent-logs
2023-03-23 14:09:13 -05:00
// @Security CoderSessionToken
// @Accept json
// @Produce json
// @Tags Agents
2023-07-28 09:57:23 -06:00
// @Param request body agentsdk.PatchLogs true "logs"
2023-03-23 14:09:13 -05:00
// @Success 200 {object} codersdk.Response
2023-07-28 09:57:23 -06:00
// @Router /workspaceagents/me/logs [patch]
func ( api * API ) patchWorkspaceAgentLogs ( rw http . ResponseWriter , r * http . Request ) {
2023-03-23 14:09:13 -05:00
ctx := r . Context ()
workspaceAgent := httpmw . WorkspaceAgent ( r )
2023-07-28 09:57:23 -06:00
var req agentsdk . PatchLogs
2023-03-23 14:09:13 -05:00
if ! httpapi . Read ( ctx , rw , r , & req ) {
return
}
if len ( req . Logs ) == 0 {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "No logs provided." ,
})
return
}
2023-09-25 16:47:17 -05:00
// This is to support the legacy API where the log source ID was
// not provided in the request body. We default to the external
// log source in this case.
if req . LogSourceID == uuid . Nil {
// Use the external log source
externalSources , err := api . Database . InsertWorkspaceAgentLogSources ( ctx , database . InsertWorkspaceAgentLogSourcesParams {
WorkspaceAgentID : workspaceAgent . ID ,
CreatedAt : dbtime . Now (),
ID : [] uuid . UUID { agentsdk . ExternalLogSourceID },
DisplayName : [] string { "External" },
Icon : [] string { "/emojis/1f310.png" },
})
if database . IsUniqueViolation ( err , database . UniqueWorkspaceAgentLogSourcesPkey ) {
err = nil
req . LogSourceID = agentsdk . ExternalLogSourceID
}
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Failed to create external log source." ,
Detail : err . Error (),
})
return
}
if len ( externalSources ) == 1 {
req . LogSourceID = externalSources [ 0 ]. ID
}
}
2023-03-23 14:09:13 -05:00
output := make ([] string , 0 )
2023-04-10 14:29:59 -05:00
level := make ([] database . LogLevel , 0 )
2023-03-23 14:09:13 -05:00
outputLength := 0
2023-06-20 14:41:55 +03:00
for _ , logEntry := range req . Logs {
2023-04-27 12:34:00 +02:00
output = append ( output , logEntry . Output )
outputLength += len ( logEntry . Output )
if logEntry . Level == "" {
2023-04-10 14:29:59 -05:00
// Default to "info" to support older agents that didn't have the level field.
2023-04-27 12:34:00 +02:00
logEntry . Level = codersdk . LogLevelInfo
2023-04-10 14:29:59 -05:00
}
2023-04-27 12:34:00 +02:00
parsedLevel := database . LogLevel ( logEntry . Level )
2023-04-10 14:29:59 -05:00
if ! parsedLevel . Valid () {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Invalid log level provided." ,
2023-04-27 12:34:00 +02:00
Detail : fmt . Sprintf ( "invalid log level: %q" , logEntry . Level ),
2023-04-10 14:29:59 -05:00
})
return
}
level = append ( level , parsedLevel )
2023-03-23 14:09:13 -05:00
}
2023-06-16 17:14:22 +03:00
2023-07-28 09:57:23 -06:00
logs , err := api . Database . InsertWorkspaceAgentLogs ( ctx , database . InsertWorkspaceAgentLogsParams {
2025-03-26 01:56:39 -05:00
AgentID : workspaceAgent . ID ,
CreatedAt : dbtime . Now (),
Output : output ,
Level : level ,
LogSourceID : req . LogSourceID ,
// #nosec G115 - Log output length is limited and fits in int32
2023-07-18 09:57:29 -06:00
OutputLength : int32 ( outputLength ),
})
2023-03-23 14:09:13 -05:00
if err != nil {
2023-07-28 09:57:23 -06:00
if ! database . IsWorkspaceAgentLogsLimitError ( err ) {
2023-07-18 09:57:29 -06:00
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
2023-07-28 09:57:23 -06:00
Message : "Failed to upload logs" ,
2023-06-16 17:14:22 +03:00
Detail : err . Error (),
})
return
}
2023-07-28 09:57:23 -06:00
if workspaceAgent . LogsOverflowed {
2023-03-23 14:09:13 -05:00
httpapi . Write ( ctx , rw , http . StatusRequestEntityTooLarge , codersdk . Response {
2023-07-28 09:57:23 -06:00
Message : "Logs limit exceeded" ,
2023-03-23 14:09:13 -05:00
Detail : err . Error (),
})
return
}
2023-07-28 09:57:23 -06:00
err := api . Database . UpdateWorkspaceAgentLogOverflowByID ( ctx , database . UpdateWorkspaceAgentLogOverflowByIDParams {
ID : workspaceAgent . ID ,
LogsOverflowed : true ,
2023-07-18 09:57:29 -06:00
})
if err != nil {
// We don't want to return here, because the agent will retry
// on failure and this isn't a huge deal. The overflow state
// is just a hint to the user that the logs are incomplete.
2023-07-28 09:57:23 -06:00
api . Logger . Warn ( ctx , "failed to update workspace agent log overflow" , slog . Error ( err ))
2023-07-18 09:57:29 -06:00
}
2024-11-01 14:17:05 +11:00
workspace , err := api . Database . GetWorkspaceByAgentID ( ctx , workspaceAgent . ID )
2023-07-18 09:57:29 -06:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
2024-11-01 14:17:05 +11:00
Message : "Failed to get workspace." ,
2023-07-18 09:57:29 -06:00
Detail : err . Error (),
})
return
}
2024-11-01 14:17:05 +11:00
api . publishWorkspaceUpdate ( ctx , workspace . OwnerID , wspubsub . WorkspaceEvent {
Kind : wspubsub . WorkspaceEventKindAgentLogsOverflow ,
WorkspaceID : workspace . ID ,
AgentID : & workspaceAgent . ID ,
})
2023-07-18 09:57:29 -06:00
httpapi . Write ( ctx , rw , http . StatusRequestEntityTooLarge , codersdk . Response {
2023-07-28 09:57:23 -06:00
Message : "Logs limit exceeded" ,
2023-03-23 14:09:13 -05:00
})
return
}
2023-06-16 17:14:22 +03:00
2023-06-20 14:41:55 +03:00
lowestLogID := logs [ 0 ]. ID
2023-06-16 17:14:22 +03:00
// Publish by the lowest log ID inserted so the
// log stream will fetch everything from that point.
2023-07-28 09:57:23 -06:00
api . publishWorkspaceAgentLogsUpdate ( ctx , workspaceAgent . ID , agentsdk . LogsNotifyMessage {
2023-06-20 14:41:55 +03:00
CreatedAfter : lowestLogID - 1 ,
2023-06-16 17:14:22 +03:00
})
2023-07-28 09:57:23 -06:00
if workspaceAgent . LogsLength == 0 {
2023-03-23 14:09:13 -05:00
// If these are the first logs being appended, we publish a UI update
// to notify the UI that logs are now available.
2024-11-01 14:17:05 +11:00
workspace , err := api . Database . GetWorkspaceByAgentID ( ctx , workspaceAgent . ID )
2023-03-23 14:09:13 -05:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
2024-11-01 14:17:05 +11:00
Message : "Failed to get workspace." ,
2023-03-23 14:09:13 -05:00
Detail : err . Error (),
})
return
}
2024-11-01 14:17:05 +11:00
api . publishWorkspaceUpdate ( ctx , workspace . OwnerID , wspubsub . WorkspaceEvent {
Kind : wspubsub . WorkspaceEventKindAgentFirstLogs ,
WorkspaceID : workspace . ID ,
AgentID : & workspaceAgent . ID ,
})
2023-03-23 14:09:13 -05:00
}
httpapi . Write ( ctx , rw , http . StatusOK , nil )
}
2025-03-31 10:55:44 -04:00
// @Summary Patch workspace agent app status
// @ID patch-workspace-agent-app-status
// @Security CoderSessionToken
// @Accept json
// @Produce json
// @Tags Agents
// @Param request body agentsdk.PatchAppStatus true "app status"
// @Success 200 {object} codersdk.Response
// @Router /workspaceagents/me/app-status [patch]
2026-02-24 13:26:55 +04:00
// @Deprecated Use UpdateAppStatus on the Agent API instead.
2025-03-31 10:55:44 -04:00
func ( api * API ) patchWorkspaceAgentAppStatus ( rw http . ResponseWriter , r * http . Request ) {
ctx := r . Context ()
workspaceAgent := httpmw . WorkspaceAgent ( r )
var req agentsdk . PatchAppStatus
if ! httpapi . Read ( ctx , rw , r , & req ) {
return
}
workspace , err := api . Database . GetWorkspaceByAgentID ( ctx , workspaceAgent . ID )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Failed to get workspace." ,
Detail : err . Error (),
})
return
}
2026-02-24 13:26:55 +04:00
// This functionality has been moved to the AppsAPI in the agentapi. We keep this HTTP handler around for back
// compatibility with older agents. We'll translate the request into the protobuf so there is only one primary
// implementation.
appAPI := & agentapi . AppsAPI {
AgentFn : func ( context . Context ) ( database . WorkspaceAgent , error ) {
return workspaceAgent , nil
2025-03-31 10:55:44 -04:00
},
2026-02-24 13:26:55 +04:00
Database : api . Database ,
Log : api . Logger ,
PublishWorkspaceUpdateFn : func ( ctx context . Context , agent * database . WorkspaceAgent , kind wspubsub . WorkspaceEventKind ) error {
api . publishWorkspaceUpdate ( ctx , workspace . OwnerID , wspubsub . WorkspaceEvent {
Kind : kind ,
WorkspaceID : workspace . ID ,
AgentID : & agent . ID ,
})
return nil
},
NotificationsEnqueuer : api . NotificationsEnqueuer ,
Clock : api . Clock ,
}
protoReq , err := agentsdk . ProtoFromPatchAppStatus ( req )
2025-03-31 10:55:44 -04:00
if err != nil {
2026-02-24 13:26:55 +04:00
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Failed to parse request." ,
2025-03-31 10:55:44 -04:00
Detail : err . Error (),
})
return
}
2026-02-24 13:26:55 +04:00
_ , err = appAPI . UpdateAppStatus ( r . Context (), protoReq )
if err != nil {
sdkErr := new ( codersdk . Error )
if xerrors . As ( err , & sdkErr ) {
httpapi . Write ( ctx , rw , sdkErr . StatusCode (), sdkErr . Response )
return
2026-01-22 13:52:32 +02:00
}
2026-02-24 13:26:55 +04:00
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Failed to update app status." ,
Detail : err . Error (),
})
return
2026-01-22 13:52:32 +02:00
}
2025-03-31 10:55:44 -04:00
httpapi . Write ( ctx , rw , http . StatusOK , nil )
}
2023-07-28 09:57:23 -06:00
// workspaceAgentLogs returns the logs associated with a workspace agent
2023-03-23 14:09:13 -05:00
//
2023-07-28 09:57:23 -06:00
// @Summary Get logs by workspace agent
// @ID get-logs-by-workspace-agent
2023-03-23 14:09:13 -05:00
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
// @Param before query int false "Before log id"
// @Param after query int false "After log id"
// @Param follow query bool false "Follow log stream"
2023-06-20 16:29:32 +03:00
// @Param no_compression query bool false "Disable compression for WebSocket connection"
2026-02-03 09:45:23 +00:00
// @Param format query string false "Log output format. Accepted: 'json' (default), 'text' (plain text with RFC3339 timestamps and ANSI colors). Not supported with follow=true." Enums(json,text)
2023-07-28 09:57:23 -06:00
// @Success 200 {array} codersdk.WorkspaceAgentLog
// @Router /workspaceagents/{workspaceagent}/logs [get]
func ( api * API ) workspaceAgentLogs ( rw http . ResponseWriter , r * http . Request ) {
2023-03-23 14:09:13 -05:00
// This mostly copies how provisioner job logs are streamed!
var (
2026-01-19 12:36:33 +00:00
ctx = r . Context ()
waws = httpmw . WorkspaceAgentAndWorkspaceParam ( r )
logger = api . Logger . With ( slog . F ( "workspace_agent_id" , waws . WorkspaceAgent . ID ))
follow = r . URL . Query (). Has ( "follow" )
afterRaw = r . URL . Query (). Get ( "after" )
noCompression = r . URL . Query (). Has ( "no_compression" )
2026-02-03 09:45:23 +00:00
format = r . URL . Query (). Get ( "format" )
2023-03-23 14:09:13 -05:00
)
2026-02-03 09:45:23 +00:00
// Validate format parameter.
if format == "" {
format = "json"
}
if format != "json" && format != "text" {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Invalid format parameter." ,
Detail : "Allowed values are \"json\" and \"text\"." ,
})
return
}
// Text format is not supported with streaming.
if format == "text" && follow {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Text format is not supported with follow mode." ,
Detail : "Use format=json or omit the follow parameter." ,
})
return
}
2023-03-23 14:09:13 -05:00
var after int64
// Only fetch logs created after the time provided.
if afterRaw != "" {
var err error
after , err = strconv . ParseInt ( afterRaw , 10 , 64 )
2023-06-16 17:14:22 +03:00
if err != nil || after < 0 {
2023-03-23 14:09:13 -05:00
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
2023-06-16 17:14:22 +03:00
Message : "Query param \"after\" must be an integer greater than or equal to zero." ,
2023-03-23 14:09:13 -05:00
Validations : [] codersdk . ValidationError {
2023-06-16 17:14:22 +03:00
{ Field : "after" , Detail : "Must be an integer greater than or equal to zero" },
2023-03-23 14:09:13 -05:00
},
})
return
}
}
2023-07-28 09:57:23 -06:00
logs , err := api . Database . GetWorkspaceAgentLogsAfter ( ctx , database . GetWorkspaceAgentLogsAfterParams {
2026-01-19 12:36:33 +00:00
AgentID : waws . WorkspaceAgent . ID ,
2023-03-23 14:09:13 -05:00
CreatedAfter : after ,
})
if errors . Is ( err , sql . ErrNoRows ) {
err = nil
}
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error fetching provisioner logs." ,
Detail : err . Error (),
})
return
}
if logs == nil {
2023-07-28 09:57:23 -06:00
logs = [] database . WorkspaceAgentLog {}
2023-03-23 14:09:13 -05:00
}
if ! follow {
2026-02-03 09:45:23 +00:00
if format == "text" {
sids , err := api . Database . GetWorkspaceAgentLogSourcesByAgentIDs ( ctx , [] uuid . UUID { waws . WorkspaceAgent . ID })
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error fetching workspace agent log sources." ,
Detail : err . Error (),
})
return
}
lsids := make ( map [ uuid . UUID ] string , len ( sids ))
for _ , sid := range sids {
lsids [ sid . ID ] = sid . DisplayName
}
rw . Header (). Set ( "Content-Type" , "text/plain; charset=utf-8" )
rw . WriteHeader ( http . StatusOK )
for _ , log := range logs {
_ , _ = rw . Write ([] byte ( db2sdk . WorkspaceAgentLog ( log ). Text ( waws . WorkspaceAgent . Name , lsids [ log . LogSourceID ])))
_ , _ = rw . Write ([] byte ( "\n" ))
}
return
}
2023-07-28 09:57:23 -06:00
httpapi . Write ( ctx , rw , http . StatusOK , convertWorkspaceAgentLogs ( logs ))
2023-03-23 14:09:13 -05:00
return
}
api . WebsocketWaitMutex . Lock ()
api . WebsocketWaitGroup . Add ( 1 )
api . WebsocketWaitMutex . Unlock ()
defer api . WebsocketWaitGroup . Done ()
2023-06-20 16:29:32 +03:00
opts := & websocket . AcceptOptions {}
// Allow client to request no compression. This is useful for buggy
// clients or if there's a client/server incompatibility. This is
2024-12-19 00:51:30 +04:00
// needed with e.g. coder/websocket and Safari (confirmed in 16.5).
2023-06-20 16:29:32 +03:00
//
// See:
// * https://github.com/nhooyr/websocket/issues/218
// * https://github.com/gobwas/ws/issues/169
if noCompression {
opts . CompressionMode = websocket . CompressionDisabled
}
conn , err := websocket . Accept ( rw , r , opts )
2023-03-23 14:09:13 -05:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Failed to accept websocket." ,
Detail : err . Error (),
})
return
}
2026-01-26 12:11:40 +00:00
ctx , cancel := context . WithCancel ( ctx )
defer cancel ()
go httpapi . HeartbeatClose ( ctx , api . Logger , cancel , conn )
2023-03-23 14:09:13 -05:00
2024-12-03 10:12:30 +04:00
encoder := wsjson . NewEncoder [[] codersdk . WorkspaceAgentLog ]( conn , websocket . MessageText )
defer encoder . Close ( websocket . StatusNormalClosure )
2023-03-23 14:09:13 -05:00
2023-07-28 09:57:23 -06:00
err = encoder . Encode ( convertWorkspaceAgentLogs ( logs ))
2023-03-23 14:09:13 -05:00
if err != nil {
return
}
2023-06-16 17:14:22 +03:00
2023-06-20 14:41:55 +03:00
lastSentLogID := after
if len ( logs ) > 0 {
lastSentLogID = logs [ len ( logs ) - 1 ]. ID
}
2023-09-19 20:02:27 +03:00
workspaceNotifyCh := make ( chan struct {}, 1 )
2023-06-16 17:14:22 +03:00
notifyCh := make ( chan struct {}, 1 )
// Allow us to immediately check if we missed any logs
// between initial fetch and subscribe.
notifyCh <- struct {}{}
2023-03-23 14:09:13 -05:00
2023-09-19 20:02:27 +03:00
// Subscribe to workspace to detect new builds.
2026-01-19 12:36:33 +00:00
closeSubscribeWorkspace , err := api . Pubsub . SubscribeWithErr ( wspubsub . WorkspaceEventChannel ( waws . WorkspaceTable . OwnerID ),
2024-11-01 14:17:05 +11:00
wspubsub . HandleWorkspaceEvent (
func ( _ context . Context , e wspubsub . WorkspaceEvent , err error ) {
if err != nil {
return
}
2026-01-19 12:36:33 +00:00
if e . Kind == wspubsub . WorkspaceEventKindStateChange && e . WorkspaceID == waws . WorkspaceTable . ID {
2024-11-01 14:17:05 +11:00
select {
case workspaceNotifyCh <- struct {}{}:
default :
}
}
}))
2023-09-19 20:02:27 +03:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Failed to subscribe to workspace for log streaming." ,
Detail : err . Error (),
})
return
}
defer closeSubscribeWorkspace ()
2023-06-16 17:14:22 +03:00
// Subscribe early to prevent missing log events.
2026-01-19 12:36:33 +00:00
closeSubscribe , err := api . Pubsub . Subscribe ( agentsdk . LogsNotifyChannel ( waws . WorkspaceAgent . ID ), func ( _ context . Context , _ [] byte ) {
2023-06-16 17:14:22 +03:00
// The message is not important, we're tracking lastSentLogID manually.
2023-03-23 14:09:13 -05:00
select {
2023-06-16 17:14:22 +03:00
case notifyCh <- struct {}{}:
2023-03-23 14:09:13 -05:00
default :
}
2023-06-16 17:14:22 +03:00
})
2023-03-23 14:09:13 -05:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
2023-09-19 20:02:27 +03:00
Message : "Failed to subscribe to agent for log streaming." ,
2023-03-23 14:09:13 -05:00
Detail : err . Error (),
})
return
}
defer closeSubscribe ()
2023-06-16 17:14:22 +03:00
// Buffer size controls the log prefetch capacity.
2023-07-28 09:57:23 -06:00
bufferedLogs := make ( chan [] database . WorkspaceAgentLog , 8 )
2023-06-16 17:14:22 +03:00
// Check at least once per minute in case we didn't receive a pubsub message.
recheckInterval := time . Minute
t := time . NewTicker ( recheckInterval )
defer t . Stop ()
2025-04-08 10:30:05 +02:00
// Log the request immediately instead of after it completes.
2025-06-12 13:50:50 +03:00
if rl := loggermw . RequestLoggerFromContext ( ctx ); rl != nil {
rl . WriteLog ( ctx , http . StatusAccepted )
}
2025-04-08 10:30:05 +02:00
2023-06-16 17:14:22 +03:00
go func () {
2023-09-19 20:02:27 +03:00
defer func () {
logger . Debug ( ctx , "end log streaming loop" )
close ( bufferedLogs )
}()
logger . Debug ( ctx , "start log streaming loop" , slog . F ( "last_sent_log_id" , lastSentLogID ))
2023-06-20 14:41:55 +03:00
2023-08-28 22:46:42 +03:00
keepGoing := true
for keepGoing {
2023-09-19 20:02:27 +03:00
var (
debugTriggeredBy string
onlyCheckLatestBuild bool
)
2023-06-16 17:14:22 +03:00
select {
case <- ctx . Done ():
return
case <- t . C :
2023-09-19 20:02:27 +03:00
debugTriggeredBy = "timer"
case <- workspaceNotifyCh :
debugTriggeredBy = "workspace"
onlyCheckLatestBuild = true
2023-06-16 17:14:22 +03:00
case <- notifyCh :
2023-09-19 20:02:27 +03:00
debugTriggeredBy = "log"
2023-06-16 17:14:22 +03:00
t . Reset ( recheckInterval )
}
2026-01-19 12:36:33 +00:00
agents , err := api . Database . GetWorkspaceAgentsInLatestBuildByWorkspaceID ( ctx , waws . WorkspaceTable . ID )
2023-09-19 20:02:27 +03:00
if err != nil && ! xerrors . Is ( err , sql . ErrNoRows ) {
2023-08-28 22:46:42 +03:00
if xerrors . Is ( err , context . Canceled ) {
return
}
logger . Warn ( ctx , "failed to get workspace agents in latest build" , slog . Error ( err ))
continue
}
// If the agent is no longer in the latest build, we can stop after
// checking once.
2026-01-19 12:36:33 +00:00
keepGoing = slices . ContainsFunc ( agents , func ( agent database . WorkspaceAgent ) bool { return agent . ID == waws . WorkspaceAgent . ID })
2023-08-28 22:46:42 +03:00
2023-09-19 20:02:27 +03:00
logger . Debug (
ctx ,
"checking for new logs" ,
slog . F ( "triggered_by" , debugTriggeredBy ),
slog . F ( "only_check_latest_build" , onlyCheckLatestBuild ),
slog . F ( "keep_going" , keepGoing ),
slog . F ( "last_sent_log_id" , lastSentLogID ),
slog . F ( "workspace_has_agents" , len ( agents ) > 0 ),
)
if onlyCheckLatestBuild && keepGoing {
continue
}
2023-07-28 09:57:23 -06:00
logs , err := api . Database . GetWorkspaceAgentLogsAfter ( ctx , database . GetWorkspaceAgentLogsAfterParams {
2026-01-19 12:36:33 +00:00
AgentID : waws . WorkspaceAgent . ID ,
2023-06-16 17:14:22 +03:00
CreatedAfter : lastSentLogID ,
})
if err != nil {
if xerrors . Is ( err , context . Canceled ) {
return
}
2023-07-28 09:57:23 -06:00
logger . Warn ( ctx , "failed to get workspace agent logs after" , slog . Error ( err ))
2023-06-16 17:14:22 +03:00
continue
}
if len ( logs ) == 0 {
2023-07-18 09:57:29 -06:00
// Just keep listening - more logs might come in the future!
2023-06-16 17:14:22 +03:00
continue
}
select {
case <- ctx . Done ():
return
case bufferedLogs <- logs :
lastSentLogID = logs [ len ( logs ) - 1 ]. ID
}
}
}()
defer func () {
// Ensure that we don't return until the goroutine has exited.
//nolint:revive // Consume channel to wait until it's closed.
for range bufferedLogs {
}
}()
2023-03-23 14:09:13 -05:00
for {
select {
case <- ctx . Done ():
2023-06-16 17:14:22 +03:00
logger . Debug ( ctx , "job logs context canceled" )
2023-03-23 14:09:13 -05:00
return
case logs , ok := <- bufferedLogs :
2023-06-16 17:14:22 +03:00
if ! ok {
select {
case <- ctx . Done ():
logger . Debug ( ctx , "job logs context canceled" )
default :
logger . Debug ( ctx , "reached the end of published logs" )
}
2023-03-23 14:09:13 -05:00
return
}
2023-07-28 09:57:23 -06:00
err = encoder . Encode ( convertWorkspaceAgentLogs ( logs ))
2023-03-23 14:09:13 -05:00
if err != nil {
return
}
}
}
}
2023-01-13 12:27:21 +01:00
// @Summary Get listening ports for workspace agent
// @ID get-listening-ports-for-workspace-agent
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
2023-01-29 15:47:24 -06:00
// @Success 200 {object} codersdk.WorkspaceAgentListeningPortsResponse
2023-01-13 12:27:21 +01:00
// @Router /workspaceagents/{workspaceagent}/listening-ports [get]
2022-10-06 22:38:22 +10:00
func ( api * API ) workspaceAgentListeningPorts ( rw http . ResponseWriter , r * http . Request ) {
ctx := r . Context ()
2026-01-19 12:36:33 +00:00
waws := httpmw . WorkspaceAgentAndWorkspaceParam ( r )
2022-10-06 22:38:22 +10:00
2024-01-30 13:53:52 -06:00
// 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 ()
2023-12-18 04:53:28 -08:00
apiAgent , err := db2sdk . WorkspaceAgent (
2026-01-19 12:36:33 +00:00
api . DERPMap (), * api . TailnetCoordinator . Load (), waws . WorkspaceAgent , nil , nil , nil , api . AgentInactiveDisconnectTimeout ,
2023-03-07 15:10:01 -06:00
api . DeploymentValues . AgentFallbackTroubleshootingURL . String (),
)
2022-10-06 22:38:22 +10:00
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 {
2023-01-13 14:30:48 +00:00
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
2022-10-06 22:38:22 +10:00
Message : fmt . Sprintf ( "Agent state is %q, it must be in the %q state." , apiAgent . Status , codersdk . WorkspaceAgentConnected ),
})
return
}
2026-01-19 12:36:33 +00:00
agentConn , release , err := api . agentProvider . AgentConn ( ctx , waws . WorkspaceAgent . ID )
2022-10-06 22:38:22 +10:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error dialing workspace agent." ,
Detail : err . Error (),
})
return
}
defer release ()
portsResponse , err := agentConn . ListeningPorts ( ctx )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error fetching listening ports." ,
Detail : err . Error (),
})
return
}
2022-10-12 01:10:02 +10:00
// Get a list of ports that are in-use by applications.
2026-01-19 12:36:33 +00:00
apps , err := api . Database . GetWorkspaceAppsByAgentID ( ctx , waws . WorkspaceAgent . ID )
2022-10-12 01:10:02 +10:00
if xerrors . Is ( err , sql . ErrNoRows ) {
apps = [] database . WorkspaceApp {}
err = nil
}
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error fetching workspace apps." ,
Detail : err . Error (),
})
return
}
appPorts := make ( map [ uint16 ] struct {}, len ( apps ))
for _ , app := range apps {
if ! app . Url . Valid || app . Url . String == "" {
continue
}
u , err := url . Parse ( app . Url . String )
if err != nil {
continue
}
port := u . Port ()
if port == "" {
continue
}
2022-12-20 05:25:59 +10:00
portNum , err := strconv . ParseUint ( port , 10 , 16 )
2022-10-12 01:10:02 +10:00
if err != nil {
continue
}
if portNum < 1 || portNum > 65535 {
continue
}
appPorts [ uint16 ( portNum )] = struct {}{}
}
// Filter out ports that are globally blocked, in-use by applications, or
// common non-HTTP ports such as databases, FTP, SSH, etc.
2023-01-29 15:47:24 -06:00
filteredPorts := make ([] codersdk . WorkspaceAgentListeningPort , 0 , len ( portsResponse . Ports ))
2022-10-12 01:10:02 +10:00
for _ , port := range portsResponse . Ports {
2024-03-26 12:44:31 -05:00
if port . Port < workspacesdk . AgentMinimumListeningPort {
2022-10-12 01:10:02 +10:00
continue
}
if _ , ok := appPorts [ port . Port ]; ok {
continue
}
2024-03-26 12:44:31 -05:00
if _ , ok := workspacesdk . AgentIgnoredListeningPorts [ port . Port ]; ok {
2022-10-12 01:10:02 +10:00
continue
}
filteredPorts = append ( filteredPorts , port )
}
portsResponse . Ports = filteredPorts
2022-10-06 22:38:22 +10:00
httpapi . Write ( ctx , rw , http . StatusOK , portsResponse )
}
2025-07-14 21:35:35 +01:00
// @Summary Watch workspace agent for container updates.
// @ID watch-workspace-agent-for-container-updates
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
// @Success 200 {object} codersdk.WorkspaceAgentListContainersResponse
// @Router /workspaceagents/{workspaceagent}/containers/watch [get]
func ( api * API ) watchWorkspaceAgentContainers ( rw http . ResponseWriter , r * http . Request ) {
var (
2026-01-19 12:36:33 +00:00
ctx = r . Context ()
waws = httpmw . WorkspaceAgentAndWorkspaceParam ( r )
logger = api . Logger . Named ( "agent_container_watcher" ). With ( slog . F ( "agent_id" , waws . WorkspaceAgent . ID ))
2025-07-14 21:35:35 +01:00
)
// 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.
2025-09-05 14:26:46 +01:00
dialCtx , dialCancel := context . WithTimeout ( ctx , 30 * time . Second )
defer dialCancel ()
2025-07-14 21:35:35 +01:00
apiAgent , err := db2sdk . WorkspaceAgent (
api . DERPMap (),
* api . TailnetCoordinator . Load (),
2026-01-19 12:36:33 +00:00
waws . WorkspaceAgent ,
2025-07-14 21:35:35 +01:00
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
}
2026-01-19 12:36:33 +00:00
agentConn , release , err := api . agentProvider . AgentConn ( dialCtx , waws . WorkspaceAgent . ID )
2025-07-14 21:35:35 +01:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error dialing workspace agent." ,
Detail : err . Error (),
})
return
}
defer release ()
2025-09-05 14:26:46 +01:00
containersCh , closer , err := agentConn . WatchContainers ( ctx , logger )
2025-07-14 21:35:35 +01:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error watching agent's containers." ,
Detail : err . Error (),
})
return
}
defer closer . Close ()
conn , err := websocket . Accept ( rw , r , nil )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Failed to upgrade connection to websocket." ,
Detail : err . Error (),
})
return
}
2025-09-05 14:26:46 +01:00
ctx , cancel := context . WithCancel ( r . Context ())
defer cancel ()
2025-07-14 21:35:35 +01:00
// Here we close the websocket for reading, so that the websocket library will handle pings and
// close frames.
_ = conn . CloseRead ( context . Background ())
ctx , wsNetConn := codersdk . WebsocketNetConn ( ctx , conn , websocket . MessageText )
defer wsNetConn . Close ()
2025-09-05 14:26:46 +01:00
go httpapi . HeartbeatClose ( ctx , logger , cancel , conn )
2025-07-14 21:35:35 +01:00
encoder := json . NewEncoder ( wsNetConn )
for {
select {
case <- api . ctx . Done ():
return
case <- ctx . Done ():
return
2025-08-15 12:32:33 +01:00
case containers , ok := <- containersCh :
if ! ok {
return
}
2025-07-14 21:35:35 +01:00
if err := encoder . Encode ( containers ); err != nil {
api . Logger . Error ( ctx , "encode containers" , slog . Error ( err ))
return
}
}
}
}
2025-02-10 11:29:30 +00:00
// @Summary Get running containers for workspace agent
// @ID get-running-containers-for-workspace-agent
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
// @Param label query string true "Labels" format(key=value)
// @Success 200 {object} codersdk.WorkspaceAgentListContainersResponse
// @Router /workspaceagents/{workspaceagent}/containers [get]
func ( api * API ) workspaceAgentListContainers ( rw http . ResponseWriter , r * http . Request ) {
ctx := r . Context ()
2026-01-19 12:36:33 +00:00
waws := httpmw . WorkspaceAgentAndWorkspaceParam ( r )
2025-02-10 11:29:30 +00:00
labelParam , ok := r . URL . Query ()[ "label" ]
if ! ok {
labelParam = [] string {}
}
labels := make ( map [ string ] string , len ( labelParam ) / 2 )
for _ , label := range labelParam {
kvs := strings . Split ( label , "=" )
if len ( kvs ) != 2 {
httpapi . Write ( r . Context (), rw , http . StatusBadRequest , codersdk . Response {
Message : "Invalid label format" ,
Detail : "Labels must be in the format key=value" ,
})
return
}
labels [ kvs [ 0 ]] = kvs [ 1 ]
}
// 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 (),
2026-01-19 12:36:33 +00:00
waws . WorkspaceAgent ,
2025-02-10 11:29:30 +00:00
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
}
2026-01-19 12:36:33 +00:00
agentConn , release , err := api . agentProvider . AgentConn ( ctx , waws . WorkspaceAgent . ID )
2025-02-10 11:29:30 +00:00
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
cts , err := agentConn . ListContainers ( ctx )
if err != nil {
if errors . Is ( err , context . Canceled ) {
httpapi . Write ( ctx , rw , http . StatusRequestTimeout , codersdk . Response {
Message : "Failed to fetch containers from agent." ,
Detail : "Request timed out." ,
})
return
}
2025-04-29 17:53:10 +03:00
// If the agent returns a codersdk.Error, we can return that directly.
if cerr , ok := codersdk . AsError ( err ); ok {
httpapi . Write ( ctx , rw , cerr . StatusCode (), cerr . Response )
return
}
2025-02-10 11:29:30 +00:00
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error fetching containers." ,
Detail : err . Error (),
})
return
}
// Filter in-place by labels
2025-03-19 12:16:14 +02:00
cts . Containers = slices . DeleteFunc ( cts . Containers , func ( ct codersdk . WorkspaceAgentContainer ) bool {
2025-02-10 11:29:30 +00:00
return ! maputil . Subset ( labels , ct . Labels )
})
httpapi . Write ( ctx , rw , http . StatusOK , cts )
}
2025-12-24 12:34:39 +00:00
// @Summary Delete devcontainer for workspace agent
// @ID delete-devcontainer-for-workspace-agent
// @Security CoderSessionToken
// @Tags Agents
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
// @Param devcontainer path string true "Devcontainer ID"
// @Success 204
// @Router /workspaceagents/{workspaceagent}/containers/devcontainers/{devcontainer} [delete]
func ( api * API ) workspaceAgentDeleteDevcontainer ( rw http . ResponseWriter , r * http . Request ) {
ctx := r . Context ()
2026-01-19 12:36:33 +00:00
waws := httpmw . WorkspaceAgentAndWorkspaceParam ( r )
2025-12-24 12:34:39 +00:00
2026-01-19 12:36:33 +00:00
if ! api . Authorize ( r , policy . ActionUpdate , waws . WorkspaceTable ) {
2025-12-24 12:34:39 +00:00
httpapi . Forbidden ( rw )
return
}
devcontainer := chi . URLParam ( r , "devcontainer" )
if devcontainer == "" {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Devcontainer ID is required." ,
Validations : [] codersdk . ValidationError {
{ Field : "devcontainer" , Detail : "Devcontainer ID is required." },
},
})
return
}
apiAgent , err := db2sdk . WorkspaceAgent (
api . DERPMap (),
* api . TailnetCoordinator . Load (),
2026-01-19 12:36:33 +00:00
waws . WorkspaceAgent ,
2025-12-24 12:34:39 +00:00
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
}
// 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.
dialCtx , dialCancel := context . WithTimeout ( ctx , 30 * time . Second )
defer dialCancel ()
2026-01-19 12:36:33 +00:00
agentConn , release , err := api . agentProvider . AgentConn ( dialCtx , waws . WorkspaceAgent . ID )
2025-12-24 12:34:39 +00:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error dialing workspace agent." ,
Detail : err . Error (),
})
return
}
defer release ()
if err = agentConn . DeleteDevcontainer ( ctx , devcontainer ); err != nil {
if errors . Is ( err , context . Canceled ) {
httpapi . Write ( ctx , rw , http . StatusRequestTimeout , codersdk . Response {
Message : "Failed to delete devcontainer from agent." ,
Detail : "Request timed out." ,
})
return
}
// If the agent returns a codersdk.Error, we can return that directly.
if cerr , ok := codersdk . AsError ( err ); ok {
httpapi . Write ( ctx , rw , cerr . StatusCode (), cerr . Response )
return
}
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error deleting devcontainer." ,
Detail : err . Error (),
})
return
}
httpapi . Write ( ctx , rw , http . StatusNoContent , nil )
}
2025-05-19 12:56:10 +03:00
// @Summary Recreate devcontainer for workspace agent
// @ID recreate-devcontainer-for-workspace-agent
// @Security CoderSessionToken
// @Tags Agents
2025-05-26 18:30:52 +03:00
// @Produce json
2025-05-19 12:56:10 +03:00
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
2025-06-26 11:41:57 +01:00
// @Param devcontainer path string true "Devcontainer ID"
2025-05-26 18:30:52 +03:00
// @Success 202 {object} codersdk.Response
2025-06-26 11:41:57 +01:00
// @Router /workspaceagents/{workspaceagent}/containers/devcontainers/{devcontainer}/recreate [post]
2025-05-19 12:56:10 +03:00
func ( api * API ) workspaceAgentRecreateDevcontainer ( rw http . ResponseWriter , r * http . Request ) {
ctx := r . Context ()
2026-01-19 12:36:33 +00:00
waws := httpmw . WorkspaceAgentAndWorkspaceParam ( r )
2025-05-19 12:56:10 +03:00
2025-06-26 11:41:57 +01:00
devcontainer := chi . URLParam ( r , "devcontainer" )
if devcontainer == "" {
2025-05-19 12:56:10 +03:00
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
2025-06-26 11:41:57 +01:00
Message : "Devcontainer ID is required." ,
2025-05-19 12:56:10 +03:00
Validations : [] codersdk . ValidationError {
2025-06-26 11:41:57 +01:00
{ Field : "devcontainer" , Detail : "Devcontainer ID is required." },
2025-05-19 12:56:10 +03:00
},
})
return
}
apiAgent , err := db2sdk . WorkspaceAgent (
api . DERPMap (),
* api . TailnetCoordinator . Load (),
2026-01-19 12:36:33 +00:00
waws . WorkspaceAgent ,
2025-05-19 12:56:10 +03:00
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
}
// 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.
dialCtx , dialCancel := context . WithTimeout ( ctx , 30 * time . Second )
defer dialCancel ()
2026-01-19 12:36:33 +00:00
agentConn , release , err := api . agentProvider . AgentConn ( dialCtx , waws . WorkspaceAgent . ID )
2025-05-19 12:56:10 +03:00
if err != nil {
httpapi . Write ( dialCtx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error dialing workspace agent." ,
Detail : err . Error (),
})
return
}
defer release ()
2025-06-26 11:41:57 +01:00
m , err := agentConn . RecreateDevcontainer ( ctx , devcontainer )
2025-05-19 12:56:10 +03:00
if err != nil {
if errors . Is ( err , context . Canceled ) {
httpapi . Write ( ctx , rw , http . StatusRequestTimeout , codersdk . Response {
Message : "Failed to recreate devcontainer from agent." ,
Detail : "Request timed out." ,
})
return
}
// If the agent returns a codersdk.Error, we can return that directly.
if cerr , ok := codersdk . AsError ( err ); ok {
httpapi . Write ( ctx , rw , cerr . StatusCode (), cerr . Response )
return
}
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error recreating devcontainer." ,
Detail : err . Error (),
})
return
}
2025-05-27 19:42:24 +03:00
httpapi . Write ( ctx , rw , http . StatusAccepted , m )
2025-05-19 12:56:10 +03:00
}
2023-01-13 12:27:21 +01:00
// @Summary Get connection info for workspace agent
// @ID get-connection-info-for-workspace-agent
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
2024-03-26 12:44:31 -05:00
// @Success 200 {object} workspacesdk.AgentConnectionInfo
2023-01-13 12:27:21 +01:00
// @Router /workspaceagents/{workspaceagent}/connection [get]
2022-08-31 20:09:44 -05:00
func ( api * API ) workspaceAgentConnection ( rw http . ResponseWriter , r * http . Request ) {
2022-09-21 17:07:00 -05:00
ctx := r . Context ()
2023-03-21 09:10:22 -05:00
2024-03-26 12:44:31 -05:00
httpapi . Write ( ctx , rw , http . StatusOK , workspacesdk . AgentConnectionInfo {
2023-07-26 09:21:04 -07:00
DERPMap : api . DERPMap (),
2023-08-24 10:22:31 -07:00
DERPForceWebSockets : api . DeploymentValues . DERP . Config . ForceWebSockets . Value (),
2023-06-22 08:02:05 +10:00
DisableDirectConnections : api . DeploymentValues . DERP . Config . BlockDirect . Value (),
2025-04-11 13:09:51 +04:00
HostnameSuffix : api . DeploymentValues . WorkspaceHostnameSuffix . Value (),
2022-08-31 20:09:44 -05:00
})
}
2023-06-21 14:33:19 -05:00
// workspaceAgentConnectionGeneric is the same as workspaceAgentConnection but
// without the workspaceagent path parameter.
//
// @Summary Get connection info for workspace agent generic
// @ID get-connection-info-for-workspace-agent-generic
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
2024-03-26 12:44:31 -05:00
// @Success 200 {object} workspacesdk.AgentConnectionInfo
2023-06-21 14:33:19 -05:00
// @Router /workspaceagents/connection [get]
// @x-apidocgen {"skip": true}
func ( api * API ) workspaceAgentConnectionGeneric ( rw http . ResponseWriter , r * http . Request ) {
ctx := r . Context ()
2024-03-26 12:44:31 -05:00
httpapi . Write ( ctx , rw , http . StatusOK , workspacesdk . AgentConnectionInfo {
2023-07-26 09:21:04 -07:00
DERPMap : api . DERPMap (),
2023-08-24 10:22:31 -07:00
DERPForceWebSockets : api . DeploymentValues . DERP . Config . ForceWebSockets . Value (),
2023-07-26 09:21:04 -07:00
DisableDirectConnections : api . DeploymentValues . DERP . Config . BlockDirect . Value (),
2025-04-11 13:09:51 +04:00
HostnameSuffix : api . DeploymentValues . WorkspaceHostnameSuffix . Value (),
2023-06-21 14:33:19 -05:00
})
}
2023-07-26 09:21:04 -07:00
// @Summary Get DERP map updates
// @ID get-derp-map-updates
// @Security CoderSessionToken
// @Tags Agents
// @Success 101
// @Router /derp-map [get]
func ( api * API ) derpMapUpdates ( rw http . ResponseWriter , r * http . Request ) {
ctx := r . Context ()
api . WebsocketWaitMutex . Lock ()
api . WebsocketWaitGroup . Add ( 1 )
api . WebsocketWaitMutex . Unlock ()
defer api . WebsocketWaitGroup . Done ()
ws , err := websocket . Accept ( rw , r , nil )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Failed to accept websocket." ,
Detail : err . Error (),
})
return
}
2024-12-03 10:12:30 +04:00
encoder := wsjson . NewEncoder [ * tailcfg . DERPMap ]( ws , websocket . MessageBinary )
defer encoder . Close ( websocket . StatusGoingAway )
2023-08-02 01:31:51 -07:00
2025-04-08 10:30:05 +02:00
// Log the request immediately instead of after it completes.
2025-06-12 13:50:50 +03:00
if rl := loggermw . RequestLoggerFromContext ( ctx ); rl != nil {
rl . WriteLog ( ctx , http . StatusAccepted )
}
2025-04-08 10:30:05 +02:00
2023-08-02 01:31:51 -07:00
go func ( ctx context . Context ) {
// TODO(mafredri): Is this too frequent? Use separate ping disconnect timeout?
t := time . NewTicker ( api . AgentConnectionUpdateFrequency )
defer t . Stop ()
for {
select {
case <- t . C :
case <- ctx . Done ():
return
}
2023-08-28 11:13:19 -07:00
ctx , cancel := context . WithTimeout ( ctx , 30 * time . Second )
2023-08-02 01:31:51 -07:00
err := ws . Ping ( ctx )
2023-08-28 11:13:19 -07:00
cancel ()
2023-08-02 01:31:51 -07:00
if err != nil {
2024-12-03 10:12:30 +04:00
_ = ws . Close ( websocket . StatusGoingAway , "ping failed" )
2023-08-02 01:31:51 -07:00
return
}
}
}( ctx )
2023-07-26 09:21:04 -07:00
ticker := time . NewTicker ( api . Options . DERPMapUpdateFrequency )
defer ticker . Stop ()
var lastDERPMap * tailcfg . DERPMap
for {
derpMap := api . DERPMap ()
if lastDERPMap == nil || ! tailnet . CompareDERPMaps ( lastDERPMap , derpMap ) {
2024-12-03 10:12:30 +04:00
err := encoder . Encode ( derpMap )
2023-07-26 09:21:04 -07:00
if err != nil {
return
}
lastDERPMap = derpMap
}
2023-08-01 08:50:43 -07:00
ticker . Reset ( api . Options . DERPMapUpdateFrequency )
2023-07-26 09:21:04 -07:00
select {
case <- ctx . Done ():
return
case <- api . ctx . Done ():
return
case <- ticker . C :
}
}
}
2022-08-31 20:09:44 -05:00
// workspaceAgentClientCoordinate accepts a WebSocket that reads node network updates.
// After accept a PubSub starts listening for new connection node updates
// which are written to the WebSocket.
2023-01-13 12:27:21 +01:00
//
// @Summary Coordinate workspace agent
// @ID coordinate-workspace-agent
// @Security CoderSessionToken
// @Tags Agents
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
// @Success 101
// @Router /workspaceagents/{workspaceagent}/coordinate [get]
2022-08-31 20:09:44 -05:00
func ( api * API ) workspaceAgentClientCoordinate ( rw http . ResponseWriter , r * http . Request ) {
2022-09-21 17:07:00 -05:00
ctx := r . Context ()
2025-04-15 10:55:30 +02:00
// Ensure the database is reachable before proceeding.
_ , err := api . Database . Ping ( ctx )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : codersdk . DatabaseNotReachable ,
Detail : err . Error (),
})
return
}
2023-04-17 14:57:21 -05:00
// This route accepts user API key auth and workspace proxy auth. The moon actor has
// full permissions so should be able to pass this authz check.
2026-01-19 12:36:33 +00:00
waws := httpmw . WorkspaceAgentAndWorkspaceParam ( r )
if ! api . Authorize ( r , policy . ActionSSH , waws ) {
2022-08-31 20:09:44 -05:00
httpapi . ResourceNotFound ( rw )
return
}
2023-04-17 14:57:21 -05:00
2022-09-22 10:14:22 -05:00
// This is used by Enterprise code to control the functionality of this route.
2025-02-21 12:21:20 +11:00
// Namely, disabling the route using `CODER_BROWSER_ONLY`.
2022-09-22 10:14:22 -05:00
override := api . WorkspaceClientCoordinateOverride . Load ()
2022-09-22 11:03:49 -05:00
if override != nil {
overrideFunc := * override
if overrideFunc != nil && overrideFunc ( rw ) {
return
}
2022-09-22 10:14:22 -05:00
}
2022-08-31 20:09:44 -05:00
2023-12-15 14:10:24 +04:00
version := "1.0"
qv := r . URL . Query (). Get ( "version" )
if qv != "" {
version = qv
}
2024-01-23 14:27:49 +04:00
if err := proto . CurrentVersion . Validate ( version ); err != nil {
2023-12-15 14:10:24 +04:00
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Unknown or unsupported API version" ,
Validations : [] codersdk . ValidationError {
{ Field : "version" , Detail : err . Error ()},
},
})
return
}
2024-11-01 14:53:53 +11:00
peerID , err := api . handleResumeToken ( ctx , rw , r )
if err != nil {
// handleResumeToken has already written the response.
return
2024-08-20 17:16:49 +10:00
}
2022-11-16 16:34:06 -06:00
api . WebsocketWaitMutex . Lock ()
api . WebsocketWaitGroup . Add ( 1 )
api . WebsocketWaitMutex . Unlock ()
defer api . WebsocketWaitGroup . Done ()
2022-08-31 20:09:44 -05:00
conn , err := websocket . Accept ( rw , r , nil )
if err != nil {
2022-09-21 17:07:00 -05:00
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
2022-08-31 20:09:44 -05:00
Message : "Failed to accept websocket." ,
Detail : err . Error (),
})
return
}
2024-02-09 11:39:08 +04:00
ctx , wsNetConn := codersdk . WebsocketNetConn ( ctx , conn , websocket . MessageBinary )
2023-02-14 16:42:55 +02:00
defer wsNetConn . Close ()
2026-01-26 12:11:40 +00:00
ctx , cancel := context . WithCancel ( ctx )
defer cancel ()
go httpapi . HeartbeatClose ( ctx , api . Logger , cancel , conn )
2022-10-04 17:10:58 -05:00
2022-08-31 20:09:44 -05:00
defer conn . Close ( websocket . StatusNormalClosure , "" )
2024-11-01 14:53:53 +11:00
err = api . TailnetClientService . ServeClient ( ctx , version , wsNetConn , tailnet . StreamID {
Name : "client" ,
ID : peerID ,
Auth : tailnet . ClientCoordinateeAuth {
2026-01-19 12:36:33 +00:00
AgentID : waws . WorkspaceAgent . ID ,
2024-11-01 14:53:53 +11:00
},
})
2023-12-15 14:10:24 +04:00
if err != nil && ! xerrors . Is ( err , io . EOF ) && ! xerrors . Is ( err , context . Canceled ) {
2022-08-31 20:09:44 -05:00
_ = conn . Close ( websocket . StatusInternalError , err . Error ())
return
}
}
2024-11-01 14:53:53 +11:00
// handleResumeToken accepts a resume_token query parameter to use the same peer ID
func ( api * API ) handleResumeToken ( ctx context . Context , rw http . ResponseWriter , r * http . Request ) ( peerID uuid . UUID , err error ) {
peerID = uuid . New ()
resumeToken := r . URL . Query (). Get ( "resume_token" )
if resumeToken != "" {
peerID , err = api . Options . CoordinatorResumeTokenProvider . VerifyResumeToken ( ctx , resumeToken )
// If the token is missing the key ID, it's probably an old token in which
// case we just want to generate a new peer ID.
2025-03-26 01:56:39 -05:00
switch {
case xerrors . Is ( err , jwtutils . ErrMissingKeyID ):
2024-11-01 14:53:53 +11:00
peerID = uuid . New ()
err = nil
2025-03-26 01:56:39 -05:00
case err != nil :
2024-11-01 14:53:53 +11:00
httpapi . Write ( ctx , rw , http . StatusUnauthorized , codersdk . Response {
Message : workspacesdk . CoordinateAPIInvalidResumeToken ,
Detail : err . Error (),
Validations : [] codersdk . ValidationError {
{ Field : "resume_token" , Detail : workspacesdk . CoordinateAPIInvalidResumeToken },
},
})
return peerID , err
2025-03-26 01:56:39 -05:00
default :
2024-11-01 14:53:53 +11:00
api . Logger . Debug ( ctx , "accepted coordinate resume token for peer" ,
slog . F ( "peer_id" , peerID . String ()))
}
}
return peerID , err
}
2024-06-03 12:29:50 -05:00
// @Summary Post workspace agent log source
// @ID post-workspace-agent-log-source
// @Security CoderSessionToken
// @Accept json
// @Produce json
// @Tags Agents
// @Param request body agentsdk.PostLogSourceRequest true "Log source request"
// @Success 200 {object} codersdk.WorkspaceAgentLogSource
// @Router /workspaceagents/me/log-source [post]
func ( api * API ) workspaceAgentPostLogSource ( rw http . ResponseWriter , r * http . Request ) {
ctx := r . Context ()
var req agentsdk . PostLogSourceRequest
if ! httpapi . Read ( ctx , rw , r , & req ) {
return
}
workspaceAgent := httpmw . WorkspaceAgent ( r )
sources , err := api . Database . InsertWorkspaceAgentLogSources ( ctx , database . InsertWorkspaceAgentLogSourcesParams {
WorkspaceAgentID : workspaceAgent . ID ,
CreatedAt : dbtime . Now (),
ID : [] uuid . UUID { req . ID },
DisplayName : [] string { req . DisplayName },
Icon : [] string { req . Icon },
})
if err != nil {
if database . IsUniqueViolation ( err , "workspace_agent_log_sources_pkey" ) {
httpapi . Write ( ctx , rw , http . StatusCreated , codersdk . WorkspaceAgentLogSource {
WorkspaceAgentID : workspaceAgent . ID ,
CreatedAt : dbtime . Now (),
ID : req . ID ,
DisplayName : req . DisplayName ,
Icon : req . Icon ,
})
return
}
httpapi . InternalServerError ( rw , err )
return
}
if len ( sources ) != 1 {
httpapi . InternalServerError ( rw , xerrors . Errorf ( "database should've returned 1 row, got %d" , len ( sources )))
return
}
apiSource := convertLogSources ( sources )[ 0 ]
httpapi . Write ( ctx , rw , http . StatusCreated , apiSource )
}
2025-05-14 14:15:36 +02:00
// @Summary Get workspace agent reinitialization
// @ID get-workspace-agent-reinitialization
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
// @Success 200 {object} agentsdk.ReinitializationEvent
// @Router /workspaceagents/me/reinit [get]
func ( api * API ) workspaceAgentReinit ( rw http . ResponseWriter , r * http . Request ) {
// Allow us to interrupt watch via cancel.
ctx , cancel := context . WithCancel ( r . Context ())
defer cancel ()
r = r . WithContext ( ctx ) // Rewire context for SSE cancellation.
workspaceAgent := httpmw . WorkspaceAgent ( r )
log := api . Logger . Named ( "workspace_agent_reinit_watcher" ). With (
slog . F ( "workspace_agent_id" , workspaceAgent . ID ),
)
workspace , err := api . Database . GetWorkspaceByAgentID ( ctx , workspaceAgent . ID )
if err != nil {
log . Error ( ctx , "failed to retrieve workspace from agent token" , slog . Error ( err ))
httpapi . InternalServerError ( rw , xerrors . New ( "failed to determine workspace from agent token" ))
}
log . Info ( ctx , "agent waiting for reinit instruction" )
reinitEvents := make ( chan agentsdk . ReinitializationEvent )
cancel , err = prebuilds . NewPubsubWorkspaceClaimListener ( api . Pubsub , log ). ListenForWorkspaceClaims ( ctx , workspace . ID , reinitEvents )
if err != nil {
log . Error ( ctx , "subscribe to prebuild claimed channel" , slog . Error ( err ))
httpapi . InternalServerError ( rw , xerrors . New ( "failed to subscribe to prebuild claimed channel" ))
return
}
defer cancel ()
transmitter := agentsdk . NewSSEAgentReinitTransmitter ( log , rw , r )
err = transmitter . Transmit ( ctx , reinitEvents )
switch {
case errors . Is ( err , agentsdk . ErrTransmissionSourceClosed ):
log . Info ( ctx , "agent reinitialization subscription closed" , slog . F ( "workspace_agent_id" , workspaceAgent . ID ))
case errors . Is ( err , agentsdk . ErrTransmissionTargetClosed ):
log . Info ( ctx , "agent connection closed" , slog . F ( "workspace_agent_id" , workspaceAgent . ID ))
case errors . Is ( err , context . Canceled ):
log . Info ( ctx , "agent reinitialization" , slog . Error ( err ))
case err != nil :
log . Error ( ctx , "failed to stream agent reinit events" , slog . Error ( err ))
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error streaming agent reinitialization events." ,
Detail : err . Error (),
})
}
}
2023-09-12 15:25:10 +02:00
// convertProvisionedApps converts applications that are in the middle of provisioning process.
// It means that they may not have an agent or workspace assigned (dry-run job).
func convertProvisionedApps ( dbApps [] database . WorkspaceApp ) [] codersdk . WorkspaceApp {
2026-01-19 12:36:33 +00:00
return db2sdk . Apps ( dbApps , [] database . WorkspaceAppStatus {}, database . WorkspaceAgent {}, "" , database . WorkspaceTable {})
2022-06-04 15:13:37 -05:00
}
2023-09-25 16:47:17 -05:00
func convertLogSources ( dbLogSources [] database . WorkspaceAgentLogSource ) [] codersdk . WorkspaceAgentLogSource {
logSources := make ([] codersdk . WorkspaceAgentLogSource , 0 )
for _ , dbLogSource := range dbLogSources {
logSources = append ( logSources , codersdk . WorkspaceAgentLogSource {
ID : dbLogSource . ID ,
DisplayName : dbLogSource . DisplayName ,
WorkspaceAgentID : dbLogSource . WorkspaceAgentID ,
CreatedAt : dbLogSource . CreatedAt ,
Icon : dbLogSource . Icon ,
})
}
return logSources
}
func convertScripts ( dbScripts [] database . WorkspaceAgentScript ) [] codersdk . WorkspaceAgentScript {
scripts := make ([] codersdk . WorkspaceAgentScript , 0 )
for _ , dbScript := range dbScripts {
scripts = append ( scripts , codersdk . WorkspaceAgentScript {
2024-09-24 10:51:49 +01:00
ID : dbScript . ID ,
2023-09-25 16:47:17 -05:00
LogPath : dbScript . LogPath ,
LogSourceID : dbScript . LogSourceID ,
Script : dbScript . Script ,
Cron : dbScript . Cron ,
RunOnStart : dbScript . RunOnStart ,
RunOnStop : dbScript . RunOnStop ,
StartBlocksLogin : dbScript . StartBlocksLogin ,
Timeout : time . Duration ( dbScript . TimeoutSeconds ) * time . Second ,
2024-09-20 14:26:13 +01:00
DisplayName : dbScript . DisplayName ,
2023-09-25 16:47:17 -05:00
})
}
return scripts
}
2023-03-31 15:26:19 -05:00
// @Summary Watch for workspace agent metadata updates
// @ID watch-for-workspace-agent-metadata-updates
// @Security CoderSessionToken
// @Tags Agents
// @Success 200 "Success"
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
// @Router /workspaceagents/{workspaceagent}/watch-metadata [get]
// @x-apidocgen {"skip": true}
2025-03-28 17:13:20 -04:00
// @Deprecated Use /workspaceagents/{workspaceagent}/watch-metadata-ws instead
func ( api * API ) watchWorkspaceAgentMetadataSSE ( rw http . ResponseWriter , r * http . Request ) {
api . watchWorkspaceAgentMetadata ( rw , r , httpapi . ServerSentEventSender )
}
// @Summary Watch for workspace agent metadata updates via WebSockets
// @ID watch-for-workspace-agent-metadata-updates-via-websockets
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
// @Success 200 {object} codersdk.ServerSentEvent
// @Param workspaceagent path string true "Workspace agent ID" format(uuid)
// @Router /workspaceagents/{workspaceagent}/watch-metadata-ws [get]
// @x-apidocgen {"skip": true}
func ( api * API ) watchWorkspaceAgentMetadataWS ( rw http . ResponseWriter , r * http . Request ) {
2026-01-26 12:11:40 +00:00
api . watchWorkspaceAgentMetadata ( rw , r , httpapi . OneWayWebSocketEventSender ( api . Logger ))
2025-03-28 17:13:20 -04:00
}
func ( api * API ) watchWorkspaceAgentMetadata (
rw http . ResponseWriter ,
r * http . Request ,
connect httpapi . EventSender ,
) {
2023-11-16 17:03:53 +02:00
// Allow us to interrupt watch via cancel.
ctx , cancel := context . WithCancel ( r . Context ())
defer cancel ()
r = r . WithContext ( ctx ) // Rewire context for SSE cancellation.
2026-01-19 12:36:33 +00:00
waws := httpmw . WorkspaceAgentAndWorkspaceParam ( r )
2026-01-22 22:47:49 -08:00
agentIDEncoded := make ([] byte , metadatabatcher . UUIDBase64Size )
err := metadatabatcher . EncodeAgentID ( waws . WorkspaceAgent . ID , agentIDEncoded )
if err != nil {
httpapi . InternalServerError ( rw , err )
return
}
2023-11-16 17:03:53 +02:00
log := api . Logger . Named ( "workspace_metadata_watcher" ). With (
2026-01-19 12:36:33 +00:00
slog . F ( "workspace_agent_id" , waws . WorkspaceAgent . ID ),
slog . F ( "workspace_id" , waws . WorkspaceTable . ID ),
2023-03-31 15:26:19 -05:00
)
2023-08-24 15:18:42 -05:00
// Send metadata on updates, we must ensure subscription before sending
// initial metadata to guarantee that events in-between are not missed.
2026-01-22 22:47:49 -08:00
// The channel carries no data - it's just a signal to fetch all metadata.
update := make ( chan struct {}, 1 )
// Subscribe to the global batched metadata channel.
// The batcher publishes only to this channel to achieve O(1) NOTIFY scaling.
cancelBatchSub , err := api . Pubsub . Subscribe ( metadatabatcher . MetadataBatchPubsubChannel , func ( _ context . Context , byt [] byte ) {
2023-11-16 17:03:53 +02:00
if ctx . Err () != nil {
return
}
2026-01-22 22:47:49 -08:00
if len ( byt ) % metadatabatcher . UUIDBase64Size != 0 {
log . Error ( ctx , "invalid batched pubsub message, pubsub message length was not a multiple of encoded agent UUID length" , slog . Error ( err ))
2023-08-24 15:18:42 -05:00
return
}
2026-01-22 22:47:49 -08:00
// Compare each encoded agentID to our encoded agent ID.
for i := 0 ; i < len ( byt ); i += metadatabatcher . UUIDBase64Size {
if ! bytes . Equal ( byt [ i : i + metadatabatcher . UUIDBase64Size ], agentIDEncoded ) {
continue
}
2023-08-24 15:18:42 -05:00
2026-01-22 22:47:49 -08:00
log . Debug ( ctx , "received metadata update from batch channel" ,
slog . F ( "agent_id" , waws . WorkspaceAgent . ID ),
slog . F ( "batch_size" , len ( byt ) / metadatabatcher . UUIDBase64Size ),
)
// Signal to re-fetch all metadata for this agent.
// Batch notifications don't include which keys changed, so we
// always fetch all keys for this agent.
// Attempt to read from the channel first so that we do not block on the write.
select {
case <- update :
default :
}
update <- struct {}{}
break
2023-10-13 16:37:55 +03:00
}
2023-08-24 15:18:42 -05:00
})
if err != nil {
httpapi . InternalServerError ( rw , err )
return
}
2026-01-22 22:47:49 -08:00
defer cancelBatchSub ()
2023-08-24 15:18:42 -05:00
// We always use the original Request context because it contains
// the RBAC actor.
2023-11-16 17:03:53 +02:00
initialMD , err := api . Database . GetWorkspaceAgentMetadata ( ctx , database . GetWorkspaceAgentMetadataParams {
2026-01-19 12:36:33 +00:00
WorkspaceAgentID : waws . WorkspaceAgent . ID ,
2023-10-13 16:37:55 +03:00
Keys : nil ,
})
2023-03-31 15:26:19 -05:00
if err != nil {
2023-08-24 15:18:42 -05:00
// If we can't successfully pull the initial metadata, pubsub
// updates will be no-op so we may as well terminate the
// connection early.
2023-03-31 15:26:19 -05:00
httpapi . InternalServerError ( rw , err )
return
}
2023-08-24 15:18:42 -05:00
2026-01-08 10:29:41 +04:00
log . Debug ( ctx , "got initial metadata" , slog . F ( "num" , len ( initialMD )))
2023-11-16 17:03:53 +02:00
metadataMap := make ( map [ string ] database . WorkspaceAgentMetadatum , len ( initialMD ))
for _ , datum := range initialMD {
2023-08-24 15:18:42 -05:00
metadataMap [ datum . Key ] = datum
}
2023-11-16 17:03:53 +02:00
//nolint:ineffassign // Release memory.
initialMD = nil
2025-03-28 17:13:20 -04:00
sendEvent , senderClosed , err := connect ( rw , r )
2023-11-16 17:03:53 +02:00
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error setting up server-sent events." ,
Detail : err . Error (),
})
return
}
// Prevent handler from returning until the sender is closed.
defer func () {
cancel ()
2025-03-28 17:13:20 -04:00
<- senderClosed
2023-11-16 17:03:53 +02:00
}()
// Synchronize cancellation from SSE -> context, this lets us simplify the
// cancellation logic.
go func () {
select {
case <- ctx . Done ():
2025-03-28 17:13:20 -04:00
case <- senderClosed :
2023-11-16 17:03:53 +02:00
cancel ()
}
}()
2023-08-24 15:18:42 -05:00
var lastSend time . Time
sendMetadata := func () {
lastSend = time . Now ()
2023-10-13 16:37:55 +03:00
values := maps . Values ( metadataMap )
2023-11-16 17:03:53 +02:00
2026-01-08 10:29:41 +04:00
log . Debug ( ctx , "sending metadata" , slog . F ( "num" , len ( values )))
2023-11-16 17:03:53 +02:00
2025-03-28 17:13:20 -04:00
_ = sendEvent ( codersdk . ServerSentEvent {
2023-08-24 15:18:42 -05:00
Type : codersdk . ServerSentEventTypeData ,
Data : convertWorkspaceAgentMetadata ( values ),
})
}
2023-10-13 16:37:55 +03:00
// We send updates exactly every second.
const sendInterval = time . Second * 1
sendTicker := time . NewTicker ( sendInterval )
defer sendTicker . Stop ()
2025-04-08 10:30:05 +02:00
// Log the request immediately instead of after it completes.
2025-06-12 13:50:50 +03:00
if rl := loggermw . RequestLoggerFromContext ( ctx ); rl != nil {
rl . WriteLog ( ctx , http . StatusAccepted )
}
2025-04-08 10:30:05 +02:00
2023-10-13 16:37:55 +03:00
// Send initial metadata.
2023-08-24 15:18:42 -05:00
sendMetadata ()
2023-06-13 15:21:06 +03:00
2023-10-13 16:37:55 +03:00
// Fetch updated metadata keys as they come in.
fetchedMetadata := make ( chan [] database . WorkspaceAgentMetadatum )
go func () {
defer close ( fetchedMetadata )
2023-11-16 17:03:53 +02:00
defer cancel ()
2023-10-13 16:37:55 +03:00
for {
select {
2023-11-16 17:03:53 +02:00
case <- ctx . Done ():
2023-10-13 16:37:55 +03:00
return
2026-01-22 22:47:49 -08:00
case <- update :
// Batch notification received - fetch all metadata for this agent.
2023-10-13 16:37:55 +03:00
md , err := api . Database . GetWorkspaceAgentMetadata ( ctx , database . GetWorkspaceAgentMetadataParams {
2026-01-19 12:36:33 +00:00
WorkspaceAgentID : waws . WorkspaceAgent . ID ,
2026-01-22 22:47:49 -08:00
Keys : nil , // nil means fetch all keys
2023-10-13 16:37:55 +03:00
})
if err != nil {
2023-11-22 17:32:31 +02:00
if ! database . IsQueryCanceledError ( err ) {
2023-10-13 16:37:55 +03:00
log . Error ( ctx , "failed to get metadata" , slog . Error ( err ))
2025-03-28 17:13:20 -04:00
_ = sendEvent ( codersdk . ServerSentEvent {
2023-11-16 17:03:53 +02:00
Type : codersdk . ServerSentEventTypeError ,
Data : codersdk . Response {
Message : "Failed to get metadata." ,
Detail : err . Error (),
},
})
2023-10-13 16:37:55 +03:00
}
return
}
select {
2023-11-16 17:03:53 +02:00
case <- ctx . Done ():
2023-10-13 16:37:55 +03:00
return
// We want to block here to avoid constantly pinging the
// database when the metadata isn't being processed.
case fetchedMetadata <- md :
2026-01-22 22:47:49 -08:00
log . Debug ( ctx , "fetched all metadata after batch update" , slog . F ( "num" , len ( md )))
2023-10-13 16:37:55 +03:00
}
}
}
}()
2023-11-16 17:03:53 +02:00
defer func () {
<- fetchedMetadata
}()
2023-10-13 16:37:55 +03:00
pendingChanges := true
2023-03-31 15:26:19 -05:00
for {
select {
2023-11-16 17:03:53 +02:00
case <- ctx . Done ():
2023-10-13 16:37:55 +03:00
return
case md , ok := <- fetchedMetadata :
if ! ok {
return
}
for _ , datum := range md {
metadataMap [ datum . Key ] = datum
}
pendingChanges = true
continue
2023-08-24 15:18:42 -05:00
case <- sendTicker . C :
// We send an update even if there's no change every 5 seconds
// to ensure that the frontend always has an accurate "Result.Age".
2023-10-13 16:37:55 +03:00
if ! pendingChanges && time . Since ( lastSend ) < 5 * time . Second {
2023-08-24 15:18:42 -05:00
continue
}
2023-10-13 16:37:55 +03:00
pendingChanges = false
2023-03-31 15:26:19 -05:00
}
2023-10-13 16:37:55 +03:00
sendMetadata ()
2023-03-31 15:26:19 -05:00
}
}
func convertWorkspaceAgentMetadata ( db [] database . WorkspaceAgentMetadatum ) [] codersdk . WorkspaceAgentMetadata {
2024-02-08 17:29:34 +01:00
// Sort the input database slice by DisplayOrder and then by Key before processing
sort . Slice ( db , func ( i , j int ) bool {
if db [ i ]. DisplayOrder == db [ j ]. DisplayOrder {
return db [ i ]. Key < db [ j ]. Key
}
return db [ i ]. DisplayOrder < db [ j ]. DisplayOrder
})
2023-03-31 15:26:19 -05:00
// An empty array is easier for clients to handle than a null.
2024-02-08 17:29:34 +01:00
result := make ([] codersdk . WorkspaceAgentMetadata , len ( db ))
for i , datum := range db {
result [ i ] = codersdk . WorkspaceAgentMetadata {
2023-03-31 15:26:19 -05:00
Result : codersdk . WorkspaceAgentMetadataResult {
Value : datum . Value ,
Error : datum . Error ,
2023-09-18 09:17:18 +01:00
CollectedAt : datum . CollectedAt . UTC (),
2023-03-31 15:26:19 -05:00
Age : int64 ( time . Since ( datum . CollectedAt ). Seconds ()),
},
Description : codersdk . WorkspaceAgentMetadataDescription {
DisplayName : datum . DisplayName ,
Key : datum . Key ,
Script : datum . Script ,
Interval : datum . Interval ,
Timeout : datum . Timeout ,
},
2024-02-08 17:29:34 +01:00
}
2023-03-31 15:26:19 -05:00
}
return result
}
2023-10-09 18:04:35 -05:00
// workspaceAgentsExternalAuth returns an access token for a given URL
// or finds a provider by ID.
2023-01-05 15:27:10 +01:00
//
2023-10-09 18:04:35 -05:00
// @Summary Get workspace agent external auth
// @ID get-workspace-agent-external-auth
2023-01-05 15:27:10 +01:00
// @Security CoderSessionToken
// @Produce json
// @Tags Agents
2023-10-09 18:04:35 -05:00
// @Param match query string true "Match"
// @Param id query string true "Provider ID"
2023-01-05 15:27:10 +01:00
// @Param listen query bool false "Wait for a new token to be issued"
2023-10-09 18:04:35 -05:00
// @Success 200 {object} agentsdk.ExternalAuthResponse
// @Router /workspaceagents/me/external-auth [get]
func ( api * API ) workspaceAgentsExternalAuth ( rw http . ResponseWriter , r * http . Request ) {
2022-10-24 19:46:24 -05:00
ctx := r . Context ()
2023-10-09 22:25:50 -05:00
query := r . URL . Query ()
2026-02-27 11:50:56 -05:00
gitRef := chatGitRef {
Branch : strings . TrimSpace ( query . Get ( "git_branch" )),
RemoteOrigin : strings . TrimSpace ( query . Get ( "git_remote_origin" )),
}
2023-10-09 18:04:35 -05:00
// Either match or configID must be provided!
2023-10-09 22:25:50 -05:00
match := query . Get ( "match" )
2023-10-09 18:04:35 -05:00
if match == "" {
// Support legacy agents!
2023-10-09 22:25:50 -05:00
match = query . Get ( "url" )
2023-10-09 18:04:35 -05:00
}
2023-10-09 22:25:50 -05:00
id := query . Get ( "id" )
2023-10-09 18:04:35 -05:00
if match == "" && id == "" {
2022-10-24 19:46:24 -05:00
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
2023-10-09 18:04:35 -05:00
Message : "'url' or 'id' must be provided!" ,
2022-10-24 19:46:24 -05:00
})
return
}
2023-10-09 18:04:35 -05:00
if match != "" && id != "" {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "'url' and 'id' cannot be provided together!" ,
})
return
}
2022-10-24 19:46:24 -05:00
// listen determines if the request will wait for a
// new token to be issued!
2026-02-27 11:50:56 -05:00
listen := query . Has ( "listen" )
2022-10-24 19:46:24 -05:00
2023-09-30 14:30:01 -05:00
var externalAuthConfig * externalauth . Config
2023-10-09 18:04:35 -05:00
for _ , extAuth := range api . ExternalAuthConfigs {
if extAuth . ID == id {
externalAuthConfig = extAuth
break
}
if match == "" || extAuth . Regex == nil {
2023-10-03 11:45:07 -05:00
continue
}
2023-10-09 18:04:35 -05:00
matches := extAuth . Regex . MatchString ( match )
2022-10-24 19:46:24 -05:00
if ! matches {
continue
}
2023-10-09 18:04:35 -05:00
externalAuthConfig = extAuth
2022-10-24 19:46:24 -05:00
}
2023-09-30 14:30:01 -05:00
if externalAuthConfig == nil {
2023-10-09 18:04:35 -05:00
detail := "External auth provider not found."
2023-09-29 14:13:20 -05:00
if len ( api . ExternalAuthConfigs ) > 0 {
regexURLs := make ([] string , 0 , len ( api . ExternalAuthConfigs ))
2023-09-30 14:30:01 -05:00
for _ , extAuth := range api . ExternalAuthConfigs {
2023-10-03 11:45:07 -05:00
if extAuth . Regex == nil {
continue
}
2023-09-30 14:30:01 -05:00
regexURLs = append ( regexURLs , fmt . Sprintf ( "%s=%q" , extAuth . ID , extAuth . Regex . String ()))
2023-08-30 08:58:31 -05:00
}
2023-10-09 18:04:35 -05:00
detail = fmt . Sprintf ( "The configured external auth provider have regex filters that do not match the url. Provider url regex: %s" , strings . Join ( regexURLs , "," ))
2023-08-30 08:58:31 -05:00
}
2022-10-24 19:46:24 -05:00
httpapi . Write ( ctx , rw , http . StatusNotFound , codersdk . Response {
2023-10-09 18:04:35 -05:00
Message : fmt . Sprintf ( "No matching external auth provider found in Coder for the url %q." , match ),
2023-08-30 08:58:31 -05:00
Detail : detail ,
2022-10-24 19:46:24 -05:00
})
return
}
workspaceAgent := httpmw . WorkspaceAgent ( r )
// We must get the workspace to get the owner ID!
resource , err := api . Database . GetWorkspaceResourceByID ( ctx , workspaceAgent . ResourceID )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Failed to get workspace resource." ,
Detail : err . Error (),
})
return
}
build , err := api . Database . GetWorkspaceBuildByJobID ( ctx , resource . JobID )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Failed to get build." ,
Detail : err . Error (),
})
return
}
workspace , err := api . Database . GetWorkspaceByID ( ctx , build . WorkspaceID )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Failed to get workspace." ,
Detail : err . Error (),
})
return
}
2025-05-15 15:32:52 +01:00
// Pre-check if the caller can read the external auth links for the owner of the
// workspace. Do this up front because a sql.ErrNoRows is expected if the user is
// in the flow of authenticating. If no row is present, the auth check is delayed
// until the user authenticates. It is preferred to reject early.
if ! api . Authorize ( r , policy . ActionReadPersonal , rbac . ResourceUserObject ( workspace . OwnerID )) {
httpapi . Forbidden ( rw )
return
}
2026-03-10 18:46:01 +00:00
// MarkStale will trigger a refresh by coderd/gitsync. This allows us to
// persist git refs as soon as the agent requests external auth so branch
2026-02-27 11:50:56 -05:00
// context is retained even if the flow requires an out-of-band login.
2026-03-10 18:46:01 +00:00
if gitRef . Branch != "" && gitRef . RemoteOrigin != "" {
//nolint:gocritic // Chat processor context required for cross-user chat lookup
api . gitSyncWorker . MarkStale ( dbauthz . AsChatd ( ctx ), workspace . ID , workspace . OwnerID , gitRef . Branch , gitRef . RemoteOrigin )
2026-02-27 11:50:56 -05:00
}
2024-01-29 08:55:15 -06:00
var previousToken * database . ExternalAuthLink
// handleRetrying will attempt to continually check for a new token
// if listen is true. This is useful if an error is encountered in the
// original single flow.
//
// By default, if no errors are encountered, then the single flow response
// is returned.
handleRetrying := func ( code int , response any ) {
if ! listen {
httpapi . Write ( ctx , rw , code , response )
2022-10-24 19:46:24 -05:00
return
}
2024-01-29 08:55:15 -06:00
2026-03-10 18:46:01 +00:00
api . workspaceAgentsExternalAuthListen ( ctx , rw , previousToken , externalAuthConfig , workspace , gitRef )
2022-10-24 19:46:24 -05:00
}
// This is the URL that will redirect the user with a state token.
2023-10-03 09:04:39 -05:00
redirectURL , err := api . AccessURL . Parse ( fmt . Sprintf ( "/external-auth/%s" , externalAuthConfig . ID ))
2022-10-24 19:46:24 -05:00
if err != nil {
2024-01-29 08:55:15 -06:00
handleRetrying ( http . StatusInternalServerError , codersdk . Response {
2022-10-24 19:46:24 -05:00
Message : "Failed to parse access URL." ,
Detail : err . Error (),
})
return
}
2023-09-30 14:30:01 -05:00
externalAuthLink , err := api . Database . GetExternalAuthLink ( ctx , database . GetExternalAuthLinkParams {
ProviderID : externalAuthConfig . ID ,
2022-10-24 19:46:24 -05:00
UserID : workspace . OwnerID ,
})
if err != nil {
if ! errors . Is ( err , sql . ErrNoRows ) {
2024-01-29 08:55:15 -06:00
handleRetrying ( http . StatusInternalServerError , codersdk . Response {
Message : "Failed to get external auth link." ,
Detail : err . Error (),
})
return
}
handleRetrying ( http . StatusOK , agentsdk . ExternalAuthResponse {
URL : redirectURL . String (),
})
return
}
2024-06-03 09:33:49 -05:00
refreshedLink , err := externalAuthConfig . RefreshToken ( ctx , api . Database , externalAuthLink )
if err != nil && ! externalauth . IsInvalidTokenError ( err ) {
2024-01-29 08:55:15 -06:00
handleRetrying ( http . StatusInternalServerError , codersdk . Response {
Message : "Failed to refresh external auth token." ,
Detail : err . Error (),
})
return
}
2024-06-03 09:33:49 -05:00
if err != nil {
2024-01-29 08:55:15 -06:00
// Set the previous token so the retry logic will skip validating the
// same token again. This should only be set if the token is invalid and there
// was no error. If it is invalid because of an error, then we should recheck.
2024-06-03 09:33:49 -05:00
previousToken = & refreshedLink
2024-01-29 08:55:15 -06:00
handleRetrying ( http . StatusOK , agentsdk . ExternalAuthResponse {
URL : redirectURL . String (),
})
return
}
2024-06-03 09:33:49 -05:00
resp , err := createExternalAuthResponse ( externalAuthConfig . Type , refreshedLink . OAuthAccessToken , refreshedLink . OAuthExtra )
2024-01-29 08:55:15 -06:00
if err != nil {
handleRetrying ( http . StatusInternalServerError , codersdk . Response {
Message : "Failed to create external auth response." ,
Detail : err . Error (),
})
return
}
httpapi . Write ( ctx , rw , http . StatusOK , resp )
}
2026-03-10 18:46:01 +00:00
func ( api * API ) workspaceAgentsExternalAuthListen ( ctx context . Context , rw http . ResponseWriter , previous * database . ExternalAuthLink , externalAuthConfig * externalauth . Config , workspace database . Workspace , gitRef chatGitRef ) {
2024-01-29 08:55:15 -06:00
// Since we're ticking frequently and this sign-in operation is rare,
// we are OK with polling to avoid the complexity of pubsub.
ticker , done := api . NewTicker ( time . Second )
defer done ()
// If we have a previous token that is invalid, we should not check this again.
// This serves to prevent doing excessive unauthorized requests to the external
// auth provider. For github, this limit is 60 per hour, so saving a call
// per invalid token can be significant.
var previousToken database . ExternalAuthLink
if previous != nil {
previousToken = * previous
}
for {
select {
case <- ctx . Done ():
return
case <- ticker :
}
externalAuthLink , err := api . Database . GetExternalAuthLink ( ctx , database . GetExternalAuthLinkParams {
ProviderID : externalAuthConfig . ID ,
UserID : workspace . OwnerID ,
})
if err != nil {
if errors . Is ( err , sql . ErrNoRows ) {
continue
}
2024-01-25 14:22:47 -06:00
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
2024-01-25 10:54:56 -06:00
Message : "Failed to get external auth link." ,
Detail : err . Error (),
})
return
}
2024-01-29 08:55:15 -06:00
// Expiry may be unset if the application doesn't configure tokens
// to expire.
// See
// https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-user-access-token-for-a-github-app.
if externalAuthLink . OAuthExpiry . Before ( dbtime . Now ()) && ! externalAuthLink . OAuthExpiry . IsZero () {
continue
}
2024-01-25 10:54:56 -06:00
2024-01-29 08:55:15 -06:00
// Only attempt to revalidate an oauth token if it has actually changed.
// No point in trying to validate the same token over and over again.
if previousToken . OAuthAccessToken == externalAuthLink . OAuthAccessToken &&
previousToken . OAuthRefreshToken == externalAuthLink . OAuthRefreshToken &&
2026-02-25 08:45:00 -07:00
previousToken . OAuthExpiry . Equal ( externalAuthLink . OAuthExpiry ) {
2024-01-29 08:55:15 -06:00
continue
}
valid , _ , err := externalAuthConfig . ValidateToken ( ctx , externalAuthLink . OAuthToken ())
if err != nil {
api . Logger . Warn ( ctx , "failed to validate external auth token" ,
slog . F ( "workspace_owner_id" , workspace . OwnerID . String ()),
slog . F ( "validate_url" , externalAuthConfig . ValidateURL ),
slog . Error ( err ),
)
}
previousToken = externalAuthLink
if ! valid {
continue
}
resp , err := createExternalAuthResponse ( externalAuthConfig . Type , externalAuthLink . OAuthAccessToken , externalAuthLink . OAuthExtra )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Failed to create external auth response." ,
Detail : err . Error (),
})
return
}
2026-03-10 18:46:01 +00:00
// MarkStale will trigger a refresh by coderd/gitsync.
//nolint:gocritic // Chat processor context required for cross-user chat lookup
api . gitSyncWorker . MarkStale ( dbauthz . AsChatd ( ctx ), workspace . ID , workspace . OwnerID , gitRef . Branch , gitRef . RemoteOrigin )
2024-01-29 08:55:15 -06:00
httpapi . Write ( ctx , rw , http . StatusOK , resp )
2024-01-25 10:54:56 -06:00
return
}
}
2024-11-01 14:53:53 +11:00
// @Summary User-scoped tailnet RPC connection
// @ID user-scoped-tailnet-rpc-connection
// @Security CoderSessionToken
// @Tags Agents
// @Success 101
// @Router /tailnet [get]
func ( api * API ) tailnetRPCConn ( rw http . ResponseWriter , r * http . Request ) {
ctx := r . Context ()
2025-02-21 12:21:20 +11:00
// This is used by Enterprise code to control the functionality of this route.
// Namely, disabling the route using `CODER_BROWSER_ONLY`.
override := api . WorkspaceClientCoordinateOverride . Load ()
if override != nil {
overrideFunc := * override
if overrideFunc != nil && overrideFunc ( rw ) {
return
}
}
2024-11-01 14:53:53 +11:00
version := "2.0"
qv := r . URL . Query (). Get ( "version" )
if qv != "" {
version = qv
}
if err := proto . CurrentVersion . Validate ( version ); err != nil {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Unknown or unsupported API version" ,
Validations : [] codersdk . ValidationError {
{ Field : "version" , Detail : err . Error ()},
},
})
return
}
peerID , err := api . handleResumeToken ( ctx , rw , r )
if err != nil {
// handleResumeToken has already written the response.
return
}
// Used to authorize tunnel request
sshPrep , err := api . HTTPAuth . AuthorizeSQLFilter ( r , policy . ActionSSH , rbac . ResourceWorkspace . Type )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusInternalServerError , codersdk . Response {
Message : "Internal error preparing sql filter." ,
Detail : err . Error (),
})
return
}
api . WebsocketWaitMutex . Lock ()
api . WebsocketWaitGroup . Add ( 1 )
api . WebsocketWaitMutex . Unlock ()
defer api . WebsocketWaitGroup . Done ()
conn , err := websocket . Accept ( rw , r , nil )
if err != nil {
httpapi . Write ( ctx , rw , http . StatusBadRequest , codersdk . Response {
Message : "Failed to accept websocket." ,
Detail : err . Error (),
})
return
}
ctx , wsNetConn := codersdk . WebsocketNetConn ( ctx , conn , websocket . MessageBinary )
defer wsNetConn . Close ()
defer conn . Close ( websocket . StatusNormalClosure , "" )
2025-03-24 16:02:33 +04:00
// Get user ID for telemetry
apiKey := httpmw . APIKey ( r )
userID := apiKey . UserID . String ()
// Store connection telemetry event
2026-03-09 20:37:05 +00:00
now := dbtime . Now ()
2025-03-24 16:02:33 +04:00
connectionTelemetryEvent := telemetry . UserTailnetConnection {
ConnectedAt : now ,
DisconnectedAt : nil ,
UserID : userID ,
PeerID : peerID . String (),
DeviceID : nil ,
DeviceOS : nil ,
CoderDesktopVersion : nil ,
}
2025-03-25 15:26:05 +04:00
fillCoderDesktopTelemetry ( r , & connectionTelemetryEvent , api . Logger )
2025-03-24 16:02:33 +04:00
api . Telemetry . Report ( & telemetry . Snapshot {
UserTailnetConnections : [] telemetry . UserTailnetConnection { connectionTelemetryEvent },
})
defer func () {
// Update telemetry event with disconnection time
2026-03-09 20:37:05 +00:00
disconnectTime := dbtime . Now ()
2025-03-24 16:02:33 +04:00
connectionTelemetryEvent . DisconnectedAt = & disconnectTime
api . Telemetry . Report ( & telemetry . Snapshot {
UserTailnetConnections : [] telemetry . UserTailnetConnection { connectionTelemetryEvent },
})
}()
2026-01-26 12:11:40 +00:00
ctx , cancel := context . WithCancel ( ctx )
defer cancel ()
go httpapi . HeartbeatClose ( ctx , api . Logger , cancel , conn )
2024-11-01 14:53:53 +11:00
err = api . TailnetClientService . ServeClient ( ctx , version , wsNetConn , tailnet . StreamID {
Name : "client" ,
ID : peerID ,
Auth : tailnet . ClientUserCoordinateeAuth {
Auth : & rbacAuthorizer {
sshPrep : sshPrep ,
db : api . Database ,
},
},
})
if err != nil && ! xerrors . Is ( err , io . EOF ) && ! xerrors . Is ( err , context . Canceled ) {
_ = conn . Close ( websocket . StatusInternalError , err . Error ())
return
}
}
2025-03-25 15:26:05 +04:00
// fillCoderDesktopTelemetry fills out the provided event based on a Coder Desktop telemetry header on the request, if
// present.
func fillCoderDesktopTelemetry ( r * http . Request , event * telemetry . UserTailnetConnection , logger slog . Logger ) {
// Parse desktop telemetry from header if it exists
desktopTelemetryHeader := r . Header . Get ( codersdk . CoderDesktopTelemetryHeader )
if desktopTelemetryHeader != "" {
var telemetryData codersdk . CoderDesktopTelemetry
if err := telemetryData . FromHeader ( desktopTelemetryHeader ); err == nil {
// Only set fields if they aren't empty
if telemetryData . DeviceID != "" {
event . DeviceID = & telemetryData . DeviceID
}
if telemetryData . DeviceOS != "" {
event . DeviceOS = & telemetryData . DeviceOS
}
if telemetryData . CoderDesktopVersion != "" {
event . CoderDesktopVersion = & telemetryData . CoderDesktopVersion
}
logger . Debug ( r . Context (), "received desktop telemetry" ,
slog . F ( "device_id" , telemetryData . DeviceID ),
slog . F ( "device_os" , telemetryData . DeviceOS ),
slog . F ( "desktop_version" , telemetryData . CoderDesktopVersion ))
} else {
logger . Warn ( r . Context (), "failed to parse desktop telemetry header" , slog . Error ( err ))
}
}
}
2023-10-09 18:04:35 -05:00
// createExternalAuthResponse creates an ExternalAuthResponse based on the
// provider type. This is to support legacy `/workspaceagents/me/gitauth`
// which uses `Username` and `Password`.
2023-10-09 23:02:16 -05:00
func createExternalAuthResponse ( typ , token string , extra pqtype . NullRawMessage ) ( agentsdk . ExternalAuthResponse , error ) {
2023-10-09 18:04:35 -05:00
var resp agentsdk . ExternalAuthResponse
2022-10-24 19:46:24 -05:00
switch typ {
2023-10-09 18:04:35 -05:00
case string ( codersdk . EnhancedExternalAuthProviderGitLab ):
2022-10-24 19:46:24 -05:00
// https://stackoverflow.com/questions/25409700/using-gitlab-token-to-clone-without-authentication
2023-10-09 18:04:35 -05:00
resp = agentsdk . ExternalAuthResponse {
2022-10-24 19:46:24 -05:00
Username : "oauth2" ,
Password : token ,
}
2023-11-08 11:05:51 -06:00
case string ( codersdk . EnhancedExternalAuthProviderBitBucketCloud ), string ( codersdk . EnhancedExternalAuthProviderBitBucketServer ):
// The string "bitbucket" was a legacy parameter that needs to still be supported.
2022-10-24 19:46:24 -05:00
// https://support.atlassian.com/bitbucket-cloud/docs/use-oauth-on-bitbucket-cloud/#Cloning-a-repository-with-an-access-token
2023-10-09 18:04:35 -05:00
resp = agentsdk . ExternalAuthResponse {
2022-10-24 19:46:24 -05:00
Username : "x-token-auth" ,
Password : token ,
}
default :
2023-10-09 18:04:35 -05:00
resp = agentsdk . ExternalAuthResponse {
2022-10-24 19:46:24 -05:00
Username : token ,
}
}
2023-10-09 18:04:35 -05:00
resp . AccessToken = token
resp . Type = typ
2023-10-09 23:02:16 -05:00
var err error
if extra . Valid {
err = json . Unmarshal ( extra . RawMessage , & resp . TokenExtra )
}
return resp , err
2022-10-24 19:46:24 -05:00
}
2023-07-28 09:57:23 -06:00
func convertWorkspaceAgentLogs ( logs [] database . WorkspaceAgentLog ) [] codersdk . WorkspaceAgentLog {
sdk := make ([] codersdk . WorkspaceAgentLog , 0 , len ( logs ))
2023-04-27 12:34:00 +02:00
for _ , logEntry := range logs {
2026-02-03 09:45:23 +00:00
sdk = append ( sdk , db2sdk . WorkspaceAgentLog ( logEntry ))
2023-03-23 14:09:13 -05:00
}
return sdk
}