cdk8s-plus-34 0.0.1 → 2.0.0

package/lib/network-policy.js

@@ -0,0 +1,344 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkPolicy = exports.NetworkPolicyTrafficDefault = exports.NetworkProtocol = exports.NetworkPolicyIpBlock = exports.NetworkPolicyPort = void 0;
+exports.validatePeerConfig = validatePeerConfig;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const base = require("./base");
+const k8s = require("./imports/k8s");
+const namespace = require("./namespace");
+const pod = require("./pod");
+const utils_1 = require("./utils");
+/**
+ * Describes a port to allow traffic on.
+ */
+class NetworkPolicyPort {
+    /**
+     * Distinct TCP ports
+     */
+    static tcp(port) {
+        return new NetworkPolicyPort(k8s.IntOrString.fromNumber(port), undefined, NetworkProtocol.TCP);
+    }
+    /**
+     * A TCP port range
+     */
+    static tcpRange(startPort, endPort) {
+        return new NetworkPolicyPort(k8s.IntOrString.fromNumber(startPort), endPort, NetworkProtocol.TCP);
+    }
+    /**
+     * Any TCP traffic
+     */
+    static allTcp() {
+        return new NetworkPolicyPort(k8s.IntOrString.fromNumber(0), 65535, NetworkProtocol.TCP);
+    }
+    /**
+     * Distinct UDP ports
+     */
+    static udp(port) {
+        return new NetworkPolicyPort(k8s.IntOrString.fromNumber(port), undefined, NetworkProtocol.UDP);
+    }
+    /**
+     * A UDP port range
+     */
+    static udpRange(startPort, endPort) {
+        return new NetworkPolicyPort(k8s.IntOrString.fromNumber(startPort), endPort, NetworkProtocol.UDP);
+    }
+    /**
+     * Any UDP traffic
+     */
+    static allUdp() {
+        return new NetworkPolicyPort(k8s.IntOrString.fromNumber(0), 65535, NetworkProtocol.UDP);
+    }
+    /**
+     * Custom port configuration.
+     */
+    static of(props) {
+        return new NetworkPolicyPort(props.port ? k8s.IntOrString.fromNumber(props.port) : undefined, props.endPort, props.protocol);
+    }
+    constructor(port, endPort, protocol) {
+        this.port = port;
+        this.endPort = endPort;
+        this.protocol = protocol;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return { port: this.port, endPort: this.endPort, protocol: this.protocol };
+    }
+}
+exports.NetworkPolicyPort = NetworkPolicyPort;
+_a = JSII_RTTI_SYMBOL_1;
+NetworkPolicyPort[_a] = { fqn: "cdk8s-plus-34.NetworkPolicyPort", version: "2.0.0" };
+/**
+ * Describes a particular CIDR (Ex. "192.168.1.1/24","2001:db9::/64") that is
+ * allowed to the pods matched by a network policy selector.
+ * The except entry describes CIDRs that should not be included within this rule.
+ */
+class NetworkPolicyIpBlock extends constructs_1.Construct {
+    /**
+     * Create an IPv4 peer from a CIDR
+     */
+    static ipv4(scope, id, cidrIp, except) {
+        const cidrMatch = cidrIp.match(/^(\d{1,3}\.){3}\d{1,3}(\/\d+)?$/);
+        if (!cidrMatch) {
+            throw new Error(`Invalid IPv4 CIDR: "${cidrIp}"`);
+        }
+        if (!cidrMatch[2]) {
+            throw new Error(`CIDR mask is missing in IPv4: "${cidrIp}". Did you mean "${cidrIp}/32"?`);
+        }
+        return new NetworkPolicyIpBlock(scope, id, cidrIp, except);
+    }
+    /**
+     * Any IPv4 address
+     */
+    static anyIpv4(scope, id) {
+        return new NetworkPolicyIpBlock(scope, id, '0.0.0.0/0');
+    }
+    /**
+     * Create an IPv6 peer from a CIDR
+     */
+    static ipv6(scope, id, cidrIp, except) {
+        const cidrMatch = cidrIp.match(/^([\da-f]{0,4}:){2,7}([\da-f]{0,4})?(\/\d+)?$/);
+        if (!cidrMatch) {
+            throw new Error(`Invalid IPv6 CIDR: "${cidrIp}"`);
+        }
+        if (!cidrMatch[3]) {
+            throw new Error(`CIDR mask is missing in IPv6: "${cidrIp}". Did you mean "${cidrIp}/128"?`);
+        }
+        return new NetworkPolicyIpBlock(scope, id, cidrIp, except);
+    }
+    /**
+     * Any IPv6 address
+     */
+    static anyIpv6(scope, id) {
+        return new NetworkPolicyIpBlock(scope, id, '::/0');
+    }
+    constructor(scope, id, 
+    /**
+     * A string representing the IP Block Valid examples are "192.168.1.1/24" or "2001:db9::/64".
+     */
+    cidr, 
+    /**
+     * A slice of CIDRs that should not be included within an IP Block Valid examples are "192.168.1.1/24" or "2001:db9::/64".
+     * Except values will be rejected if they are outside the CIDR range.
+     */
+    except) {
+        super(scope, id);
+        this.cidr = cidr;
+        this.except = except;
+    }
+    /**
+     * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()
+     */
+    toNetworkPolicyPeerConfig() {
+        return { ipBlock: this };
+    }
+    /**
+     * @see INetworkPolicyPeer.toPodSelector()
+     */
+    toPodSelector() {
+        return undefined;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return { cidr: this.cidr, except: this.except };
+    }
+}
+exports.NetworkPolicyIpBlock = NetworkPolicyIpBlock;
+_b = JSII_RTTI_SYMBOL_1;
+NetworkPolicyIpBlock[_b] = { fqn: "cdk8s-plus-34.NetworkPolicyIpBlock", version: "2.0.0" };
+/**
+ * Network protocols.
+ */
+var NetworkProtocol;
+(function (NetworkProtocol) {
+    /**
+     * TCP.
+     */
+    NetworkProtocol["TCP"] = "TCP";
+    /**
+     * UDP.
+     */
+    NetworkProtocol["UDP"] = "UDP";
+    /**
+     * SCTP.
+     */
+    NetworkProtocol["SCTP"] = "SCTP";
+})(NetworkProtocol || (exports.NetworkProtocol = NetworkProtocol = {}));
+/**
+ * Default behaviors of network traffic in policies.
+ */
+var NetworkPolicyTrafficDefault;
+(function (NetworkPolicyTrafficDefault) {
+    /**
+     * The policy denies all traffic.
+     * Since rules are additive, additional rules or policies can allow
+     * specific traffic.
+     */
+    NetworkPolicyTrafficDefault["DENY"] = "DENY";
+    /**
+     * The policy allows all traffic (either ingress or egress).
+     * Since rules are additive, no additional rule or policies can
+     * subsequently deny the traffic.
+     */
+    NetworkPolicyTrafficDefault["ALLOW"] = "ALLOW";
+})(NetworkPolicyTrafficDefault || (exports.NetworkPolicyTrafficDefault = NetworkPolicyTrafficDefault = {}));
+/**
+ * Control traffic flow at the IP address or port level (OSI layer 3 or 4),
+ * network policies are an application-centric construct which allow you
+ * to specify how a pod is allowed to communicate with various network peers.
+ *
+ * - Outgoing traffic is allowed if there are no network policies selecting
+ *   the pod (and cluster policy otherwise allows the traffic),
+ *   OR if the traffic matches at least one egress rule across all of the
+ *   network policies that select the pod.
+ *
+ * - Incoming traffic is allowed to a pod if there are no network policies
+ *   selecting the pod (and cluster policy otherwise allows the traffic),
+ *   OR if the traffic source is the pod's local node,
+ *   OR if the traffic matches at least one ingress rule across all of
+ *   the network policies that select the pod.
+ *
+ * Network policies do not conflict; they are additive.
+ * If any policy or policies apply to a given pod for a given
+ * direction, the connections allowed in that direction from
+ * that pod is the union of what the applicable policies allow.
+ * Thus, order of evaluation does not affect the policy result.
+ *
+ * For a connection from a source pod to a destination pod to be allowed,
+ * both the egress policy on the source pod and the ingress policy on the
+ * destination pod need to allow the connection.
+ * If either side does not allow the connection, it will not happen.
+ *
+ * @see https://kubernetes.io/docs/concepts/services-networking/network-policies/#networkpolicy-resource
+ */
+class NetworkPolicy extends base.Resource {
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'networkpolicies';
+        this._egressRules = [];
+        this._ingressRules = [];
+        this._policyTypes = new Set();
+        const podSelector = props.selector ?? pod.Pods.all(this, 'AllPods');
+        this._podSelectorConfig = podSelector.toPodSelectorConfig();
+        let ns;
+        if (!props.metadata?.namespace) {
+            if (this._podSelectorConfig.namespaces?.labelSelector && !this._podSelectorConfig.namespaces?.labelSelector.isEmpty()) {
+                throw new Error(`Unable to create a network policy for a selector (${podSelector.node.path}) that selects pods in namespaces based on labels`);
+            }
+            if (this._podSelectorConfig.namespaces?.names && this._podSelectorConfig.namespaces.names.length > 1) {
+                throw new Error(`Unable to create a network policy for a selector (${podSelector.node.path}) that selects pods in multiple namespaces`);
+            }
+            ns = this._podSelectorConfig.namespaces?.names ? this._podSelectorConfig.namespaces?.names[0] : undefined;
+        }
+        else {
+            ns = props.metadata.namespace;
+        }
+        this.apiObject = new k8s.KubeNetworkPolicy(this, 'Resource', {
+            metadata: { ...props.metadata, namespace: ns },
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+        this.configureDefaultBehavior('Egress', props.egress?.default);
+        this.configureDefaultBehavior('Ingress', props.ingress?.default);
+        for (const rule of props.egress?.rules ?? []) {
+            this.addEgressRule(rule.peer, rule.ports);
+        }
+        for (const rule of props.ingress?.rules ?? []) {
+            this.addIngressRule(rule.peer, rule.ports);
+        }
+    }
+    /**
+     * Allow outgoing traffic to the peer.
+     *
+     * If ports are not passed, traffic will be allowed on all ports.
+     */
+    addEgressRule(peer, ports) {
+        this._policyTypes.add('Egress');
+        this._egressRules.push({ ports: (ports ?? []).map(p => p._toKube()), to: this.createNetworkPolicyPeers(peer) });
+    }
+    /**
+     * Allow incoming traffic from the peer.
+     *
+     * If ports are not passed, traffic will be allowed on all ports.
+     */
+    addIngressRule(peer, ports) {
+        this._policyTypes.add('Ingress');
+        this._ingressRules.push({ ports: (ports ?? []).map(p => p._toKube()), from: this.createNetworkPolicyPeers(peer) });
+    }
+    createNetworkPolicyPeers(peer) {
+        const config = peer.toNetworkPolicyPeerConfig();
+        validatePeerConfig(config);
+        if (config.ipBlock) {
+            // ip block is a single peer.
+            return [{ ipBlock: config.ipBlock._toKube() }];
+        }
+        if (!config.podSelector.namespaces?.names) {
+            // when no explicit namespaces are defined we can just use
+            // the selector as is
+            return [{
+                    namespaceSelector: config.podSelector.namespaces?.labelSelector?._toKube(),
+                    podSelector: config.podSelector.labelSelector._toKube(),
+                }];
+        }
+        // when explicit namespaces are defined, we need to create a separate
+        // peer for each, since a label selector cannot have multiple name labels. (they will conflict)
+        const namespaceSelector = config.podSelector?.namespaces?.labelSelector?._toKube() ?? {};
+        return config.podSelector.namespaces.names.map(n => ({
+            podSelector: config.podSelector.labelSelector._toKube(),
+            namespaceSelector: {
+                matchExpressions: namespaceSelector.matchExpressions,
+                matchLabels: {
+                    ...namespaceSelector.matchLabels,
+                    [namespace.Namespace.NAME_LABEL]: n,
+                },
+            },
+        }));
+    }
+    configureDefaultBehavior(direction, _default) {
+        if (!_default) {
+            return;
+        }
+        if (_default === NetworkPolicyTrafficDefault.DENY) {
+            // https://kubernetes.io/docs/concepts/services-networking/network-policies/#default-deny-all-egress-traffic
+            this._policyTypes.add(direction);
+        }
+        if (_default === NetworkPolicyTrafficDefault.ALLOW) {
+            // https://kubernetes.io/docs/concepts/services-networking/network-policies/#allow-all-egress-traffic
+            this._policyTypes.add(direction);
+            if (direction === 'Egress') {
+                this._egressRules.push({});
+            }
+            else {
+                this._ingressRules.push({});
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        return {
+            podSelector: this._podSelectorConfig.labelSelector._toKube(),
+            egress: (0, utils_1.undefinedIfEmpty)(this._egressRules),
+            ingress: (0, utils_1.undefinedIfEmpty)(this._ingressRules),
+            policyTypes: (0, utils_1.undefinedIfEmpty)(Array.from(this._policyTypes)),
+        };
+    }
+}
+exports.NetworkPolicy = NetworkPolicy;
+_c = JSII_RTTI_SYMBOL_1;
+NetworkPolicy[_c] = { fqn: "cdk8s-plus-34.NetworkPolicy", version: "2.0.0" };
+function validatePeerConfig(peerConfig) {
+    if (!peerConfig.ipBlock && !peerConfig.podSelector) {
+        throw new Error('Inavlid peer: either \'ipBlock\' or \'podSelector\' must be defined');
+    }
+    if (peerConfig.ipBlock && peerConfig.podSelector) {
+        throw new Error('Inavlid peer: only one of \'ipBlock\' and \'podSelector\' must be defined');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-policy.js","sourceRoot":"","sources":["../src/network-policy.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, Lazy } from 'cdk8s';\nimport { Construct, IConstruct } from 'constructs';\nimport * as base from './base';\nimport * as k8s from './imports/k8s';\nimport * as namespace from './namespace';\nimport * as pod from './pod';\nimport { undefinedIfEmpty } from './utils';\n\n/**\n * Properties for `NetworkPolicyPort`.\n */\nexport interface NetworkPolicyPortProps {\n\n  /**\n   * Specific port number.\n   *\n   * @default - all ports are allowed.\n   */\n  readonly port?: number;\n\n  /**\n   * End port (relative to `port`). Only applies if `port` is defined.\n   * Use this to specify a port range, rather that a specific one.\n   *\n   * @default - not a port range.\n   */\n  readonly endPort?: number;\n\n  /**\n   * Protocol.\n   *\n   * @default NetworkProtocol.TCP\n   */\n  readonly protocol?: NetworkProtocol;\n}\n\n/**\n * Describes a port to allow traffic on.\n */\nexport class NetworkPolicyPort {\n\n  /**\n   * Distinct TCP ports\n   */\n  public static tcp(port: number): NetworkPolicyPort {\n    return new NetworkPolicyPort(k8s.IntOrString.fromNumber(port), undefined, NetworkProtocol.TCP);\n  }\n\n  /**\n   * A TCP port range\n   */\n  public static tcpRange(startPort: number, endPort: number) {\n    return new NetworkPolicyPort(k8s.IntOrString.fromNumber(startPort), endPort, NetworkProtocol.TCP);\n  }\n\n  /**\n   * Any TCP traffic\n   */\n  public static allTcp() {\n    return new NetworkPolicyPort(k8s.IntOrString.fromNumber(0), 65535, NetworkProtocol.TCP);\n  }\n\n  /**\n   * Distinct UDP ports\n   */\n  public static udp(port: number): NetworkPolicyPort {\n    return new NetworkPolicyPort(k8s.IntOrString.fromNumber(port), undefined, NetworkProtocol.UDP);\n  }\n\n  /**\n   * A UDP port range\n   */\n  public static udpRange(startPort: number, endPort: number) {\n    return new NetworkPolicyPort(k8s.IntOrString.fromNumber(startPort), endPort, NetworkProtocol.UDP);\n  }\n\n  /**\n   * Any UDP traffic\n   */\n  public static allUdp() {\n    return new NetworkPolicyPort(k8s.IntOrString.fromNumber(0), 65535, NetworkProtocol.UDP);\n  }\n\n  /**\n   * Custom port configuration.\n   */\n  public static of(props: NetworkPolicyPortProps): NetworkPolicyPort {\n    return new NetworkPolicyPort(props.port ? k8s.IntOrString.fromNumber(props.port) : undefined, props.endPort, props.protocol);\n  }\n\n  private constructor(\n    private readonly port?: k8s.IntOrString,\n    private readonly endPort?: number,\n    private readonly protocol?: NetworkProtocol) {}\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.NetworkPolicyPort {\n    return { port: this.port, endPort: this.endPort, protocol: this.protocol };\n  }\n\n}\n\n/**\n * Configuration for network peers.\n * A peer can either by an ip block, or a selection of pods, not both.\n */\nexport interface NetworkPolicyPeerConfig {\n\n  /**\n   * The ip block this peer represents.\n   */\n  readonly ipBlock?: NetworkPolicyIpBlock;\n\n  /**\n   * The pod selector this peer represents.\n   */\n  readonly podSelector?: pod.PodSelectorConfig;\n\n}\n\n/**\n * Describes a peer to allow traffic to/from.\n */\nexport interface INetworkPolicyPeer extends IConstruct {\n  /**\n   * Return the configuration of this peer.\n   */\n  toNetworkPolicyPeerConfig(): NetworkPolicyPeerConfig;\n\n  /**\n   * Convert the peer into a pod selector, if possible.\n   */\n  toPodSelector(): pod.IPodSelector | undefined;\n}\n\n/**\n * Describes a rule allowing traffic from / to pods matched by a network policy selector.\n */\nexport interface NetworkPolicyRule {\n\n  /**\n   * The ports of the rule.\n   *\n   * @default - traffic is allowed on all ports.\n   */\n  readonly ports?: NetworkPolicyPort[];\n\n  /**\n   * Peer this rule interacts with.\n   */\n  readonly peer: INetworkPolicyPeer;\n\n}\n\n/**\n * Describes a particular CIDR (Ex. \"192.168.1.1/24\",\"2001:db9::/64\") that is\n * allowed to the pods matched by a network policy selector.\n * The except entry describes CIDRs that should not be included within this rule.\n */\nexport class NetworkPolicyIpBlock extends Construct implements INetworkPolicyPeer {\n\n  /**\n   * Create an IPv4 peer from a CIDR\n   */\n  public static ipv4(scope: Construct, id: string, cidrIp: string, except?: string[]): NetworkPolicyIpBlock {\n    const cidrMatch = cidrIp.match(/^(\\d{1,3}\\.){3}\\d{1,3}(\\/\\d+)?$/);\n\n    if (!cidrMatch) {\n      throw new Error(`Invalid IPv4 CIDR: \"${cidrIp}\"`);\n    }\n\n    if (!cidrMatch[2]) {\n      throw new Error(`CIDR mask is missing in IPv4: \"${cidrIp}\". Did you mean \"${cidrIp}/32\"?`);\n    }\n\n    return new NetworkPolicyIpBlock(scope, id, cidrIp, except);\n  }\n\n  /**\n   * Any IPv4 address\n   */\n  public static anyIpv4(scope: Construct, id: string): NetworkPolicyIpBlock {\n    return new NetworkPolicyIpBlock(scope, id, '0.0.0.0/0');\n  }\n\n  /**\n   * Create an IPv6 peer from a CIDR\n   */\n  public static ipv6(scope: Construct, id: string, cidrIp: string, except?: string[]): NetworkPolicyIpBlock {\n\n    const cidrMatch = cidrIp.match(/^([\\da-f]{0,4}:){2,7}([\\da-f]{0,4})?(\\/\\d+)?$/);\n\n    if (!cidrMatch) {\n      throw new Error(`Invalid IPv6 CIDR: \"${cidrIp}\"`);\n    }\n\n    if (!cidrMatch[3]) {\n      throw new Error(`CIDR mask is missing in IPv6: \"${cidrIp}\". Did you mean \"${cidrIp}/128\"?`);\n    }\n\n    return new NetworkPolicyIpBlock(scope, id, cidrIp, except);\n  }\n\n  /**\n   * Any IPv6 address\n   */\n  public static anyIpv6(scope: Construct, id: string): NetworkPolicyIpBlock {\n    return new NetworkPolicyIpBlock(scope, id, '::/0');\n  }\n\n  private constructor(scope: Construct, id: string,\n    /**\n     * A string representing the IP Block Valid examples are \"192.168.1.1/24\" or \"2001:db9::/64\".\n     */\n    public readonly cidr: string,\n    /**\n     * A slice of CIDRs that should not be included within an IP Block Valid examples are \"192.168.1.1/24\" or \"2001:db9::/64\".\n     * Except values will be rejected if they are outside the CIDR range.\n     */\n    public readonly except?: string[]) {\n    super(scope, id);\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toNetworkPolicyPeerConfig()\n   */\n  public toNetworkPolicyPeerConfig(): NetworkPolicyPeerConfig {\n    return { ipBlock: this };\n  }\n\n  /**\n   * @see INetworkPolicyPeer.toPodSelector()\n   */\n  public toPodSelector(): pod.IPodSelector | undefined {\n    return undefined;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.IpBlock {\n    return { cidr: this.cidr, except: this.except };\n  }\n\n}\n\n/**\n * Network protocols.\n */\nexport enum NetworkProtocol {\n  /**\n   * TCP.\n   */\n  TCP = 'TCP',\n  /**\n   * UDP.\n   */\n  UDP = 'UDP',\n  /**\n   * SCTP.\n   */\n  SCTP = 'SCTP',\n}\n\n/**\n * Default behaviors of network traffic in policies.\n */\nexport enum NetworkPolicyTrafficDefault {\n  /**\n   * The policy denies all traffic.\n   * Since rules are additive, additional rules or policies can allow\n   * specific traffic.\n   */\n  DENY = 'DENY',\n  /**\n   * The policy allows all traffic (either ingress or egress).\n   * Since rules are additive, no additional rule or policies can\n   * subsequently deny the traffic.\n   */\n  ALLOW = 'ALLOW',\n}\n\n/**\n * Describes how the network policy should configure egress / ingress traffic.\n */\nexport interface NetworkPolicyTraffic {\n\n  /**\n   * Specifies the default behavior of the policy when\n   * no rules are defined.\n   *\n   * @default - unset, the policy does not change the behavior.\n   */\n  readonly default?: NetworkPolicyTrafficDefault;\n\n  /**\n   * List of rules to be applied to the selected pods.\n   * If empty, the behavior of the policy is dictated by the `default` property.\n   *\n   * @default - no rules\n   */\n  readonly rules?: NetworkPolicyRule[];\n}\n\n/**\n * Options for `NetworkPolicy.addEgressRule`.\n */\nexport interface NetworkPolicyAddEgressRuleOptions {\n\n  /**\n   * Ports the rule should 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?: NetworkPolicyPort[];\n\n}\n\n\n/**\n * Properties for `NetworkPolicy`.\n */\nexport interface NetworkPolicyProps extends base.ResourceProps {\n\n  /**\n   * Which pods does this policy object applies to.\n   *\n   * This can either be a single pod / workload, or a grouping of pods selected\n   * via the `Pods.select` function. Rules is applied to any pods selected by this property.\n   * Multiple network policies can select the same set of pods.\n   * In this case, the rules for each are combined additively.\n   *\n   * Note that\n   *\n   * @default - will select all pods in the namespace of the policy.\n   */\n  readonly selector?: pod.IPodSelector;\n\n  /**\n   * Egress traffic configuration.\n   *\n   * @default - the policy doesn't change egress behavior of the pods it selects.\n   */\n  readonly egress?: NetworkPolicyTraffic;\n\n  /**\n   * Ingress traffic configuration.\n   *\n   * @default - the policy doesn't change ingress behavior of the pods it selects.\n   */\n  readonly ingress?: NetworkPolicyTraffic;\n}\n\n/**\n * Control traffic flow at the IP address or port level (OSI layer 3 or 4),\n * network policies are an application-centric construct which allow you\n * to specify how a pod is allowed to communicate with various network peers.\n *\n * - Outgoing traffic is allowed if there are no network policies selecting\n *   the pod (and cluster policy otherwise allows the traffic),\n *   OR if the traffic matches at least one egress rule across all of the\n *   network policies that select the pod.\n *\n * - Incoming traffic is allowed to a pod if there are no network policies\n *   selecting the pod (and cluster policy otherwise allows the traffic),\n *   OR if the traffic source is the pod's local node,\n *   OR if the traffic matches at least one ingress rule across all of\n *   the network policies that select the pod.\n *\n * Network policies do not conflict; they are additive.\n * If any policy or policies apply to a given pod for a given\n * direction, the connections allowed in that direction from\n * that pod is the union of what the applicable policies allow.\n * Thus, order of evaluation does not affect the policy result.\n *\n * For a connection from a source pod to a destination pod to be allowed,\n * both the egress policy on the source pod and the ingress policy on the\n * destination pod need to allow the connection.\n * If either side does not allow the connection, it will not happen.\n *\n * @see https://kubernetes.io/docs/concepts/services-networking/network-policies/#networkpolicy-resource\n */\nexport class NetworkPolicy extends base.Resource {\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType: string = 'networkpolicies';\n\n  private readonly _podSelectorConfig: pod.PodSelectorConfig;\n  private readonly _egressRules: k8s.NetworkPolicyEgressRule[] = [];\n  private readonly _ingressRules: k8s.NetworkPolicyIngressRule[] = [];\n  private readonly _policyTypes: Set<string> = new Set();\n\n  public constructor(scope: Construct, id: string, props: NetworkPolicyProps = {}) {\n    super(scope, id);\n\n    const podSelector = props.selector ?? pod.Pods.all(this, 'AllPods');\n    this._podSelectorConfig = podSelector.toPodSelectorConfig();\n\n    let ns;\n\n    if (!props.metadata?.namespace) {\n\n      if (this._podSelectorConfig.namespaces?.labelSelector && !this._podSelectorConfig.namespaces?.labelSelector.isEmpty()) {\n        throw new Error(`Unable to create a network policy for a selector (${podSelector.node.path}) that selects pods in namespaces based on labels`);\n      }\n\n      if (this._podSelectorConfig.namespaces?.names && this._podSelectorConfig.namespaces.names.length > 1) {\n        throw new Error(`Unable to create a network policy for a selector (${podSelector.node.path}) that selects pods in multiple namespaces`);\n      }\n\n      ns = this._podSelectorConfig.namespaces?.names ? this._podSelectorConfig.namespaces?.names[0] : undefined;\n\n    } else {\n      ns = props.metadata.namespace;\n    }\n\n    this.apiObject = new k8s.KubeNetworkPolicy(this, 'Resource', {\n      metadata: { ...props.metadata, namespace: ns },\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n\n    this.configureDefaultBehavior('Egress', props.egress?.default);\n    this.configureDefaultBehavior('Ingress', props.ingress?.default);\n\n    for (const rule of props.egress?.rules ?? []) {\n      this.addEgressRule(rule.peer, rule.ports);\n    }\n\n    for (const rule of props.ingress?.rules ?? []) {\n      this.addIngressRule(rule.peer, rule.ports);\n    }\n  }\n\n  /**\n   * Allow outgoing traffic to the peer.\n   *\n   * If ports are not passed, traffic will be allowed on all ports.\n   */\n  public addEgressRule(peer: INetworkPolicyPeer, ports?: NetworkPolicyPort[]) {\n    this._policyTypes.add('Egress');\n    this._egressRules.push({ ports: (ports ?? []).map(p => p._toKube()), to: this.createNetworkPolicyPeers(peer) });\n  }\n\n  /**\n   * Allow incoming traffic from the peer.\n   *\n   * If ports are not passed, traffic will be allowed on all ports.\n   */\n  public addIngressRule(peer: INetworkPolicyPeer, ports?: NetworkPolicyPort[]) {\n    this._policyTypes.add('Ingress');\n    this._ingressRules.push({ ports: (ports ?? []).map(p => p._toKube()), from: this.createNetworkPolicyPeers(peer) });\n  }\n\n  private createNetworkPolicyPeers(peer: INetworkPolicyPeer): k8s.NetworkPolicyPeer[] {\n\n    const config = peer.toNetworkPolicyPeerConfig();\n\n    validatePeerConfig(config);\n\n    if (config.ipBlock) {\n      // ip block is a single peer.\n      return [{ ipBlock: config.ipBlock._toKube() }];\n    }\n\n    if (!config.podSelector!.namespaces?.names) {\n      // when no explicit namespaces are defined we can just use\n      // the selector as is\n      return [{\n        namespaceSelector: config.podSelector!.namespaces?.labelSelector?._toKube(),\n        podSelector: config.podSelector!.labelSelector._toKube(),\n      }];\n    }\n\n    // when explicit namespaces are defined, we need to create a separate\n    // peer for each, since a label selector cannot have multiple name labels. (they will conflict)\n    const namespaceSelector = config.podSelector?.namespaces?.labelSelector?._toKube() ?? {};\n    return config.podSelector!.namespaces.names!.map(n => ({\n      podSelector: config.podSelector!.labelSelector._toKube(),\n      namespaceSelector: {\n        matchExpressions: namespaceSelector.matchExpressions,\n        matchLabels: {\n          ...namespaceSelector.matchLabels,\n          [namespace.Namespace.NAME_LABEL]: n,\n        },\n      },\n    }));\n  }\n\n  private configureDefaultBehavior(direction: 'Ingress' | 'Egress', _default?: NetworkPolicyTrafficDefault) {\n\n    if (!_default) { return;}\n\n    if (_default === NetworkPolicyTrafficDefault.DENY) {\n      // https://kubernetes.io/docs/concepts/services-networking/network-policies/#default-deny-all-egress-traffic\n      this._policyTypes.add(direction);\n    }\n\n    if (_default === NetworkPolicyTrafficDefault.ALLOW) {\n      // https://kubernetes.io/docs/concepts/services-networking/network-policies/#allow-all-egress-traffic\n      this._policyTypes.add(direction);\n      if (direction === 'Egress') {\n        this._egressRules.push({});\n      } else {\n        this._ingressRules.push({});\n      }\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.NetworkPolicySpec {\n    return {\n      podSelector: this._podSelectorConfig.labelSelector._toKube(),\n      egress: undefinedIfEmpty(this._egressRules),\n      ingress: undefinedIfEmpty(this._ingressRules),\n      policyTypes: undefinedIfEmpty(Array.from(this._policyTypes)),\n    };\n  }\n\n}\n\nexport function validatePeerConfig(peerConfig: NetworkPolicyPeerConfig) {\n  if (!peerConfig.ipBlock && !peerConfig.podSelector) {\n    throw new Error('Inavlid peer: either \\'ipBlock\\' or \\'podSelector\\' must be defined');\n  }\n  if (peerConfig.ipBlock && peerConfig.podSelector) {\n    throw new Error('Inavlid peer: only one of \\'ipBlock\\' and \\'podSelector\\' must be defined');\n  }\n}\n"]}