cdk8s-plus-36 0.0.1 → 2.0.0

package/lib/job.d.ts

@@ -0,0 +1,64 @@
+import { ApiObject, Duration } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as k8s from './imports/k8s';
+import * as workload from './workload';
+/**
+ * Properties for `Job`.
+ */
+export interface JobProps extends workload.WorkloadProps {
+    /**
+     * Specifies the duration the job may be active before the system tries to terminate it.
+     *
+     * @default - If unset, then there is no deadline.
+     */
+    readonly activeDeadline?: Duration;
+    /**
+     * Specifies the number of retries before marking this job failed.
+     *
+     * @default - If not set, system defaults to 6.
+     */
+    readonly backoffLimit?: number;
+    /**
+     * Limits the lifetime of a Job that has finished execution (either Complete
+     * or Failed). If this field is set, after the Job finishes, it is eligible to
+     * be automatically deleted. When the Job is being deleted, its lifecycle
+     * guarantees (e.g. finalizers) will be honored. If this field is set to zero,
+     * the Job becomes eligible to be deleted immediately after it finishes. This
+     * field is alpha-level and is only honored by servers that enable the
+     * `TTLAfterFinished` feature.
+     *
+     * @default - If this field is unset, the Job won't be automatically deleted.
+     */
+    readonly ttlAfterFinished?: Duration;
+}
+/**
+ * A Job creates one or more Pods and ensures that a specified number of them successfully terminate. As pods successfully complete,
+ * the Job tracks the successful completions. When a specified number of successful completions is reached, the task (ie, Job) is complete.
+ * Deleting a Job will clean up the Pods it created. A simple case is to create one Job object in order to reliably run one Pod to completion.
+ * The Job object will start a new Pod if the first Pod fails or is deleted (for example due to a node hardware failure or a node reboot).
+ * You can also use a Job to run multiple Pods in parallel.
+ */
+export declare class Job extends workload.Workload {
+    /**
+     * Duration before job is terminated. If undefined, there is no deadline.
+     */
+    readonly activeDeadline?: Duration;
+    /**
+     * Number of retries before marking failed.
+     */
+    readonly backoffLimit?: number;
+    /**
+     * TTL before the job is deleted after it is finished.
+     */
+    readonly ttlAfterFinished?: Duration;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "jobs";
+    constructor(scope: Construct, id: string, props?: JobProps);
+    /**
+     * @internal
+     */
+    _toKube(): k8s.JobSpec;
+}

package/lib/job.js

@@ -0,0 +1,101 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const k8s = __importStar(require("./imports/k8s"));
+const pod = __importStar(require("./pod"));
+const workload = __importStar(require("./workload"));
+/**
+ * A Job creates one or more Pods and ensures that a specified number of them successfully terminate. As pods successfully complete,
+ * the Job tracks the successful completions. When a specified number of successful completions is reached, the task (ie, Job) is complete.
+ * Deleting a Job will clean up the Pods it created. A simple case is to create one Job object in order to reliably run one Pod to completion.
+ * The Job object will start a new Pod if the first Pod fails or is deleted (for example due to a node hardware failure or a node reboot).
+ * You can also use a Job to run multiple Pods in parallel.
+ */
+class Job extends workload.Workload {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Job", version: "2.0.0" };
+    /**
+     * Duration before job is terminated. If undefined, there is no deadline.
+     */
+    activeDeadline;
+    /**
+     * Number of retries before marking failed.
+     */
+    backoffLimit;
+    /**
+     * TTL before the job is deleted after it is finished.
+     */
+    ttlAfterFinished;
+    /**
+     * @see base.Resource.apiObject
+     */
+    apiObject;
+    resourceType = 'jobs';
+    constructor(scope, id, props = {}) {
+        super(scope, id, {
+            restartPolicy: pod.RestartPolicy.NEVER,
+            select: false,
+            ...props,
+        });
+        this.apiObject = new k8s.KubeJob(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this.activeDeadline = props.activeDeadline;
+        this.backoffLimit = props.backoffLimit;
+        this.ttlAfterFinished = props.ttlAfterFinished;
+        if (this.isolate) {
+            this.connections.isolate();
+        }
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            template: {
+                metadata: this.podMetadata.toJson(),
+                spec: this._toPodSpec(),
+            },
+            activeDeadlineSeconds: this.activeDeadline?.toSeconds(),
+            backoffLimit: this.backoffLimit,
+            ttlSecondsAfterFinished: this.ttlAfterFinished ? this.ttlAfterFinished.toSeconds() : undefined,
+        };
+    }
+}
+exports.Job = Job;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiam9iLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2pvYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsaUNBQWtEO0FBRWxELG1EQUFxQztBQUNyQywyQ0FBNkI7QUFDN0IscURBQXVDO0FBb0N2Qzs7Ozs7O0dBTUc7QUFDSCxNQUFhLEdBQUksU0FBUSxRQUFRLENBQUMsUUFBUTs7SUFFeEM7O09BRUc7SUFDYSxjQUFjLENBQVk7SUFFMUM7O09BRUc7SUFDYSxZQUFZLENBQVU7SUFFdEM7O09BRUc7SUFDYSxnQkFBZ0IsQ0FBWTtJQUU1Qzs7T0FFRztJQUNnQixTQUFTLENBQVk7SUFFeEIsWUFBWSxHQUFHLE1BQU0sQ0FBQztJQUV0QyxZQUFZLEtBQWdCLEVBQUUsRUFBVSxFQUFFLFFBQWtCLEVBQUU7UUFDNUQsS0FBSyxDQUFDLEtBQUssRUFBRSxFQUFFLEVBQUU7WUFDZixhQUFhLEVBQUUsR0FBRyxDQUFDLGFBQWEsQ0FBQyxLQUFLO1lBQ3RDLE1BQU0sRUFBRSxLQUFLO1lBQ2IsR0FBRyxLQUFLO1NBQ1QsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLEdBQUcsQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLFVBQVUsRUFBRTtZQUNqRCxRQUFRLEVBQUUsS0FBSyxDQUFDLFFBQVE7WUFDeEIsSUFBSSxFQUFFLFlBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUM7U0FDbEQsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLGNBQWMsR0FBRyxLQUFLLENBQUMsY0FBYyxDQUFDO1FBQzNDLElBQUksQ0FBQyxZQUFZLEdBQUcsS0FBSyxDQUFDLFlBQVksQ0FBQztRQUN2QyxJQUFJLENBQUMsZ0JBQWdCLEdBQUcsS0FBSyxDQUFDLGdCQUFnQixDQUFDO1FBRS9DLElBQUksSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ2pCLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDN0IsQ0FBQztJQUNILENBQUM7SUFFRDs7T0FFRztJQUNJLE9BQU87UUFDWixPQUFPO1lBQ0wsUUFBUSxFQUFFO2dCQUNSLFFBQVEsRUFBRSxJQUFJLENBQUMsV0FBVyxDQUFDLE1BQU0sRUFBRTtnQkFDbkMsSUFBSSxFQUFFLElBQUksQ0FBQyxVQUFVLEVBQUU7YUFDeEI7WUFDRCxxQkFBcUIsRUFBRSxJQUFJLENBQUMsY0FBYyxFQUFFLFNBQVMsRUFBRTtZQUN2RCxZQUFZLEVBQUUsSUFBSSxDQUFDLFlBQVk7WUFDL0IsdUJBQXVCLEVBQUUsSUFBSSxDQUFDLGdCQUFnQixDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxFQUFFLENBQUMsQ0FBQyxDQUFDLFNBQVM7U0FDL0YsQ0FBQztJQUNKLENBQUM7O0FBMURILGtCQTREQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFwaU9iamVjdCwgTGF6eSwgRHVyYXRpb24gfSBmcm9tICdjZGs4cyc7XG5pbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tICdjb25zdHJ1Y3RzJztcbmltcG9ydCAqIGFzIGs4cyBmcm9tICcuL2ltcG9ydHMvazhzJztcbmltcG9ydCAqIGFzIHBvZCBmcm9tICcuL3BvZCc7XG5pbXBvcnQgKiBhcyB3b3JrbG9hZCBmcm9tICcuL3dvcmtsb2FkJztcblxuLyoqXG4gKiBQcm9wZXJ0aWVzIGZvciBgSm9iYC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBKb2JQcm9wcyBleHRlbmRzIHdvcmtsb2FkLldvcmtsb2FkUHJvcHMge1xuXG4gIC8qKlxuICAgKiBTcGVjaWZpZXMgdGhlIGR1cmF0aW9uIHRoZSBqb2IgbWF5IGJlIGFjdGl2ZSBiZWZvcmUgdGhlIHN5c3RlbSB0cmllcyB0byB0ZXJtaW5hdGUgaXQuXG4gICAqXG4gICAqIEBkZWZhdWx0IC0gSWYgdW5zZXQsIHRoZW4gdGhlcmUgaXMgbm8gZGVhZGxpbmUuXG4gICAqL1xuICByZWFkb25seSBhY3RpdmVEZWFkbGluZT86IER1cmF0aW9uO1xuXG4gIC8qKlxuICAgKiBTcGVjaWZpZXMgdGhlIG51bWJlciBvZiByZXRyaWVzIGJlZm9yZSBtYXJraW5nIHRoaXMgam9iIGZhaWxlZC5cbiAgICpcbiAgICogQGRlZmF1bHQgLSBJZiBub3Qgc2V0LCBzeXN0ZW0gZGVmYXVsdHMgdG8gNi5cbiAgICovXG4gIHJlYWRvbmx5IGJhY2tvZmZMaW1pdD86IG51bWJlcjtcblxuICAvKipcbiAgICogTGltaXRzIHRoZSBsaWZldGltZSBvZiBhIEpvYiB0aGF0IGhhcyBmaW5pc2hlZCBleGVjdXRpb24gKGVpdGhlciBDb21wbGV0ZVxuICAgKiBvciBGYWlsZWQpLiBJZiB0aGlzIGZpZWxkIGlzIHNldCwgYWZ0ZXIgdGhlIEpvYiBmaW5pc2hlcywgaXQgaXMgZWxpZ2libGUgdG9cbiAgICogYmUgYXV0b21hdGljYWxseSBkZWxldGVkLiBXaGVuIHRoZSBKb2IgaXMgYmVpbmcgZGVsZXRlZCwgaXRzIGxpZmVjeWNsZVxuICAgKiBndWFyYW50ZWVzIChlLmcuIGZpbmFsaXplcnMpIHdpbGwgYmUgaG9ub3JlZC4gSWYgdGhpcyBmaWVsZCBpcyBzZXQgdG8gemVybyxcbiAgICogdGhlIEpvYiBiZWNvbWVzIGVsaWdpYmxlIHRvIGJlIGRlbGV0ZWQgaW1tZWRpYXRlbHkgYWZ0ZXIgaXQgZmluaXNoZXMuIFRoaXNcbiAgICogZmllbGQgaXMgYWxwaGEtbGV2ZWwgYW5kIGlzIG9ubHkgaG9ub3JlZCBieSBzZXJ2ZXJzIHRoYXQgZW5hYmxlIHRoZVxuICAgKiBgVFRMQWZ0ZXJGaW5pc2hlZGAgZmVhdHVyZS5cbiAgICpcbiAgICogQGRlZmF1bHQgLSBJZiB0aGlzIGZpZWxkIGlzIHVuc2V0LCB0aGUgSm9iIHdvbid0IGJlIGF1dG9tYXRpY2FsbHkgZGVsZXRlZC5cbiAgICovXG4gIHJlYWRvbmx5IHR0bEFmdGVyRmluaXNoZWQ/OiBEdXJhdGlvbjtcblxufVxuXG4vKipcbiAqIEEgSm9iIGNyZWF0ZXMgb25lIG9yIG1vcmUgUG9kcyBhbmQgZW5zdXJlcyB0aGF0IGEgc3BlY2lmaWVkIG51bWJlciBvZiB0aGVtIHN1Y2Nlc3NmdWxseSB0ZXJtaW5hdGUuIEFzIHBvZHMgc3VjY2Vzc2Z1bGx5IGNvbXBsZXRlLFxuICogdGhlIEpvYiB0cmFja3MgdGhlIHN1Y2Nlc3NmdWwgY29tcGxldGlvbnMuIFdoZW4gYSBzcGVjaWZpZWQgbnVtYmVyIG9mIHN1Y2Nlc3NmdWwgY29tcGxldGlvbnMgaXMgcmVhY2hlZCwgdGhlIHRhc2sgKGllLCBKb2IpIGlzIGNvbXBsZXRlLlxuICogRGVsZXRpbmcgYSBKb2Igd2lsbCBjbGVhbiB1cCB0aGUgUG9kcyBpdCBjcmVhdGVkLiBBIHNpbXBsZSBjYXNlIGlzIHRvIGNyZWF0ZSBvbmUgSm9iIG9iamVjdCBpbiBvcmRlciB0byByZWxpYWJseSBydW4gb25lIFBvZCB0byBjb21wbGV0aW9uLlxuICogVGhlIEpvYiBvYmplY3Qgd2lsbCBzdGFydCBhIG5ldyBQb2QgaWYgdGhlIGZpcnN0IFBvZCBmYWlscyBvciBpcyBkZWxldGVkIChmb3IgZXhhbXBsZSBkdWUgdG8gYSBub2RlIGhhcmR3YXJlIGZhaWx1cmUgb3IgYSBub2RlIHJlYm9vdCkuXG4gKiBZb3UgY2FuIGFsc28gdXNlIGEgSm9iIHRvIHJ1biBtdWx0aXBsZSBQb2RzIGluIHBhcmFsbGVsLlxuICovXG5leHBvcnQgY2xhc3MgSm9iIGV4dGVuZHMgd29ya2xvYWQuV29ya2xvYWQge1xuXG4gIC8qKlxuICAgKiBEdXJhdGlvbiBiZWZvcmUgam9iIGlzIHRlcm1pbmF0ZWQuIElmIHVuZGVmaW5lZCwgdGhlcmUgaXMgbm8gZGVhZGxpbmUuXG4gICAqL1xuICBwdWJsaWMgcmVhZG9ubHkgYWN0aXZlRGVhZGxpbmU/OiBEdXJhdGlvbjtcblxuICAvKipcbiAgICogTnVtYmVyIG9mIHJldHJpZXMgYmVmb3JlIG1hcmtpbmcgZmFpbGVkLlxuICAgKi9cbiAgcHVibGljIHJlYWRvbmx5IGJhY2tvZmZMaW1pdD86IG51bWJlcjtcblxuICAvKipcbiAgICogVFRMIGJlZm9yZSB0aGUgam9iIGlzIGRlbGV0ZWQgYWZ0ZXIgaXQgaXMgZmluaXNoZWQuXG4gICAqL1xuICBwdWJsaWMgcmVhZG9ubHkgdHRsQWZ0ZXJGaW5pc2hlZD86IER1cmF0aW9uO1xuXG4gIC8qKlxuICAgKiBAc2VlIGJhc2UuUmVzb3VyY2UuYXBpT2JqZWN0XG4gICAqL1xuICBwcm90ZWN0ZWQgcmVhZG9ubHkgYXBpT2JqZWN0OiBBcGlPYmplY3Q7XG5cbiAgcHVibGljIHJlYWRvbmx5IHJlc291cmNlVHlwZSA9ICdqb2JzJztcblxuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nLCBwcm9wczogSm9iUHJvcHMgPSB7fSkge1xuICAgIHN1cGVyKHNjb3BlLCBpZCwge1xuICAgICAgcmVzdGFydFBvbGljeTogcG9kLlJlc3RhcnRQb2xpY3kuTkVWRVIsXG4gICAgICBzZWxlY3Q6IGZhbHNlLFxuICAgICAgLi4ucHJvcHMsXG4gICAgfSk7XG5cbiAgICB0aGlzLmFwaU9iamVjdCA9IG5ldyBrOHMuS3ViZUpvYih0aGlzLCAnUmVzb3VyY2UnLCB7XG4gICAgICBtZXRhZGF0YTogcHJvcHMubWV0YWRhdGEsXG4gICAgICBzcGVjOiBMYXp5LmFueSh7IHByb2R1Y2U6ICgpID0+IHRoaXMuX3RvS3ViZSgpIH0pLFxuICAgIH0pO1xuXG4gICAgdGhpcy5hY3RpdmVEZWFkbGluZSA9IHByb3BzLmFjdGl2ZURlYWRsaW5lO1xuICAgIHRoaXMuYmFja29mZkxpbWl0ID0gcHJvcHMuYmFja29mZkxpbWl0O1xuICAgIHRoaXMudHRsQWZ0ZXJGaW5pc2hlZCA9IHByb3BzLnR0bEFmdGVyRmluaXNoZWQ7XG5cbiAgICBpZiAodGhpcy5pc29sYXRlKSB7XG4gICAgICB0aGlzLmNvbm5lY3Rpb25zLmlzb2xhdGUoKTtcbiAgICB9XG4gIH1cblxuICAvKipcbiAgICogQGludGVybmFsXG4gICAqL1xuICBwdWJsaWMgX3RvS3ViZSgpOiBrOHMuSm9iU3BlYyB7XG4gICAgcmV0dXJuIHtcbiAgICAgIHRlbXBsYXRlOiB7XG4gICAgICAgIG1ldGFkYXRhOiB0aGlzLnBvZE1ldGFkYXRhLnRvSnNvbigpLFxuICAgICAgICBzcGVjOiB0aGlzLl90b1BvZFNwZWMoKSxcbiAgICAgIH0sXG4gICAgICBhY3RpdmVEZWFkbGluZVNlY29uZHM6IHRoaXMuYWN0aXZlRGVhZGxpbmU/LnRvU2Vjb25kcygpLFxuICAgICAgYmFja29mZkxpbWl0OiB0aGlzLmJhY2tvZmZMaW1pdCxcbiAgICAgIHR0bFNlY29uZHNBZnRlckZpbmlzaGVkOiB0aGlzLnR0bEFmdGVyRmluaXNoZWQgPyB0aGlzLnR0bEFmdGVyRmluaXNoZWQudG9TZWNvbmRzKCkgOiB1bmRlZmluZWQsXG4gICAgfTtcbiAgfVxuXG59XG4iXX0=

package/lib/namespace.d.ts

@@ -0,0 +1,128 @@
+import { ApiObject } from 'cdk8s';
+import { Construct, IConstruct } from 'constructs';
+import * as base from './base';
+import * as k8s from './imports/k8s';
+import * as networkpolicy from './network-policy';
+import * as pod from './pod';
+/**
+ * Configuration for selecting namespaces.
+ */
+export interface NamespaceSelectorConfig {
+    /**
+     * A selector to select namespaces by labels.
+     */
+    readonly labelSelector?: pod.LabelSelector;
+    /**
+     * A list of names to select namespaces by names.
+     */
+    readonly names?: string[];
+}
+/**
+ * Represents an object that can select namespaces.
+ */
+export interface INamespaceSelector extends IConstruct {
+    /**
+     * Return the configuration of this selector.
+     */
+    toNamespaceSelectorConfig(): NamespaceSelectorConfig;
+}
+/**
+ * Properties for `Namespace`.
+ */
+export interface NamespaceProps extends base.ResourceProps {
+}
+/**
+ * In Kubernetes, namespaces provides a mechanism for isolating groups of resources within a single cluster.
+ * Names of resources need to be unique within a namespace, but not across namespaces.
+ * Namespace-based scoping is applicable only for namespaced objects (e.g. Deployments, Services, etc) and
+ * not for cluster-wide objects (e.g. StorageClass, Nodes, PersistentVolumes, etc).
+ */
+export declare class Namespace extends base.Resource implements INamespaceSelector, networkpolicy.INetworkPolicyPeer {
+    /**
+     * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/#automatic-labelling
+     */
+    static readonly NAME_LABEL = "kubernetes.io/metadata.name";
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType: string;
+    private readonly _pods;
+    constructor(scope: Construct, id: string, props?: NamespaceProps);
+    /**
+     * @see INamespaceSelector.toNamespaceSelectorConfig()
+     */
+    toNamespaceSelectorConfig(): NamespaceSelectorConfig;
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig;
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector(): pod.IPodSelector | undefined;
+    /**
+     * @internal
+     */
+    _toKube(): k8s.NamespaceSpec;
+}
+/**
+ * Options for `Namespaces.select`.
+ */
+export interface NamespacesSelectOptions {
+    /**
+     * Labels the namespaces must have.
+     * This is equivalent to using an 'Is' selector.
+     *
+     * @default - no strict labels requirements.
+     */
+    readonly labels?: {
+        [key: string]: string;
+    };
+    /**
+     * Namespaces must satisfy these selectors.
+     * The selectors query labels, just like the `labels` property, but they
+     * provide a more advanced matching mechanism.
+     *
+     * @default - no selector requirements.
+     */
+    readonly expressions?: pod.LabelExpression[];
+    /**
+     * Namespaces names must be one of these.
+     *
+     * @default - no name requirements.
+     */
+    readonly names?: string[];
+}
+/**
+ * Represents a group of namespaces.
+ */
+export declare class Namespaces extends Construct implements INamespaceSelector, networkpolicy.INetworkPolicyPeer {
+    private readonly expressions?;
+    private readonly names?;
+    private readonly labels?;
+    /**
+     * Select specific namespaces.
+     */
+    static select(scope: Construct, id: string, options: NamespacesSelectOptions): Namespaces;
+    /**
+     * Select all namespaces.
+     */
+    static all(scope: Construct, id: string): Namespaces;
+    private readonly _pods;
+    constructor(scope: Construct, id: string, expressions?: pod.LabelExpression[] | undefined, names?: string[] | undefined, labels?: {
+        [key: string]: string;
+    } | undefined);
+    /**
+     * @see INamespaceSelector.toNamespaceSelectorConfig()
+     */
+    toNamespaceSelectorConfig(): NamespaceSelectorConfig;
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig;
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector(): pod.IPodSelector | undefined;
+}

package/lib/namespace.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Namespaces = exports.Namespace = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const base = __importStar(require("./base"));
+const k8s = __importStar(require("./imports/k8s"));
+const pod = __importStar(require("./pod"));
+/**
+ * In Kubernetes, namespaces provides a mechanism for isolating groups of resources within a single cluster.
+ * Names of resources need to be unique within a namespace, but not across namespaces.
+ * Namespace-based scoping is applicable only for namespaced objects (e.g. Deployments, Services, etc) and
+ * not for cluster-wide objects (e.g. StorageClass, Nodes, PersistentVolumes, etc).
+ */
+class Namespace extends base.Resource {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Namespace", version: "2.0.0" };
+    /**
+     * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/#automatic-labelling
+     */
+    static NAME_LABEL = 'kubernetes.io/metadata.name';
+    /**
+     * @see base.Resource.apiObject
+     */
+    apiObject;
+    resourceType = 'namespaces';
+    _pods;
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.apiObject = new k8s.KubeNamespace(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this._pods = pod.Pods.all(this, 'Pods', {
+            namespaces: Namespaces.select(this, 'Namespaces', { names: [this.name] }),
+        });
+    }
+    /**
+     * @see INamespaceSelector.toNamespaceSelectorConfig()
+     */
+    toNamespaceSelectorConfig() {
+        return { names: [this.name] };
+    }
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig() {
+        return this._pods.toNetworkPolicyPeerConfig();
+    }
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector() {
+        return this._pods.toPodSelector();
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {};
+    }
+}
+exports.Namespace = Namespace;
+/**
+ * Represents a group of namespaces.
+ */
+class Namespaces extends constructs_1.Construct {
+    expressions;
+    names;
+    labels;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Namespaces", version: "2.0.0" };
+    /**
+     * Select specific namespaces.
+     */
+    static select(scope, id, options) {
+        return new Namespaces(scope, id, options.expressions, options.names, options.labels);
+    }
+    /**
+     * Select all namespaces.
+     */
+    static all(scope, id) {
+        return Namespaces.select(scope, id, { expressions: [], labels: {} });
+    }
+    _pods;
+    constructor(scope, id, expressions, names, labels) {
+        super(scope, id);
+        this.expressions = expressions;
+        this.names = names;
+        this.labels = labels;
+        this._pods = pod.Pods.all(this, 'Pods', { namespaces: this });
+    }
+    /**
+     * @see INamespaceSelector.toNamespaceSelectorConfig()
+     */
+    toNamespaceSelectorConfig() {
+        return {
+            labelSelector: pod.LabelSelector.of({ expressions: this.expressions, labels: this.labels }),
+            names: this.names,
+        };
+    }
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig() {
+        return this._pods.toNetworkPolicyPeerConfig();
+    }
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector() {
+        return this._pods.toPodSelector();
+    }
+}
+exports.Namespaces = Namespaces;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"namespace.js","sourceRoot":"","sources":["../src/namespace.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iCAAwC;AACxC,2CAAmD;AACnD,6CAA+B;AAC/B,mDAAqC;AAErC,2CAA6B;AAiC7B;;;;;GAKG;AACH,MAAa,SAAU,SAAQ,IAAI,CAAC,QAAQ;;IAE1C;;OAEG;IACI,MAAM,CAAU,UAAU,GAAG,6BAA6B,CAAC;IAElE;;OAEG;IACgB,SAAS,CAAY;IAExB,YAAY,GAAW,YAAY,CAAC;IAEnC,KAAK,CAAW;IAEjC,YAAmB,KAAgB,EAAE,EAAU,EAAE,QAAwB,EAAE;QACzE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE;YACvD,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;QAEH,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE;YACtC,UAAU,EAAE,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;SAC1E,CAAC,CAAC;IAEL,CAAC;IAED;;OAEG;IACI,yBAAyB;QAC9B,OAAO,EAAE,KAAK,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,yBAAyB;QAC9B,OAAO,IAAI,CAAC,KAAK,CAAC,yBAAyB,EAAE,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;IACpC,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,OAAO,EAAE,CAAC;IACZ,CAAC;;AAxDH,8BA0DC;AAiCD;;GAEG;AACH,MAAa,UAAW,SAAQ,sBAAS;IAmBpB;IACA;IACA;;IAnBnB;;OAEG;IACI,MAAM,CAAC,MAAM,CAAC,KAAgB,EAAE,EAAU,EAAE,OAAgC;QACjF,OAAO,IAAI,UAAU,CAAC,KAAK,EAAE,EAAE,EAAE,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACvF,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,GAAG,CAAC,KAAgB,EAAE,EAAU;QAC5C,OAAO,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;IACvE,CAAC;IAEgB,KAAK,CAAW;IAEjC,YAAY,KAAgB,EAAE,EAAU,EACrB,WAAmC,EACnC,KAAgB,EAChB,MAAkC;QACnD,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAHA,gBAAW,GAAX,WAAW,CAAwB;QACnC,UAAK,GAAL,KAAK,CAAW;QAChB,WAAM,GAAN,MAAM,CAA4B;QAGnD,IAAI,CAAC,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;IAChE,CAAC;IAED;;OAEG;IACI,yBAAyB;QAC9B,OAAO;YACL,aAAa,EAAE,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAE;YAC5F,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,yBAAyB;QAC9B,OAAO,IAAI,CAAC,KAAK,CAAC,yBAAyB,EAAE,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,CAAC;IACpC,CAAC;;AAjDH,gCAmDC","sourcesContent":["import { ApiObject, Lazy } from 'cdk8s';\nimport { Construct, IConstruct } from 'constructs';\nimport * as base from './base';\nimport * as k8s from './imports/k8s';\nimport * as networkpolicy from './network-policy';\nimport * as pod from './pod';\n\n/**\n * Configuration for selecting namespaces.\n */\nexport interface NamespaceSelectorConfig {\n\n  /**\n   * A selector to select namespaces by labels.\n   */\n  readonly labelSelector?: pod.LabelSelector;\n\n  /**\n   * A list of names to select namespaces by names.\n   */\n  readonly names?: string[];\n}\n\n/**\n * Represents an object that can select namespaces.\n */\nexport interface INamespaceSelector extends IConstruct {\n  /**\n   * Return the configuration of this selector.\n   */\n  toNamespaceSelectorConfig(): NamespaceSelectorConfig;\n}\n\n/**\n * Properties for `Namespace`.\n */\nexport interface NamespaceProps extends base.ResourceProps {}\n\n/**\n * In Kubernetes, namespaces provides a mechanism for isolating groups of resources within a single cluster.\n * Names of resources need to be unique within a namespace, but not across namespaces.\n * Namespace-based scoping is applicable only for namespaced objects (e.g. Deployments, Services, etc) and\n * not for cluster-wide objects (e.g. StorageClass, Nodes, PersistentVolumes, etc).\n */\nexport class Namespace extends base.Resource implements INamespaceSelector, networkpolicy.INetworkPolicyPeer {\n\n  /**\n   * @see https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/#automatic-labelling\n   */\n  public static readonly NAME_LABEL = 'kubernetes.io/metadata.name';\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType: string = 'namespaces';\n\n  private readonly _pods: pod.Pods;\n\n  public constructor(scope: Construct, id: string, props: NamespaceProps = {}) {\n    super(scope, id);\n\n    this.apiObject = new k8s.KubeNamespace(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n\n    this._pods = pod.Pods.all(this, 'Pods', {\n      namespaces: Namespaces.select(this, 'Namespaces', { names: [this.name] }),\n    });\n\n  }\n\n  /**\n   * @see INamespaceSelector.toNamespaceSelectorConfig()\n   */\n  public toNamespaceSelectorConfig(): NamespaceSelectorConfig {\n    return { names: [this.name] };\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()\n   */\n  public toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig {\n    return this._pods.toNetworkPolicyPeerConfig();\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toPodSelector()\n   */\n  public toPodSelector(): pod.IPodSelector | undefined {\n    return this._pods.toPodSelector();\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.NamespaceSpec {\n    return {};\n  }\n\n}\n\n/**\n * Options for `Namespaces.select`.\n */\nexport interface NamespacesSelectOptions {\n\n  /**\n   * Labels the namespaces must have.\n   * This is equivalent to using an 'Is' selector.\n   *\n   * @default - no strict labels requirements.\n   */\n  readonly labels?: { [key: string]: string };\n\n  /**\n   * Namespaces must satisfy these selectors.\n   * The selectors query labels, just like the `labels` property, but they\n   * provide a more advanced matching mechanism.\n   *\n   * @default - no selector requirements.\n   */\n  readonly expressions?: pod.LabelExpression[];\n\n  /**\n   * Namespaces names must be one of these.\n   *\n   * @default - no name requirements.\n   */\n  readonly names?: string[];\n\n}\n\n/**\n * Represents a group of namespaces.\n */\nexport class Namespaces extends Construct implements INamespaceSelector, networkpolicy.INetworkPolicyPeer {\n\n  /**\n   * Select specific namespaces.\n   */\n  public static select(scope: Construct, id: string, options: NamespacesSelectOptions): Namespaces {\n    return new Namespaces(scope, id, options.expressions, options.names, options.labels);\n  }\n\n  /**\n   * Select all namespaces.\n   */\n  public static all(scope: Construct, id: string): Namespaces {\n    return Namespaces.select(scope, id, { expressions: [], labels: {} });\n  }\n\n  private readonly _pods: pod.Pods;\n\n  constructor(scope: Construct, id: string,\n    private readonly expressions?: pod.LabelExpression[],\n    private readonly names?: string[],\n    private readonly labels?: { [key: string]: string }) {\n    super(scope, id);\n\n    this._pods = pod.Pods.all(this, 'Pods', { namespaces: this });\n  }\n\n  /**\n   * @see INamespaceSelector.toNamespaceSelectorConfig()\n   */\n  public toNamespaceSelectorConfig(): NamespaceSelectorConfig {\n    return {\n      labelSelector: pod.LabelSelector.of({ expressions: this.expressions, labels: this.labels } ),\n      names: this.names,\n    };\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()\n   */\n  public toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig {\n    return this._pods.toNetworkPolicyPeerConfig();\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toPodSelector()\n   */\n  public toPodSelector(): pod.IPodSelector | undefined {\n    return this._pods.toPodSelector();\n  }\n\n}\n"]}