cdk8s-plus-34 0.0.1 → 2.0.0

package/lib/stateful-set.d.ts

@@ -0,0 +1,206 @@
+import { ApiObject, Duration } from 'cdk8s';
+import { Construct } from 'constructs';
+import { IScalable, ScalingTarget } from './horizontal-pod-autoscaler';
+import * as k8s from './imports/k8s';
+import { PersistentVolumeClaimProps } from './pvc';
+import * as service from './service';
+import * as workload from './workload';
+/**
+ * Controls how pods are created during initial scale up, when replacing pods on nodes,
+ * or when scaling down.
+ *
+ * The default policy is `OrderedReady`, where pods are created in increasing order
+ * (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before
+ * continuing. When scaling down, the pods are removed in the opposite order.
+ *
+ * The alternative policy is `Parallel` which will create pods in parallel to match the
+ * desired scale without waiting, and on scale down will delete all pods at once.
+ */
+export declare enum PodManagementPolicy {
+    ORDERED_READY = "OrderedReady",
+    PARALLEL = "Parallel"
+}
+/**
+ * Properties for initialization of `StatefulSet`.
+ */
+export interface StatefulSetProps extends workload.WorkloadProps {
+    /**
+     * Service to associate with the statefulset.
+     *
+     * @default - A new headless service will be created.
+     */
+    readonly service?: service.Service;
+    /**
+     * Number of desired pods.
+     *
+     * @default 1
+     */
+    readonly replicas?: number;
+    /**
+     * Pod management policy to use for this statefulset.
+     *
+     * @default PodManagementPolicy.ORDERED_READY
+     */
+    readonly podManagementPolicy?: PodManagementPolicy;
+    /**
+     * Indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template.
+     *
+     * @default - RollingUpdate with partition set to 0
+     */
+    readonly strategy?: StatefulSetUpdateStrategy;
+    /**
+     * Minimum duration for which a newly created pod should be ready without any of its container crashing,
+     * for it to be considered available. Zero means the pod will be considered available as soon as it is ready.
+     *
+     * This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate.
+     *
+     * @see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#min-ready-seconds
+     * @default Duration.seconds(0)
+     */
+    readonly minReady?: Duration;
+    /**
+     * A list of PersistentVolumeClaim templates that will be created for each pod in the StatefulSet.
+     * The StatefulSet controller creates a PVC and a PV for each template based on the pod's ordinal index,
+     * ensuring stable storage across pod restarts and rescheduling.
+     *
+     * Each claim in this list must have at least one matching (by name) volumeMount in one of the containers.
+     *
+     * @default - No volume claim templates will be created.
+     */
+    readonly volumeClaimTemplates?: PersistentVolumeClaimTemplateProps[];
+}
+/**
+ * StatefulSet is the workload API object used to manage stateful applications.
+ *
+ * Manages the deployment and scaling of a set of Pods, and provides guarantees
+ * about the ordering and uniqueness of these Pods.
+ *
+ * Like a Deployment, a StatefulSet manages Pods that are based on an identical
+ * container spec. Unlike a Deployment, a StatefulSet maintains a sticky identity
+ * for each of their Pods. These pods are created from the same spec, but are not
+ * interchangeable: each has a persistent identifier that it maintains across any
+ * rescheduling.
+ *
+ * If you want to use storage volumes to provide persistence for your workload, you
+ * can use a StatefulSet as part of the solution. Although individual Pods in a StatefulSet
+ * are susceptible to failure, the persistent Pod identifiers make it easier to match existing
+ * volumes to the new Pods that replace any that have failed.
+ *
+ * Using StatefulSets
+ * ------------------
+ * StatefulSets are valuable for applications that require one or more of the following.
+ *
+ * - Stable, unique network identifiers.
+ * - Stable, persistent storage.
+ * - Ordered, graceful deployment and scaling.
+ * - Ordered, automated rolling updates.
+ */
+export declare class StatefulSet extends workload.Workload implements IScalable {
+    /**
+     * Number of desired pods.
+     */
+    readonly replicas?: number;
+    /**
+     * Management policy to use for the set.
+     */
+    readonly podManagementPolicy: PodManagementPolicy;
+    /**
+     * The update startegy of this stateful set.
+     */
+    readonly strategy: StatefulSetUpdateStrategy;
+    /**
+     * Minimum duration for which a newly created pod should be ready without
+     * any of its container crashing, for it to be considered available.
+     */
+    readonly minReady: Duration;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "statefulsets";
+    hasAutoscaler: boolean;
+    readonly service: service.Service;
+    volumeClaimTemplates?: PersistentVolumeClaimTemplateProps[];
+    constructor(scope: Construct, id: string, props: StatefulSetProps);
+    addVolumeClaimTemplate(template: PersistentVolumeClaimTemplateProps): void;
+    private _createHeadlessService;
+    /**
+     * @internal
+     */
+    _toKube(): k8s.StatefulSetSpec;
+    /**
+     * @internal
+     */
+    _toPodSpec(): k8s.PodSpec;
+    /**
+     * @internal
+     */
+    private _filterPodSpecVolumes;
+    /**
+     * @see IScalable.markHasAutoscaler()
+     */
+    markHasAutoscaler(): void;
+    /**
+     * @see IScalable.toScalingTarget()
+     */
+    toScalingTarget(): ScalingTarget;
+    /**
+     * @internal
+     */
+    private _toPersistentVolumeClaims;
+}
+/**
+ * Options for `StatefulSetUpdateStrategy.rollingUpdate`.
+ */
+export interface StatefulSetUpdateStrategyRollingUpdateOptions {
+    /**
+     * If specified, all Pods with an ordinal that is greater than or equal to the partition will
+     * be updated when the StatefulSet's .spec.template is updated. All Pods with an ordinal that
+     * is less than the partition will not be updated, and, even if they are deleted, they will be
+     * recreated at the previous version.
+     *
+     * If the partition is greater than replicas, updates to the pod template will not be propagated to Pods.
+     * In most cases you will not need to use a partition, but they are useful if you want to stage an
+     * update, roll out a canary, or perform a phased roll out.
+     *
+     * @see https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/#partitions
+     * @default 0
+     */
+    readonly partition?: number;
+}
+/**
+ * StatefulSet update strategies.
+ */
+export declare class StatefulSetUpdateStrategy {
+    private readonly strategy;
+    /**
+     * The controller will not automatically update the Pods in a StatefulSet.
+     * Users must manually delete Pods to cause the controller to create new Pods
+     * that reflect modifications.
+     */
+    static onDelete(): StatefulSetUpdateStrategy;
+    /**
+     * The controller will delete and recreate each Pod in the StatefulSet.
+     * It will proceed in the same order as Pod termination (from the largest ordinal to the smallest),
+     * updating each Pod one at a time. The Kubernetes control plane waits until an updated
+     * Pod is Running and Ready prior to updating its predecessor.
+     */
+    static rollingUpdate(options?: StatefulSetUpdateStrategyRollingUpdateOptions): StatefulSetUpdateStrategy;
+    private constructor();
+    /**
+     * @internal
+     */
+    _toKube(): k8s.StatefulSetUpdateStrategy;
+}
+/**
+ * A PersistentVolumeClaim template for StatefulSets
+ */
+export interface PersistentVolumeClaimTemplateProps extends PersistentVolumeClaimProps {
+    /**
+     * The name of the claim that the StatefulSet controller will create for each pod.
+     * This will be used to name the created PVC in the format <claim-name>-<pod-name>
+     *
+     * This name should match the name of a volume mount in one of the containers.
+     */
+    readonly name: string;
+}

package/lib/stateful-set.js

@@ -0,0 +1,244 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatefulSetUpdateStrategy = exports.StatefulSet = exports.PodManagementPolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const container = require("./container");
+const k8s = require("./imports/k8s");
+const k8s_1 = require("./imports/k8s");
+const service = require("./service");
+const workload = require("./workload");
+/**
+ * Controls how pods are created during initial scale up, when replacing pods on nodes,
+ * or when scaling down.
+ *
+ * The default policy is `OrderedReady`, where pods are created in increasing order
+ * (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before
+ * continuing. When scaling down, the pods are removed in the opposite order.
+ *
+ * The alternative policy is `Parallel` which will create pods in parallel to match the
+ * desired scale without waiting, and on scale down will delete all pods at once.
+ */
+var PodManagementPolicy;
+(function (PodManagementPolicy) {
+    PodManagementPolicy["ORDERED_READY"] = "OrderedReady";
+    PodManagementPolicy["PARALLEL"] = "Parallel";
+})(PodManagementPolicy || (exports.PodManagementPolicy = PodManagementPolicy = {}));
+/**
+ * StatefulSet is the workload API object used to manage stateful applications.
+ *
+ * Manages the deployment and scaling of a set of Pods, and provides guarantees
+ * about the ordering and uniqueness of these Pods.
+ *
+ * Like a Deployment, a StatefulSet manages Pods that are based on an identical
+ * container spec. Unlike a Deployment, a StatefulSet maintains a sticky identity
+ * for each of their Pods. These pods are created from the same spec, but are not
+ * interchangeable: each has a persistent identifier that it maintains across any
+ * rescheduling.
+ *
+ * If you want to use storage volumes to provide persistence for your workload, you
+ * can use a StatefulSet as part of the solution. Although individual Pods in a StatefulSet
+ * are susceptible to failure, the persistent Pod identifiers make it easier to match existing
+ * volumes to the new Pods that replace any that have failed.
+ *
+ * Using StatefulSets
+ * ------------------
+ * StatefulSets are valuable for applications that require one or more of the following.
+ *
+ * - Stable, unique network identifiers.
+ * - Stable, persistent storage.
+ * - Ordered, graceful deployment and scaling.
+ * - Ordered, automated rolling updates.
+ */
+class StatefulSet extends workload.Workload {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.resourceType = 'statefulsets';
+        this.hasAutoscaler = false;
+        this.apiObject = new k8s.KubeStatefulSet(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this.service = props.service ?? this._createHeadlessService();
+        this.apiObject.addDependency(this.service);
+        this.replicas = props.replicas;
+        this.strategy = props.strategy ?? StatefulSetUpdateStrategy.rollingUpdate();
+        this.podManagementPolicy = props.podManagementPolicy ?? PodManagementPolicy.ORDERED_READY;
+        this.minReady = props.minReady ?? cdk8s_1.Duration.seconds(0);
+        props?.volumeClaimTemplates?.forEach(template => this.addVolumeClaimTemplate(template));
+        this.service.select(this);
+        if (this.isolate) {
+            this.connections.isolate();
+        }
+    }
+    addVolumeClaimTemplate(template) {
+        if (this.volumeClaimTemplates?.some(t => t.name === template.name)) {
+            throw new Error(`A volume claim template with name "${template.name}" already exists`);
+        }
+        this.volumeClaimTemplates = this.volumeClaimTemplates
+            ? [...this.volumeClaimTemplates, template]
+            : [template];
+    }
+    _createHeadlessService() {
+        const myPorts = container.extractContainerPorts(this);
+        const myPortNumbers = myPorts.map(p => p.number);
+        const ports = myPorts.map(p => ({
+            port: p.number,
+            targetPort: p.number,
+            protocol: p.protocol,
+            name: p.name,
+        }));
+        if (ports.length === 0) {
+            throw new Error(`Unable to create a service for the stateful set ${this.name}: StatefulSet ports cannot be determined.`);
+        }
+        // validate the ports are owned by our containers
+        for (const port of ports) {
+            const targetPort = port.targetPort ?? port.port;
+            if (!myPortNumbers.includes(targetPort)) {
+                throw new Error(`Unable to expose stateful set ${this.name} via a service: Port ${targetPort} is not exposed by any container`);
+            }
+        }
+        const metadata = { namespace: this.metadata.namespace };
+        return new service.Service(this, 'Service', {
+            selector: this,
+            ports,
+            metadata,
+            clusterIP: 'None',
+            type: service.ServiceType.CLUSTER_IP,
+        });
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            replicas: this.hasAutoscaler ? undefined : (this.replicas ?? 1),
+            serviceName: this.service.name,
+            minReadySeconds: this.minReady.toSeconds(),
+            template: {
+                metadata: this.podMetadata.toJson(),
+                spec: this._toPodSpec(),
+            },
+            selector: this._toLabelSelector(),
+            podManagementPolicy: this.podManagementPolicy,
+            volumeClaimTemplates: this._toPersistentVolumeClaims(),
+            updateStrategy: this.strategy._toKube(),
+        };
+    }
+    /**
+     * @internal
+     */
+    _toPodSpec() {
+        const podSpec = super._toPodSpec();
+        return {
+            ...podSpec,
+            volumes: this._filterPodSpecVolumes(podSpec),
+        };
+    }
+    /**
+     * @internal
+     */
+    _filterPodSpecVolumes(podSpec) {
+        // When using volumeClaimTemplates, the volumes with matching names should not be included in the pod spec
+        if (this.volumeClaimTemplates && podSpec.volumes) {
+            const volumeClaimNames = this.volumeClaimTemplates.map(vct => vct.name);
+            const volumesWithNoTemplates = podSpec.volumes.filter(vol => !volumeClaimNames.includes(vol.name));
+            // If there are no volumes after filtering, don't include volumes property
+            if (volumesWithNoTemplates.length === 0) {
+                return undefined;
+            }
+            else {
+                return volumesWithNoTemplates;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * @see IScalable.markHasAutoscaler()
+     */
+    markHasAutoscaler() {
+        this.hasAutoscaler = true;
+    }
+    /**
+     * @see IScalable.toScalingTarget()
+     */
+    toScalingTarget() {
+        return {
+            kind: this.apiObject.kind,
+            apiVersion: this.apiObject.apiVersion,
+            name: this.name,
+            containers: this.containers,
+            replicas: this.replicas,
+        };
+    }
+    /**
+     * @internal
+     */
+    _toPersistentVolumeClaims() {
+        const volumeNames = this.containers.flatMap(it => it.mounts).map(mount => mount.volume.name);
+        this.volumeClaimTemplates?.forEach(t => {
+            if (!volumeNames.includes(t.name)) {
+                throw new Error(`Volume claim template with name "${t.name}" is not used by any container mount`);
+            }
+        });
+        return this.volumeClaimTemplates?.map(template => {
+            const resources = template.storage
+                ? { requests: { storage: k8s_1.Quantity.fromString(template.storage.asString()) } }
+                : {};
+            return {
+                metadata: {
+                    name: template.name,
+                },
+                spec: {
+                    accessModes: template.accessModes,
+                    storageClassName: template.storageClassName,
+                    resources,
+                },
+            };
+        });
+    }
+}
+exports.StatefulSet = StatefulSet;
+_a = JSII_RTTI_SYMBOL_1;
+StatefulSet[_a] = { fqn: "cdk8s-plus-34.StatefulSet", version: "2.0.0" };
+/**
+ * StatefulSet update strategies.
+ */
+class StatefulSetUpdateStrategy {
+    /**
+     * The controller will not automatically update the Pods in a StatefulSet.
+     * Users must manually delete Pods to cause the controller to create new Pods
+     * that reflect modifications.
+     */
+    static onDelete() {
+        return new StatefulSetUpdateStrategy({
+            type: 'OnDelete',
+        });
+    }
+    /**
+     * The controller will delete and recreate each Pod in the StatefulSet.
+     * It will proceed in the same order as Pod termination (from the largest ordinal to the smallest),
+     * updating each Pod one at a time. The Kubernetes control plane waits until an updated
+     * Pod is Running and Ready prior to updating its predecessor.
+     */
+    static rollingUpdate(options = {}) {
+        return new StatefulSetUpdateStrategy({
+            type: 'RollingUpdate',
+            rollingUpdate: { partition: options.partition ?? 0 },
+        });
+    }
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return this.strategy;
+    }
+}
+exports.StatefulSetUpdateStrategy = StatefulSetUpdateStrategy;
+_b = JSII_RTTI_SYMBOL_1;
+StatefulSetUpdateStrategy[_b] = { fqn: "cdk8s-plus-34.StatefulSetUpdateStrategy", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stateful-set.js","sourceRoot":"","sources":["../src/stateful-set.ts"],"names":[],"mappings":";;;;;AAAA,iCAAkD;AAElD,yCAAyC;AAEzC,qCAAqC;AACrC,uCAA8G;AAE9G,qCAAqC;AACrC,uCAAuC;AAEvC;;;;;;;;;;GAUG;AACH,IAAY,mBAGX;AAHD,WAAY,mBAAmB;IAC7B,qDAA8B,CAAA;IAC9B,4CAAqB,CAAA;AACvB,CAAC,EAHW,mBAAmB,mCAAnB,mBAAmB,QAG9B;AAyDD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAa,WAAY,SAAQ,QAAQ,CAAC,QAAQ;IAmChD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAuB;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QATV,iBAAY,GAAG,cAAc,CAAC;QAEvC,kBAAa,GAAG,KAAK,CAAC;QAS3B,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,CAAC,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE;YACzD,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,IAAI,EAAE,YAAI,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;SAClD,CAAC,CAAC;QACH,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9D,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE3C,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,yBAAyB,CAAC,aAAa,EAAE,CAAC;QAC5E,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,mBAAmB,IAAI,mBAAmB,CAAC,aAAa,CAAC;QAC1F,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,gBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACtD,KAAK,EAAE,oBAAoB,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAAC,CAAC;QACxF,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAE1B,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;QAC7B,CAAC;IACH,CAAC;IAEM,sBAAsB,CAAC,QAA4C;QACxE,IAAI,IAAI,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACnE,MAAM,IAAI,KAAK,CAAC,sCAAsC,QAAQ,CAAC,IAAI,kBAAkB,CAAC,CAAC;QACzF,CAAC;QACD,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,oBAAoB;YACnD,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC;YAC1C,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IACjB,CAAC;IAEO,sBAAsB;QAC5B,MAAM,OAAO,GAAG,SAAS,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;QACtD,MAAM,aAAa,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACjD,MAAM,KAAK,GAA0B,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACrD,IAAI,EAAE,CAAC,CAAC,MAAM;YACd,UAAU,EAAE,CAAC,CAAC,MAAM;YACpB,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,IAAI,EAAE,CAAC,CAAC,IAAI;SACb,CAAC,CAAC,CAAC;QACJ,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,mDAAmD,IAAI,CAAC,IAAI,2CAA2C,CAAC,CAAC;QAC3H,CAAC;QAED,iDAAiD;QACjD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,IAAI,CAAC;YAChD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gBACxC,MAAM,IAAI,KAAK,CAAC,iCAAiC,IAAI,CAAC,IAAI,wBAAwB,UAAU,kCAAkC,CAAC,CAAC;YAClI,CAAC;QACH,CAAC;QAED,MAAM,QAAQ,GAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QAC7D,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE;YAC1C,QAAQ,EAAE,IAAI;YACd,KAAK;YACL,QAAQ;YACR,SAAS,EAAE,MAAM;YACjB,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,UAAU;SACrC,CAAC,CAAC;IAEL,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,OAAO;YACL,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,CAAC;YAC/D,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;YAC9B,eAAe,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE;YAC1C,QAAQ,EAAE;gBACR,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE;gBACnC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE;aACxB;YACD,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE;YACjC,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;YAC7C,oBAAoB,EAAE,IAAI,CAAC,yBAAyB,EAAE;YACtD,cAAc,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE;SACxC,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,UAAU;QACf,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QACnC,OAAO;YACL,GAAG,OAAO;YACV,OAAO,EAAE,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC;SAC7C,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,qBAAqB,CAAC,OAAgB;QAC5C,0GAA0G;QAC1G,IAAI,IAAI,CAAC,oBAAoB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACjD,MAAM,gBAAgB,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACxE,MAAM,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;YAEnG,0EAA0E;YAC1E,IAAI,sBAAsB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACxC,OAAO,SAAS,CAAC;YACnB,CAAC;iBAAM,CAAC;gBACN,OAAO,sBAAsB,CAAC;YAChC,CAAC;QACH,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACI,iBAAiB;QACtB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC5B,CAAC;IAED;;OAEG;IACI,eAAe;QACpB,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI;YACzB,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU;YACrC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,yBAAyB;QAC/B,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC7F,IAAI,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE;YACrC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;gBAClC,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC,IAAI,sCAAsC,CAAC,CAAC;YACpG,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,oBAAoB,EAAE,GAAG,CAAC,QAAQ,CAAC,EAAE;YAC/C,MAAM,SAAS,GAA+B,QAAQ,CAAC,OAAO;gBAC5D,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,cAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE;gBAC7E,CAAC,CAAC,EAAE,CAAC;YACP,OAAO;gBACL,QAAQ,EAAE;oBACR,IAAI,EAAE,QAAQ,CAAC,IAAI;iBACpB;gBACD,IAAI,EAAE;oBACJ,WAAW,EAAE,QAAQ,CAAC,WAAW;oBACjC,gBAAgB,EAAE,QAAQ,CAAC,gBAAgB;oBAC3C,SAAS;iBACV;aACF,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;;AAjMH,kCAkMC;;;AAwBD;;GAEG;AACH,MAAa,yBAAyB;IAEpC;;;;OAIG;IACI,MAAM,CAAC,QAAQ;QACpB,OAAO,IAAI,yBAAyB,CAAC;YACnC,IAAI,EAAE,UAAU;SACjB,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,aAAa,CAAC,UAAyD,EAAE;QAErF,OAAO,IAAI,yBAAyB,CAAC;YACnC,IAAI,EAAE,eAAe;YACrB,aAAa,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,CAAC,EAAE;SACrD,CAAC,CAAC;IACL,CAAC;IAED,YAAqC,QAAuC;QAAvC,aAAQ,GAAR,QAAQ,CAA+B;IAC5E,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;;AAnCH,8DAqCC","sourcesContent":["import { ApiObject, Lazy, Duration } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport * as container from './container';\nimport { IScalable, ScalingTarget } from './horizontal-pod-autoscaler';\nimport * as k8s from './imports/k8s';\nimport { KubePersistentVolumeClaimProps, PodSpec, Quantity, VolumeResourceRequirements } from './imports/k8s';\nimport { PersistentVolumeClaimProps } from './pvc';\nimport * as service from './service';\nimport * as workload from './workload';\n\n/**\n * Controls how pods are created during initial scale up, when replacing pods on nodes,\n * or when scaling down.\n *\n * The default policy is `OrderedReady`, where pods are created in increasing order\n * (pod-0, then pod-1, etc) and the controller will wait until each pod is ready before\n * continuing. When scaling down, the pods are removed in the opposite order.\n *\n * The alternative policy is `Parallel` which will create pods in parallel to match the\n * desired scale without waiting, and on scale down will delete all pods at once.\n */\nexport enum PodManagementPolicy {\n  ORDERED_READY = 'OrderedReady',\n  PARALLEL = 'Parallel',\n}\n\n/**\n * Properties for initialization of `StatefulSet`.\n */\nexport interface StatefulSetProps extends workload.WorkloadProps {\n  /**\n   * Service to associate with the statefulset.\n   *\n   * @default - A new headless service will be created.\n   */\n  readonly service?: service.Service;\n\n  /**\n   * Number of desired pods.\n   *\n   * @default 1\n   */\n  readonly replicas?: number;\n\n  /**\n   * Pod management policy to use for this statefulset.\n   *\n   * @default PodManagementPolicy.ORDERED_READY\n   */\n  readonly podManagementPolicy?: PodManagementPolicy;\n\n  /**\n   * Indicates the StatefulSetUpdateStrategy that will be employed to update Pods in the StatefulSet when a revision is made to Template.\n   *\n   * @default - RollingUpdate with partition set to 0\n   */\n  readonly strategy?: StatefulSetUpdateStrategy;\n\n  /**\n   * Minimum duration for which a newly created pod should be ready without any of its container crashing,\n   * for it to be considered available. Zero means the pod will be considered available as soon as it is ready.\n   *\n   * This is an alpha field and requires enabling StatefulSetMinReadySeconds feature gate.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#min-ready-seconds\n   * @default Duration.seconds(0)\n   */\n  readonly minReady?: Duration;\n\n  /**\n   * A list of PersistentVolumeClaim templates that will be created for each pod in the StatefulSet.\n   * The StatefulSet controller creates a PVC and a PV for each template based on the pod's ordinal index,\n   * ensuring stable storage across pod restarts and rescheduling.\n   *\n   * Each claim in this list must have at least one matching (by name) volumeMount in one of the containers.\n   *\n   * @default - No volume claim templates will be created.\n   */\n  readonly volumeClaimTemplates?: PersistentVolumeClaimTemplateProps[];\n}\n\n/**\n * StatefulSet is the workload API object used to manage stateful applications.\n *\n * Manages the deployment and scaling of a set of Pods, and provides guarantees\n * about the ordering and uniqueness of these Pods.\n *\n * Like a Deployment, a StatefulSet manages Pods that are based on an identical\n * container spec. Unlike a Deployment, a StatefulSet maintains a sticky identity\n * for each of their Pods. These pods are created from the same spec, but are not\n * interchangeable: each has a persistent identifier that it maintains across any\n * rescheduling.\n *\n * If you want to use storage volumes to provide persistence for your workload, you\n * can use a StatefulSet as part of the solution. Although individual Pods in a StatefulSet\n * are susceptible to failure, the persistent Pod identifiers make it easier to match existing\n * volumes to the new Pods that replace any that have failed.\n *\n * Using StatefulSets\n * ------------------\n * StatefulSets are valuable for applications that require one or more of the following.\n *\n * - Stable, unique network identifiers.\n * - Stable, persistent storage.\n * - Ordered, graceful deployment and scaling.\n * - Ordered, automated rolling updates.\n */\nexport class StatefulSet extends workload.Workload implements IScalable {\n  /**\n   * Number of desired pods.\n   */\n  public readonly replicas?: number;\n\n  /**\n   * Management policy to use for the set.\n   */\n  public readonly podManagementPolicy: PodManagementPolicy;\n\n  /**\n   * The update startegy of this stateful set.\n   */\n  public readonly strategy: StatefulSetUpdateStrategy;\n\n  /**\n   * Minimum duration for which a newly created pod should be ready without\n   * any of its container crashing, for it to be considered available.\n   */\n  public readonly minReady: Duration;\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'statefulsets';\n\n  public hasAutoscaler = false;\n\n  public readonly service: service.Service;\n\n  public volumeClaimTemplates?: PersistentVolumeClaimTemplateProps[];\n\n  constructor(scope: Construct, id: string, props: StatefulSetProps) {\n    super(scope, id, props);\n\n    this.apiObject = new k8s.KubeStatefulSet(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n    this.service = props.service ?? this._createHeadlessService();\n\n    this.apiObject.addDependency(this.service);\n\n    this.replicas = props.replicas;\n    this.strategy = props.strategy ?? StatefulSetUpdateStrategy.rollingUpdate();\n    this.podManagementPolicy = props.podManagementPolicy ?? PodManagementPolicy.ORDERED_READY;\n    this.minReady = props.minReady ?? Duration.seconds(0);\n    props?.volumeClaimTemplates?.forEach(template => this.addVolumeClaimTemplate(template));\n    this.service.select(this);\n\n    if (this.isolate) {\n      this.connections.isolate();\n    }\n  }\n\n  public addVolumeClaimTemplate(template: PersistentVolumeClaimTemplateProps) {\n    if (this.volumeClaimTemplates?.some(t => t.name === template.name)) {\n      throw new Error(`A volume claim template with name \"${template.name}\" already exists`);\n    }\n    this.volumeClaimTemplates = this.volumeClaimTemplates\n      ? [...this.volumeClaimTemplates, template]\n      : [template];\n  }\n\n  private _createHeadlessService() {\n    const myPorts = container.extractContainerPorts(this);\n    const myPortNumbers = myPorts.map(p => p.number);\n    const ports: service.ServicePort[] = myPorts.map(p => ({\n      port: p.number,\n      targetPort: p.number,\n      protocol: p.protocol,\n      name: p.name,\n    }));\n    if (ports.length === 0) {\n      throw new Error(`Unable to create a service for the stateful set ${this.name}: StatefulSet ports cannot be determined.`);\n    }\n\n    // validate the ports are owned by our containers\n    for (const port of ports) {\n      const targetPort = port.targetPort ?? port.port;\n      if (!myPortNumbers.includes(targetPort)) {\n        throw new Error(`Unable to expose stateful set ${this.name} via a service: Port ${targetPort} is not exposed by any container`);\n      }\n    }\n\n    const metadata: any = { namespace: this.metadata.namespace };\n    return new service.Service(this, 'Service', {\n      selector: this,\n      ports,\n      metadata,\n      clusterIP: 'None',\n      type: service.ServiceType.CLUSTER_IP,\n    });\n\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.StatefulSetSpec {\n    return {\n      replicas: this.hasAutoscaler ? undefined : (this.replicas ?? 1),\n      serviceName: this.service.name,\n      minReadySeconds: this.minReady.toSeconds(),\n      template: {\n        metadata: this.podMetadata.toJson(),\n        spec: this._toPodSpec(),\n      },\n      selector: this._toLabelSelector(),\n      podManagementPolicy: this.podManagementPolicy,\n      volumeClaimTemplates: this._toPersistentVolumeClaims(),\n      updateStrategy: this.strategy._toKube(),\n    };\n  }\n\n  /**\n   * @internal\n   */\n  public _toPodSpec(): k8s.PodSpec {\n    const podSpec = super._toPodSpec();\n    return {\n      ...podSpec,\n      volumes: this._filterPodSpecVolumes(podSpec),\n    };\n  }\n\n  /**\n   * @internal\n   */\n  private _filterPodSpecVolumes(podSpec: PodSpec) {\n    // When using volumeClaimTemplates, the volumes with matching names should not be included in the pod spec\n    if (this.volumeClaimTemplates && podSpec.volumes) {\n      const volumeClaimNames = this.volumeClaimTemplates.map(vct => vct.name);\n      const volumesWithNoTemplates = podSpec.volumes.filter(vol => !volumeClaimNames.includes(vol.name));\n\n      // If there are no volumes after filtering, don't include volumes property\n      if (volumesWithNoTemplates.length === 0) {\n        return undefined;\n      } else {\n        return volumesWithNoTemplates;\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * @see IScalable.markHasAutoscaler()\n   */\n  public markHasAutoscaler() {\n    this.hasAutoscaler = true;\n  }\n\n  /**\n   * @see IScalable.toScalingTarget()\n   */\n  public toScalingTarget(): ScalingTarget {\n    return {\n      kind: this.apiObject.kind,\n      apiVersion: this.apiObject.apiVersion,\n      name: this.name,\n      containers: this.containers,\n      replicas: this.replicas,\n    };\n  }\n\n  /**\n   * @internal\n   */\n  private _toPersistentVolumeClaims(): KubePersistentVolumeClaimProps[] | undefined {\n    const volumeNames = this.containers.flatMap(it => it.mounts).map(mount => mount.volume.name);\n    this.volumeClaimTemplates?.forEach(t => {\n      if (!volumeNames.includes(t.name)) {\n        throw new Error(`Volume claim template with name \"${t.name}\" is not used by any container mount`);\n      }\n    });\n    return this.volumeClaimTemplates?.map(template => {\n      const resources: VolumeResourceRequirements = template.storage\n        ? { requests: { storage: Quantity.fromString(template.storage.asString()) } }\n        : {};\n      return {\n        metadata: {\n          name: template.name,\n        },\n        spec: {\n          accessModes: template.accessModes,\n          storageClassName: template.storageClassName,\n          resources,\n        },\n      };\n    });\n  }\n}\n\n/**\n * Options for `StatefulSetUpdateStrategy.rollingUpdate`.\n */\nexport interface StatefulSetUpdateStrategyRollingUpdateOptions {\n\n  /**\n   * If specified, all Pods with an ordinal that is greater than or equal to the partition will\n   * be updated when the StatefulSet's .spec.template is updated. All Pods with an ordinal that\n   * is less than the partition will not be updated, and, even if they are deleted, they will be\n   * recreated at the previous version.\n   *\n   * If the partition is greater than replicas, updates to the pod template will not be propagated to Pods.\n   * In most cases you will not need to use a partition, but they are useful if you want to stage an\n   * update, roll out a canary, or perform a phased roll out.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/controllers/statefulset/#partitions\n   * @default 0\n   */\n  readonly partition?: number;\n\n}\n\n/**\n * StatefulSet update strategies.\n */\nexport class StatefulSetUpdateStrategy {\n\n  /**\n   * The controller will not automatically update the Pods in a StatefulSet.\n   * Users must manually delete Pods to cause the controller to create new Pods\n   * that reflect modifications.\n   */\n  public static onDelete(): StatefulSetUpdateStrategy {\n    return new StatefulSetUpdateStrategy({\n      type: 'OnDelete',\n    });\n  }\n\n  /**\n   * The controller will delete and recreate each Pod in the StatefulSet.\n   * It will proceed in the same order as Pod termination (from the largest ordinal to the smallest),\n   * updating each Pod one at a time. The Kubernetes control plane waits until an updated\n   * Pod is Running and Ready prior to updating its predecessor.\n   */\n  public static rollingUpdate(options: StatefulSetUpdateStrategyRollingUpdateOptions = {}): StatefulSetUpdateStrategy {\n\n    return new StatefulSetUpdateStrategy({\n      type: 'RollingUpdate',\n      rollingUpdate: { partition: options.partition ?? 0 },\n    });\n  }\n\n  private constructor(private readonly strategy: k8s.StatefulSetUpdateStrategy) {\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.StatefulSetUpdateStrategy {\n    return this.strategy;\n  }\n\n}\n\n/**\n * A PersistentVolumeClaim template for StatefulSets\n */\nexport interface PersistentVolumeClaimTemplateProps extends PersistentVolumeClaimProps {\n  /**\n   * The name of the claim that the StatefulSet controller will create for each pod.\n   * This will be used to name the created PVC in the format <claim-name>-<pod-name>\n   *\n   * This name should match the name of a volume mount in one of the containers.\n   */\n  readonly name: string;\n}\n"]}

package/lib/utils.d.ts

@@ -0,0 +1,4 @@
+import { IConstruct } from 'constructs';
+export declare function undefinedIfEmpty<T>(obj: T): T | undefined;
+export declare function filterUndefined(obj: any): any;
+export declare function address(...constructs: IConstruct[]): string;

package/lib/utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.undefinedIfEmpty = undefinedIfEmpty;
+exports.filterUndefined = filterUndefined;
+exports.address = address;
+function undefinedIfEmpty(obj) {
+    if (typeof (obj) === 'string' && obj === '') {
+        return undefined;
+    }
+    if (Array.isArray(obj) && obj.length === 0) {
+        return undefined;
+    }
+    if (typeof (obj) === 'object' && (Object.keys(obj).length === 0 || Object.values(obj).filter(x => x).length === 0)) {
+        return undefined;
+    }
+    return obj;
+}
+function filterUndefined(obj) {
+    const ret = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (v !== undefined) {
+            ret[k] = v;
+        }
+    }
+    return ret;
+}
+function address(...constructs) {
+    const addresses = constructs
+        .map(c => c.node.addr)
+        .sort((a, b) => a.localeCompare(b));
+    return addresses.join('');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSw0Q0FLQztBQUVELDBDQVFDO0FBRUQsMEJBS0M7QUF0QkQsU0FBZ0IsZ0JBQWdCLENBQUksR0FBTTtJQUN4QyxJQUFJLE9BQU0sQ0FBQyxHQUFHLENBQUMsS0FBSyxRQUFRLElBQUksR0FBRyxLQUFLLEVBQUUsRUFBRSxDQUFDO1FBQUMsT0FBTyxTQUFTLENBQUM7SUFBQyxDQUFDO0lBQ2pFLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxHQUFHLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQUMsT0FBTyxTQUFTLENBQUM7SUFBQyxDQUFDO0lBQ2pFLElBQUksT0FBTSxDQUFDLEdBQUcsQ0FBQyxLQUFLLFFBQVEsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBd0IsQ0FBQyxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUF3QixDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFBQyxPQUFPLFNBQVMsQ0FBQztJQUFDLENBQUM7SUFDbEwsT0FBTyxHQUFHLENBQUM7QUFDYixDQUFDO0FBRUQsU0FBZ0IsZUFBZSxDQUFDLEdBQVE7SUFDdEMsTUFBTSxHQUFHLEdBQVEsRUFBRSxDQUFDO0lBQ3BCLEtBQUssTUFBTSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDekMsSUFBSSxDQUFDLEtBQUssU0FBUyxFQUFFLENBQUM7WUFDcEIsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUNiLENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUM7QUFDYixDQUFDO0FBRUQsU0FBZ0IsT0FBTyxDQUFDLEdBQUcsVUFBd0I7SUFDakQsTUFBTSxTQUFTLEdBQUcsVUFBVTtTQUN6QixHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztTQUNyQixJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDdEMsT0FBTyxTQUFTLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0FBQzVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJQ29uc3RydWN0IH0gZnJvbSAnY29uc3RydWN0cyc7XG5cbmV4cG9ydCBmdW5jdGlvbiB1bmRlZmluZWRJZkVtcHR5PFQ+KG9iajogVCk6IFQgfCB1bmRlZmluZWQge1xuICBpZiAodHlwZW9mKG9iaikgPT09ICdzdHJpbmcnICYmIG9iaiA9PT0gJycpIHsgcmV0dXJuIHVuZGVmaW5lZDsgfVxuICBpZiAoQXJyYXkuaXNBcnJheShvYmopICYmIG9iai5sZW5ndGggPT09IDApIHsgcmV0dXJuIHVuZGVmaW5lZDsgfVxuICBpZiAodHlwZW9mKG9iaikgPT09ICdvYmplY3QnICYmIChPYmplY3Qua2V5cyhvYmogYXMgdW5rbm93biBhcyBvYmplY3QpLmxlbmd0aCA9PT0gMCB8fCBPYmplY3QudmFsdWVzKG9iaiBhcyB1bmtub3duIGFzIG9iamVjdCkuZmlsdGVyKHggPT4geCkubGVuZ3RoID09PSAwKSkgeyByZXR1cm4gdW5kZWZpbmVkOyB9XG4gIHJldHVybiBvYmo7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBmaWx0ZXJVbmRlZmluZWQob2JqOiBhbnkpOiBhbnkge1xuICBjb25zdCByZXQ6IGFueSA9IHt9O1xuICBmb3IgKGNvbnN0IFtrLCB2XSBvZiBPYmplY3QuZW50cmllcyhvYmopKSB7XG4gICAgaWYgKHYgIT09IHVuZGVmaW5lZCkge1xuICAgICAgcmV0W2tdID0gdjtcbiAgICB9XG4gIH1cbiAgcmV0dXJuIHJldDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGFkZHJlc3MoLi4uY29uc3RydWN0czogSUNvbnN0cnVjdFtdKSB7XG4gIGNvbnN0IGFkZHJlc3NlcyA9IGNvbnN0cnVjdHNcbiAgICAubWFwKGMgPT4gYy5ub2RlLmFkZHIpXG4gICAgLnNvcnQoKGEsIGIpID0+IGEubG9jYWxlQ29tcGFyZShiKSk7XG4gIHJldHVybiBhZGRyZXNzZXMuam9pbignJyk7XG59XG4iXX0=