@highstate/backend 0.7.1 → 0.7.3

package/src/runner/local.ts

@@ -0,0 +1,698 @@
+import type { ConfigMap, Stack } from "@pulumi/pulumi/automation"
+import type { LibraryBackend } from "../library"
+import { EventEmitter, on } from "node:events"
+import { resolve } from "node:path"
+import { getInstanceId } from "@highstate/contract"
+import { ensureDependencyInstalled } from "nypm"
+import { mapValues, omit, pick, pickBy } from "remeda"
+import { z } from "zod"
+import { sha256 } from "crypto-hash"
+import { errorToString, LocalPulumiHost, runWithRetryOnError, updateResourceCount } from "../common"
+import {
+  createInstanceState,
+  instanceFileSchema,
+  instancePageSchema,
+  instanceStatusFieldSchema,
+  instanceTerminalSchema,
+  instanceTriggerSchema,
+  type InstancePageBlock,
+  type InstanceState,
+  type InstanceStateUpdate,
+  type InstanceStatus,
+  type InstanceTerminal,
+} from "../shared"
+import {
+  type RunnerBackend,
+  type RunnerBaseOptions,
+  type InstanceUpdateOptions,
+  type InstanceWatchOptions,
+  InvalidInstanceStatusError,
+  type InstanceDestroyOptions,
+} from "./abstractions"
+
+type Events = {
+  [K in `state:${string}`]: [Partial<InstanceState>]
+}
+
+export const localRunnerBackendConfig = z.object({
+  HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK: z.boolean({ coerce: true }).default(false),
+  HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT: z.boolean({ coerce: true }).default(true),
+  HIGHSTATE_BACKEND_RUNNER_LOCAL_CACHE_DIR: z.string().optional(),
+})
+
+export class LocalRunnerBackend implements RunnerBackend {
+  private readonly events = new EventEmitter<Events>()
+
+  constructor(
+    private readonly skipStateCheck: boolean,
+    private readonly printOutput: boolean,
+    private readonly cacheDir: string,
+    private readonly pulumiProjectHost: LocalPulumiHost,
+    private readonly libraryBackend: LibraryBackend,
+  ) {}
+
+  async *watch(options: InstanceWatchOptions): AsyncIterable<InstanceStateUpdate> {
+    const stream = on(
+      //
+      this.events,
+      `state:${LocalRunnerBackend.getInstanceId(options)}`,
+      { signal: options.signal },
+    ) as AsyncIterable<[InstanceStateUpdate]>
+
+    for await (const [statePatch] of stream) {
+      yield statePatch
+
+      if (statePatch.status && options.finalStatuses?.includes(statePatch.status)) {
+        return
+      }
+    }
+  }
+
+  getState(options: RunnerBaseOptions): Promise<InstanceState> {
+    return this.pulumiProjectHost.runEmpty(
+      {
+        projectId: options.projectId,
+        pulumiProjectName: options.instanceType,
+        pulumiStackName: LocalRunnerBackend.getStackName(options),
+      },
+      async stack => {
+        const info = await stack.info()
+        const instanceId = getInstanceId(options.instanceType, options.instanceName)
+
+        if (!info) {
+          return createInstanceState(instanceId)
+        }
+
+        if (info.result === "failed") {
+          return createInstanceState(instanceId, "error")
+        }
+
+        if (info.result !== "succeeded") {
+          return createInstanceState(instanceId, "unknown")
+        }
+
+        const summary = await stack.workspace.stack()
+        const resourceCount = summary?.resourceCount
+
+        if (!resourceCount) {
+          return createInstanceState(instanceId, "not_created")
+        }
+
+        return createInstanceState(instanceId, "created", {
+          currentResourceCount: resourceCount,
+          totalResourceCount: resourceCount,
+        })
+      },
+    )
+  }
+
+  getTerminalFactory(
+    options: RunnerBaseOptions,
+    terminalName: string,
+  ): Promise<InstanceTerminal | null> {
+    return this.pulumiProjectHost.runEmpty(
+      {
+        projectId: options.projectId,
+        pulumiProjectName: options.instanceType,
+        pulumiStackName: LocalRunnerBackend.getStackName(options),
+      },
+      async stack => {
+        const outputs = await stack.outputs()
+
+        if (!outputs["$terminals"]) {
+          return null
+        }
+
+        const terminals = z.array(instanceTerminalSchema).parse(outputs["$terminals"].value)
+        const terminal = terminals.find(t => t.name === terminalName)
+
+        if (!terminal) {
+          return null
+        }
+
+        return terminal
+      },
+    )
+  }
+
+  getPageContent(
+    options: RunnerBaseOptions,
+    pageName: string,
+  ): Promise<InstancePageBlock[] | null> {
+    return this.pulumiProjectHost.runEmpty(
+      {
+        projectId: options.projectId,
+        pulumiProjectName: options.instanceType,
+        pulumiStackName: LocalRunnerBackend.getStackName(options),
+      },
+      async stack => {
+        const outputs = await stack.outputs()
+
+        if (!outputs["$pages"]) {
+          return null
+        }
+
+        const pages = z.array(instancePageSchema).parse(outputs["$pages"].value)
+        const page = pages.find(p => p.name === pageName)
+
+        if (!page) {
+          return null
+        }
+
+        return page.content
+      },
+    )
+  }
+
+  getFileContent(options: RunnerBaseOptions, fileName: string): Promise<string | null> {
+    return this.pulumiProjectHost.runEmpty(
+      {
+        projectId: options.projectId,
+        pulumiProjectName: options.instanceType,
+        pulumiStackName: LocalRunnerBackend.getStackName(options),
+      },
+      async stack => {
+        const outputs = await stack.outputs()
+
+        if (!outputs["$files"]) {
+          return null
+        }
+
+        const files = z.array(instanceFileSchema).parse(outputs["$files"].value)
+        const file = files.find(f => f.meta.name === fileName)
+
+        if (!file) {
+          return null
+        }
+
+        return file.content
+      },
+    )
+  }
+
+  async update(options: InstanceUpdateOptions): Promise<void> {
+    const currentStatus = await this.validateStatus(options, [
+      "not_created",
+      "updating",
+      "created",
+      "error",
+    ])
+
+    if (currentStatus === "updating") {
+      return
+    }
+
+    const configMap: ConfigMap = {
+      ...mapValues(options.config, value => ({ value })),
+      ...mapValues(options.secrets, value => ({ value, secret: true })),
+    }
+
+    void this.updateWorker(options, configMap, false)
+  }
+
+  async preview(options: InstanceUpdateOptions): Promise<void> {
+    const currentStatus = await this.validateStatus(options, [
+      "not_created",
+      "previewing",
+      "created",
+      "error",
+    ])
+
+    if (currentStatus === "previewing") {
+      return
+    }
+
+    const configMap: ConfigMap = {
+      ...mapValues(options.config, value => ({ value })),
+      ...mapValues(options.secrets, value => ({ value, secret: true })),
+    }
+
+    void this.updateWorker(options, configMap, true)
+  }
+
+  private async updateWorker(
+    options: InstanceUpdateOptions,
+    configMap: ConfigMap,
+    preview: boolean,
+  ): Promise<void> {
+    const instanceId = LocalRunnerBackend.getInstanceId(options)
+
+    try {
+      const resolvedSource = await this.libraryBackend.getResolvedUnitSource(options.instanceType)
+      if (!resolvedSource) {
+        throw new Error(`Resolved unit source not found for ${options.instanceType}`)
+      }
+
+      await this.pulumiProjectHost.runLocal(
+        {
+          projectId: options.projectId,
+          pulumiProjectName: options.instanceType,
+          pulumiStackName: LocalRunnerBackend.getStackName(options),
+          projectPath: resolvedSource.projectPath,
+          stackConfig: configMap,
+          envVars: {
+            HIGHSTATE_CACHE_DIR: this.cacheDir,
+          },
+        },
+        async stack => {
+          await this.setStackConfig(stack, configMap)
+
+          this.updateState({
+            id: instanceId,
+            status: preview ? "previewing" : "updating",
+            currentResourceCount: 0,
+            totalResourceCount: 0,
+          })
+
+          let currentResourceCount = 0
+          let totalResourceCount = 0
+
+          await runWithRetryOnError(
+            async () => {
+              await stack[preview ? "preview" : "up"]({
+                color: "always",
+                refresh: options.refresh,
+                signal: options.signal,
+                diff: preview,
+
+                onEvent: event => {
+                  if (event.resourcePreEvent) {
+                    totalResourceCount = updateResourceCount(
+                      event.resourcePreEvent.metadata.op,
+                      totalResourceCount,
+                    )
+
+                    this.updateState({ id: instanceId, totalResourceCount })
+                    return
+                  }
+
+                  if (event.resOutputsEvent) {
+                    currentResourceCount = updateResourceCount(
+                      event.resOutputsEvent.metadata.op,
+                      currentResourceCount,
+                    )
+
+                    this.updateState({ id: instanceId, currentResourceCount })
+                    return
+                  }
+                },
+
+                onOutput: message => {
+                  this.updateState({ id: instanceId, logLine: message })
+
+                  if (this.printOutput) {
+                    console.log(message)
+                  }
+                },
+              })
+
+              const extraOutputs = await this.getExtraOutputsStatePatch(stack)
+
+              this.updateState({
+                id: instanceId,
+                status: "created",
+                totalResourceCount: currentResourceCount,
+                ...extraOutputs,
+              })
+            },
+            async error => {
+              const isUnlocked = await this.pulumiProjectHost.tryUnlockStack(stack, error)
+              if (isUnlocked) return true
+
+              const isResolved = await this.tryInstallMissingDependencies(
+                error,
+                resolvedSource.allowedDependencies,
+              )
+              if (isResolved) return true
+
+              return false
+            },
+          )
+        },
+      )
+    } catch (error) {
+      this.updateState({
+        id: instanceId,
+        status: "error",
+        error: errorToString(error),
+      })
+    }
+  }
+
+  private async setStackConfig(stack: Stack, configMap: ConfigMap): Promise<void> {
+    const currentConfig = await stack.getAllConfig()
+    const currentConfigKeys = Object.keys(currentConfig)
+
+    await stack.removeAllConfig(currentConfigKeys)
+    await stack.setAllConfig(configMap)
+  }
+
+  async destroy(options: InstanceDestroyOptions): Promise<void> {
+    const currentStatus = await this.validateStatus(options, [
+      "not_created",
+      "destroying",
+      "created",
+      "error",
+    ])
+
+    if (currentStatus === "destroying") {
+      return
+    }
+
+    void this.destroyWorker(options)
+  }
+
+  private async destroyWorker(options: InstanceDestroyOptions): Promise<void> {
+    const instanceId = LocalRunnerBackend.getInstanceId(options)
+
+    try {
+      const resolvedSource = await this.libraryBackend.getResolvedUnitSource(options.instanceType)
+      if (!resolvedSource) {
+        throw new Error(`Resolved unit source not found for ${options.instanceType}`)
+      }
+
+      await this.pulumiProjectHost.runLocal(
+        {
+          projectId: options.projectId,
+          pulumiProjectName: options.instanceType,
+          pulumiStackName: LocalRunnerBackend.getStackName(options),
+          projectPath: resolvedSource.projectPath,
+          envVars: {
+            HIGHSTATE_CACHE_DIR: this.cacheDir,
+            PULUMI_K8S_DELETE_UNREACHABLE: options.deleteUnreachable ? "true" : "",
+          },
+        },
+        async stack => {
+          const summary = await stack.workspace.stack()
+          let currentResourceCount = summary?.resourceCount ?? 0
+
+          this.updateState({
+            id: instanceId,
+            status: "destroying",
+            currentResourceCount,
+            totalResourceCount: currentResourceCount,
+          })
+
+          await runWithRetryOnError(
+            async () => {
+              await stack.destroy({
+                color: "always",
+                refresh: options.refresh,
+                remove: true,
+                signal: options.signal,
+
+                onEvent: event => {
+                  if (event.resOutputsEvent) {
+                    currentResourceCount = updateResourceCount(
+                      event.resOutputsEvent.metadata.op,
+                      currentResourceCount,
+                    )
+
+                    this.updateState({ id: instanceId, currentResourceCount })
+                    return
+                  }
+                },
+
+                onOutput: message => {
+                  this.updateState({ id: instanceId, logLine: message })
+
+                  if (this.printOutput) {
+                    console.log(message)
+                  }
+                },
+              })
+
+              const extraOutputs = await this.getExtraOutputsStatePatch(stack)
+
+              this.updateState({
+                id: instanceId,
+                status: "not_created",
+                totalResourceCount: currentResourceCount,
+                ...extraOutputs,
+              })
+            },
+            error => this.pulumiProjectHost.tryUnlockStack(stack, error),
+          )
+        },
+      )
+    } catch (error) {
+      const { StackNotFoundError } = await import("@pulumi/pulumi/automation/index.js")
+
+      if (error instanceof StackNotFoundError) {
+        this.updateState({
+          id: instanceId,
+          status: "not_created",
+          totalResourceCount: 0,
+          currentResourceCount: 0,
+          statusFields: [],
+          pages: [],
+          files: [],
+          terminals: [],
+          triggers: [],
+        })
+        return
+      }
+
+      this.updateState({
+        id: instanceId,
+        status: "error",
+        error: errorToString(error),
+      })
+    }
+  }
+
+  async refresh(options: RunnerBaseOptions): Promise<void> {
+    const currentStatus = await this.validateStatus(options, [
+      "not_created",
+      "created",
+      "refreshing",
+      "error",
+    ])
+
+    if (currentStatus === "refreshing") {
+      return
+    }
+
+    void this.refreshWorker(options)
+  }
+
+  private async refreshWorker(options: RunnerBaseOptions): Promise<void> {
+    const instanceId = LocalRunnerBackend.getInstanceId(options)
+
+    try {
+      await this.pulumiProjectHost.runEmpty(
+        {
+          projectId: options.projectId,
+          pulumiProjectName: options.instanceType,
+          pulumiStackName: LocalRunnerBackend.getStackName(options),
+        },
+        async stack => {
+          const summary = await stack.workspace.stack()
+
+          let currentResourceCount = 0
+          let totalResourceCount = summary?.resourceCount ?? 0
+
+          this.updateState({
+            id: instanceId,
+            status: "refreshing",
+            currentResourceCount,
+            totalResourceCount,
+          })
+
+          await runWithRetryOnError(
+            async () => {
+              await stack.refresh({
+                color: "always",
+                onEvent: event => {
+                  if (event.resourcePreEvent) {
+                    totalResourceCount = updateResourceCount(
+                      event.resourcePreEvent.metadata.op,
+                      totalResourceCount,
+                    )
+
+                    this.updateState({ id: instanceId, totalResourceCount })
+                    return
+                  }
+
+                  if (event.resOutputsEvent) {
+                    currentResourceCount = updateResourceCount(
+                      event.resOutputsEvent.metadata.op,
+                      currentResourceCount,
+                    )
+
+                    this.updateState({ id: instanceId, currentResourceCount })
+                    return
+                  }
+                },
+                onOutput: message => {
+                  this.updateState({ id: instanceId, logLine: message })
+
+                  if (this.printOutput) {
+                    console.log(message)
+                  }
+                },
+                signal: options.signal,
+              })
+
+              const extraOutputs = await this.getExtraOutputsStatePatch(stack)
+
+              this.updateState({
+                id: instanceId,
+                status: "created",
+                totalResourceCount: currentResourceCount,
+                ...extraOutputs,
+              })
+            },
+            error => this.pulumiProjectHost.tryUnlockStack(stack, error),
+          )
+        },
+      )
+    } catch (error) {
+      this.updateState({
+        id: instanceId,
+        status: "error",
+        error: errorToString(error),
+      })
+    }
+  }
+
+  private async getExtraOutputsStatePatch(stack: Stack) {
+    const outputs = await stack.outputs()
+    const patch: Omit<InstanceStateUpdate, "id"> = {}
+
+    if (outputs["$status"]) {
+      patch.statusFields = z.array(instanceStatusFieldSchema).parse(outputs["$status"].value)
+    } else {
+      patch.statusFields = []
+    }
+
+    if (outputs["$pages"]) {
+      const pages = z.array(instancePageSchema).parse(outputs["$pages"].value)
+
+      patch.pages = pages.map(page => omit(page, ["content"]))
+    } else {
+      patch.pages = []
+    }
+
+    if (outputs["$files"]) {
+      const files = z.array(instanceFileSchema).parse(outputs["$files"].value)
+
+      patch.files = files.map(file => file.meta)
+    } else {
+      patch.files = []
+    }
+
+    if (outputs["$terminals"]) {
+      const terminals = z.array(instanceTerminalSchema).parse(outputs["$terminals"].value)
+
+      patch.terminals = terminals.map(terminal => pick(terminal, ["name", "title", "description"]))
+    } else {
+      patch.terminals = []
+    }
+
+    if (outputs["$triggers"]) {
+      patch.triggers = z.array(instanceTriggerSchema).parse(outputs["$triggers"].value)
+    } else {
+      patch.triggers = []
+    }
+
+    if (outputs["$secrets"]) {
+      patch.secrets = pickBy(
+        z.record(z.string().nullish()).parse(outputs["$secrets"].value),
+        v => !!v,
+      ) as Record<string, string>
+    } else {
+      patch.secrets = null
+    }
+
+    patch.outputHash = await sha256(JSON.stringify(outputs))
+
+    return patch
+  }
+
+  private updateState(patch: InstanceStateUpdate) {
+    this.events.emit(`state:${patch.id}`, patch)
+  }
+
+  private async validateStatus(
+    options: RunnerBaseOptions,
+    expectedStatuses: InstanceStatus[],
+  ): Promise<InstanceStatus | undefined> {
+    if (this.skipStateCheck) {
+      return
+    }
+
+    const existingState = await this.getState(options)
+
+    if (!existingState) {
+      return
+    }
+
+    if (!expectedStatuses.includes(existingState.status)) {
+      throw new InvalidInstanceStatusError(existingState.status, expectedStatuses)
+    }
+
+    return existingState.status
+  }
+
+  private static getInstanceId(options: RunnerBaseOptions) {
+    return getInstanceId(options.instanceType, options.instanceName)
+  }
+
+  private async tryInstallMissingDependencies(
+    error: unknown,
+    allowedDependencies: string[],
+  ): Promise<boolean> {
+    if (!(error instanceof Error)) {
+      return false
+    }
+
+    const pattern = /Cannot find module '(.*)'/
+    const match = error.message.match(pattern)
+
+    if (!match) {
+      return false
+    }
+
+    const packageName = match[1]
+
+    if (!allowedDependencies.includes(packageName)) {
+      throw new Error(
+        `Dependency '${packageName}' was requested to be auto-installed, but it is not allowed. Please add it to the 'peerDependencies' in the package.json of the unit.`,
+      )
+    }
+
+    await ensureDependencyInstalled(packageName)
+    return true
+  }
+
+  private static getStackName(options: RunnerBaseOptions) {
+    return `${options.projectId}_${options.instanceName}`
+  }
+
+  public static create(
+    config: z.infer<typeof localRunnerBackendConfig>,
+    pulumiProjectHost: LocalPulumiHost,
+    libraryBackend: LibraryBackend,
+  ): RunnerBackend {
+    let cacheDir = config.HIGHSTATE_BACKEND_RUNNER_LOCAL_CACHE_DIR
+    if (!cacheDir) {
+      const homeDir = process.env.HOME ?? process.env.USERPROFILE
+      if (!homeDir) {
+        throw new Error(
+          "Failed to determine the home directory, please set HIGHSTATE_BACKEND_RUNNER_LOCAL_CACHE_DIR",
+        )
+      }
+
+      cacheDir = resolve(homeDir, ".cache", "highstate")
+    }
+
+    return new LocalRunnerBackend(
+      config.HIGHSTATE_BACKEND_RUNNER_LOCAL_SKIP_STATE_CHECK,
+      config.HIGHSTATE_BACKEND_RUNNER_LOCAL_PRINT_OUTPUT,
+      cacheDir,
+      pulumiProjectHost,
+      libraryBackend,
+    )
+  }
+}