diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99fc888e..466e036c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,16 @@
## Unreleased
+### Fixed
+
+- The plugin no longer immediately starts polling workspaces when connecting to
+ a remote. It will only do this when the Coder sidebar is open.
+
+### Changed
+
+- Instead of monitoring all workspaces for impending autostops and deletions,
+ the plugin now only monitors the connected workspace.
+
## [v1.3.2](https://github.com/coder/vscode-coder/releases/tag/v1.3.2) (2024-09-10)
### Fixed
diff --git a/src/commands.ts b/src/commands.ts
index f2956d29..380f796c 100644
--- a/src/commands.ts
+++ b/src/commands.ts
@@ -459,7 +459,7 @@ export class Commands {
{
useCustom: true,
modal: true,
- detail: `${this.workspace.owner_name}/${this.workspace.name} will be updated then this window will reload to watch the build logs and reconnect.`,
+ detail: `Update ${this.workspace.owner_name}/${this.workspace.name} to the latest version?`,
},
"Update",
)
diff --git a/src/remote.ts b/src/remote.ts
index 1d10c90d..b8d15c7a 100644
--- a/src/remote.ts
+++ b/src/remote.ts
@@ -1,7 +1,6 @@
import { isAxiosError } from "axios"
import { Api } from "coder/site/src/api/api"
import { Workspace } from "coder/site/src/api/typesGenerated"
-import EventSource from "eventsource"
import find from "find-process"
import * as fs from "fs/promises"
import * as jsonc from "jsonc-parser"
@@ -20,7 +19,7 @@ import { SSHConfig, SSHValues, mergeSSHConfigValues } from "./sshConfig"
import { computeSSHProperties, sshSupportsSetEnv } from "./sshSupport"
import { Storage } from "./storage"
import { AuthorityPrefix, expandPath, parseRemoteAuthority } from "./util"
-import { WorkspaceAction } from "./workspaceAction"
+import { WorkspaceMonitor } from "./workspaceMonitor"
export interface RemoteDetails extends vscode.Disposable {
url: string
@@ -292,9 +291,6 @@ export class Remote {
// Register before connection so the label still displays!
disposables.push(this.registerLabelFormatter(remoteAuthority, workspace.owner_name, workspace.name))
- // Initialize any WorkspaceAction notifications (auto-off, upcoming deletion)
- const action = await WorkspaceAction.init(this.vscodeProposed, workspaceRestClient, this.storage)
-
// If the workspace is not in a running state, try to get it running.
const updatedWorkspace = await this.maybeWaitForRunning(workspaceRestClient, workspace)
if (!updatedWorkspace) {
@@ -376,88 +372,10 @@ export class Remote {
}
}
- // Watch for workspace updates.
- this.storage.writeToCoderOutputChannel(`Establishing watcher for ${workspaceName}...`)
- const workspaceUpdate = new vscode.EventEmitter<Workspace>()
- const watchURL = new URL(`${baseUrlRaw}/api/v2/workspaces/${workspace.id}/watch`)
- const eventSource = new EventSource(watchURL.toString(), {
- headers: {
- "Coder-Session-Token": token,
- },
- })
-
- const workspaceUpdatedStatus = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 999)
- disposables.push(workspaceUpdatedStatus)
-
- let hasShownOutdatedNotification = false
- const refreshWorkspaceUpdatedStatus = (newWorkspace: Workspace) => {
- // If the newly gotten workspace was updated, then we show a notification
- // to the user that they should update. Only show this once per session.
- if (newWorkspace.outdated && !hasShownOutdatedNotification) {
- hasShownOutdatedNotification = true
- workspaceRestClient
- .getTemplate(newWorkspace.template_id)
- .then((template) => {
- return workspaceRestClient.getTemplateVersion(template.active_version_id)
- })
- .then((version) => {
- let infoMessage = `A new version of your workspace is available.`
- if (version.message) {
- infoMessage = `A new version of your workspace is available: ${version.message}`
- }
- vscode.window.showInformationMessage(infoMessage, "Update").then((action) => {
- if (action === "Update") {
- vscode.commands.executeCommand("coder.workspace.update", newWorkspace, workspaceRestClient)
- }
- })
- })
- }
- if (!newWorkspace.outdated) {
- vscode.commands.executeCommand("setContext", "coder.workspace.updatable", false)
- workspaceUpdatedStatus.hide()
- return
- }
- workspaceUpdatedStatus.name = "Coder Workspace Update"
- workspaceUpdatedStatus.text = "$(fold-up) Update Workspace"
- workspaceUpdatedStatus.command = "coder.workspace.update"
- // Important for hiding the "Update Workspace" command.
- vscode.commands.executeCommand("setContext", "coder.workspace.updatable", true)
- workspaceUpdatedStatus.show()
- }
- // Show an initial status!
- refreshWorkspaceUpdatedStatus(workspace)
-
- eventSource.addEventListener("data", (event: MessageEvent<string>) => {
- const workspace = JSON.parse(event.data) as Workspace
- if (!workspace) {
- return
- }
- refreshWorkspaceUpdatedStatus(workspace)
- this.commands.workspace = workspace
- workspaceUpdate.fire(workspace)
- if (workspace.latest_build.status === "stopping" || workspace.latest_build.status === "stopped") {
- const action = this.vscodeProposed.window.showInformationMessage(
- "Your workspace stopped!",
- {
- useCustom: true,
- modal: true,
- detail: "Reloading the window will start it again.",
- },
- "Reload Window",
- )
- if (!action) {
- return
- }
- this.reloadWindow()
- }
- // If a new build is initialized for a workspace, we automatically
- // reload the window. Then the build log will appear, and startup
- // will continue as expected.
- if (workspace.latest_build.status === "starting") {
- this.reloadWindow()
- return
- }
- })
+ // Watch the workspace for changes.
+ const monitor = new WorkspaceMonitor(workspace, workspaceRestClient, this.storage, this.vscodeProposed)
+ disposables.push(monitor)
+ disposables.push(monitor.onChange.event((w) => (this.commands.workspace = w)))
// Wait for the agent to connect.
if (agent.status === "connecting") {
@@ -469,7 +387,7 @@ export class Remote {
},
async () => {
await new Promise<void>((resolve) => {
- const updateEvent = workspaceUpdate.event((workspace) => {
+ const updateEvent = monitor.onChange.event((workspace) => {
if (!agent) {
return
}
@@ -552,8 +470,6 @@ export class Remote {
url: baseUrlRaw,
token,
dispose: () => {
- eventSource.close()
- action.cleanupWorkspaceActions()
disposables.forEach((d) => d.dispose())
},
}
@@ -735,7 +651,7 @@ export class Remote {
} else {
statusText += network.preferred_derp + " "
networkStatus.tooltip =
- "You're connected through a relay 🕵️.\nWe'll switch over to peer-to-peer when available."
+ "You're connected through a relay 🕵.\nWe'll switch over to peer-to-peer when available."
}
networkStatus.tooltip +=
"\n\nDownload ↓ " +
@@ -751,9 +667,7 @@ export class Remote {
if (!network.p2p) {
const derpLatency = network.derp_latency[network.preferred_derp]
- networkStatus.tooltip += `You ↔ ${derpLatency.toFixed(2)}ms ↔ ${network.preferred_derp} ↔ ${(
- network.latency - derpLatency
- ).toFixed(2)}ms ↔ Workspace`
+ networkStatus.tooltip += `You ↔ ${derpLatency.toFixed(2)}ms ↔ ${network.preferred_derp} ↔ ${(network.latency - derpLatency).toFixed(2)}ms ↔ Workspace`
let first = true
Object.keys(network.derp_latency).forEach((region) => {
diff --git a/src/workspaceAction.ts b/src/workspaceAction.ts
deleted file mode 100644
index eba8cebd..00000000
--- a/src/workspaceAction.ts
+++ /dev/null
@@ -1,177 +0,0 @@
-import { isAxiosError } from "axios"
-import { Api } from "coder/site/src/api/api"
-import { Workspace, WorkspacesResponse, WorkspaceBuild } from "coder/site/src/api/typesGenerated"
-import { formatDistanceToNowStrict } from "date-fns"
-import * as vscode from "vscode"
-import { Storage } from "./storage"
-
-interface NotifiedWorkspace {
- workspace: Workspace
- wasNotified: boolean
- impendingActionDeadline: string
-}
-
-type WithRequired<T, K extends keyof T> = T & Required<Pick<T, K>>
-
-type WorkspaceWithDeadline = Workspace & { latest_build: WithRequired<WorkspaceBuild, "deadline"> }
-type WorkspaceWithDeletingAt = WithRequired<Workspace, "deleting_at">
-
-export class WorkspaceAction {
- // We use this same interval in the Dashboard to poll for updates on the Workspaces page.
- #POLL_INTERVAL: number = 1000 * 5
- #fetchWorkspacesInterval?: ReturnType<typeof setInterval>
-
- #ownedWorkspaces: readonly Workspace[] = []
- #workspacesApproachingAutostop: NotifiedWorkspace[] = []
- #workspacesApproachingDeletion: NotifiedWorkspace[] = []
-
- private constructor(
- private readonly vscodeProposed: typeof vscode,
- private readonly restClient: Api,
- private readonly storage: Storage,
- ownedWorkspaces: readonly Workspace[],
- ) {
- this.#ownedWorkspaces = ownedWorkspaces
-
- // seed initial lists
- this.updateNotificationLists()
-
- this.notifyAll()
-
- // set up polling so we get current workspaces data
- this.pollGetWorkspaces()
- }
-
- static async init(vscodeProposed: typeof vscode, restClient: Api, storage: Storage) {
- // fetch all workspaces owned by the user and set initial public class fields
- let ownedWorkspacesResponse: WorkspacesResponse
- try {
- ownedWorkspacesResponse = await restClient.getWorkspaces({ q: "owner:me" })
- } catch (error) {
- let status
- if (isAxiosError(error)) {
- status = error.response?.status
- }
- if (status !== 401) {
- storage.writeToCoderOutputChannel(
- `Failed to fetch owned workspaces. Some workspace notifications may be missing: ${error}`,
- )
- }
-
- ownedWorkspacesResponse = { workspaces: [], count: 0 }
- }
- return new WorkspaceAction(vscodeProposed, restClient, storage, ownedWorkspacesResponse.workspaces)
- }
-
- updateNotificationLists() {
- this.#workspacesApproachingAutostop = this.#ownedWorkspaces
- .filter(this.filterWorkspacesImpendingAutostop)
- .map((workspace) =>
- this.transformWorkspaceObjects(workspace, this.#workspacesApproachingAutostop, workspace.latest_build.deadline),
- )
-
- this.#workspacesApproachingDeletion = this.#ownedWorkspaces
- .filter(this.filterWorkspacesImpendingDeletion)
- .map((workspace) =>
- this.transformWorkspaceObjects(workspace, this.#workspacesApproachingDeletion, workspace.deleting_at),
- )
- }
-
- filterWorkspacesImpendingAutostop(workspace: Workspace): workspace is WorkspaceWithDeadline {
- // a workspace is eligible for autostop if the workspace is running and it has a deadline
- if (workspace.latest_build.status !== "running" || !workspace.latest_build.deadline) {
- return false
- }
-
- const halfHourMilli = 1000 * 60 * 30
- // return workspaces with a deadline that is in 30 min or less
- return Math.abs(new Date().getTime() - new Date(workspace.latest_build.deadline).getTime()) <= halfHourMilli
- }
-
- filterWorkspacesImpendingDeletion(workspace: Workspace): workspace is WorkspaceWithDeletingAt {
- if (!workspace.deleting_at) {
- return false
- }
-
- const dayMilli = 1000 * 60 * 60 * 24
-
- // return workspaces with a deleting_at that is 24 hrs or less
- return Math.abs(new Date().getTime() - new Date(workspace.deleting_at).getTime()) <= dayMilli
- }
-
- transformWorkspaceObjects(workspace: Workspace, workspaceList: NotifiedWorkspace[], deadlineField: string) {
- const wasNotified = workspaceList.find((nw) => nw.workspace.id === workspace.id)?.wasNotified ?? false
- const impendingActionDeadline = formatDistanceToNowStrict(new Date(deadlineField))
- return { workspace, wasNotified, impendingActionDeadline }
- }
-
- async pollGetWorkspaces() {
- let errorCount = 0
- this.#fetchWorkspacesInterval = setInterval(async () => {
- try {
- const workspacesResult = await this.restClient.getWorkspaces({ q: "owner:me" })
- this.#ownedWorkspaces = workspacesResult.workspaces
- this.updateNotificationLists()
- this.notifyAll()
- } catch (error) {
- errorCount++
-
- let status
- if (isAxiosError(error)) {
- status = error.response?.status
- }
- if (status !== 401) {
- this.storage.writeToCoderOutputChannel(
- `Failed to poll owned workspaces. Some workspace notifications may be missing: ${error}`,
- )
- }
- if (errorCount === 3) {
- clearInterval(this.#fetchWorkspacesInterval)
- }
- }
- }, this.#POLL_INTERVAL)
- }
-
- notifyAll() {
- this.notifyImpendingAutostop()
- this.notifyImpendingDeletion()
- }
-
- notifyImpendingAutostop() {
- this.#workspacesApproachingAutostop?.forEach((notifiedWorkspace: NotifiedWorkspace) => {
- if (notifiedWorkspace.wasNotified) {
- // don't message the user; we've already messaged
- return
- }
-
- // we display individual notifications for each workspace as VS Code
- // intentionally strips new lines from the message text
- // https://github.com/Microsoft/vscode/issues/48900
- this.vscodeProposed.window.showInformationMessage(
- `${notifiedWorkspace.workspace.name} is scheduled to shut down in ${notifiedWorkspace.impendingActionDeadline}.`,
- )
- notifiedWorkspace.wasNotified = true
- })
- }
-
- notifyImpendingDeletion() {
- this.#workspacesApproachingDeletion?.forEach((notifiedWorkspace: NotifiedWorkspace) => {
- if (notifiedWorkspace.wasNotified) {
- // don't message the user; we've already messaged
- return
- }
-
- // we display individual notifications for each workspace as VS Code
- // intentionally strips new lines from the message text
- // https://github.com/Microsoft/vscode/issues/48900
- this.vscodeProposed.window.showInformationMessage(
- `${notifiedWorkspace.workspace.name} is scheduled for deletion in ${notifiedWorkspace.impendingActionDeadline}.`,
- )
- notifiedWorkspace.wasNotified = true
- })
- }
-
- cleanupWorkspaceActions() {
- clearInterval(this.#fetchWorkspacesInterval)
- }
-}
diff --git a/src/workspaceMonitor.ts b/src/workspaceMonitor.ts
new file mode 100644
index 00000000..0ea186ba
--- /dev/null
+++ b/src/workspaceMonitor.ts
@@ -0,0 +1,201 @@
+import { Api } from "coder/site/src/api/api"
+import { Workspace } from "coder/site/src/api/typesGenerated"
+import { formatDistanceToNowStrict } from "date-fns"
+import EventSource from "eventsource"
+import * as vscode from "vscode"
+import { errToStr } from "./api-helper"
+import { Storage } from "./storage"
+
+/**
+ * Monitor a single workspace using SSE for events like shutdown and deletion.
+ * Notify the user about relevant changes and update contexts as needed. The
+ * workspace status is also shown in the status bar menu.
+ */
+export class WorkspaceMonitor implements vscode.Disposable {
+ private eventSource: EventSource
+ private disposed = false
+
+ // How soon in advance to notify about autostop and deletion.
+ private autostopNotifyTime = 1000 * 60 * 30 // 30 minutes.
+ private deletionNotifyTime = 1000 * 60 * 60 * 24 // 24 hours.
+
+ // Only notify once.
+ private notifiedAutostop = false
+ private notifiedDeletion = false
+ private notifiedOutdated = false
+ private notifiedNotRunning = false
+
+ readonly onChange = new vscode.EventEmitter<Workspace>()
+ private readonly statusBarItem: vscode.StatusBarItem
+
+ // For logging.
+ private readonly name: string
+
+ constructor(
+ workspace: Workspace,
+ private readonly restClient: Api,
+ private readonly storage: Storage,
+ // We use the proposed API to get access to useCustom in dialogs.
+ private readonly vscodeProposed: typeof vscode,
+ ) {
+ this.name = `${workspace.owner_name}/${workspace.name}`
+ const url = this.restClient.getAxiosInstance().defaults.baseURL
+ const token = this.restClient.getAxiosInstance().defaults.headers.common["Coder-Session-Token"] as
+ | string
+ | undefined
+ const watchUrl = new URL(`${url}/api/v2/workspaces/${workspace.id}/watch`)
+ this.storage.writeToCoderOutputChannel(`Monitoring ${this.name}...`)
+
+ const eventSource = new EventSource(watchUrl.toString(), {
+ headers: {
+ "Coder-Session-Token": token,
+ },
+ })
+
+ eventSource.addEventListener("data", (event) => {
+ try {
+ const newWorkspaceData = JSON.parse(event.data) as Workspace
+ this.update(newWorkspaceData)
+ this.maybeNotify(newWorkspaceData)
+ this.onChange.fire(newWorkspaceData)
+ } catch (error) {
+ this.notifyError(error)
+ }
+ })
+
+ eventSource.addEventListener("error", (error) => {
+ this.notifyError(error)
+ })
+
+ // Store so we can close in dispose().
+ this.eventSource = eventSource
+
+ const statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 999)
+ statusBarItem.name = "Coder Workspace Update"
+ statusBarItem.text = "$(fold-up) Update Workspace"
+ statusBarItem.command = "coder.workspace.update"
+
+ // Store so we can update when the workspace data updates.
+ this.statusBarItem = statusBarItem
+
+ this.update(workspace) // Set initial state.
+ this.maybeNotify(workspace)
+ }
+
+ /**
+ * Permanently close the SSE stream.
+ */
+ dispose() {
+ if (!this.disposed) {
+ this.storage.writeToCoderOutputChannel(`Unmonitoring ${this.name}...`)
+ this.statusBarItem.dispose()
+ this.eventSource.close()
+ this.disposed = true
+ }
+ }
+
+ private update(workspace: Workspace) {
+ this.updateContext(workspace)
+ this.updateStatusBar(workspace)
+ }
+
+ private maybeNotify(workspace: Workspace) {
+ this.maybeNotifyOutdated(workspace)
+ this.maybeNotifyAutostop(workspace)
+ this.maybeNotifyDeletion(workspace)
+ this.maybeNotifyNotRunning(workspace)
+ }
+
+ private maybeNotifyAutostop(workspace: Workspace) {
+ if (
+ workspace.latest_build.status === "running" &&
+ workspace.latest_build.deadline &&
+ !this.notifiedAutostop &&
+ this.isImpending(workspace.latest_build.deadline, this.autostopNotifyTime)
+ ) {
+ const toAutostopTime = formatDistanceToNowStrict(new Date(workspace.latest_build.deadline))
+ vscode.window.showInformationMessage(`${this.name} is scheduled to shut down in ${toAutostopTime}.`)
+ this.notifiedAutostop = true
+ }
+ }
+
+ private maybeNotifyDeletion(workspace: Workspace) {
+ if (
+ workspace.deleting_at &&
+ !this.notifiedDeletion &&
+ this.isImpending(workspace.deleting_at, this.deletionNotifyTime)
+ ) {
+ const toShutdownTime = formatDistanceToNowStrict(new Date(workspace.deleting_at))
+ vscode.window.showInformationMessage(`${this.name} is scheduled for deletion in ${toShutdownTime}.`)
+ this.notifiedDeletion = true
+ }
+ }
+
+ private maybeNotifyNotRunning(workspace: Workspace) {
+ if (!this.notifiedNotRunning && workspace.latest_build.status !== "running") {
+ this.notifiedNotRunning = true
+ this.vscodeProposed.window
+ .showInformationMessage(
+ `${this.name} is no longer running!`,
+ {
+ detail: `The workspace status is "${workspace.latest_build.status}". Reload the window to reconnect.`,
+ modal: true,
+ useCustom: true,
+ },
+ "Reload Window",
+ )
+ .then((action) => {
+ if (!action) {
+ return
+ }
+ vscode.commands.executeCommand("workbench.action.reloadWindow")
+ })
+ }
+ }
+
+ private isImpending(target: string, notifyTime: number): boolean {
+ const nowTime = new Date().getTime()
+ const targetTime = new Date(target).getTime()
+ const timeLeft = targetTime - nowTime
+ return timeLeft >= 0 && timeLeft <= notifyTime
+ }
+
+ private maybeNotifyOutdated(workspace: Workspace) {
+ if (!this.notifiedOutdated && workspace.outdated) {
+ this.notifiedOutdated = true
+ this.restClient
+ .getTemplate(workspace.template_id)
+ .then((template) => {
+ return this.restClient.getTemplateVersion(template.active_version_id)
+ })
+ .then((version) => {
+ const infoMessage = version.message
+ ? `A new version of your workspace is available: ${version.message}`
+ : "A new version of your workspace is available."
+ vscode.window.showInformationMessage(infoMessage, "Update").then((action) => {
+ if (action === "Update") {
+ vscode.commands.executeCommand("coder.workspace.update", workspace, this.restClient)
+ }
+ })
+ })
+ }
+ }
+
+ private notifyError(error: unknown) {
+ const message = errToStr(error, "No error message was provided")
+ this.storage.writeToCoderOutputChannel(message)
+ vscode.window.showErrorMessage(`Failed to monitor workspace: ${message}`)
+ }
+
+ private updateContext(workspace: Workspace) {
+ vscode.commands.executeCommand("setContext", "coder.workspace.updatable", workspace.outdated)
+ }
+
+ private updateStatusBar(workspace: Workspace) {
+ if (!workspace.outdated) {
+ this.statusBarItem.hide()
+ } else {
+ this.statusBarItem.show()
+ }
+ }
+}
diff --git a/src/workspacesProvider.ts b/src/workspacesProvider.ts
index 3806f3da..99182fa3 100644
--- a/src/workspacesProvider.ts
+++ b/src/workspacesProvider.ts
@@ -36,6 +36,7 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
private agentWatchers: Record<WorkspaceAgent["id"], AgentWatcher> = {}
private timeout: NodeJS.Timeout | undefined
private fetching = false
+ private visible = false
constructor(
private readonly getWorkspacesQuery: WorkspaceQuery,
@@ -48,10 +49,10 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
// fetchAndRefresh fetches new workspaces, re-renders the entire tree, then
// keeps refreshing (if a timer length was provided) as long as the user is
// still logged in and no errors were encountered fetching workspaces.
- // Calling this while already refreshing is a no-op and will return
- // immediately.
+ // Calling this while already refreshing or not visible is a no-op and will
+ // return immediately.
async fetchAndRefresh() {
- if (this.fetching) {
+ if (this.fetching || !this.visible) {
return
}
this.fetching = true
@@ -83,7 +84,7 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
* Fetch workspaces and turn them into tree items. Throw an error if not
* logged in or the query fails.
*/
- async fetch(): Promise<WorkspaceTreeItem[]> {
+ private async fetch(): Promise<WorkspaceTreeItem[]> {
// If there is no URL configured, assume we are logged out.
const restClient = this.restClient
const url = restClient.getAxiosInstance().defaults.baseURL
@@ -146,6 +147,7 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
* Either start or stop the refresh timer based on visibility.
*/
setVisibility(visible: boolean) {
+ this.visible = visible
if (!visible) {
this.cancelPendingRefresh()
} else {