k8ts 0.4.20 → 0.4.22

package/src/resources/deployment/deployment.ts

@@ -1,7 +1,8 @@
-import { manifest, Origin, Refable, relations } from "@k8ts/instruments"
+import { manifest, Origin, Refable, relations, WritableDeep } from "@k8ts/instruments"
 import { Meta, MutableMeta } from "@k8ts/metadata"
 import { omit } from "lodash"
 import { CDK } from "../../_imports"
+import { MakeError } from "../../error"
 import { k8ts } from "../../kind-map"
 import { api } from "../../kinds"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
@@ -10,13 +11,22 @@ import { PodTemplate } from "../pod/pod-template"
 
 export type Deployment<Ports extends string> = Deployment.Deployment<Ports>
 export namespace Deployment {
-    export type SmallerProps = Omit<CDK.DeploymentSpec, "selector" | "template">
-    export type Props<Ports extends string> = SmallerProps & {
+    export type DeploymentStrategy =
+        | { type: "Recreate" }
+        | ({
+              type: "RollingUpdate"
+          } & CDK.RollingUpdateDeployment)
+    export type NormalProps = WritableDeep<
+        Omit<CDK.DeploymentSpec, "selector" | "template" | "strategy">
+    >
+    export type Props<Ports extends string> = NormalProps & {
         template: PodTemplate.Props<Ports>
+        strategy?: DeploymentStrategy
     }
     export type AbsDeployment<Ports extends string> = Refable<api.apps_.v1_.Deployment> & {
         __PORTS__: Ports
     }
+
     @k8ts(api.apps_.v1_.Deployment)
     @equiv_cdk8s(CDK.KubeDeployment)
     @relations({
@@ -34,7 +44,8 @@ export namespace Deployment {
                             app: self.name
                         }
                     },
-                    template: noKindFields
+                    template: noKindFields,
+                    strategy: self._strategy
                 }
             }
         }
@@ -44,6 +55,22 @@ export namespace Deployment {
         kind = api.apps_.v1_.Deployment
         template: PodTemplate<Ports>
 
+        private get _strategy() {
+            const strat = this.props.strategy
+            if (!strat) {
+                return undefined
+            }
+            if (strat.type === "Recreate") {
+                return strat
+            }
+            if (strat.type === "RollingUpdate") {
+                return {
+                    type: "RollingUpdate",
+                    rollingUpdate: omit(strat, "type")
+                }
+            }
+            throw new MakeError(`Invalid strategy type: ${strat}`)
+        }
         constructor(origin: Origin, meta: Meta | MutableMeta, props: Props<Ports>) {
             super(origin, meta, props)
             this.template = new PodTemplate.PodTemplate(

package/src/resources/pod/container/container.ts

@@ -5,6 +5,7 @@ import {
     relations,
     ResourcesSpec,
     Unit,
+    WritableDeep,
     type CmdBuilder,
     type InputEnvMapping,
     type InputPortSetRecord,
@@ -34,6 +35,7 @@ export namespace Container {
     export type Mounts = {
         [key: string]: SomeMount
     }
+
     export interface K8tsProps<Ports extends string = never> {
         image: TaggedImage
         ports?: InputPortSetRecord<Ports>
@@ -44,7 +46,7 @@ export namespace Container {
         resources?: Resources
     }
     export type Props<Ports extends string = never> = K8tsProps<Ports> &
-        Omit<CDK.Container, keyof K8tsProps | "name">
+        WritableDeep<Omit<CDK.Container, keyof K8tsProps | "name">>
 
     @k8ts(api.v1_.Pod_.Container)
     @relations({

package/src/resources/pod/pod-template.ts

@@ -17,6 +17,16 @@ export namespace PodTemplate {
     export type Props<Ports extends string> = PodProps & {
         POD: PodContainerProducer<Ports>
     }
+    export type HostPortSpec<Ports extends string> = {
+        [port in Ports]?: {
+            ip?: string
+            port?: number
+        }
+    }
+    export interface HostNetInput<Ports extends string> {
+        hostNetwork?: boolean
+        ports: HostPortSpec<Ports>
+    }
     @k8ts(api.v1_.PodTemplate)
     @relations({
         kids: s => [...s.containers, ...s.volumes]

package/src/resources/utils/adapters.ts

@@ -5,7 +5,9 @@ export function toContainerPort(entry: PortSetEntry): CDK.ContainerPort {
     return {
         containerPort: entry.port,
         name: entry.name,
-        protocol: entry.protocol
+        protocol: entry.protocol,
+        hostPort: entry.hostPort,
+        hostIp: entry.hostIp?.text
     }
 }
 

package/src/runner/exporter/assembler.ts

@@ -7,7 +7,7 @@ import type { File } from "../../file"
 import { ResourceLoader, type ResourceLoaderEventsTable } from "./loader"
 import { Manifester, NodeManifest, type ManifesterEventsTable } from "./manifester"
 import { ManifestSaver, type ManifestSaverEventsTable } from "./saver"
-import { YamlSerializer, type YamlSerializerEventsTable } from "./serializer"
+import { YamlSerializer, type SerializerEventsTable } from "./serializer"
 import { NodeGraphValidator, ValidatorEventsTable } from "./validator"
 
 export class Assembler extends Emittery<AssemblerEventsTable> {
@@ -166,7 +166,7 @@ export type AssemblyStage =
     | "gathering"
 export interface AssemblerEventsTable
     extends ManifestSaverEventsTable,
-        YamlSerializerEventsTable,
+        SerializerEventsTable,
         ManifesterEventsTable,
         ResourceLoaderEventsTable,
         ValidatorEventsTable {

package/src/runner/exporter/serializer.ts

@@ -1,4 +1,4 @@
-import { BaseManifest, ManifestSourceEmbedder } from "@k8ts/instruments"
+import { BaseManifest, ManifestSourceEmbedder, type ResourceNode } from "@k8ts/instruments"
 import Emittery from "emittery"
 import { dump, type DumpOptions } from "js-yaml"
 import { CDK } from "../../_imports"
@@ -9,17 +9,21 @@ export interface YamlSerializerOptions {
 }
 export interface SerializingEvent {
     manifest: BaseManifest
+    resource: ResourceNode
 }
-export interface YamlSerializerEventsTable {
+export interface SerializerEventsTable {
     serialize: SerializingEvent
 }
-export class YamlSerializer extends Emittery<YamlSerializerEventsTable> {
+export class YamlSerializer extends Emittery<SerializerEventsTable> {
     constructor(private readonly _options: Partial<YamlSerializerOptions>) {
         super()
     }
 
     async serialize(input: BaseManifest) {
-        await this.emit("serialize", { manifest: input })
+        await this.emit("serialize", {
+            manifest: input,
+            resource: ManifestSourceEmbedder.get(input).node
+        })
 
         try {
             const result = dump(input, {

package/src/runner/runner.ts

@@ -1,10 +1,17 @@
 import { GitTrace, Trace } from "@k8ts/instruments"
 import { Meta } from "@k8ts/metadata"
 import chalk from "chalk"
+import Emittery from "emittery"
 import StackTracey from "stacktracey"
 import { File } from "../file"
 import { proverbsPath } from "../paths"
-import { Assembler, AssemblerOptions, ProgressOptions, ProgressShower } from "./exporter"
+import {
+    Assembler,
+    AssemblerEventsTable,
+    AssemblerOptions,
+    ProgressOptions,
+    ProgressShower
+} from "./exporter"
 import { k8ts_namespace } from "./exporter/meta"
 import { Proverbs } from "./silly/proverbs"
 import { Summarizer } from "./summarizer"
@@ -15,8 +22,10 @@ export interface RunnerOptions extends AssemblerOptions {
     progress: ProgressOptions
 }
 
-export class Runner {
-    constructor(private readonly _options: RunnerOptions) {}
+export class Runner extends Emittery<AssemblerEventsTable> {
+    constructor(private readonly _options: RunnerOptions) {
+        super()
+    }
 
     async run(input: Iterable<File.Input>) {
         const gitInfo = await GitTrace.make({
@@ -36,6 +45,9 @@ export class Runner {
 
         const progressShower = new ProgressShower(options.progress)
         const assembler = new Assembler(options)
+        assembler.onAny(async (name, data) => {
+            await this.emit(name, data)
+        })
         const summarizer = new Summarizer({
             printOptions: this._options.printOptions
         })