cdk8s-plus-36 0.0.1 → 2.0.0

package/lib/pod.js

@@ -0,0 +1,1227 @@
+"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.PodConnections = exports.PodConnectionsIsolation = exports.PodScheduling = exports.Topology = exports.Node = exports.NamedNode = exports.TaintedNode = exports.LabeledNode = exports.Pods = exports.NodeTaintQuery = exports.TaintEffect = exports.LabelExpression = exports.NodeLabelQuery = exports.DnsPolicy = exports.FsGroupChangePolicy = exports.RestartPolicy = exports.PodSecurityContext = exports.PodDns = exports.Pod = exports.LabelSelector = exports.AbstractPod = 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 container = __importStar(require("./container"));
+const k8s = __importStar(require("./imports/k8s"));
+const networkpolicy = __importStar(require("./network-policy"));
+const utils_1 = require("./utils");
+class AbstractPod extends base.Resource {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.AbstractPod", version: "2.0.0" };
+    restartPolicy;
+    serviceAccount;
+    securityContext;
+    dns;
+    dockerRegistryAuth;
+    automountServiceAccountToken;
+    shareProcessNamespace;
+    hostNetwork;
+    terminationGracePeriod;
+    enableServiceLinks;
+    isolate;
+    _containers = [];
+    _initContainers = [];
+    _hostAliases = [];
+    _volumes = new Map();
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.restartPolicy = props.restartPolicy ?? RestartPolicy.ALWAYS;
+        this.serviceAccount = props.serviceAccount;
+        this.securityContext = new PodSecurityContext(props.securityContext);
+        this.dns = new PodDns(props.dns);
+        this.dockerRegistryAuth = props.dockerRegistryAuth;
+        this.automountServiceAccountToken = props.automountServiceAccountToken ?? false;
+        this.shareProcessNamespace = props.shareProcessNamespace ?? false;
+        this.isolate = props.isolate ?? false;
+        this.hostNetwork = props.hostNetwork ?? false;
+        this.terminationGracePeriod = props.terminationGracePeriod ?? cdk8s_1.Duration.seconds(30);
+        this.enableServiceLinks = props.enableServiceLinks;
+        if (props.containers) {
+            props.containers.forEach(c => this.addContainer(c));
+        }
+        if (props.volumes) {
+            props.volumes.forEach(v => this.addVolume(v));
+        }
+        if (props.initContainers) {
+            props.initContainers.forEach(c => this.addInitContainer(c));
+        }
+        if (props.hostAliases) {
+            props.hostAliases.forEach(c => this.addHostAlias(c));
+        }
+    }
+    get containers() {
+        return [...this._containers];
+    }
+    get initContainers() {
+        return [...this._initContainers];
+    }
+    get volumes() {
+        return Array.from(this._volumes.values());
+    }
+    get hostAliases() {
+        return [...this._hostAliases];
+    }
+    /**
+     * @see IPodSelector.toPodSelectorConfig()
+     */
+    toPodSelectorConfig() {
+        const podAddress = this.podMetadata.getLabel(Pod.ADDRESS_LABEL);
+        if (!podAddress) {
+            // shouldn't happen because we add this label automatically in both pods and workloads.
+            throw new Error(`Unable to create a label selector since ${Pod.ADDRESS_LABEL} label is missing`);
+        }
+        return {
+            labelSelector: LabelSelector.of({ labels: { [Pod.ADDRESS_LABEL]: podAddress } }),
+            namespaces: this.metadata.namespace ? {
+                names: [this.metadata.namespace],
+            } : undefined,
+        };
+    }
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig() {
+        return { podSelector: this.toPodSelectorConfig() };
+    }
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector() {
+        return this;
+    }
+    addContainer(cont) {
+        const impl = new container.Container(cont);
+        this.attachContainer(impl);
+        return impl;
+    }
+    attachContainer(cont) {
+        this._containers.push(cont);
+    }
+    addInitContainer(cont) {
+        // https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#differences-from-regular-containers
+        if (!this.isSidecarContainer(cont) && cont.readiness) {
+            throw new Error('Init containers must not have a readiness probe');
+        }
+        if (!this.isSidecarContainer(cont) && cont.liveness) {
+            throw new Error('Init containers must not have a liveness probe');
+        }
+        if (!this.isSidecarContainer(cont) && cont.startup) {
+            throw new Error('Init containers must not have a startup probe');
+        }
+        const impl = new container.Container({
+            ...cont,
+            name: cont.name ?? `init-${this._initContainers.length}`,
+        });
+        this._initContainers.push(impl);
+        return impl;
+    }
+    // Any initContainer that has `restartPolicy=Always` is a sidecar container. Please refer to
+    // documentation for more details:
+    // https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/#differences-from-init-containers
+    isSidecarContainer(cont) {
+        return cont.restartPolicy === container.ContainerRestartPolicy.ALWAYS;
+    }
+    addHostAlias(hostAlias) {
+        this._hostAliases.push(hostAlias);
+    }
+    addVolume(vol) {
+        const existingVolume = this._volumes.get(vol.name);
+        if (existingVolume) {
+            throw new Error(`Volume with name ${vol.name} already exists`);
+        }
+        this._volumes.set(vol.name, vol);
+    }
+    /**
+     * @see ISubect.toSubjectConfiguration()
+     */
+    toSubjectConfiguration() {
+        if (!this.serviceAccount && !this.automountServiceAccountToken) {
+            throw new Error(`${this.name} cannot be converted to a role binding subject:`
+                + ' You must either assign a service account to it, or use \'automountServiceAccountToken: true\'');
+        }
+        // 'default' is assumed to be the name of the default service account
+        // in the cluster.
+        const serviceAccountName = this.serviceAccount?.name ?? 'default';
+        return {
+            kind: 'ServiceAccount',
+            name: serviceAccountName,
+            apiGroup: '',
+        };
+    }
+    /**
+     * @internal
+     */
+    _toPodSpec() {
+        if (this.containers.length === 0) {
+            throw new Error('PodSpec must have at least 1 container');
+        }
+        const volumes = new Map();
+        const containers = [];
+        const initContainers = [];
+        for (const cont of this.containers) {
+            // check if restartPolicy is defined for containers
+            if (cont.restartPolicy) {
+                throw new Error(`Invalid container spec: ${cont.name} has non-empty restartPolicy field. The field can only be specified for initContainers`);
+            }
+            // automatically add volume from the container mount
+            // to this pod so thats its available to the container.
+            for (const mount of cont.mounts) {
+                addVolume(mount.volume);
+            }
+            containers.push(cont._toKube());
+        }
+        for (const cont of this.initContainers) {
+            // automatically add volume from the container mount
+            // to this pod so thats its available to the container.
+            for (const mount of cont.mounts) {
+                addVolume(mount.volume);
+            }
+            initContainers.push(cont._toKube());
+        }
+        for (const vol of this.volumes) {
+            addVolume(vol);
+        }
+        function addVolume(vol) {
+            const existingVolume = volumes.get(vol.name);
+            // its ok to call this function twice on the same volume, but its not ok to
+            // call it twice on a different volume with the same name.
+            if (existingVolume && existingVolume !== vol) {
+                throw new Error(`Invalid mount configuration. At least two different volumes have the same name: ${vol.name}`);
+            }
+            volumes.set(vol.name, vol);
+        }
+        const dns = this.dns._toKube();
+        return {
+            restartPolicy: this.restartPolicy,
+            serviceAccountName: this.serviceAccount?.name,
+            containers: containers,
+            securityContext: (0, utils_1.undefinedIfEmpty)(this.securityContext._toKube()),
+            initContainers: (0, utils_1.undefinedIfEmpty)(initContainers),
+            hostAliases: (0, utils_1.undefinedIfEmpty)(this.hostAliases),
+            volumes: (0, utils_1.undefinedIfEmpty)(Array.from(volumes.values()).map(v => v._toKube())),
+            dnsPolicy: dns.policy,
+            dnsConfig: (0, utils_1.undefinedIfEmpty)(dns.config),
+            hostname: dns.hostname,
+            subdomain: dns.subdomain,
+            setHostnameAsFqdn: dns.hostnameAsFQDN,
+            imagePullSecrets: this.dockerRegistryAuth ? [{ name: this.dockerRegistryAuth.name }] : undefined,
+            automountServiceAccountToken: this.automountServiceAccountToken,
+            shareProcessNamespace: this.shareProcessNamespace,
+            hostNetwork: this.hostNetwork,
+            terminationGracePeriodSeconds: this.terminationGracePeriod?.toSeconds(),
+            enableServiceLinks: this.enableServiceLinks,
+        };
+    }
+}
+exports.AbstractPod = AbstractPod;
+/**
+ * Match a resource by labels.
+ */
+class LabelSelector {
+    expressions;
+    labels;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.LabelSelector", version: "2.0.0" };
+    static of(options = {}) {
+        return new LabelSelector(options.expressions ?? [], options.labels ?? {});
+    }
+    constructor(expressions, labels) {
+        this.expressions = expressions;
+        this.labels = labels;
+    }
+    isEmpty() {
+        return this.expressions.length === 0 && Object.keys(this.labels).length === 0;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        if (this.isEmpty()) {
+            return {};
+        }
+        return {
+            matchExpressions: (0, utils_1.undefinedIfEmpty)(this.expressions.map(q => ({
+                key: q.key,
+                operator: q.operator,
+                values: q.values,
+            }))),
+            matchLabels: (0, utils_1.undefinedIfEmpty)(this.labels),
+        };
+    }
+}
+exports.LabelSelector = LabelSelector;
+/**
+ * Pod is a collection of containers that can run on a host. This resource is
+ * created by clients and scheduled onto hosts.
+ */
+class Pod extends AbstractPod {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Pod", version: "2.0.0" };
+    /**
+     * This label is autoamtically added by cdk8s to any pod. It provides
+     * a unique and stable identifier for the pod.
+     */
+    static ADDRESS_LABEL = 'cdk8s.io/metadata.addr';
+    /**
+     * @see base.Resource.apiObject
+     */
+    apiObject;
+    resourceType = 'pods';
+    scheduling;
+    connections;
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.apiObject = new k8s.KubePod(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this.metadata.addLabel(Pod.ADDRESS_LABEL, cdk8s_1.Names.toLabelValue(this));
+        this.scheduling = new PodScheduling(this);
+        this.connections = new PodConnections(this);
+        if (this.isolate) {
+            this.connections.isolate();
+        }
+    }
+    get podMetadata() {
+        return this.metadata;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        const scheduling = this.scheduling._toKube();
+        return {
+            ...this._toPodSpec(),
+            affinity: scheduling.affinity,
+            nodeName: scheduling.nodeName,
+            tolerations: scheduling.tolerations,
+        };
+    }
+}
+exports.Pod = Pod;
+/**
+ * Holds dns settings of the pod.
+ */
+class PodDns {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.PodDns", version: "2.0.0" };
+    /**
+     * The DNS policy of this pod.
+     */
+    policy;
+    /**
+     * The configured hostname of the pod. Undefined means its set to a system-defined value.
+     */
+    hostname;
+    /**
+     * The configured subdomain of the pod.
+     */
+    subdomain;
+    /**
+     * Whether or not the pods hostname is set to its FQDN.
+     */
+    hostnameAsFQDN;
+    _nameservers;
+    _searches;
+    _options;
+    constructor(props = {}) {
+        this.hostname = props.hostname;
+        this.subdomain = props.subdomain;
+        this.policy = props.policy ?? DnsPolicy.CLUSTER_FIRST;
+        this.hostnameAsFQDN = props.hostnameAsFQDN ?? false;
+        this._nameservers = props.nameservers ?? [];
+        this._searches = props.searches ?? [];
+        this._options = props.options ?? [];
+    }
+    /**
+     * Nameservers defined for this pod.
+     */
+    get nameservers() {
+        return [...this._nameservers];
+    }
+    /**
+     * Search domains defined for this pod.
+     */
+    get searches() {
+        return [...this._searches];
+    }
+    /**
+     * Custom dns options defined for this pod.
+     */
+    get options() {
+        return [...this._options];
+    }
+    /**
+     * Add a nameserver.
+     */
+    addNameserver(...nameservers) {
+        this._nameservers.push(...nameservers);
+    }
+    /**
+     * Add a search domain.
+     */
+    addSearch(...searches) {
+        this._searches.push(...searches);
+    }
+    /**
+     * Add a custom option.
+     */
+    addOption(...options) {
+        this._options.push(...options);
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        if (this.policy === DnsPolicy.NONE && this.nameservers.length === 0) {
+            throw new Error('When dns policy is set to NONE, at least one nameserver is required');
+        }
+        if (this.nameservers.length > 3) {
+            throw new Error('There can be at most 3 nameservers specified');
+        }
+        if (this.searches.length > 6) {
+            throw new Error('There can be at most 6 search domains specified');
+        }
+        return {
+            hostname: this.hostname,
+            subdomain: this.subdomain,
+            hostnameAsFQDN: this.hostnameAsFQDN,
+            policy: this.policy,
+            config: {
+                nameservers: (0, utils_1.undefinedIfEmpty)(this.nameservers),
+                searches: (0, utils_1.undefinedIfEmpty)(this.searches),
+                options: (0, utils_1.undefinedIfEmpty)(this.options),
+            },
+        };
+    }
+}
+exports.PodDns = PodDns;
+/**
+ * Holds pod-level security attributes and common container settings.
+ */
+class PodSecurityContext {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.PodSecurityContext", version: "2.0.0" };
+    ensureNonRoot;
+    user;
+    group;
+    fsGroup;
+    fsGroupChangePolicy;
+    _sysctls = [];
+    constructor(props = {}) {
+        this.ensureNonRoot = props.ensureNonRoot ?? true;
+        this.fsGroupChangePolicy = props.fsGroupChangePolicy ?? FsGroupChangePolicy.ALWAYS;
+        this.user = props.user;
+        this.group = props.group;
+        this.fsGroup = props.fsGroup;
+        for (const sysctl of props.sysctls ?? []) {
+            this._sysctls.push(sysctl);
+        }
+    }
+    get sysctls() {
+        return [...this._sysctls];
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            runAsGroup: this.group,
+            runAsUser: this.user,
+            fsGroup: this.fsGroup,
+            runAsNonRoot: this.ensureNonRoot,
+            fsGroupChangePolicy: this.fsGroupChangePolicy,
+            sysctls: (0, utils_1.undefinedIfEmpty)(this._sysctls),
+        };
+    }
+}
+exports.PodSecurityContext = PodSecurityContext;
+/**
+ * Restart policy for all containers within the pod.
+ */
+var RestartPolicy;
+(function (RestartPolicy) {
+    /**
+     * Always restart the pod after it exits.
+     */
+    RestartPolicy["ALWAYS"] = "Always";
+    /**
+     * Only restart if the pod exits with a non-zero exit code.
+     */
+    RestartPolicy["ON_FAILURE"] = "OnFailure";
+    /**
+     * Never restart the pod.
+     */
+    RestartPolicy["NEVER"] = "Never";
+})(RestartPolicy || (exports.RestartPolicy = RestartPolicy = {}));
+var FsGroupChangePolicy;
+(function (FsGroupChangePolicy) {
+    /**
+     * Only change permissions and ownership if permission and ownership of root directory does
+     * not match with expected permissions of the volume.
+     * This could help shorten the time it takes to change ownership and permission of a volume
+     */
+    FsGroupChangePolicy["ON_ROOT_MISMATCH"] = "OnRootMismatch";
+    /**
+     * Always change permission and ownership of the volume when volume is mounted.
+     */
+    FsGroupChangePolicy["ALWAYS"] = "Always";
+})(FsGroupChangePolicy || (exports.FsGroupChangePolicy = FsGroupChangePolicy = {}));
+/**
+ * Pod DNS policies.
+ */
+var DnsPolicy;
+(function (DnsPolicy) {
+    /**
+     * Any DNS query that does not match the configured cluster domain suffix,
+     * such as "www.kubernetes.io", is forwarded to the
+     * upstream nameserver inherited from the node.
+     * Cluster administrators may have extra stub-domain and upstream DNS servers configured.
+     */
+    DnsPolicy["CLUSTER_FIRST"] = "ClusterFirst";
+    /**
+     * For Pods running with hostNetwork, you should
+     * explicitly set its DNS policy "ClusterFirstWithHostNet".
+     */
+    DnsPolicy["CLUSTER_FIRST_WITH_HOST_NET"] = "ClusterFirstWithHostNet";
+    /**
+     * The Pod inherits the name resolution configuration
+     * from the node that the pods run on.
+     */
+    DnsPolicy["DEFAULT"] = "Default";
+    /**
+     * It allows a Pod to ignore DNS settings from the Kubernetes environment.
+     * All DNS settings are supposed to be provided using the dnsConfig
+     * field in the Pod Spec.
+     */
+    DnsPolicy["NONE"] = "None";
+})(DnsPolicy || (exports.DnsPolicy = DnsPolicy = {}));
+/**
+ * Represents a query that can be performed against nodes with labels.
+ */
+class NodeLabelQuery {
+    key;
+    operator;
+    values;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.NodeLabelQuery", version: "2.0.0" };
+    /**
+     * Requires value of label `key` to equal `value`.
+     */
+    static is(key, value) {
+        return NodeLabelQuery.in(key, [value]);
+    }
+    /**
+     * Requires value of label `key` to be one of `values`.
+     */
+    static in(key, values) {
+        return new NodeLabelQuery(key, 'In', values);
+    }
+    /**
+     * Requires value of label `key` to be none of `values`.
+     */
+    static notIn(key, values) {
+        return new NodeLabelQuery(key, 'NotIn', values);
+    }
+    /**
+     * Requires label `key` to exist.
+     */
+    static exists(key) {
+        return new NodeLabelQuery(key, 'Exists', undefined);
+    }
+    /**
+     * Requires label `key` to not exist.
+     */
+    static doesNotExist(key) {
+        return new NodeLabelQuery(key, 'DoesNotExist', undefined);
+    }
+    /**
+     * Requires value of label `key` to greater than all elements in `values`.
+     */
+    static gt(key, values) {
+        return new NodeLabelQuery(key, 'Gt', values);
+    }
+    /**
+     * Requires value of label `key` to less than all elements in `values`.
+     */
+    static lt(key, values) {
+        return new NodeLabelQuery(key, 'Lt', values);
+    }
+    constructor(key, operator, values) {
+        this.key = key;
+        this.operator = operator;
+        this.values = values;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            key: this.key,
+            operator: this.operator,
+            values: this.values,
+        };
+    }
+}
+exports.NodeLabelQuery = NodeLabelQuery;
+/**
+ * Represents a query that can be performed against resources with labels.
+ */
+class LabelExpression {
+    key;
+    operator;
+    values;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.LabelExpression", version: "2.0.0" };
+    /**
+     * Requires value of label `key` to be one of `values`.
+     */
+    static in(key, values) {
+        return new LabelExpression(key, 'In', values);
+    }
+    /**
+     * Requires value of label `key` to be none of `values`.
+     */
+    static notIn(key, values) {
+        return new LabelExpression(key, 'NotIn', values);
+    }
+    /**
+     * Requires label `key` to exist.
+     */
+    static exists(key) {
+        return new LabelExpression(key, 'Exists', undefined);
+    }
+    /**
+     * Requires label `key` to not exist.
+     */
+    static doesNotExist(key) {
+        return new LabelExpression(key, 'DoesNotExist', undefined);
+    }
+    constructor(key, operator, values) {
+        this.key = key;
+        this.operator = operator;
+        this.values = values;
+    }
+}
+exports.LabelExpression = LabelExpression;
+/**
+ * Taint effects.
+ */
+var TaintEffect;
+(function (TaintEffect) {
+    /**
+     * This means that no pod will be able to schedule
+     * onto the node unless it has a matching toleration.
+     */
+    TaintEffect["NO_SCHEDULE"] = "NoSchedule";
+    /**
+     * This is a "preference" or "soft" version of `NO_SCHEDULE` -- the system
+     * will try to avoid placing a pod that does not tolerate the taint on the node,
+     * but it is not required
+     */
+    TaintEffect["PREFER_NO_SCHEDULE"] = "PreferNoSchedule";
+    /**
+     * This affects pods that are already running on the node as follows:
+     *
+     * - Pods that do not tolerate the taint are evicted immediately.
+     * - Pods that tolerate the taint without specifying `duration` remain bound forever.
+     * - Pods that tolerate the taint with a specified `duration` remain bound for
+     *   the specified amount of time.
+     */
+    TaintEffect["NO_EXECUTE"] = "NoExecute";
+})(TaintEffect || (exports.TaintEffect = TaintEffect = {}));
+/**
+ * Taint queries that can be perfomed against nodes.
+ */
+class NodeTaintQuery {
+    operator;
+    key;
+    value;
+    effect;
+    evictAfter;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.NodeTaintQuery", version: "2.0.0" };
+    /**
+     * Matches a taint with a specific key and value.
+     */
+    static is(key, value, options = {}) {
+        return new NodeTaintQuery('Equal', key, value, options.effect, options.evictAfter);
+    }
+    /**
+     * Matches a tain with any value of a specific key.
+     */
+    static exists(key, options = {}) {
+        return new NodeTaintQuery('Exists', key, undefined, options.effect, options.evictAfter);
+    }
+    /**
+     * Matches any taint.
+     */
+    static any() {
+        return new NodeTaintQuery('Exists');
+    }
+    constructor(operator, key, value, effect, evictAfter) {
+        this.operator = operator;
+        this.key = key;
+        this.value = value;
+        this.effect = effect;
+        this.evictAfter = evictAfter;
+        if (evictAfter && effect !== TaintEffect.NO_EXECUTE) {
+            throw new Error('Only \'NO_EXECUTE\' effects can specify \'evictAfter\'');
+        }
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            effect: this.effect,
+            key: this.key,
+            operator: this.operator,
+            tolerationSeconds: this.evictAfter?.toSeconds(),
+            value: this.value,
+        };
+    }
+}
+exports.NodeTaintQuery = NodeTaintQuery;
+/**
+ * Represents a group of pods.
+ */
+class Pods extends constructs_1.Construct {
+    expressions;
+    labels;
+    namespaces;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Pods", version: "2.0.0" };
+    /**
+     * Select pods in the cluster with various selectors.
+     */
+    static select(scope, id, options) {
+        return new Pods(scope, id, options.expressions, options.labels, options.namespaces);
+    }
+    /**
+     * Select all pods.
+     */
+    static all(scope, id, options = {}) {
+        return Pods.select(scope, id, { namespaces: options.namespaces });
+    }
+    constructor(scope, id, expressions, labels, namespaces) {
+        super(scope, id);
+        this.expressions = expressions;
+        this.labels = labels;
+        this.namespaces = namespaces;
+    }
+    /**
+     * @see IPodSelector.toPodSelectorConfig()
+     */
+    toPodSelectorConfig() {
+        return {
+            labelSelector: LabelSelector.of({ expressions: this.expressions, labels: this.labels }),
+            namespaces: this.namespaces?.toNamespaceSelectorConfig(),
+        };
+    }
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig() {
+        return { podSelector: this.toPodSelectorConfig() };
+    }
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector() {
+        return this;
+    }
+}
+exports.Pods = Pods;
+/**
+ * A node that is matched by label selectors.
+ */
+class LabeledNode {
+    labelSelector;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.LabeledNode", version: "2.0.0" };
+    constructor(labelSelector) {
+        this.labelSelector = labelSelector;
+    }
+    ;
+}
+exports.LabeledNode = LabeledNode;
+/**
+ * A node that is matched by taint selectors.
+ */
+class TaintedNode {
+    taintSelector;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.TaintedNode", version: "2.0.0" };
+    constructor(taintSelector) {
+        this.taintSelector = taintSelector;
+    }
+    ;
+}
+exports.TaintedNode = TaintedNode;
+/**
+ * A node that is matched by its name.
+ */
+class NamedNode {
+    name;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.NamedNode", version: "2.0.0" };
+    constructor(name) {
+        this.name = name;
+    }
+    ;
+}
+exports.NamedNode = NamedNode;
+/**
+ * Represents a node in the cluster.
+ */
+class Node {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Node", version: "2.0.0" };
+    /**
+     * Match a node by its labels.
+     */
+    static labeled(...labelSelector) {
+        return new LabeledNode(labelSelector);
+    }
+    /**
+     * Match a node by its name.
+     */
+    static named(nodeName) {
+        return new NamedNode(nodeName);
+    }
+    /**
+     * Match a node by its taints.
+     */
+    static tainted(...taintSelector) {
+        return new TaintedNode(taintSelector);
+    }
+}
+exports.Node = Node;
+/**
+ * Available topology domains.
+ */
+class Topology {
+    key;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.Topology", version: "2.0.0" };
+    /**
+     * A hostname represents a single node in the cluster.
+     *
+     * @see https://kubernetes.io/docs/reference/labels-annotations-taints/#kubernetesiohostname
+     */
+    static HOSTNAME = new Topology('kubernetes.io/hostname');
+    /**
+     * A zone represents a logical failure domain. It is common for Kubernetes clusters to
+     * span multiple zones for increased availability. While the exact definition of a zone is
+     * left to infrastructure implementations, common properties of a zone include very low
+     * network latency within a zone, no-cost network traffic within a zone, and failure
+     * independence from other zones. For example, nodes within a zone might share a network
+     * switch, but nodes in different zones should not.
+     *
+     * @see https://kubernetes.io/docs/reference/labels-annotations-taints/#topologykubernetesiozone
+     */
+    static ZONE = new Topology('topology.kubernetes.io/zone');
+    /**
+     * A region represents a larger domain, made up of one or more zones. It is uncommon
+     * for Kubernetes clusters to span multiple regions. While the exact definition of a
+     * zone or region is left to infrastructure implementations, common properties of a region
+     * include higher network latency between them than within them, non-zero cost for network
+     * traffic between them, and failure independence from other zones or regions.
+     *
+     * For example, nodes within a region might share power infrastructure (e.g. a UPS or generator), but
+     * nodes in different regions typically would not.
+     *
+     * @see https://kubernetes.io/docs/reference/labels-annotations-taints/#topologykubernetesioregion
+     */
+    static REGION = new Topology('topology.kubernetes.io/region');
+    /**
+     * Custom key for the node label that the system uses to denote the topology domain.
+     */
+    static custom(key) {
+        return new Topology(key);
+    }
+    constructor(key) {
+        this.key = key;
+    }
+    ;
+}
+exports.Topology = Topology;
+/**
+ * Controls the pod scheduling strategy.
+ */
+class PodScheduling {
+    instance;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.PodScheduling", version: "2.0.0" };
+    _nodeAffinityPreferred = [];
+    _nodeAffinityRequired = [];
+    _podAffinityPreferred = [];
+    _podAffinityRequired = [];
+    _podAntiAffinityPreferred = [];
+    _podAntiAffinityRequired = [];
+    _tolerations = [];
+    _nodeName;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    /**
+     * Assign this pod a specific node by name.
+     *
+     * The scheduler ignores the Pod, and the kubelet on the named node
+     * tries to place the Pod on that node. Overrules any affinity rules of the pod.
+     *
+     * Some limitations of static assignment are:
+     *
+     * - If the named node does not exist, the Pod will not run, and in some
+     *   cases may be automatically deleted.
+     * - If the named node does not have the resources to accommodate the Pod,
+     *   the Pod will fail and its reason will indicate why, for example OutOfmemory or OutOfcpu.
+     * - Node names in cloud environments are not always predictable or stable.
+     *
+     * Will throw is the pod is already assigned to named node.
+     *
+     * Under the hood, this method utilizes the `nodeName` property.
+     */
+    assign(node) {
+        if (this._nodeName) {
+            // disallow overriding an static node assignment
+            throw new Error(`Cannot assign ${this.instance.podMetadata.name} to node ${node.name}. It is already assigned to node ${this._nodeName}`);
+        }
+        else {
+            this._nodeName = node.name;
+        }
+    }
+    /**
+     * Allow this pod to tolerate taints matching these tolerations.
+     *
+     * You can put multiple taints on the same node and multiple tolerations on the same pod.
+     * The way Kubernetes processes multiple taints and tolerations is like a filter: start with
+     * all of a node's taints, then ignore the ones for which the pod has a matching toleration;
+     * the remaining un-ignored taints have the indicated effects on the pod. In particular:
+     *
+     * - if there is at least one un-ignored taint with effect NoSchedule then Kubernetes will
+     *   not schedule the pod onto that node
+     * - if there is no un-ignored taint with effect NoSchedule but there is at least one un-ignored
+     *   taint with effect PreferNoSchedule then Kubernetes will try to not schedule the pod onto the node
+     * - if there is at least one un-ignored taint with effect NoExecute then the pod will be evicted from
+     *   the node (if it is already running on the node), and will not be scheduled onto the node (if it is
+     *   not yet running on the node).
+     *
+     * Under the hood, this method utilizes the `tolerations` property.
+     *
+     * @see https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/
+     */
+    tolerate(node) {
+        for (const query of node.taintSelector) {
+            this._tolerations.push(query._toKube());
+        }
+    }
+    /**
+     * Attract this pod to a node matched by selectors.
+     * You can select a node by using `Node.labeled()`.
+     *
+     * Attracting to multiple nodes (i.e invoking this method multiple times) acts as
+     * an OR condition, meaning the pod will be assigned to either one of the nodes.
+     *
+     * Under the hood, this method utilizes the `nodeAffinity` property.
+     *
+     * @see https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#node-affinity
+     */
+    attract(node, options = {}) {
+        const term = this.createNodeAffinityTerm(node);
+        if (options.weight) {
+            this.validateWeight(options.weight);
+            this._nodeAffinityPreferred.push({ weight: options.weight, preference: term });
+        }
+        else {
+            this._nodeAffinityRequired.push(term);
+        }
+    }
+    /**
+     * Co-locate this pod with a scheduling selection.
+     *
+     * A selection can be one of:
+     *
+     * - An instance of a `Pod`.
+     * - An instance of a `Workload` (e.g `Deployment`, `StatefulSet`).
+     * - An un-managed pod that can be selected via `Pods.select()`.
+     *
+     * Co-locating with multiple selections ((i.e invoking this method multiple times)) acts as
+     * an AND condition. meaning the pod will be assigned to a node that satisfies all
+     * selections (i.e runs at least one pod that satisifies each selection).
+     *
+     * Under the hood, this method utilizes the `podAffinity` property.
+     *
+     * @see https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#inter-pod-affinity-and-anti-affinity
+     */
+    colocate(selector, options = {}) {
+        const topology = options.topology ?? Topology.HOSTNAME;
+        const term = this.createPodAffinityTerm(topology, selector);
+        if (options.weight) {
+            this.validateWeight(options.weight);
+            this._podAffinityPreferred.push({ weight: options.weight, podAffinityTerm: term });
+        }
+        else {
+            this._podAffinityRequired.push(term);
+        }
+    }
+    /**
+     * Seperate this pod from a scheduling selection.
+     *
+     * A selection can be one of:
+     *
+     * - An instance of a `Pod`.
+     * - An instance of a `Workload` (e.g `Deployment`, `StatefulSet`).
+     * - An un-managed pod that can be selected via `Pods.select()`.
+     *
+     * Seperating from multiple selections acts as an AND condition. meaning the pod
+     * will not be assigned to a node that satisfies all selections (i.e runs at least one pod that satisifies each selection).
+     *
+     * Under the hood, this method utilizes the `podAntiAffinity` property.
+     *
+     * @see https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#inter-pod-affinity-and-anti-affinity
+     */
+    separate(selector, options = {}) {
+        const topology = options.topology ?? Topology.HOSTNAME;
+        const term = this.createPodAffinityTerm(topology, selector);
+        if (options.weight) {
+            this.validateWeight(options.weight);
+            this._podAntiAffinityPreferred.push({ weight: options.weight, podAffinityTerm: term });
+        }
+        else {
+            this._podAntiAffinityRequired.push(term);
+        }
+    }
+    createPodAffinityTerm(topology, selector) {
+        const config = selector.toPodSelectorConfig();
+        return {
+            topologyKey: topology.key,
+            labelSelector: config.labelSelector._toKube(),
+            namespaceSelector: config.namespaces?.labelSelector?._toKube(),
+            namespaces: config.namespaces?.names,
+        };
+    }
+    createNodeAffinityTerm(node) {
+        return { matchExpressions: node.labelSelector.map(s => s._toKube()) };
+    }
+    validateWeight(weight) {
+        if (weight < 1 || weight > 100) {
+            // https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#node-affinity-weight
+            throw new Error(`Invalid affinity weight: ${weight}. Must be in range 1-100`);
+        }
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        const atLeastOne = (...arrays) => {
+            return arrays.flat().length > 0;
+        };
+        const hasNodeAffinity = atLeastOne(this._nodeAffinityPreferred, this._nodeAffinityRequired);
+        const hasPodAffinity = atLeastOne(this._podAffinityPreferred, this._podAffinityRequired);
+        const hasPodAntiAffinty = atLeastOne(this._podAntiAffinityPreferred, this._podAntiAffinityRequired);
+        const hasAffinity = hasNodeAffinity || hasPodAffinity || hasPodAntiAffinty;
+        return {
+            affinity: hasAffinity ? {
+                nodeAffinity: hasNodeAffinity ? {
+                    preferredDuringSchedulingIgnoredDuringExecution: (0, utils_1.undefinedIfEmpty)(this._nodeAffinityPreferred),
+                    requiredDuringSchedulingIgnoredDuringExecution: this._nodeAffinityRequired.length > 0 ? {
+                        nodeSelectorTerms: this._nodeAffinityRequired,
+                    } : undefined,
+                } : undefined,
+                podAffinity: hasPodAffinity ? {
+                    preferredDuringSchedulingIgnoredDuringExecution: (0, utils_1.undefinedIfEmpty)(this._podAffinityPreferred),
+                    requiredDuringSchedulingIgnoredDuringExecution: (0, utils_1.undefinedIfEmpty)(this._podAffinityRequired),
+                } : undefined,
+                podAntiAffinity: hasPodAntiAffinty ? {
+                    preferredDuringSchedulingIgnoredDuringExecution: (0, utils_1.undefinedIfEmpty)(this._podAntiAffinityPreferred),
+                    requiredDuringSchedulingIgnoredDuringExecution: (0, utils_1.undefinedIfEmpty)(this._podAntiAffinityRequired),
+                } : undefined,
+            } : undefined,
+            nodeName: this._nodeName,
+            tolerations: (0, utils_1.undefinedIfEmpty)(this._tolerations),
+        };
+    }
+}
+exports.PodScheduling = PodScheduling;
+/**
+ * Isolation determines which policies are created
+ * when allowing connections from a a pod / workload to peers.
+ */
+var PodConnectionsIsolation;
+(function (PodConnectionsIsolation) {
+    /**
+     * Only creates network policies that select the pod.
+     */
+    PodConnectionsIsolation["POD"] = "POD";
+    /**
+     * Only creates network policies that select the peer.
+     */
+    PodConnectionsIsolation["PEER"] = "PEER";
+})(PodConnectionsIsolation || (exports.PodConnectionsIsolation = PodConnectionsIsolation = {}));
+/**
+ * Controls network isolation rules for inter-pod communication.
+ */
+class PodConnections {
+    instance;
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "cdk8s-plus-36.PodConnections", version: "2.0.0" };
+    constructor(instance) {
+        this.instance = instance;
+    }
+    /**
+     * Allow network traffic from this pod to the peer.
+     *
+     * By default, this will create an egress network policy for this pod, and an ingress
+     * network policy for the peer. This is required if both sides are already isolated.
+     * Use `options.isolation` to control this behavior.
+     *
+     * @example
+     *
+     * // create only an egress policy that selects the 'web' pod to allow outgoing traffic
+     * // to the 'redis' pod. this requires the 'redis' pod to not be isolated for ingress.
+     * web.connections.allowTo(redis, { isolation: Isolation.POD })
+     *
+     * // create only an ingress policy that selects the 'redis' peer to allow incoming traffic
+     * // from the 'web' pod. this requires the 'web' pod to not be isolated for egress.
+     * web.connections.allowTo(redis, { isolation: Isolation.PEER })
+     *
+     */
+    allowTo(peer, options = {}) {
+        return this.allow('Egress', peer, { ports: this.extractPorts(peer), ...options });
+    }
+    /**
+     * Allow network traffic from the peer to this pod.
+     *
+     * By default, this will create an ingress network policy for this pod, and an egress
+     * network policy for the peer. This is required if both sides are already isolated.
+     * Use `options.isolation` to control this behavior.
+     *
+     * @example
+     *
+     * // create only an egress policy that selects the 'web' pod to allow outgoing traffic
+     * // to the 'redis' pod. this requires the 'redis' pod to not be isolated for ingress.
+     * redis.connections.allowFrom(web, { isolation: Isolation.PEER })
+     *
+     * // create only an ingress policy that selects the 'redis' peer to allow incoming traffic
+     * // from the 'web' pod. this requires the 'web' pod to not be isolated for egress.
+     * redis.connections.allowFrom(web, { isolation: Isolation.POD })
+     *
+     */
+    allowFrom(peer, options = {}) {
+        return this.allow('Ingress', peer, { ports: this.extractPorts(this.instance), ...options });
+    }
+    allow(direction, peer, options = {}) {
+        const config = peer.toNetworkPolicyPeerConfig();
+        networkpolicy.validatePeerConfig(config);
+        const peerAddress = (0, utils_1.address)(peer);
+        if (!options.isolation || options.isolation === PodConnectionsIsolation.POD) {
+            const src = new networkpolicy.NetworkPolicy(this.instance, `Allow${direction}${peerAddress}`, {
+                selector: this.instance,
+                // the policy must be defined in the namespace of the pod
+                // so it can select it.
+                metadata: { namespace: this.instance.metadata.namespace },
+            });
+            switch (direction) {
+                case 'Egress':
+                    src.addEgressRule(peer, options.ports);
+                    break;
+                case 'Ingress':
+                    src.addIngressRule(peer, options.ports);
+            }
+        }
+        if (!options.isolation || options.isolation === PodConnectionsIsolation.PEER) {
+            if (config.ipBlock) {
+                // for an ip block we don't need to create the opposite policies
+                return;
+            }
+            const podSelector = peer.toPodSelector();
+            if (!podSelector) {
+                throw new Error(`Unable to create policies for peer '${peer.node.addr}' since its not a pod selector`);
+            }
+            const oppositeDirection = direction === 'Egress' ? 'Ingress' : 'Egress';
+            const podSelectorConfig = podSelector.toPodSelectorConfig();
+            let namespaces;
+            if (!podSelectorConfig.namespaces) {
+                // if the peer doesn't specify namespaces, we assume the same namespace.
+                namespaces = [this.instance.metadata.namespace];
+            }
+            else {
+                // a peer cannot specify namespaces by labels because
+                // we won't be able to extract the names of those namespaces.
+                if (podSelectorConfig.namespaces.labelSelector && !podSelectorConfig.namespaces.labelSelector.isEmpty()) {
+                    throw new Error(`Unable to create an ${oppositeDirection} policy for peer '${peer.node.path}' (pod=${this.instance.name}). Peer must specify namespaces only by name`);
+                }
+                // a peer must specify namespaces by name.
+                if (!podSelectorConfig.namespaces.names) {
+                    throw new Error(`Unable to create an ${oppositeDirection} policy for peer '${peer.node.path}' (pod=${this.instance.name}). Peer must specify namespace names`);
+                }
+                namespaces = podSelectorConfig.namespaces.names;
+            }
+            for (const name of namespaces) {
+                switch (direction) {
+                    case 'Egress':
+                        new networkpolicy.NetworkPolicy(this.instance, `AllowIngress${name}${peerAddress}`, {
+                            selector: podSelector,
+                            metadata: { namespace: name },
+                            ingress: { rules: [{ peer: this.instance, ports: options.ports }] },
+                        });
+                        break;
+                    case 'Ingress':
+                        new networkpolicy.NetworkPolicy(this.instance, `AllowEgress${name}${peerAddress}`, {
+                            selector: podSelector,
+                            metadata: { namespace: name },
+                            egress: { rules: [{ peer: this.instance, ports: options.ports }] },
+                        });
+                        break;
+                    default:
+                        throw new Error(`Unsupported direction: ${direction}`);
+                }
+            }
+        }
+    }
+    extractPorts(selector) {
+        return container.extractContainerPorts(selector).map(n => networkpolicy.NetworkPolicyPort.tcp(n.number));
+    }
+    /**
+     * Sets the default network policy for Pod/Workload to have all egress and ingress connections as disabled
+     */
+    isolate() {
+        new networkpolicy.NetworkPolicy(this.instance, 'DefaultDenyAll', {
+            selector: this.instance,
+            // the policy must be defined in the namespace of the pod
+            // so it can select it.
+            metadata: { namespace: this.instance.metadata.namespace },
+            egress: {
+                default: networkpolicy.NetworkPolicyTrafficDefault.DENY,
+            },
+            ingress: {
+                default: networkpolicy.NetworkPolicyTrafficDefault.DENY,
+            },
+        });
+    }
+}
+exports.PodConnections = PodConnections;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pod.js","sourceRoot":"","sources":["../src/pod.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, ApiObjectMetadataDefinition, Duration, Lazy, Names } from 'cdk8s';\nimport { Construct, IConstruct } from 'constructs';\nimport * as base from './base';\nimport * as container from './container';\nimport * as k8s from './imports/k8s';\nimport * as namespace from './namespace';\nimport * as networkpolicy from './network-policy';\nimport * as rb from './role-binding';\nimport * as secret from './secret';\nimport * as serviceaccount from './service-account';\nimport { undefinedIfEmpty, address } from './utils';\nimport * as volume from './volume';\n\nexport abstract class AbstractPod extends base.Resource implements IPodSelector, networkpolicy.INetworkPolicyPeer, rb.ISubject {\n\n  public readonly restartPolicy?: RestartPolicy;\n  public readonly serviceAccount?: serviceaccount.IServiceAccount;\n  public readonly securityContext: PodSecurityContext;\n  public readonly dns: PodDns;\n  public readonly dockerRegistryAuth?: secret.ISecret;\n  public readonly automountServiceAccountToken: boolean;\n  public readonly shareProcessNamespace: boolean;\n  public readonly hostNetwork?: boolean;\n  public readonly terminationGracePeriod?: Duration;\n  public readonly enableServiceLinks?: boolean;\n\n  protected readonly isolate: boolean;\n\n  private readonly _containers: container.Container[] = [];\n  private readonly _initContainers: container.Container[] = [];\n  private readonly _hostAliases: HostAlias[] = [];\n  private readonly _volumes: Map<string, volume.Volume> = new Map();\n\n  public abstract readonly podMetadata: ApiObjectMetadataDefinition;\n\n  constructor(scope: Construct, id: string, props: AbstractPodProps = {}) {\n    super(scope, id);\n\n    this.restartPolicy = props.restartPolicy ?? RestartPolicy.ALWAYS;\n    this.serviceAccount = props.serviceAccount;\n    this.securityContext = new PodSecurityContext(props.securityContext);\n    this.dns = new PodDns(props.dns);\n    this.dockerRegistryAuth = props.dockerRegistryAuth;\n    this.automountServiceAccountToken = props.automountServiceAccountToken ?? false;\n    this.shareProcessNamespace = props.shareProcessNamespace ?? false;\n    this.isolate = props.isolate ?? false;\n    this.hostNetwork = props.hostNetwork ?? false;\n    this.terminationGracePeriod = props.terminationGracePeriod ?? Duration.seconds(30);\n    this.enableServiceLinks = props.enableServiceLinks;\n\n    if (props.containers) {\n      props.containers.forEach(c => this.addContainer(c));\n    }\n\n    if (props.volumes) {\n      props.volumes.forEach(v => this.addVolume(v));\n    }\n\n    if (props.initContainers) {\n      props.initContainers.forEach(c => this.addInitContainer(c));\n    }\n\n    if (props.hostAliases) {\n      props.hostAliases.forEach(c => this.addHostAlias(c));\n    }\n\n  }\n\n  public get containers(): container.Container[] {\n    return [...this._containers];\n  }\n\n  public get initContainers(): container.Container[] {\n    return [...this._initContainers];\n  }\n\n  public get volumes(): volume.Volume[] {\n    return Array.from(this._volumes.values());\n  }\n\n  public get hostAliases(): HostAlias[] {\n    return [...this._hostAliases];\n  }\n\n  /**\n   * @see IPodSelector.toPodSelectorConfig()\n   */\n  public toPodSelectorConfig(): PodSelectorConfig {\n    const podAddress = this.podMetadata.getLabel(Pod.ADDRESS_LABEL);\n    if (!podAddress) {\n      // shouldn't happen because we add this label automatically in both pods and workloads.\n      throw new Error(`Unable to create a label selector since ${Pod.ADDRESS_LABEL} label is missing`);\n    }\n    return {\n      labelSelector: LabelSelector.of({ labels: { [Pod.ADDRESS_LABEL]: podAddress } }),\n      namespaces: this.metadata.namespace ? {\n        names: [this.metadata.namespace],\n      } : undefined,\n    };\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()\n   */\n  public toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig {\n    return { podSelector: this.toPodSelectorConfig() };\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toPodSelector()\n   */\n  public toPodSelector(): IPodSelector | undefined {\n    return this;\n  }\n\n  public addContainer(cont: container.ContainerProps): container.Container {\n    const impl = new container.Container(cont);\n    this.attachContainer(impl);\n    return impl;\n  }\n\n  public attachContainer(cont: container.Container) {\n    this._containers.push(cont);\n  }\n\n  public addInitContainer(cont: container.ContainerProps): container.Container {\n\n    // https://kubernetes.io/docs/concepts/workloads/pods/init-containers/#differences-from-regular-containers\n    if (!this.isSidecarContainer(cont) && cont.readiness) {\n      throw new Error('Init containers must not have a readiness probe');\n    }\n\n    if (!this.isSidecarContainer(cont) && cont.liveness) {\n      throw new Error('Init containers must not have a liveness probe');\n    }\n\n    if (!this.isSidecarContainer(cont) && cont.startup) {\n      throw new Error('Init containers must not have a startup probe');\n    }\n\n    const impl = new container.Container({\n      ...cont,\n      name: cont.name ?? `init-${this._initContainers.length}`,\n    });\n\n    this._initContainers.push(impl);\n    return impl;\n  }\n\n  // Any initContainer that has `restartPolicy=Always` is a sidecar container. Please refer to\n  // documentation for more details:\n  // https://kubernetes.io/docs/concepts/workloads/pods/sidecar-containers/#differences-from-init-containers\n  private isSidecarContainer(cont: container.ContainerProps) {\n    return cont.restartPolicy === container.ContainerRestartPolicy.ALWAYS;\n  }\n\n  public addHostAlias(hostAlias: HostAlias): void {\n    this._hostAliases.push(hostAlias);\n  }\n\n  public addVolume(vol: volume.Volume): void {\n    const existingVolume = this._volumes.get(vol.name);\n    if (existingVolume) {\n      throw new Error(`Volume with name ${vol.name} already exists`);\n    }\n    this._volumes.set(vol.name, vol);\n  }\n\n  /**\n   * @see ISubect.toSubjectConfiguration()\n   */\n  public toSubjectConfiguration(): rb.SubjectConfiguration {\n\n    if (!this.serviceAccount && !this.automountServiceAccountToken) {\n      throw new Error(`${this.name} cannot be converted to a role binding subject:`\n        + ' You must either assign a service account to it, or use \\'automountServiceAccountToken: true\\'');\n    }\n\n    // 'default' is assumed to be the name of the default service account\n    // in the cluster.\n    const serviceAccountName = this.serviceAccount?.name ?? 'default';\n\n    return {\n      kind: 'ServiceAccount',\n      name: serviceAccountName,\n      apiGroup: '',\n    };\n  }\n\n  /**\n   * @internal\n   */\n  public _toPodSpec(): k8s.PodSpec {\n\n    if (this.containers.length === 0) {\n      throw new Error('PodSpec must have at least 1 container');\n    }\n\n    const volumes: Map<string, volume.Volume> = new Map();\n    const containers: k8s.Container[] = [];\n    const initContainers: k8s.Container[] = [];\n\n    for (const cont of this.containers) {\n      // check if restartPolicy is defined for containers\n      if (cont.restartPolicy) {\n        throw new Error(`Invalid container spec: ${cont.name} has non-empty restartPolicy field. The field can only be specified for initContainers`);\n      }\n      // automatically add volume from the container mount\n      // to this pod so thats its available to the container.\n      for (const mount of cont.mounts) {\n        addVolume(mount.volume);\n      }\n      containers.push(cont._toKube());\n    }\n\n    for (const cont of this.initContainers) {\n      // automatically add volume from the container mount\n      // to this pod so thats its available to the container.\n      for (const mount of cont.mounts) {\n        addVolume(mount.volume);\n      }\n      initContainers.push(cont._toKube());\n    }\n\n    for (const vol of this.volumes) {\n      addVolume(vol);\n    }\n\n    function addVolume(vol: volume.Volume) {\n      const existingVolume = volumes.get(vol.name);\n      // its ok to call this function twice on the same volume, but its not ok to\n      // call it twice on a different volume with the same name.\n      if (existingVolume && existingVolume !== vol) {\n        throw new Error(`Invalid mount configuration. At least two different volumes have the same name: ${vol.name}`);\n      }\n      volumes.set(vol.name, vol);\n    }\n\n    const dns = this.dns._toKube();\n\n    return {\n      restartPolicy: this.restartPolicy,\n      serviceAccountName: this.serviceAccount?.name,\n      containers: containers,\n      securityContext: undefinedIfEmpty(this.securityContext._toKube()),\n      initContainers: undefinedIfEmpty(initContainers),\n      hostAliases: undefinedIfEmpty(this.hostAliases),\n      volumes: undefinedIfEmpty(Array.from(volumes.values()).map(v => v._toKube())),\n      dnsPolicy: dns.policy,\n      dnsConfig: undefinedIfEmpty(dns.config),\n      hostname: dns.hostname,\n      subdomain: dns.subdomain,\n      setHostnameAsFqdn: dns.hostnameAsFQDN,\n      imagePullSecrets: this.dockerRegistryAuth ? [{ name: this.dockerRegistryAuth.name }] : undefined,\n      automountServiceAccountToken: this.automountServiceAccountToken,\n      shareProcessNamespace: this.shareProcessNamespace,\n      hostNetwork: this.hostNetwork,\n      terminationGracePeriodSeconds: this.terminationGracePeriod?.toSeconds(),\n      enableServiceLinks: this.enableServiceLinks,\n    };\n\n  }\n\n}\n\n/**\n * Sysctl defines a kernel parameter to be set\n */\nexport interface Sysctl {\n  /**\n   * Name of a property to set\n   */\n  readonly name: string;\n\n  /**\n   * Value of a property to set\n   */\n  readonly value: string;\n}\n\n/**\n * Properties for `PodSecurityContext`\n */\nexport interface PodSecurityContextProps {\n\n  /**\n   * Modify the ownership and permissions of pod volumes to this GID.\n   *\n   * @default - Volume ownership is not changed.\n   */\n  readonly fsGroup?: number;\n\n  /**\n   * Defines behavior of changing ownership and permission of the volume before being exposed inside Pod.\n   * This field will only apply to volume types which support fsGroup based ownership(and permissions).\n   * It will have no effect on ephemeral volume types such as: secret, configmaps and emptydir.\n   *\n   * @default FsGroupChangePolicy.ALWAYS\n   */\n  readonly fsGroupChangePolicy?: FsGroupChangePolicy;\n\n  /**\n   * The UID to run the entrypoint of the container process.\n   *\n   * @default - User specified in image metadata\n   */\n  readonly user?: number;\n\n  /**\n   * The GID to run the entrypoint of the container process.\n   *\n   * @default - Group configured by container runtime\n   */\n  readonly group?: number;\n\n  /**\n   * Indicates that the container must run as a non-root user.\n   * If true, the Kubelet will validate the image at runtime to ensure that it does\n   * not run as UID 0 (root) and fail to start the container if it does.\n   *\n   * @default true\n   */\n  readonly ensureNonRoot?: boolean;\n\n  /**\n   * Sysctls hold a list of namespaced sysctls used for the pod.\n   * Pods with unsupported sysctls (by the container runtime) might fail to launch.\n   *\n   * @default - No sysctls\n   */\n  readonly sysctls?: Sysctl[];\n}\n\n/**\n * Properties for `AbstractPod`.\n */\nexport interface AbstractPodProps extends base.ResourceProps {\n\n  /**\n   * List of containers belonging to the pod. Containers cannot currently be\n   * added or removed. There must be at least one container in a Pod.\n   *\n   * You can add additionnal containers using `podSpec.addContainer()`\n   *\n   * @default - No containers. Note that a pod spec must include at least one container.\n   */\n  readonly containers?: container.ContainerProps[];\n\n  /**\n   * List of initialization containers belonging to the pod.\n   * Init containers are executed in order prior to containers being started.\n   * If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy.\n   * The name for an init container or normal container must be unique among all containers.\n   * Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes.\n   * The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit\n   * for each resource type, and then using the max of of that value or the sum of the normal containers.\n   * Limits are applied to init containers in a similar fashion.\n   *\n   * Init containers cannot currently be added ,removed or updated.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/pods/init-containers/\n   * @default - No init containers.\n   */\n  readonly initContainers?: container.ContainerProps[];\n\n  /**\n   * List of volumes that can be mounted by containers belonging to the pod.\n   *\n   * You can also add volumes later using `podSpec.addVolume()`\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes\n   *\n   * @default - No volumes.\n   */\n  readonly volumes?: volume.Volume[];\n\n  /**\n   * Restart policy for all containers within the pod.\n   *\n   * @see https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy\n   *\n   * @default RestartPolicy.ALWAYS\n   */\n  readonly restartPolicy?: RestartPolicy;\n\n  /**\n   * A service account provides an identity for processes that run in a Pod.\n   *\n   * When you (a human) access the cluster (for example, using kubectl), you are\n   * authenticated by the apiserver as a particular User Account (currently this\n   * is usually admin, unless your cluster administrator has customized your\n   * cluster). Processes in containers inside pods can also contact the\n   * apiserver. When they do, they are authenticated as a particular Service\n   * Account (for example, default).\n   *\n   * @see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/\n   *\n   * @default - No service account.\n   */\n  readonly serviceAccount?: serviceaccount.IServiceAccount;\n\n  /**\n   * SecurityContext holds pod-level security attributes and common container settings.\n   *\n   * @default\n   *\n   *   fsGroupChangePolicy: FsGroupChangePolicy.FsGroupChangePolicy.ALWAYS\n   *   ensureNonRoot: true\n   */\n  readonly securityContext?: PodSecurityContextProps;\n\n  /**\n   * HostAlias holds the mapping between IP and hostnames that will be injected as an entry in the pod's hosts file.\n   *\n   * @schema io.k8s.api.core.v1.HostAlias\n   */\n  readonly hostAliases?: HostAlias[];\n\n  /**\n   * DNS settings for the pod.\n   *\n   * @see https://kubernetes.io/docs/concepts/services-networking/dns-pod-service/\n   *\n   * @default\n   *\n   *  policy: DnsPolicy.CLUSTER_FIRST\n   *  hostnameAsFQDN: false\n   */\n  readonly dns?: PodDnsProps;\n\n  /**\n   * A secret containing docker credentials for authenticating to a registry.\n   *\n   * @default - No auth. Images are assumed to be publicly available.\n   */\n  readonly dockerRegistryAuth?: secret.ISecret;\n\n  /**\n   * Indicates whether a service account token should be automatically mounted.\n   *\n   * @default false\n   * @see https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#use-the-default-service-account-to-access-the-api-server\n   */\n  readonly automountServiceAccountToken?: boolean;\n\n  /**\n   * When process namespace sharing is enabled, processes in a container are visible to all other containers in the same pod.\n   *\n   * @default false\n   * @see https://kubernetes.io/docs/tasks/configure-pod-container/share-process-namespace/\n   */\n  readonly shareProcessNamespace?: boolean;\n\n  /**\n   * Isolates the pod. This will prevent any ingress or egress connections to / from this pod.\n   * You can however allow explicit connections post instantiation by using the `.connections` property.\n   *\n   * @default false\n   */\n  readonly isolate?: boolean;\n\n  /**\n   * Host network for the pod.\n   *\n   * @default false\n   */\n  readonly hostNetwork?: boolean;\n\n  /**\n   * Grace period until the pod is terminated\n   *\n   * @default Duration.seconds(30)\n   */\n  readonly terminationGracePeriod?: Duration;\n\n  /**\n   * Indicates whether information about services should be injected into pod's\n   * environment variables, matching the syntax of Docker links.\n   *\n   * @default true\n   * @see https://kubernetes.io/docs/concepts/services-networking/connect-applications-service/#accessing-the-service\n   */\n  readonly enableServiceLinks?: boolean;\n}\n\n/**\n * Properties for `Pod`.\n */\nexport interface PodProps extends AbstractPodProps {\n}\n\n/**\n * Options for `LabelSelector.of`.\n */\nexport interface LabelSelectorOptions {\n\n  /**\n   * Strict label matchers.\n   */\n  readonly labels?: { [key: string]: string };\n\n  /**\n   * Expression based label matchers.\n   */\n  readonly expressions?: LabelExpression[];\n}\n\n/**\n * Match a resource by labels.\n */\nexport class LabelSelector {\n\n  public static of(options: LabelSelectorOptions = {}) {\n    return new LabelSelector(options.expressions ?? [], options.labels ?? {});\n  }\n\n  private constructor(\n    private readonly expressions: LabelExpression[],\n    private readonly labels: { [key: string]: string }) {\n  }\n\n  public isEmpty() {\n    return this.expressions.length === 0 && Object.keys(this.labels).length === 0;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.LabelSelector {\n    if (this.isEmpty()) {\n      return {};\n    }\n    return {\n      matchExpressions: undefinedIfEmpty(this.expressions.map(q => ({\n        key: q.key,\n        operator: q.operator,\n        values: q.values,\n      }))),\n      matchLabels: undefinedIfEmpty(this.labels),\n    };\n  }\n}\n\n/**\n * Configuration for selecting pods, optionally in particular namespaces.\n */\nexport interface PodSelectorConfig {\n\n  /**\n   * A selector to select pods by labels.\n   */\n  readonly labelSelector: LabelSelector;\n\n  /**\n   * Configuration for selecting which namepsaces are the pods allowed to be in.\n   */\n  readonly namespaces?: namespace.NamespaceSelectorConfig;\n\n}\n\n/**\n * Represents an object that can select pods.\n */\nexport interface IPodSelector extends IConstruct {\n  /**\n   * Return the configuration of this selector.\n   */\n  toPodSelectorConfig(): PodSelectorConfig;\n}\n\n/**\n * Pod is a collection of containers that can run on a host. This resource is\n * created by clients and scheduled onto hosts.\n */\nexport class Pod extends AbstractPod {\n\n  /**\n   * This label is autoamtically added by cdk8s to any pod. It provides\n   * a unique and stable identifier for the pod.\n   */\n  public static readonly ADDRESS_LABEL = 'cdk8s.io/metadata.addr';\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'pods';\n\n  public readonly scheduling: PodScheduling;\n  public readonly connections: PodConnections;\n\n  constructor(scope: Construct, id: string, props: PodProps = {}) {\n    super(scope, id, props);\n\n    this.apiObject = new k8s.KubePod(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n\n    this.metadata.addLabel(Pod.ADDRESS_LABEL, Names.toLabelValue(this));\n\n    this.scheduling = new PodScheduling(this);\n    this.connections = new PodConnections(this);\n\n    if (this.isolate) {\n      this.connections.isolate();\n    }\n  }\n\n  public get podMetadata(): ApiObjectMetadataDefinition {\n    return this.metadata;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.PodSpec {\n    const scheduling = this.scheduling._toKube();\n\n    return {\n      ...this._toPodSpec(),\n      affinity: scheduling.affinity,\n      nodeName: scheduling.nodeName,\n      tolerations: scheduling.tolerations,\n    };\n  }\n\n}\n\n/**\n * Properties for `PodDns`.\n */\nexport interface PodDnsProps {\n\n  /**\n   * Specifies the hostname of the Pod.\n   *\n   * @default - Set to a system-defined value.\n   */\n  readonly hostname?: string;\n\n  /**\n   * If specified, the fully qualified Pod hostname will be \"<hostname>.<subdomain>.<pod namespace>.svc.<cluster domain>\".\n   *\n   * @default - No subdomain.\n   */\n  readonly subdomain?: string;\n\n  /**\n   * If true the pod's hostname will be configured as the pod's FQDN, rather than the leaf name (the default).\n   * In Linux containers, this means setting the FQDN in the hostname field of the kernel (the nodename field of struct utsname).\n   * In Windows containers, this means setting the registry value of hostname for the registry\n   * key HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters to FQDN.\n   * If a pod does not have FQDN, this has no effect.\n   *\n   * @default false\n   */\n  readonly hostnameAsFQDN?: boolean;\n\n  /**\n   * Set DNS policy for the pod.\n   *\n   * If policy is set to `None`, other configuration must be supplied.\n   *\n   * @default DnsPolicy.CLUSTER_FIRST\n   */\n  readonly policy?: DnsPolicy;\n\n  /**\n   * A list of IP addresses that will be used as DNS servers for the Pod. There can be at most 3 IP addresses specified.\n   * When the policy is set to \"NONE\", the list must contain at least one IP address,\n   * otherwise this property is optional.\n   * The servers listed will be combined to the base nameservers generated from\n   * the specified DNS policy with duplicate addresses removed.\n   */\n  readonly nameservers?: string[];\n\n  /**\n   * A list of DNS search domains for hostname lookup in the Pod.\n   * When specified, the provided list will be merged into the base\n   * search domain names generated from the chosen DNS policy.\n   * Duplicate domain names are removed.\n   *\n   * Kubernetes allows for at most 6 search domains.\n   */\n  readonly searches?: string[];\n\n  /**\n   * List of objects where each object may have a name property (required)\n   * and a value property (optional). The contents in this property\n   * will be merged to the options generated from the specified DNS policy.\n   * Duplicate entries are removed.\n   */\n  readonly options?: DnsOption[];\n}\n\n/**\n * Holds dns settings of the pod.\n */\nexport class PodDns {\n\n  /**\n   * The DNS policy of this pod.\n   */\n  public readonly policy: DnsPolicy;\n\n  /**\n   * The configured hostname of the pod. Undefined means its set to a system-defined value.\n   */\n  public readonly hostname?: string;\n\n  /**\n   * The configured subdomain of the pod.\n   */\n  public readonly subdomain?: string;\n\n  /**\n   * Whether or not the pods hostname is set to its FQDN.\n   */\n  public readonly hostnameAsFQDN: boolean;\n\n  private readonly _nameservers: string[];\n  private readonly _searches: string[];\n  private readonly _options: DnsOption[];\n\n  constructor(props: PodDnsProps = {}) {\n    this.hostname = props.hostname;\n    this.subdomain = props.subdomain;\n    this.policy = props.policy ?? DnsPolicy.CLUSTER_FIRST;\n    this.hostnameAsFQDN = props.hostnameAsFQDN ?? false;\n    this._nameservers = props.nameservers ?? [];\n    this._searches = props.searches ?? [];\n    this._options = props.options ?? [];\n  }\n\n  /**\n   * Nameservers defined for this pod.\n   */\n  public get nameservers(): string[] {\n    return [...this._nameservers];\n  }\n\n  /**\n   * Search domains defined for this pod.\n   */\n  public get searches(): string[] {\n    return [...this._searches];\n  }\n\n  /**\n   * Custom dns options defined for this pod.\n   */\n  public get options(): DnsOption[] {\n    return [...this._options];\n  }\n\n  /**\n   * Add a nameserver.\n   */\n  public addNameserver(...nameservers: string[]) {\n    this._nameservers.push(...nameservers);\n  }\n\n  /**\n   * Add a search domain.\n   */\n  public addSearch(...searches: string[]) {\n    this._searches.push(...searches);\n  }\n\n  /**\n   * Add a custom option.\n   */\n  public addOption(...options: DnsOption[]) {\n    this._options.push(...options);\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): {\n    hostname?: string;\n    subdomain?: string;\n    hostnameAsFQDN: boolean;\n    policy: string;\n    config: k8s.PodDnsConfig;\n  } {\n\n    if (this.policy === DnsPolicy.NONE && this.nameservers.length === 0) {\n      throw new Error('When dns policy is set to NONE, at least one nameserver is required');\n    }\n\n    if (this.nameservers.length > 3) {\n      throw new Error('There can be at most 3 nameservers specified');\n    }\n\n    if (this.searches.length > 6) {\n      throw new Error('There can be at most 6 search domains specified');\n    }\n\n    return {\n      hostname: this.hostname,\n      subdomain: this.subdomain,\n      hostnameAsFQDN: this.hostnameAsFQDN,\n      policy: this.policy,\n      config: {\n        nameservers: undefinedIfEmpty(this.nameservers),\n        searches: undefinedIfEmpty(this.searches),\n        options: undefinedIfEmpty(this.options),\n      },\n    };\n  }\n\n}\n\n/**\n * Holds pod-level security attributes and common container settings.\n */\nexport class PodSecurityContext {\n\n  public readonly ensureNonRoot: boolean;\n  public readonly user?: number;\n  public readonly group?: number;\n  public readonly fsGroup?: number;\n  public readonly fsGroupChangePolicy: FsGroupChangePolicy;\n\n  private readonly _sysctls: Sysctl[] = [];\n\n  constructor(props: PodSecurityContextProps = {}) {\n    this.ensureNonRoot = props.ensureNonRoot ?? true;\n    this.fsGroupChangePolicy = props.fsGroupChangePolicy ?? FsGroupChangePolicy.ALWAYS;\n    this.user = props.user;\n    this.group = props.group;\n    this.fsGroup = props.fsGroup;\n\n    for (const sysctl of props.sysctls ?? []) {\n      this._sysctls.push(sysctl);\n    }\n\n  }\n\n  public get sysctls(): Sysctl[] {\n    return [...this._sysctls];\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.PodSecurityContext {\n    return {\n      runAsGroup: this.group,\n      runAsUser: this.user,\n      fsGroup: this.fsGroup,\n      runAsNonRoot: this.ensureNonRoot,\n      fsGroupChangePolicy: this.fsGroupChangePolicy,\n      sysctls: undefinedIfEmpty(this._sysctls),\n    };\n  }\n\n}\n\n/**\n * Restart policy for all containers within the pod.\n */\nexport enum RestartPolicy {\n  /**\n   * Always restart the pod after it exits.\n   */\n  ALWAYS = 'Always',\n\n  /**\n   * Only restart if the pod exits with a non-zero exit code.\n   */\n  ON_FAILURE = 'OnFailure',\n\n  /**\n   * Never restart the pod.\n   */\n  NEVER = 'Never',\n}\n\nexport enum FsGroupChangePolicy {\n\n  /**\n   * Only change permissions and ownership if permission and ownership of root directory does\n   * not match with expected permissions of the volume.\n   * This could help shorten the time it takes to change ownership and permission of a volume\n   */\n  ON_ROOT_MISMATCH = 'OnRootMismatch',\n\n  /**\n   * Always change permission and ownership of the volume when volume is mounted.\n   */\n  ALWAYS = 'Always',\n}\n\n/**\n * Custom DNS option.\n */\nexport interface DnsOption {\n\n  /**\n   * Option name.\n   */\n  readonly name: string;\n\n  /**\n   * Option value.\n   *\n   * @default - No value.\n   */\n  readonly value?: string;\n}\n\n/**\n * Pod DNS policies.\n */\nexport enum DnsPolicy {\n\n  /**\n   * Any DNS query that does not match the configured cluster domain suffix,\n   * such as \"www.kubernetes.io\", is forwarded to the\n   * upstream nameserver inherited from the node.\n   * Cluster administrators may have extra stub-domain and upstream DNS servers configured.\n   */\n  CLUSTER_FIRST = 'ClusterFirst',\n\n  /**\n   * For Pods running with hostNetwork, you should\n   * explicitly set its DNS policy \"ClusterFirstWithHostNet\".\n   */\n  CLUSTER_FIRST_WITH_HOST_NET = 'ClusterFirstWithHostNet',\n\n  /**\n   * The Pod inherits the name resolution configuration\n   * from the node that the pods run on.\n   */\n  DEFAULT = 'Default',\n\n  /**\n   * It allows a Pod to ignore DNS settings from the Kubernetes environment.\n   * All DNS settings are supposed to be provided using the dnsConfig\n   * field in the Pod Spec.\n   */\n  NONE = 'None',\n\n}\n\n/**\n * HostAlias holds the mapping between IP and hostnames that will be injected as\n * an entry in the pod's /etc/hosts file.\n */\nexport interface HostAlias {\n  /**\n   * Hostnames for the chosen IP address.\n   */\n  readonly hostnames: string[];\n\n  /**\n   * IP address of the host file entry.\n   */\n  readonly ip: string;\n}\n\n/**\n * Represents a query that can be performed against nodes with labels.\n */\nexport class NodeLabelQuery {\n\n  /**\n   * Requires value of label `key` to equal `value`.\n   */\n  public static is(key: string, value: string) {\n    return NodeLabelQuery.in(key, [value]);\n  }\n\n  /**\n   * Requires value of label `key` to be one of `values`.\n   */\n  public static in(key: string, values: string[]) {\n    return new NodeLabelQuery(key, 'In', values);\n  }\n\n  /**\n   * Requires value of label `key` to be none of `values`.\n   */\n  public static notIn(key: string, values: string[]) {\n    return new NodeLabelQuery(key, 'NotIn', values);\n  }\n\n  /**\n   * Requires label `key` to exist.\n   */\n  public static exists(key: string) {\n    return new NodeLabelQuery(key, 'Exists', undefined);\n  }\n\n  /**\n   * Requires label `key` to not exist.\n   */\n  public static doesNotExist(key: string) {\n    return new NodeLabelQuery(key, 'DoesNotExist', undefined);\n  }\n\n  /**\n   * Requires value of label `key` to greater than all elements in `values`.\n   */\n  public static gt(key: string, values: string[]) {\n    return new NodeLabelQuery(key, 'Gt', values);\n  }\n\n  /**\n   * Requires value of label `key` to less than all elements in `values`.\n   */\n  public static lt(key: string, values: string[]) {\n    return new NodeLabelQuery(key, 'Lt', values);\n  }\n\n  private constructor(\n    private readonly key: string,\n    private readonly operator: string,\n    private readonly values?: string[]) {\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.NodeSelectorRequirement {\n    return {\n      key: this.key,\n      operator: this.operator,\n      values: this.values,\n    };\n  }\n}\n\n/**\n * Represents a query that can be performed against resources with labels.\n */\nexport class LabelExpression {\n\n  /**\n   * Requires value of label `key` to be one of `values`.\n   */\n  public static in(key: string, values: string[]) {\n    return new LabelExpression(key, 'In', values);\n  }\n\n  /**\n   * Requires value of label `key` to be none of `values`.\n   */\n  public static notIn(key: string, values: string[]) {\n    return new LabelExpression(key, 'NotIn', values);\n  }\n\n  /**\n   * Requires label `key` to exist.\n   */\n  public static exists(key: string) {\n    return new LabelExpression(key, 'Exists', undefined);\n  }\n\n  /**\n   * Requires label `key` to not exist.\n   */\n  public static doesNotExist(key: string) {\n    return new LabelExpression(key, 'DoesNotExist', undefined);\n  }\n\n  private constructor(\n    public readonly key: string,\n    public readonly operator: string,\n    public readonly values?: string[]) {\n  }\n\n}\n\n/**\n * Taint effects.\n */\nexport enum TaintEffect {\n  /**\n   * This means that no pod will be able to schedule\n   * onto the node unless it has a matching toleration.\n   */\n  NO_SCHEDULE = 'NoSchedule',\n\n  /**\n   * This is a \"preference\" or \"soft\" version of `NO_SCHEDULE` -- the system\n   * will try to avoid placing a pod that does not tolerate the taint on the node,\n   * but it is not required\n   */\n  PREFER_NO_SCHEDULE = 'PreferNoSchedule',\n\n  /**\n   * This affects pods that are already running on the node as follows:\n   *\n   * - Pods that do not tolerate the taint are evicted immediately.\n   * - Pods that tolerate the taint without specifying `duration` remain bound forever.\n   * - Pods that tolerate the taint with a specified `duration` remain bound for\n   *   the specified amount of time.\n   */\n  NO_EXECUTE = 'NoExecute',\n}\n\n/**\n * Options for `NodeTaintQuery`.\n */\nexport interface NodeTaintQueryOptions {\n  /**\n   * The taint effect to match.\n   *\n   * @default - all effects are matched.\n   */\n  readonly effect?: TaintEffect;\n\n  /**\n   * How much time should a pod that tolerates the `NO_EXECUTE` effect\n   * be bound to the node. Only applies for the `NO_EXECUTE` effect.\n   *\n   * @default - bound forever.\n   */\n  readonly evictAfter?: Duration;\n}\n\n/**\n * Taint queries that can be perfomed against nodes.\n */\nexport class NodeTaintQuery {\n\n  /**\n   * Matches a taint with a specific key and value.\n   */\n  public static is(key: string, value: string, options: NodeTaintQueryOptions = {}): NodeTaintQuery {\n    return new NodeTaintQuery('Equal', key, value, options.effect, options.evictAfter);\n  }\n\n  /**\n   * Matches a tain with any value of a specific key.\n   */\n  public static exists(key: string, options: NodeTaintQueryOptions = {}): NodeTaintQuery {\n    return new NodeTaintQuery('Exists', key, undefined, options.effect, options.evictAfter);\n  }\n\n  /**\n   * Matches any taint.\n   */\n  public static any(): NodeTaintQuery {\n    return new NodeTaintQuery('Exists');\n  }\n\n  private constructor(\n    private readonly operator: string,\n    private readonly key?: string,\n    private readonly value?: string,\n    private readonly effect?: TaintEffect,\n    private readonly evictAfter?: Duration,\n  ) {\n    if (evictAfter && effect !== TaintEffect.NO_EXECUTE) {\n      throw new Error('Only \\'NO_EXECUTE\\' effects can specify \\'evictAfter\\'');\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.Toleration {\n\n    return {\n      effect: this.effect,\n      key: this.key,\n      operator: this.operator,\n      tolerationSeconds: this.evictAfter?.toSeconds(),\n      value: this.value,\n    };\n  }\n\n}\n\n/**\n * Options for `Pods.all`.\n */\nexport interface PodsAllOptions {\n\n  /**\n   * Namespaces the pods are allowed to be in.\n   * Use `Namespaces.all()` to allow all namespaces.\n   *\n   * @default - unset, implies the namespace of the resource this selection is used in.\n   */\n  readonly namespaces?: namespace.Namespaces;\n}\n\n/**\n * Options for `Pods.select`.\n */\nexport interface PodsSelectOptions {\n\n  /**\n   * Labels the pods must have.\n   *\n   * @default - no strict labels requirements.\n   */\n  readonly labels?: { [key: string]: string };\n\n  /**\n   * Expressions the pods must satisify.\n   *\n   * @default - no expressions requirements.\n   */\n  readonly expressions?: LabelExpression[];\n\n  /**\n   * Namespaces the pods are allowed to be in.\n   * Use `Namespaces.all()` to allow all namespaces.\n   *\n   * @default - unset, implies the namespace of the resource this selection is used in.\n   */\n  readonly namespaces?: namespace.Namespaces;\n\n}\n\n/**\n * Represents a group of pods.\n */\nexport class Pods extends Construct implements IPodSelector {\n\n  /**\n   * Select pods in the cluster with various selectors.\n   */\n  public static select(scope: Construct, id: string, options: PodsSelectOptions): Pods {\n    return new Pods(scope, id, options.expressions, options.labels, options.namespaces);\n  }\n\n  /**\n   * Select all pods.\n   */\n  public static all(scope: Construct, id: string, options: PodsAllOptions = {}) {\n    return Pods.select(scope, id, { namespaces: options.namespaces });\n  }\n\n  constructor(\n    scope: Construct, id: string,\n    private readonly expressions?: LabelExpression[],\n    private readonly labels?: { [key: string]: string },\n    private readonly namespaces?: namespace.INamespaceSelector) {\n    super(scope, id);\n  }\n\n  /**\n   * @see IPodSelector.toPodSelectorConfig()\n   */\n  public toPodSelectorConfig(): PodSelectorConfig {\n    return {\n      labelSelector: LabelSelector.of({ expressions: this.expressions, labels: this.labels }),\n      namespaces: this.namespaces?.toNamespaceSelectorConfig(),\n    };\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()\n   */\n  public toNetworkPolicyPeerConfig(): networkpolicy.NetworkPolicyPeerConfig {\n    return { podSelector: this.toPodSelectorConfig() };\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toPodSelector()\n   */\n  public toPodSelector(): IPodSelector | undefined {\n    return this;\n  }\n\n}\n\n/**\n * A node that is matched by label selectors.\n */\nexport class LabeledNode {\n  public constructor(public readonly labelSelector: NodeLabelQuery[]) {\n  };\n}\n\n/**\n * A node that is matched by taint selectors.\n */\nexport class TaintedNode {\n  public constructor(public readonly taintSelector: NodeTaintQuery[]) {\n  };\n}\n\n/**\n * A node that is matched by its name.\n */\nexport class NamedNode {\n  public constructor(public readonly name: string) {\n  };\n}\n\n/**\n * Represents a node in the cluster.\n */\nexport class Node {\n\n  /**\n   * Match a node by its labels.\n   */\n  public static labeled(...labelSelector: NodeLabelQuery[]): LabeledNode {\n    return new LabeledNode(labelSelector);\n  }\n\n  /**\n   * Match a node by its name.\n   */\n  public static named(nodeName: string): NamedNode {\n    return new NamedNode(nodeName);\n  }\n\n  /**\n   * Match a node by its taints.\n   */\n  public static tainted(...taintSelector: NodeTaintQuery[]): TaintedNode {\n    return new TaintedNode(taintSelector);\n  }\n\n}\n\n/**\n * Available topology domains.\n */\nexport class Topology {\n\n  /**\n   * A hostname represents a single node in the cluster.\n   *\n   * @see https://kubernetes.io/docs/reference/labels-annotations-taints/#kubernetesiohostname\n   */\n  public static readonly HOSTNAME = new Topology('kubernetes.io/hostname');\n\n  /**\n   * A zone represents a logical failure domain. It is common for Kubernetes clusters to\n   * span multiple zones for increased availability. While the exact definition of a zone is\n   * left to infrastructure implementations, common properties of a zone include very low\n   * network latency within a zone, no-cost network traffic within a zone, and failure\n   * independence from other zones. For example, nodes within a zone might share a network\n   * switch, but nodes in different zones should not.\n   *\n   * @see https://kubernetes.io/docs/reference/labels-annotations-taints/#topologykubernetesiozone\n   */\n  public static readonly ZONE = new Topology('topology.kubernetes.io/zone');\n\n  /**\n   * A region represents a larger domain, made up of one or more zones. It is uncommon\n   * for Kubernetes clusters to span multiple regions. While the exact definition of a\n   * zone or region is left to infrastructure implementations, common properties of a region\n   * include higher network latency between them than within them, non-zero cost for network\n   * traffic between them, and failure independence from other zones or regions.\n   *\n   * For example, nodes within a region might share power infrastructure (e.g. a UPS or generator), but\n   * nodes in different regions typically would not.\n   *\n   * @see https://kubernetes.io/docs/reference/labels-annotations-taints/#topologykubernetesioregion\n   */\n  public static readonly REGION = new Topology('topology.kubernetes.io/region');\n\n  /**\n   * Custom key for the node label that the system uses to denote the topology domain.\n   */\n  public static custom(key: string): Topology {\n    return new Topology(key);\n  }\n\n  private constructor(public readonly key: string) {\n  };\n}\n\n/**\n * Options for `PodScheduling.colocate`.\n */\nexport interface PodSchedulingColocateOptions {\n  /**\n   * Which topology to coloate on.\n   *\n   * @default - Topology.HOSTNAME\n   */\n  readonly topology?: Topology;\n\n  /**\n   * Indicates the co-location is optional (soft), with this weight score.\n   *\n   * @default - no weight. co-location is assumed to be required (hard).\n   */\n  readonly weight?: number;\n}\n\n/**\n * Options for `PodScheduling.separate`.\n */\nexport interface PodSchedulingSeparateOptions {\n  /**\n   * Which topology to separate on.\n   *\n   * @default - Topology.HOSTNAME\n   */\n  readonly topology?: Topology;\n\n  /**\n   * Indicates the separation is optional (soft), with this weight score.\n   *\n   * @default - no weight. separation is assumed to be required (hard).\n   */\n  readonly weight?: number;\n}\n\n/**\n * Options for `PodScheduling.attract`.\n */\nexport interface PodSchedulingAttractOptions {\n  /**\n   * Indicates the attraction is optional (soft), with this weight score.\n   *\n   * @default - no weight. assignment is assumed to be required (hard).\n   */\n  readonly weight?: number;\n}\n\n/**\n * Controls the pod scheduling strategy.\n */\nexport class PodScheduling {\n\n  private _nodeAffinityPreferred: k8s.PreferredSchedulingTerm[] = [];\n  private _nodeAffinityRequired: k8s.NodeSelectorTerm[] = [];\n  private _podAffinityPreferred: k8s.WeightedPodAffinityTerm[] = [];\n  private _podAffinityRequired: k8s.PodAffinityTerm[] = [];\n  private _podAntiAffinityPreferred: k8s.WeightedPodAffinityTerm[] = [];\n  private _podAntiAffinityRequired: k8s.PodAffinityTerm[] = [];\n  private _tolerations: k8s.Toleration[] = [];\n  private _nodeName?: string;\n\n  constructor(protected readonly instance: AbstractPod) {\n  }\n\n  /**\n   * Assign this pod a specific node by name.\n   *\n   * The scheduler ignores the Pod, and the kubelet on the named node\n   * tries to place the Pod on that node. Overrules any affinity rules of the pod.\n   *\n   * Some limitations of static assignment are:\n   *\n   * - If the named node does not exist, the Pod will not run, and in some\n   *   cases may be automatically deleted.\n   * - If the named node does not have the resources to accommodate the Pod,\n   *   the Pod will fail and its reason will indicate why, for example OutOfmemory or OutOfcpu.\n   * - Node names in cloud environments are not always predictable or stable.\n   *\n   * Will throw is the pod is already assigned to named node.\n   *\n   * Under the hood, this method utilizes the `nodeName` property.\n   */\n  public assign(node: NamedNode) {\n\n    if (this._nodeName) {\n      // disallow overriding an static node assignment\n      throw new Error(`Cannot assign ${this.instance.podMetadata.name} to node ${node.name}. It is already assigned to node ${this._nodeName}`);\n    } else {\n      this._nodeName = node.name;\n    }\n  }\n\n  /**\n   * Allow this pod to tolerate taints matching these tolerations.\n   *\n   * You can put multiple taints on the same node and multiple tolerations on the same pod.\n   * The way Kubernetes processes multiple taints and tolerations is like a filter: start with\n   * all of a node's taints, then ignore the ones for which the pod has a matching toleration;\n   * the remaining un-ignored taints have the indicated effects on the pod. In particular:\n   *\n   * - if there is at least one un-ignored taint with effect NoSchedule then Kubernetes will\n   *   not schedule the pod onto that node\n   * - if there is no un-ignored taint with effect NoSchedule but there is at least one un-ignored\n   *   taint with effect PreferNoSchedule then Kubernetes will try to not schedule the pod onto the node\n   * - if there is at least one un-ignored taint with effect NoExecute then the pod will be evicted from\n   *   the node (if it is already running on the node), and will not be scheduled onto the node (if it is\n   *   not yet running on the node).\n   *\n   * Under the hood, this method utilizes the `tolerations` property.\n   *\n   * @see https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/\n   */\n  public tolerate(node: TaintedNode) {\n    for (const query of node.taintSelector) {\n      this._tolerations.push(query._toKube());\n    }\n  }\n\n  /**\n   * Attract this pod to a node matched by selectors.\n   * You can select a node by using `Node.labeled()`.\n   *\n   * Attracting to multiple nodes (i.e invoking this method multiple times) acts as\n   * an OR condition, meaning the pod will be assigned to either one of the nodes.\n   *\n   * Under the hood, this method utilizes the `nodeAffinity` property.\n   *\n   * @see https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#node-affinity\n   */\n  public attract(node: LabeledNode, options: PodSchedulingAttractOptions = {}) {\n\n    const term = this.createNodeAffinityTerm(node);\n\n    if (options.weight) {\n      this.validateWeight(options.weight);\n      this._nodeAffinityPreferred.push({ weight: options.weight, preference: term });\n    } else {\n      this._nodeAffinityRequired.push(term);\n    }\n  }\n\n  /**\n   * Co-locate this pod with a scheduling selection.\n   *\n   * A selection can be one of:\n   *\n   * - An instance of a `Pod`.\n   * - An instance of a `Workload` (e.g `Deployment`, `StatefulSet`).\n   * - An un-managed pod that can be selected via `Pods.select()`.\n   *\n   * Co-locating with multiple selections ((i.e invoking this method multiple times)) acts as\n   * an AND condition. meaning the pod will be assigned to a node that satisfies all\n   * selections (i.e runs at least one pod that satisifies each selection).\n   *\n   * Under the hood, this method utilizes the `podAffinity` property.\n   *\n   * @see https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#inter-pod-affinity-and-anti-affinity\n   */\n  public colocate(selector: IPodSelector, options: PodSchedulingColocateOptions = {}) {\n\n    const topology = options.topology ?? Topology.HOSTNAME;\n    const term = this.createPodAffinityTerm(topology, selector);\n\n    if (options.weight) {\n      this.validateWeight(options.weight);\n      this._podAffinityPreferred.push({ weight: options.weight, podAffinityTerm: term });\n    } else {\n      this._podAffinityRequired.push(term);\n    }\n  }\n\n  /**\n   * Seperate this pod from a scheduling selection.\n   *\n   * A selection can be one of:\n   *\n   * - An instance of a `Pod`.\n   * - An instance of a `Workload` (e.g `Deployment`, `StatefulSet`).\n   * - An un-managed pod that can be selected via `Pods.select()`.\n   *\n   * Seperating from multiple selections acts as an AND condition. meaning the pod\n   * will not be assigned to a node that satisfies all selections (i.e runs at least one pod that satisifies each selection).\n   *\n   * Under the hood, this method utilizes the `podAntiAffinity` property.\n   *\n   * @see https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#inter-pod-affinity-and-anti-affinity\n   */\n  public separate(selector: IPodSelector, options: PodSchedulingSeparateOptions = {}) {\n\n    const topology = options.topology ?? Topology.HOSTNAME;\n    const term = this.createPodAffinityTerm(topology, selector);\n\n    if (options.weight) {\n      this.validateWeight(options.weight);\n      this._podAntiAffinityPreferred.push({ weight: options.weight, podAffinityTerm: term });\n    } else {\n      this._podAntiAffinityRequired.push(term);\n    }\n\n  }\n\n  private createPodAffinityTerm(topology: Topology, selector: IPodSelector): k8s.PodAffinityTerm {\n    const config = selector.toPodSelectorConfig();\n    return {\n      topologyKey: topology.key,\n      labelSelector: config.labelSelector._toKube(),\n      namespaceSelector: config.namespaces?.labelSelector?._toKube(),\n      namespaces: config.namespaces?.names,\n    };\n  }\n\n  private createNodeAffinityTerm(node: LabeledNode): k8s.NodeSelectorTerm {\n    return { matchExpressions: node.labelSelector.map(s => s._toKube()) };\n  }\n\n  private validateWeight(weight: number) {\n    if (weight < 1 || weight > 100) {\n      // https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#node-affinity-weight\n      throw new Error(`Invalid affinity weight: ${weight}. Must be in range 1-100`);\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): { affinity?: k8s.Affinity; nodeName?: string; tolerations?: k8s.Toleration[] } {\n\n    const atLeastOne = (...arrays: Array<any>[]) => {\n      return arrays.flat().length > 0;\n    };\n\n    const hasNodeAffinity = atLeastOne(this._nodeAffinityPreferred, this._nodeAffinityRequired);\n    const hasPodAffinity = atLeastOne(this._podAffinityPreferred, this._podAffinityRequired);\n    const hasPodAntiAffinty = atLeastOne(this._podAntiAffinityPreferred, this._podAntiAffinityRequired);\n    const hasAffinity = hasNodeAffinity || hasPodAffinity || hasPodAntiAffinty;\n\n    return {\n      affinity: hasAffinity ? {\n        nodeAffinity: hasNodeAffinity ? {\n          preferredDuringSchedulingIgnoredDuringExecution: undefinedIfEmpty(this._nodeAffinityPreferred),\n          requiredDuringSchedulingIgnoredDuringExecution: this._nodeAffinityRequired.length > 0 ? {\n            nodeSelectorTerms: this._nodeAffinityRequired,\n          } : undefined,\n        } : undefined,\n        podAffinity: hasPodAffinity ? {\n          preferredDuringSchedulingIgnoredDuringExecution: undefinedIfEmpty(this._podAffinityPreferred),\n          requiredDuringSchedulingIgnoredDuringExecution: undefinedIfEmpty(this._podAffinityRequired),\n        } : undefined,\n        podAntiAffinity: hasPodAntiAffinty ? {\n          preferredDuringSchedulingIgnoredDuringExecution: undefinedIfEmpty(this._podAntiAffinityPreferred),\n          requiredDuringSchedulingIgnoredDuringExecution: undefinedIfEmpty(this._podAntiAffinityRequired),\n        } : undefined,\n      } : undefined,\n      nodeName: this._nodeName,\n      tolerations: undefinedIfEmpty(this._tolerations),\n    };\n  }\n}\n\n/**\n * Isolation determines which policies are created\n * when allowing connections from a a pod / workload to peers.\n */\nexport enum PodConnectionsIsolation {\n\n  /**\n   * Only creates network policies that select the pod.\n   */\n  POD = 'POD',\n\n  /**\n   * Only creates network policies that select the peer.\n   */\n  PEER = 'PEER',\n\n}\n\n/**\n * Options for `PodConnections.allowTo`.\n */\nexport interface PodConnectionsAllowToOptions {\n\n  /**\n   * Which isolation should be applied to establish the connection.\n   *\n   * @default - unset, isolates both the pod and the peer.\n   */\n  readonly isolation?: PodConnectionsIsolation;\n\n  /**\n   * Ports to allow outgoing traffic to.\n   *\n   * @default - If the peer is a managed pod, take its ports. Otherwise, all ports are allowed.\n   */\n  readonly ports?: networkpolicy.NetworkPolicyPort[];\n\n}\n\n/**\n * Options for `PodConnections.allowFrom`.\n */\nexport interface PodConnectionsAllowFromOptions {\n\n  /**\n   * Which isolation should be applied to establish the connection.\n   *\n   * @default - unset, isolates both the pod and the peer.\n   */\n  readonly isolation?: PodConnectionsIsolation;\n\n  /**\n   * Ports to allow incoming traffic to.\n   *\n   * @default - The pod ports.\n   */\n  readonly ports?: networkpolicy.NetworkPolicyPort[];\n\n}\n\n/**\n * Controls network isolation rules for inter-pod communication.\n */\nexport class PodConnections {\n\n  constructor(protected readonly instance: AbstractPod) {\n  }\n\n  /**\n   * Allow network traffic from this pod to the peer.\n   *\n   * By default, this will create an egress network policy for this pod, and an ingress\n   * network policy for the peer. This is required if both sides are already isolated.\n   * Use `options.isolation` to control this behavior.\n   *\n   * @example\n   *\n   * // create only an egress policy that selects the 'web' pod to allow outgoing traffic\n   * // to the 'redis' pod. this requires the 'redis' pod to not be isolated for ingress.\n   * web.connections.allowTo(redis, { isolation: Isolation.POD })\n   *\n   * // create only an ingress policy that selects the 'redis' peer to allow incoming traffic\n   * // from the 'web' pod. this requires the 'web' pod to not be isolated for egress.\n   * web.connections.allowTo(redis, { isolation: Isolation.PEER })\n   *\n   */\n  public allowTo(peer: networkpolicy.INetworkPolicyPeer, options: PodConnectionsAllowToOptions = {}) {\n    return this.allow('Egress', peer, { ports: this.extractPorts(peer), ...options });\n  }\n\n  /**\n   * Allow network traffic from the peer to this pod.\n   *\n   * By default, this will create an ingress network policy for this pod, and an egress\n   * network policy for the peer. This is required if both sides are already isolated.\n   * Use `options.isolation` to control this behavior.\n   *\n   * @example\n   *\n   * // create only an egress policy that selects the 'web' pod to allow outgoing traffic\n   * // to the 'redis' pod. this requires the 'redis' pod to not be isolated for ingress.\n   * redis.connections.allowFrom(web, { isolation: Isolation.PEER })\n   *\n   * // create only an ingress policy that selects the 'redis' peer to allow incoming traffic\n   * // from the 'web' pod. this requires the 'web' pod to not be isolated for egress.\n   * redis.connections.allowFrom(web, { isolation: Isolation.POD })\n   *\n   */\n  public allowFrom(peer: networkpolicy.INetworkPolicyPeer, options: PodConnectionsAllowFromOptions = {}) {\n    return this.allow('Ingress', peer, { ports: this.extractPorts(this.instance), ...options });\n  }\n\n  private allow(direction: 'Ingress' | 'Egress', peer: networkpolicy.INetworkPolicyPeer, options: PodConnectionsAllowToOptions | PodConnectionsAllowFromOptions = {}) {\n\n    const config = peer.toNetworkPolicyPeerConfig();\n    networkpolicy.validatePeerConfig(config);\n\n    const peerAddress = address(peer);\n\n    if (!options.isolation || options.isolation === PodConnectionsIsolation.POD) {\n\n      const src = new networkpolicy.NetworkPolicy(this.instance, `Allow${direction}${peerAddress}`, {\n        selector: this.instance,\n        // the policy must be defined in the namespace of the pod\n        // so it can select it.\n        metadata: { namespace: this.instance.metadata.namespace },\n      });\n\n      switch (direction) {\n        case 'Egress':\n          src.addEgressRule(peer, options.ports);\n          break;\n        case 'Ingress':\n          src.addIngressRule(peer, options.ports);\n      }\n\n    }\n\n    if (!options.isolation || options.isolation === PodConnectionsIsolation.PEER) {\n\n      if (config.ipBlock) {\n        // for an ip block we don't need to create the opposite policies\n        return;\n      }\n\n      const podSelector = peer.toPodSelector();\n      if (!podSelector) {\n        throw new Error(`Unable to create policies for peer '${peer.node.addr}' since its not a pod selector`);\n      }\n\n      const oppositeDirection = direction === 'Egress' ? 'Ingress' : 'Egress';\n\n      const podSelectorConfig = podSelector.toPodSelectorConfig();\n      let namespaces: (string | undefined)[];\n\n      if (!podSelectorConfig.namespaces) {\n\n        // if the peer doesn't specify namespaces, we assume the same namespace.\n        namespaces = [this.instance.metadata.namespace];\n\n      } else {\n\n        // a peer cannot specify namespaces by labels because\n        // we won't be able to extract the names of those namespaces.\n        if (podSelectorConfig.namespaces.labelSelector && !podSelectorConfig.namespaces.labelSelector.isEmpty()) {\n          throw new Error(`Unable to create an ${oppositeDirection} policy for peer '${peer.node.path}' (pod=${this.instance.name}). Peer must specify namespaces only by name`);\n        }\n\n        // a peer must specify namespaces by name.\n        if (!podSelectorConfig.namespaces.names) {\n          throw new Error(`Unable to create an ${oppositeDirection} policy for peer '${peer.node.path}' (pod=${this.instance.name}). Peer must specify namespace names`);\n        }\n\n        namespaces = podSelectorConfig.namespaces.names;\n      }\n\n      for (const name of namespaces) {\n        switch (direction) {\n          case 'Egress':\n            new networkpolicy.NetworkPolicy(this.instance, `AllowIngress${name}${peerAddress}`, {\n              selector: podSelector,\n              metadata: { namespace: name },\n              ingress: { rules: [{ peer: this.instance, ports: options.ports }] },\n            });\n            break;\n          case 'Ingress':\n            new networkpolicy.NetworkPolicy(this.instance, `AllowEgress${name}${peerAddress}`, {\n              selector: podSelector,\n              metadata: { namespace: name },\n              egress: { rules: [{ peer: this.instance, ports: options.ports }] },\n            });\n            break;\n          default:\n            throw new Error(`Unsupported direction: ${direction}`);\n        }\n      }\n\n    }\n  }\n\n  private extractPorts(selector?: networkpolicy.INetworkPolicyPeer): networkpolicy.NetworkPolicyPort[] {\n    return container.extractContainerPorts(selector).map(n => networkpolicy.NetworkPolicyPort.tcp(n.number));\n  }\n\n  /**\n   * Sets the default network policy for Pod/Workload to have all egress and ingress connections as disabled\n   */\n  public isolate() {\n    new networkpolicy.NetworkPolicy(this.instance, 'DefaultDenyAll', {\n      selector: this.instance,\n      // the policy must be defined in the namespace of the pod\n      // so it can select it.\n      metadata: { namespace: this.instance.metadata.namespace },\n      egress: {\n        default: networkpolicy.NetworkPolicyTrafficDefault.DENY,\n      },\n      ingress: {\n        default: networkpolicy.NetworkPolicyTrafficDefault.DENY,\n      },\n    });\n  }\n}\n"]}