k8ts 0.13.2 → 0.14.0

package/src/resources/workload/statefulset/statefulset.ts

@@ -0,0 +1,137 @@
+import { K8sResource, ResourceRef, TemplateOrigin } from "@k8ts/instruments"
+import { K8S } from "@k8ts/sample-interfaces"
+import { doddle, seq } from "doddle"
+import { merge, omit } from "lodash"
+import { Pvc } from "../../.."
+import { apps } from "../../../gvks/apps"
+import { K8tsResourceError } from "../../errors"
+import { Service } from "../../network"
+import type { Pod_Scope } from "../pod/container/scope"
+import { Pod } from "../pod/pod"
+import { createSelectionMetadata } from "../util"
+import type { Workload_Ref } from "../workload-ref"
+import type { StatefulSet_Props } from "./props"
+import { StatefulSet_Scope } from "./scope"
+export class StatefulSet<
+        Name extends string = string,
+        SvcName extends string = string,
+        Ports extends string = string,
+        SvcPorts extends NoInfer<Ports> = Ports
+    >
+    extends K8sResource<Name, StatefulSet_Props<Ports, SvcPorts, SvcName>>
+    implements Workload_Ref<Ports>
+{
+    private readonly _template = new TemplateOrigin(`${this.ident.name}_template`, {
+        owner: this
+    })
+    readonly Service = new Service(
+        this.props.$service.name,
+        {
+            ...this.props.$service,
+            $backend: this,
+            $frontend: {
+                type: "Headless"
+            }
+        },
+        {
+            metadata: {
+                "^k8ts.org/auto-created-by": this.__entity_id__
+            }
+        }
+    )
+    get kind() {
+        return apps.v1.StatefulSet._
+    }
+
+    protected __needs__(): Record<string, ResourceRef> {
+        return {
+            service: this.Service
+        }
+    }
+
+    get selectorLabels() {
+        return createSelectionMetadata(this)
+    }
+
+    private _podTemplate = doddle(() => {
+        const self = this
+        const wrappedContainers = (podScope: Pod_Scope) => {
+            return this.props.$template.containers$(new StatefulSet_Scope(podScope, self._template))
+        }
+        const resource = new Pod(
+            `${self.ident.name}`,
+            {
+                ...self.props.$template,
+                containers$: wrappedContainers
+            },
+            {
+                origins: {
+                    own: self._template,
+                    subscope: self["__origin__"]
+                },
+                metadata: this.selectorLabels
+            }
+        )
+
+        return resource
+    })
+
+    protected __kids__(): Iterable<ResourceRef> {
+        this._podTemplate.pull()
+        return [...this.PvcTemplates, this.PodTemplate]
+    }
+
+    protected async __body__(): Promise<K8S.KubeStatefulSetProps> {
+        const self = this
+        const template = await self.PodTemplate["__manifest__"]()
+        const noKindFields = omit(template, ["kind", "apiVersion"])
+        const spec = {
+            replicas: self.props.$replicas,
+            selector: {
+                matchLabels: this.selectorLabels.labels
+            },
+            serviceName: self.Service.ident.name,
+            template: noKindFields,
+            volumeClaimTemplates: await Promise.all(
+                seq(self.PvcTemplates).map(pvc => pvc["__manifest__"]())
+            ),
+            updateStrategy: self._updateStrategy
+        } satisfies K8S.StatefulSetSpec
+        const spec2 = merge(spec, self.props.$$manifest)
+        return {
+            spec: spec2
+        }
+    }
+
+    private get _updateStrategy() {
+        const strategy = this.props.$updateStrategy
+        if (!strategy) {
+            return undefined
+        }
+        if (strategy.type === "OnDelete") {
+            return { type: "OnDelete" }
+        }
+        if (strategy.type === "RollingUpdate") {
+            return {
+                type: "RollingUpdate",
+                rollingUpdate: omit(strategy, "type")
+            }
+        }
+        throw new K8tsResourceError(`Invalid update strategy type: ${strategy}`)
+    }
+
+    get PodTemplate() {
+        return this._podTemplate.pull()
+    }
+
+    get PvcTemplates() {
+        this._podTemplate.pull()
+        return seq(this._template.resources)
+            .filter(x => x.is(Pvc))
+            .toIterable()
+    }
+
+    get ports() {
+        return this.PodTemplate.ports
+    }
+}

package/src/resources/workload/util.ts

@@ -0,0 +1,8 @@
+import type { K8sResource } from "@k8ts/instruments"
+import { Metadata } from "@k8ts/metadata"
+
+export function createSelectionMetadata(r: K8sResource) {
+    return new Metadata({
+        "%k8ts.org/owner": r["__entity_id__"]
+    })
+}

package/src/resources/workload/workload-ref.ts

@@ -0,0 +1,5 @@
+import type { PortExports, ResourceRef } from "@k8ts/instruments"
+
+export type Workload_Ref<Ports extends string> = ResourceRef & {
+    ports: PortExports<Ports>
+}

package/src/runner/{exporter → engine}/assembler.ts

@@ -1,66 +1,102 @@
-import { OriginNode, type Origin_Exporter } from "@k8ts/instruments"
-import { Meta } from "@k8ts/metadata"
+import { OriginVertex, type ExporterOrigin, type ResourceVertex } from "@k8ts/instruments"
+import { Metadata, type Metadata_Input } from "@k8ts/metadata"
 import { aseq } from "doddle"
-import Emittery from "emittery"
+import EventEmitter from "eventemitter3"
 import { cloneDeep } from "lodash"
-import { Assembler_RscLoader, type Assembler_RscLoaderEvents } from "./loader"
-import { Manifester, NodeManifest, type ManifesterEventsTable } from "./manifester"
-import { ManifestSaver, type ManifestSaverEventsTable } from "./saver"
-import { YamlSerializer, type SerializerEventsTable } from "./serializer"
-import { NodeGraphValidator, ValidatorEventsTable } from "./validator"
+import path from "path"
+import { version } from "../../version"
+import { Engine_ResourceLoader, type AssemblerRscLoaderEvents } from "./loader"
+import { Engine_Manifester, NodeManifest, type ManifesterEventsTable } from "./manifester"
+import { Engine_Saver, type ManifestSaverEventsTable } from "./saver"
+import { Engine_Serializer_Yaml, type SerializerEventsTable } from "./serializer"
 
-export class Assembler extends Emittery<AssemblerEventsTable> {
-    constructor(private readonly _options: AssemblerOptions) {
-        super()
+export const assemblerEventNames = (() => {
+    const rec: Record<keyof AssemblerEventsTable, true> = {
+        purge: true,
+        stage: true,
+        load: true,
+        manifest: true,
+        serialize: true,
+        save: true
     }
+    return Object.keys(rec) as (keyof AssemblerEventsTable)[]
+})()
+export class Assembler {
+    private _emitter: EventEmitter<AssemblerEventsTable> = new EventEmitter()
+    constructor(private readonly _options: AssemblerOptions) {}
 
-    async assemble(inFiles: Iterable<Origin_Exporter>) {
-        const _emit = async <Name extends keyof AssemblerEventsTable>(
-            event: Name,
+    on<Name extends keyof AssemblerEventsTable>(
+        event: Name,
+        listener: (payload: AssemblerEventsTable[Name]) => void
+    ) {
+        this._emitter.on(event, listener as any)
+        return this
+    }
+
+    onAny(
+        handler: <Name extends keyof AssemblerEventsTable>(
+            name: Name,
             payload: AssemblerEventsTable[Name]
-        ) => {
-            return await this.emit(event, payload)
+        ) => void
+    ) {
+        for (const eventName of assemblerEventNames) {
+            this._emitter.on(eventName, (payload: unknown) => {
+                handler(eventName, payload as any)
+            })
         }
-        const validator = new NodeGraphValidator({})
-        const loader = new Assembler_RscLoader({})
-        loader.onAny(_emit)
-        const generator = new Manifester({
-            cwd: this._options.cwd
+        return this
+    }
+    private _attachProductionAnnotations(resource: ResourceVertex) {
+        const loc = resource.trace.format({
+            cwd: this._options.displayCwd || this._options.cwd
+        })
+        resource.metadata!.add(`build.k8ts.org/`, {
+            "^constructed-at": loc,
+            "^produced-by": `k8ts@${version}`
+        })
+    }
+    async assemble(inFiles: Iterable<ExporterOrigin>) {
+        const emitter = this._emitter
+        const loader = new Engine_ResourceLoader({
+            emitter
+        })
+        emitter.on("load", ({ resource }) => {
+            this._attachProductionAnnotations(resource)
         })
-        generator.onAny(_emit)
-        const serializer = new YamlSerializer({})
-        serializer.onAny(_emit)
-        const saver = new ManifestSaver({
-            outdir: this._options.outdir
+        const generator = new Engine_Manifester({
+            cwd: this._options.cwd,
+            emitter
+        })
+        const serializer = new Engine_Serializer_Yaml({ emitter })
+        const saver = new Engine_Saver({
+            outdir: path.resolve(this._options.cwd ?? ".", this._options.outdir),
+            emitter
         })
-        saver.onAny(_emit)
         const reports = aseq(inFiles)
-            .map(x => x.node)
+            .map(x => x.__vertex__)
             .before(async () => {
-                await _emit("stage", { stage: "gathering" })
-            })
-            .each(async file => {
-                await _emit("received-file", { file: file })
+                emitter.emit("stage", { stage: "gathering" })
             })
+
             .after(async () => {
-                await _emit("stage", { stage: "loading" })
+                emitter.emit("stage", { stage: "loading" })
             })
             .collect()
             .map(async file => {
                 const loaded = await loader.load(file)
-                loaded.forEach(r => r.meta!.add(this._options.meta))
+                loaded.forEach(r => r.metadata!.add(this._options.metadata))
                 return {
                     file: file,
-                    resources: loaded.filter(x => !x.isExternal)
+                    resources: loaded.filter(x => !x.noEmit)
                 }
             })
             .after(async () => {
-                await _emit("stage", { stage: "manifesting" })
+                emitter.emit("stage", { stage: "manifesting" })
             })
             .collect()
             .map(async ({ file, resources }) => {
                 const manifests = await aseq(resources)
-                    .filter(x => !x.disabled)
+                    .filter(x => !x.noEmit)
                     .map(async resource => {
                         return await generator.generate(resource)
                     })
@@ -72,17 +108,11 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
                     resources: manifests
                 } satisfies FileNodes
             })
+
             .after(async () => {
-                await _emit("stage", { stage: "validating" })
-            })
-            .chunk(1000000)
-            .concatMap(async x => {
-                validator.validate(x)
-                return x
-            })
-            .after(async () => {
-                await _emit("stage", { stage: "serializing" })
+                emitter.emit("stage", { stage: "serializing" })
             })
+            .collect()
             .map(async ({ file, resources }) => {
                 const artifacts = await aseq(resources)
                     .map(async obj => {
@@ -100,7 +130,7 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
                 }
             })
             .after(async () => {
-                await _emit("stage", { stage: "saving" })
+                emitter.emit("stage", { stage: "saving" })
             })
             .after(async () => {
                 await saver.prepareOnce()
@@ -120,7 +150,7 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
                 }
             })
             .after(async () => {
-                await _emit("stage", { stage: "done" })
+                emitter.emit("stage", { stage: "done" })
             })
             .collect()
             .toArray()
@@ -132,14 +162,14 @@ export class Assembler extends Emittery<AssemblerEventsTable> {
     }
 }
 export interface FileNodes {
-    file: OriginNode
+    file: OriginVertex
     resources: NodeManifest[]
 }
 export interface Artifact extends NodeManifest {
     yaml: string
 }
 export interface AssembledFile {
-    file: OriginNode
+    file: OriginVertex
     path: string
     filename: string
     bytes: number
@@ -150,10 +180,11 @@ export interface AssembledResult {
     options: AssemblerOptions
 }
 export interface AssemblerOptions {
+    displayCwd?: string
     cwd?: string
     printOptions?: boolean
     outdir: string
-    meta?: Omit<Meta.Input, "name" | "namespace"> | Meta
+    metadata?: Omit<Metadata_Input, "name" | "namespace"> | Metadata
 }
 export type AssemblyStage =
     | "loading"
@@ -169,9 +200,7 @@ export interface AssemblerEventsTable
     extends ManifestSaverEventsTable,
         SerializerEventsTable,
         ManifesterEventsTable,
-        Assembler_RscLoaderEvents,
-        ValidatorEventsTable {
-    ["received-file"]: { file: OriginNode }
+        AssemblerRscLoaderEvents {
     ["stage"]: { stage: AssemblyStage }
 }
 export type AnyAssemblerEvent = {

package/src/runner/engine/index.ts

@@ -0,0 +1,2 @@
+export * from "../viz/progress-shower"
+export * from "./assembler"

package/src/runner/{exporter → engine}/loader.ts

@@ -1,26 +1,24 @@
-import { OriginNode, Rsc_Node, type Node, type Rsc_Top } from "@k8ts/instruments"
-import Emittery from "emittery"
-import { MakeError } from "../../error"
-export class Assembler_RscLoader extends Emittery<Assembler_RscLoaderEvents> {
-    constructor(private readonly _options: Assembler_RscLoaderOptions) {
-        super()
-    }
+import { OriginVertex, ResourceVertex, type K8sResource, type Vertex } from "@k8ts/instruments"
+import type EventEmitter from "eventemitter3"
+import { K8tsEngineError } from "../error"
+export class Engine_ResourceLoader {
+    constructor(private readonly _options: AssemblerRscLoaderOptions) {}
 
-    private _checkNames(resources: Rsc_Node[]) {
-        let names = new Map<string, Rsc_Node>()
+    private _checkNames(resources: ResourceVertex[]) {
+        let names = new Map<string, ResourceVertex>()
         const nameRegexp = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/
         for (const resource of resources) {
-            const name = [resource.kind.name, resource.namespace, resource.name]
+            const name = [resource.kind.value, resource.namespace, resource.name]
                 .filter(Boolean)
                 .join("/")
             const existing = names.get(name)
             if (existing) {
-                throw new MakeError(
+                throw new K8tsEngineError(
                     `Duplicate resource designation ${name}. Existing: ${existing.format("source")}, new: ${resource.format("source")}`
                 )
             }
             if (!nameRegexp.test(resource.name)) {
-                throw new MakeError(
+                throw new K8tsEngineError(
                     `Invalid resource name ${resource.name}. Must match ${nameRegexp}`
                 )
             }
@@ -28,13 +26,16 @@ export class Assembler_RscLoader extends Emittery<Assembler_RscLoaderEvents> {
         }
     }
 
-    async load(input: OriginNode) {
+    async load(input: OriginVertex) {
+        if (input.noEmit) {
+            return []
+        }
         // TODO: Handle ORIGINS that are referenced but not passed to the runner
-        let resources = [] as Rsc_Node[]
+        let resources = [] as ResourceVertex[]
 
-        const addResource = async (res: Node) => {
-            if (!(res instanceof Rsc_Node)) {
-                throw new Error(`Expected ResourceNode, got ${res.constructor.name}`)
+        const addResource = async (res: Vertex) => {
+            if (!(res instanceof ResourceVertex)) {
+                throw new K8tsEngineError(`Expected ResourceNode, got ${res.constructor.name}`)
             }
             if (resources.some(r => r.equals(res))) {
                 return
@@ -42,29 +43,29 @@ export class Assembler_RscLoader extends Emittery<Assembler_RscLoaderEvents> {
             if (!res.isRoot) {
                 return
             }
+            if (res.hasInheritedNoEmit) {
+                return
+            }
             const origin = res.origin
-
             if (!origin.isChildOf(input)) {
                 return
             }
             const event = {
-                isExported: res.meta!.has(`#k8ts.org/is-exported`),
+                isExported: res.metadata!.has(`#k8ts.org/exported`),
                 resource: res
             } as const
 
-            await this.emit("load", event)
-            const resourceOriginMetas = res.origin.inheritedMeta
+            this._options.emitter?.emit("load", event)
 
-            res.meta!.add(resourceOriginMetas)
             origin.entity["__emit__"]("resource/loaded", {
                 origin: origin.entity,
-                resource: res.entity as Rsc_Top
+                resource: res.entity as K8sResource
             })
             resources.push(res)
         }
 
         for (const resource of input.resources) {
-            await addResource(resource.node)
+            await addResource(resource.__vertex__)
         }
 
         // Some resources might appear as dependencies to sub-resources that
@@ -79,13 +80,15 @@ export class Assembler_RscLoader extends Emittery<Assembler_RscLoaderEvents> {
         return [...resources]
     }
 }
-export interface Assembler_RscLoadedEvent {
+export interface AssemblerRscLoadedEvent {
     isExported: boolean
-    resource: Rsc_Node
+    resource: ResourceVertex
 }
 
-export interface Assembler_RscLoaderEvents {
-    load: Assembler_RscLoadedEvent
+export interface AssemblerRscLoaderEvents {
+    load: AssemblerRscLoadedEvent
 }
 
-export interface Assembler_RscLoaderOptions {}
+export interface AssemblerRscLoaderOptions {
+    emitter?: EventEmitter<any>
+}

package/src/runner/{exporter → engine}/manifester.ts

@@ -1,16 +1,19 @@
-import { Manifest, ManifestSourceEmbedder, Rsc_Node, Rsc_Top } from "@k8ts/instruments"
-import Emittery from "emittery"
+import {
+    K8sResource,
+    K8tsManifest,
+    ManifestSourceEmbedder,
+    ResourceVertex
+} from "@k8ts/instruments"
+import type EventEmitter from "eventemitter3"
 import { cloneDeep, cloneDeepWith, isEmpty, unset } from "lodash"
-import { version } from "../../version"
 export interface ManifesterOptions {
     cwd?: string
+    emitter?: EventEmitter<any>
 }
 
-export class Manifester extends Emittery<ManifesterEventsTable> {
-    constructor(private readonly _options: ManifesterOptions) {
-        super()
-    }
-    private _cleanSpecificEmptyObjects(manifest: Manifest) {
+export class Engine_Manifester {
+    constructor(private readonly _options: ManifesterOptions) {}
+    private _cleanSpecificEmptyObjects(manifest: K8tsManifest) {
         const clone = cloneDeepWith(manifest, (value, key) => {
             if (key !== "metadata") {
                 return
@@ -25,7 +28,7 @@ export class Manifester extends Emittery<ManifesterEventsTable> {
         })
         return clone
     }
-    private _cleanNullishValues(manifest: Manifest) {
+    private _cleanNullishValues(manifest: K8tsManifest) {
         const _cleanKeys = (obj: any) => {
             if (typeof obj !== "object") {
                 return obj
@@ -42,7 +45,7 @@ export class Manifester extends Emittery<ManifesterEventsTable> {
         return cloneDeepWith(clone, _cleanKeys)
     }
 
-    private async _generate(resource: Rsc_Top): Promise<Manifest> {
+    private async _generate(resource: K8sResource): Promise<K8tsManifest> {
         const manifest = await resource["__manifest__"]()
 
         const noNullish = this._cleanNullishValues(manifest)
@@ -50,26 +53,11 @@ export class Manifester extends Emittery<ManifesterEventsTable> {
         return noEmpty
     }
 
-    private _attachProductionAnnotations(resource: Rsc_Node) {
-        const loc = resource.trace.format({
-            cwd: this._options.cwd
-        })
-        resource.meta!.add(`build.k8ts.org/`, {
-            "^constructed-at": loc,
-            "^produced-by": `k8ts@${version}`
-        })
-    }
-
-    async generate(res: Rsc_Node): Promise<NodeManifest> {
-        this._attachProductionAnnotations(res)
-        await this.emit("manifest", { resource: res })
-        const manifest = await this._generate(res.entity as Rsc_Top)
+    async generate(res: ResourceVertex): Promise<NodeManifest> {
+        this._options.emitter?.emit("manifest", { resource: res })
+        const manifest = await this._generate(res.entity as K8sResource)
         ManifestSourceEmbedder.add(manifest, res.entity)
-        res.origin.entity["__emit__"]("resource/manifested", {
-            origin: res.origin.entity,
-            manifest,
-            resource: res.entity as Rsc_Top
-        })
+
         return {
             node: res,
             manifest: manifest
@@ -78,11 +66,11 @@ export class Manifester extends Emittery<ManifesterEventsTable> {
 }
 
 export interface NodeManifest {
-    node: Rsc_Node
-    manifest: Manifest
+    node: ResourceVertex
+    manifest: K8tsManifest
 }
 export interface ManifesterManifestEvent {
-    resource: Rsc_Node
+    resource: ResourceVertex
 }
 
 export interface ManifesterEventsTable {

package/src/runner/{exporter → engine}/saver.ts

@@ -1,19 +1,17 @@
-import type { OriginNode } from "@k8ts/instruments"
-import Emittery from "emittery"
+import type { OriginVertex } from "@k8ts/instruments"
+import type EventEmitter from "eventemitter3"
 import { glob, mkdir, rm, writeFile } from "fs/promises"
 import { join, resolve } from "path"
-export class ManifestSaver extends Emittery<ManifestSaverEventsTable> {
+export class Engine_Saver {
     private _encoder = new TextEncoder()
-    constructor(private readonly _options: ManifestSaverOptions) {
-        super()
-    }
+    constructor(private readonly _options: ManifestSaverOptions) {}
 
     _splat(manifests: string[]) {
         return manifests.join("\n---\n")
     }
 
     async prepareOnce() {
-        await this.emit("purge", {
+        this._options.emitter?.emit("purge", {
             outdir: this._options.outdir
         })
         await mkdir(this._options.outdir, { recursive: true })
@@ -28,7 +26,7 @@ export class ManifestSaver extends Emittery<ManifestSaverEventsTable> {
         }
     }
 
-    async save(origin: OriginNode, manifests: string[]) {
+    async save(origin: OriginVertex, manifests: string[]) {
         const content = this._splat(manifests)
         const filename = `${origin.name}`
         const encoded = this._encoder.encode(content)
@@ -40,7 +38,7 @@ export class ManifestSaver extends Emittery<ManifestSaverEventsTable> {
             bytes: encoded.byteLength
         }
 
-        await this.emit("save", e)
+        this._options.emitter?.emit("save", e)
         await mkdir(this._options.outdir, { recursive: true })
         await writeFile(join(this._options.outdir, filename), encoded)
         return e
@@ -62,4 +60,5 @@ export interface ManifestSaverEventsTable {
 
 export interface ManifestSaverOptions {
     outdir: string
+    emitter?: EventEmitter<any>
 }