@highstate/k8s 0.9.18 → 0.9.20

package/src/stateful-set.ts

@@ -1,23 +1,30 @@
+import type { AccessPointRoute } from "@highstate/common"
 import type { k8s } from "@highstate/library"
-import type { HttpRoute } from "./gateway"
-import type { Service } from "./service"
+import type { Container } from "./container"
 import type { NetworkPolicy } from "./network-policy"
-import { output, type ComponentResourceOptions, Output, type Input } from "@highstate/pulumi"
-import { apps, types } from "@pulumi/kubernetes"
-import { omit } from "remeda"
-import { deepmerge } from "deepmerge-ts"
+import type { Service } from "./service"
+import { getOrCreate, type UnitTerminal } from "@highstate/contract"
 import {
-  getProvider,
-  mapMetadata,
-  resourceIdToString,
-  withPatchName,
-  type ResourceId,
-} from "./shared"
+  type ComponentResourceOptions,
+  type Input,
+  type Inputs,
+  interpolate,
+  type Output,
+  output,
+  toPromise,
+  type Unwrap,
+} from "@highstate/pulumi"
+import { apps, type types } from "@pulumi/kubernetes"
+import { deepmerge } from "deepmerge-ts"
+import { omit } from "remeda"
+import { Namespace } from "./namespace"
+import { getProvider, mapMetadata } from "./shared"
 import {
-  exposableWorkloadExtraArgs,
   ExposableWorkload,
   type ExposableWorkloadArgs,
+  exposableWorkloadExtraArgs,
   getExposableWorkloadComponents,
+  type WorkloadTerminalArgs,
 } from "./workload"
 
 export type StatefulSetArgs = Omit<ExposableWorkloadArgs, "existing"> &
@@ -39,11 +46,19 @@ export abstract class StatefulSet extends ExposableWorkload {
   protected constructor(
     type: string,
     name: string,
-    args: ExposableWorkloadArgs,
+    args: Inputs,
     opts: ComponentResourceOptions | undefined,
 
-    cluster: Output<k8s.Cluster>,
+    apiVersion: Output<string>,
+    kind: Output<string>,
+    terminalArgs: Output<Unwrap<WorkloadTerminalArgs>>,
+    containers: Output<Container[]>,
+    namespace: Output<Namespace>,
     metadata: Output<types.output.meta.v1.ObjectMeta>,
+    networkPolicy: Output<NetworkPolicy | undefined>,
+
+    service: Output<Service | undefined>,
+    routes: Output<AccessPointRoute[]>,
 
     /**
      * The spec of the underlying Kubernetes stateful set.
@@ -54,23 +69,21 @@ export abstract class StatefulSet extends ExposableWorkload {
      * The status of the underlying Kubernetes stateful set.
      */
     readonly status: Output<types.output.apps.v1.StatefulSetStatus>,
-
-    networkPolicy: Output<NetworkPolicy | undefined>,
-
-    service: Output<Service | undefined>,
-    httpRoute: Output<HttpRoute | undefined>,
   ) {
     super(
       type,
       name,
       args,
       opts,
-      "statefulset",
-      cluster,
+      apiVersion,
+      kind,
+      terminalArgs,
+      containers,
+      namespace,
       metadata,
       networkPolicy,
       service,
-      httpRoute,
+      routes,
     )
   }
 
@@ -79,66 +92,162 @@ export abstract class StatefulSet extends ExposableWorkload {
    */
   get entity(): Output<k8s.StatefulSet> {
     return output({
-      type: "k8s.stateful-set",
+      type: "stateful-set",
       clusterId: this.cluster.id,
+      clusterName: this.cluster.name,
       metadata: this.metadata,
       service: this.service.entity,
     })
   }
 
+  /**
+   * Creates a new stateful set.
+   */
   static create(name: string, args: StatefulSetArgs, opts?: ComponentResourceOptions): StatefulSet {
     return new CreatedStatefulSet(name, args, opts)
   }
 
+  /**
+   * Creates a new stateful set or patches an existing one.
+   *
+   * @param name The name of the resource. May not be the same as the stateful set name.
+   * @param args The arguments to create or patch the stateful set with.
+   * @param opts Optional resource options.
+   */
   static createOrPatch(
     name: string,
     args: CreateOrGetStatefulSetArgs,
     opts?: ComponentResourceOptions,
   ): StatefulSet {
-    if (!args.existing) {
-      return new CreatedStatefulSet(name, args, opts)
+    if (args.existing) {
+      return new StatefulSetPatch(name, {
+        ...args,
+        name: output(args.existing).metadata.name,
+        namespace: Namespace.forResourceAsync(args.existing, output(args.namespace).cluster),
+      })
     }
 
-    return new StatefulSetPatch(
-      name,
-      {
-        ...args,
-        name: withPatchName("stateful set", args.existing, args.cluster),
-        namespace: output(args.existing).metadata.namespace,
-      },
-      opts,
-    )
+    return new CreatedStatefulSet(name, args, opts)
+  }
+
+  /**
+   * Creates a new stateful set or gets an existing one.
+   *
+   * @param name The name of the resource. May not be the same as the stateful set name. Will not be used when existing stateful set is retrieved.
+   * @param args The arguments to create or get the stateful set with.
+   * @param opts Optional resource options.
+   */
+  static async createOrGet(
+    name: string,
+    args: CreateOrGetStatefulSetArgs,
+    opts?: ComponentResourceOptions,
+  ): Promise<StatefulSet> {
+    if (args.existing) {
+      return await StatefulSet.forAsync(args.existing, output(args.namespace).cluster)
+    }
+
+    return new CreatedStatefulSet(name, args, opts)
   }
 
+  /**
+   * Patches an existing stateful set.
+   *
+   * Will throw an error if the stateful set does not exist.
+   *
+   * @param name The name of the resource. May not be the same as the stateful set name.
+   * @param args The arguments to patch the stateful set with.
+   * @param opts Optional resource options.
+   */
   static patch(name: string, args: StatefulSetArgs, opts?: ComponentResourceOptions): StatefulSet {
     return new StatefulSetPatch(name, args, opts)
   }
 
-  static createOrGet(
+  /**
+   * Wraps an existing Kubernetes stateful set.
+   */
+  static wrap(
     name: string,
-    args: CreateOrGetStatefulSetArgs,
+    args: WrappedStatefulSetArgs,
     opts?: ComponentResourceOptions,
   ): StatefulSet {
-    if (!args.existing) {
-      return new CreatedStatefulSet(name, args, opts)
-    }
-
-    return new ExternalStatefulSet(name, output(args.existing).metadata, args.cluster, opts)
+    return new WrappedStatefulSet(name, args, opts)
   }
 
-  static wrap(
+  /**
+   * Gets an existing stateful set.
+   *
+   * Will throw an error if the stateful set does not exist.
+   */
+  static get(
     name: string,
-    statefulSet: Input<apps.v1.StatefulSet>,
-    cluster: Input<k8s.Cluster>,
+    args: ExternalStatefulSetArgs,
     opts?: ComponentResourceOptions,
   ): StatefulSet {
-    return new WrappedStatefulSet(name, statefulSet, cluster, opts)
+    return new ExternalStatefulSet(name, args, opts)
+  }
+
+  private static readonly statefulSetCache = new Map<string, StatefulSet>()
+
+  /**
+   * Gets an existing stateful set for a given entity.
+   * Prefer this method over `get` when possible.
+   *
+   * It automatically names the resource with the following format: `{clusterName}.{namespace}.{name}.{clusterId}`.
+   *
+   * This method is idempotent and will return the same instance for the same entity.
+   *
+   * @param entity The entity to get the stateful set for.
+   * @param cluster The cluster where the stateful set is located.
+   */
+  static for(entity: k8s.StatefulSet, cluster: Input<k8s.Cluster>): StatefulSet {
+    return getOrCreate(
+      StatefulSet.statefulSetCache,
+      `${entity.clusterName}.${entity.metadata.namespace}.${entity.metadata.name}.${entity.clusterId}`,
+      name => {
+        return StatefulSet.get(name, {
+          name: entity.metadata.name,
+          namespace: Namespace.forResource(entity, cluster),
+        })
+      },
+    )
+  }
+
+  /**
+   * Gets an existing stateful set for a given entity.
+   * Prefer this method over `get` when possible.
+   *
+   * It automatically names the resource with the following format: `{clusterName}.{namespace}.{name}.{clusterId}`.
+   *
+   * This method is idempotent and will return the same instance for the same entity.
+   *
+   * @param entity The entity to get the stateful set for.
+   * @param cluster The cluster where the stateful set is located.
+   */
+  static async forAsync(
+    entity: Input<k8s.StatefulSet>,
+    cluster: Input<k8s.Cluster>,
+  ): Promise<StatefulSet> {
+    const resolvedEntity = await toPromise(entity)
+    return StatefulSet.for(resolvedEntity, cluster)
+  }
+
+  protected getTerminalMeta(): Output<UnitTerminal["meta"]> {
+    return output({
+      title: "StatefulSet",
+      globalTitle: interpolate`StatefulSet | ${this.metadata.name}`,
+      description: "The shell inside the stateful set.",
+      icon: "devicon:kubernetes",
+    })
+  }
+
+  protected get resourceType(): string {
+    return "statefulset"
   }
 }
 
 class CreatedStatefulSet extends StatefulSet {
   constructor(name: string, args: StatefulSetArgs, opts?: ComponentResourceOptions) {
-    const { labels, podTemplate, networkPolicy, service, httpRoute } =
+    const { labels, podTemplate, networkPolicy, containers, service, routes } =
       getExposableWorkloadComponents(
         name,
         {
@@ -151,24 +260,28 @@ class CreatedStatefulSet extends StatefulSet {
         opts,
       )
 
-    const statefulSet = output({ args, podTemplate }).apply(async ({ args, podTemplate }) => {
+    const statefulSet = output(args.namespace).cluster.apply(cluster => {
       return new apps.v1.StatefulSet(
         name,
         {
           metadata: mapMetadata(args, name),
-          spec: deepmerge(
-            {
-              serviceName: service.apply(service => service!.metadata.name),
-              template: podTemplate,
-              selector: { matchLabels: labels },
+          spec: output({ args, podTemplate, labels, service }).apply(
+            ({ args, podTemplate, labels, service }) => {
+              return deepmerge(
+                {
+                  serviceName: service?.metadata.name,
+                  template: podTemplate,
+                  selector: { matchLabels: labels },
+                },
+                omit(args, exposableWorkloadExtraArgs),
+              ) as types.input.apps.v1.StatefulSetSpec
             },
-            omit(args, exposableWorkloadExtraArgs),
-          ) as types.input.apps.v1.StatefulSetSpec,
+          ),
         },
         {
           ...opts,
           parent: this,
-          provider: await getProvider(args.cluster),
+          provider: getProvider(cluster),
         },
       )
     })
@@ -179,45 +292,47 @@ class CreatedStatefulSet extends StatefulSet {
       args,
       opts,
 
-      output(args.cluster),
+      statefulSet.apiVersion,
+      statefulSet.kind,
+      output(args.terminal ?? {}),
+      containers,
+      output(args.namespace),
       statefulSet.metadata,
-      statefulSet.spec,
-      statefulSet.status,
-
       networkPolicy,
+
       service,
-      httpRoute,
+      routes,
+
+      statefulSet.spec,
+      statefulSet.status,
     )
   }
 }
 
 class StatefulSetPatch extends StatefulSet {
   constructor(name: string, args: StatefulSetArgs, opts?: ComponentResourceOptions) {
-    const { podSpec, networkPolicy, service, httpRoute } = getExposableWorkloadComponents(
-      name,
-      args,
-      () => this,
-      opts,
-    )
+    const { labels, podTemplate, networkPolicy, containers, service, routes } =
+      getExposableWorkloadComponents(name, args, () => this, opts)
 
-    const statefulSet = output({ args, podSpec }).apply(async ({ args, podSpec }) => {
+    const statefulSet = output(args.namespace).cluster.apply(cluster => {
       return new apps.v1.StatefulSetPatch(
         name,
         {
           metadata: mapMetadata(args, name),
-          spec: deepmerge(
-            {
-              template: {
-                spec: podSpec,
+          spec: output({ args, podTemplate, labels }).apply(({ args, podTemplate, labels }) => {
+            return deepmerge(
+              {
+                template: podTemplate,
+                selector: { matchLabels: labels },
               },
-            },
-            omit(args, exposableWorkloadExtraArgs),
-          ) as types.input.apps.v1.StatefulSetSpec,
+              omit(args, exposableWorkloadExtraArgs),
+            ) as types.input.apps.v1.StatefulSetSpec
+          }),
         },
         {
           ...opts,
           parent: this,
-          provider: await getProvider(args.cluster),
+          provider: getProvider(cluster),
         },
       )
     })
@@ -228,71 +343,109 @@ class StatefulSetPatch extends StatefulSet {
       args,
       opts,
 
-      output(args.cluster),
+      statefulSet.apiVersion,
+      statefulSet.kind,
+      output(args.terminal ?? {}),
+      containers,
+      output(args.namespace),
       statefulSet.metadata,
-      statefulSet.spec,
-      statefulSet.status,
-
       networkPolicy,
+
       service,
-      httpRoute,
+      routes,
+
+      statefulSet.spec,
+      statefulSet.status,
     )
   }
 }
 
-class ExternalStatefulSet extends StatefulSet {
-  constructor(
-    name: string,
-    id: Input<ResourceId>,
-    cluster: Input<k8s.Cluster>,
-    opts?: ComponentResourceOptions,
-  ) {
-    const statefulSet = output(id).apply(async id => {
-      return apps.v1.StatefulSet.get(name, resourceIdToString(id), {
-        ...opts,
-        parent: this,
-        provider: await getProvider(cluster),
-      })
-    })
+export type WrappedStatefulSetArgs = {
+  /**
+   * The underlying Kubernetes stateful set to wrap.
+   */
+  statefulSet: Input<apps.v1.StatefulSet>
 
+  // TODO: remove
+  service?: Input<Service>
+
+  /**
+   * The namespace where the stateful set is located.
+   */
+  namespace: Input<Namespace>
+
+  /**
+   * The args for the terminal to use.
+   */
+  terminal?: Input<WorkloadTerminalArgs>
+}
+
+class WrappedStatefulSet extends StatefulSet {
+  constructor(name: string, args: WrappedStatefulSetArgs, opts?: ComponentResourceOptions) {
     super(
-      "highstate:k8s:ExternalStatefulSet",
+      "highstate:k8s:WrappedStatefulSet",
       name,
-      { namespace: output(id).namespace, cluster },
+      args,
       opts,
-      output(cluster),
-      statefulSet.metadata,
-      statefulSet.spec,
-      statefulSet.status,
+
+      output(args.statefulSet).apiVersion,
+      output(args.statefulSet).kind,
+      output(args.terminal ?? {}),
+      output([]),
+      output(args.namespace),
+      output(args.statefulSet).metadata,
 
       output(undefined),
-      output(undefined),
-      output(undefined),
+      output(args.service),
+      output([]),
+
+      output(args.statefulSet).spec,
+      output(args.statefulSet).status,
     )
   }
 }
 
-class WrappedStatefulSet extends StatefulSet {
-  constructor(
-    name: string,
-    statefulSet: Input<apps.v1.StatefulSet>,
-    cluster: Input<k8s.Cluster>,
-    opts?: ComponentResourceOptions,
-  ) {
+export type ExternalStatefulSetArgs = {
+  /**
+   * The name of the stateful set to get.
+   */
+  name: Input<string>
+
+  /**
+   * The namespace where the stateful set is located.
+   */
+  namespace: Input<Namespace>
+}
+
+class ExternalStatefulSet extends StatefulSet {
+  constructor(name: string, args: ExternalStatefulSetArgs, opts?: ComponentResourceOptions) {
+    const statefulSet = output(args.namespace).cluster.apply(cluster => {
+      return apps.v1.StatefulSet.get(
+        name,
+        interpolate`${output(args.namespace).metadata.name}/${args.name}`,
+        { ...opts, parent: this, provider: getProvider(cluster) },
+      )
+    })
+
     super(
-      "highstate:k8s:WrappedStatefulSet",
+      "highstate:k8s:ExternalStatefulSet",
       name,
-      { namespace: output(statefulSet).metadata.namespace, cluster },
+      args,
       opts,
 
-      output(cluster),
-      output(statefulSet).metadata,
-      output(statefulSet).spec,
-      output(statefulSet).status,
+      statefulSet.apiVersion,
+      statefulSet.kind,
+      output({}),
+      output([]),
+      output(args.namespace),
+      statefulSet.metadata,
 
       output(undefined),
       output(undefined),
-      output(undefined),
+      output([]),
+
+      statefulSet.spec,
+      statefulSet.status,
     )
   }
 }