cdk8s-plus-31 2.0.0

package/lib/pvc.js

@@ -0,0 +1,152 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentVolumeMode = exports.PersistentVolumeAccessMode = exports.PersistentVolumeClaim = void 0;
+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");
+class ImportedPersistentVolumeClaim extends constructs_1.Construct {
+    constructor(scope, id, name) {
+        super(scope, id);
+        this.resourceType = 'persistentvolumeclaims';
+        this._name = name;
+    }
+    get name() {
+        return this._name;
+    }
+    get apiVersion() {
+        return k8s.KubePersistentVolumeClaim.GVK.apiVersion;
+    }
+    get apiGroup() {
+        return '';
+    }
+    get kind() {
+        return k8s.KubePersistentVolumeClaim.GVK.kind;
+    }
+    get resourceName() {
+        return this.name;
+    }
+}
+/**
+ * A PersistentVolumeClaim (PVC) is a request for storage by a user.
+ * It is similar to a Pod. Pods consume node resources and PVCs consume PV resources.
+ * Pods can request specific levels of resources (CPU and Memory).
+ * Claims can request specific size and access modes
+ */
+class PersistentVolumeClaim extends base.Resource {
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'persistentvolumeclaims';
+        this.storage = props.storage;
+        this.volumeMode = props.volumeMode ?? PersistentVolumeMode.FILE_SYSTEM;
+        this.storageClassName = props.storageClassName;
+        this._accessModes = props.accessModes;
+        if (props.volume) {
+            this.bind(props.volume);
+        }
+        this.apiObject = new k8s.KubePersistentVolumeClaim(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+    }
+    /**
+     * Imports a pvc from the cluster as a reference.
+     */
+    static fromClaimName(scope, id, claimName) {
+        return new ImportedPersistentVolumeClaim(scope, id, claimName);
+    }
+    /**
+     * Access modes requirement of this claim.
+     */
+    get accessModes() {
+        return this._accessModes ? [...this._accessModes] : undefined;
+    }
+    /**
+     * PV this claim is bound to. Undefined means the claim is not bound
+     * to any specific volume.
+     */
+    get volume() {
+        return this._volume;
+    }
+    /**
+     * Bind a claim to a specific volume.
+     * Note that you must also bind the volume to the claim.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#binding
+     *
+     * @param vol The PV to bind to.
+     */
+    bind(vol) {
+        if (this._volume && this._volume.name !== vol.name) {
+            throw new Error(`Cannot bind claim '${this.name}' to volume '${vol.name}' since it is already bound to volume '${this._volume.name}'`);
+        }
+        this._volume = vol;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        const storage = this.storage ? k8s.Quantity.fromString(this.storage.toGibibytes() + 'Gi') : undefined;
+        return {
+            volumeName: this.volume ? this.volume.name : undefined,
+            accessModes: this.accessModes?.map(a => a.toString()),
+            resources: storage ? { requests: { storage } } : undefined,
+            volumeMode: this.volumeMode,
+            storageClassName: this.storageClassName,
+        };
+    }
+}
+exports.PersistentVolumeClaim = PersistentVolumeClaim;
+_a = JSII_RTTI_SYMBOL_1;
+PersistentVolumeClaim[_a] = { fqn: "cdk8s-plus-31.PersistentVolumeClaim", version: "2.0.0" };
+/**
+ * Access Modes.
+ */
+var PersistentVolumeAccessMode;
+(function (PersistentVolumeAccessMode) {
+    /**
+     * The volume can be mounted as read-write by a single node.
+     * ReadWriteOnce access mode still can allow multiple pods to access
+     * the volume when the pods are running on the same node.
+     */
+    PersistentVolumeAccessMode["READ_WRITE_ONCE"] = "ReadWriteOnce";
+    /**
+     * The volume can be mounted as read-only by many nodes.
+     */
+    PersistentVolumeAccessMode["READ_ONLY_MANY"] = "ReadOnlyMany";
+    /**
+     * The volume can be mounted as read-write by many nodes.
+     */
+    PersistentVolumeAccessMode["READ_WRITE_MANY"] = "ReadWriteMany";
+    /**
+     * The volume can be mounted as read-write by a single Pod.
+     * Use ReadWriteOncePod access mode if you want to ensure that
+     * only one pod across whole cluster can read that PVC or write to it.
+     * This is only supported for CSI volumes and Kubernetes version 1.22+.
+     */
+    PersistentVolumeAccessMode["READ_WRITE_ONCE_POD"] = "ReadWriteOncePod";
+})(PersistentVolumeAccessMode = exports.PersistentVolumeAccessMode || (exports.PersistentVolumeAccessMode = {}));
+/**
+ * Volume Modes.
+ */
+var PersistentVolumeMode;
+(function (PersistentVolumeMode) {
+    /**
+     * Volume is ounted into Pods into a directory.
+     * If the volume is backed by a block device and the device is empty,
+     * Kubernetes creates a filesystem on the device before mounting it
+     * for the first time.
+     */
+    PersistentVolumeMode["FILE_SYSTEM"] = "Filesystem";
+    /**
+     * Use a volume as a raw block device. Such volume is presented into a Pod as a block device,
+     * without any filesystem on it. This mode is useful to provide a Pod the fastest possible way
+     * to access a volume, without any filesystem layer between the Pod
+     * and the volume. On the other hand, the application running in
+     * the Pod must know how to handle a raw block device
+     */
+    PersistentVolumeMode["BLOCK"] = "Block";
+})(PersistentVolumeMode = exports.PersistentVolumeMode || (exports.PersistentVolumeMode = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pvc.js","sourceRoot":"","sources":["../src/pvc.ts"],"names":[],"mappings":"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","sourcesContent":["import { Size, ApiObject, Lazy } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport * as base from './base';\nimport * as k8s from './imports/k8s';\nimport * as pv from './pv';\n\n/**\n * Contract of a `PersistentVolumeClaim`.\n */\nexport interface IPersistentVolumeClaim extends base.IResource {\n\n}\n\n/**\n * Properties for `PersistentVolumeClaim`.\n */\nexport interface PersistentVolumeClaimProps extends base.ResourceProps {\n\n  /**\n   * Contains the access modes the volume should support.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1\n   * @default - No access modes requirement.\n   */\n  readonly accessModes?: PersistentVolumeAccessMode[];\n\n  /**\n   * Minimum storage size the volume should have.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources\n   * @default - No storage requirement.\n   */\n  readonly storage?: Size;\n\n  /**\n   * Name of the StorageClass required by the claim.\n   * When this property is not set, the behavior is as follows:\n   *\n   * - If the admission plugin is turned on, the storage class marked as default will be used.\n   * - If the admission plugin is turned off, the pvc can only be bound to volumes without a storage class.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1\n   * @default - Not set.\n   */\n  readonly storageClassName?: string;\n\n  /**\n   * Defines what type of volume is required by the claim.\n   *\n   * @default VolumeMode.FILE_SYSTEM\n   */\n  readonly volumeMode?: PersistentVolumeMode;\n\n  /**\n   * The PersistentVolume backing this claim.\n   *\n   * The control plane still checks that storage class, access modes,\n   * and requested storage size on the volume are valid.\n   *\n   * Note that in order to guarantee a proper binding, the volume should\n   * also define a `claimRef` referring to this claim. Otherwise, the volume may be\n   * claimed be other pvc's before it gets a chance to bind to this one.\n   *\n   * If the volume is managed (i.e not imported), you can use `pv.claim()` to easily\n   * create a bi-directional bounded claim.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#binding.\n   * @default - No specific volume binding.\n   */\n  readonly volume?: pv.IPersistentVolume;\n\n}\n\nclass ImportedPersistentVolumeClaim extends Construct implements IPersistentVolumeClaim {\n\n  private readonly _name: string;\n\n  public readonly resourceType = 'persistentvolumeclaims';\n\n  constructor(scope: Construct, id: string, name: string) {\n    super(scope, id);\n    this._name = name;\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get apiVersion(): string {\n    return k8s.KubePersistentVolumeClaim.GVK.apiVersion;\n  }\n\n  public get apiGroup(): string {\n    return '';\n  }\n\n  public get kind(): string {\n    return k8s.KubePersistentVolumeClaim.GVK.kind;\n  }\n\n  public get resourceName(): string {\n    return this.name;\n  }\n\n}\n\n/**\n * A PersistentVolumeClaim (PVC) is a request for storage by a user.\n * It is similar to a Pod. Pods consume node resources and PVCs consume PV resources.\n * Pods can request specific levels of resources (CPU and Memory).\n * Claims can request specific size and access modes\n */\nexport class PersistentVolumeClaim extends base.Resource implements IPersistentVolumeClaim {\n\n  /**\n   * Imports a pvc from the cluster as a reference.\n   */\n  public static fromClaimName(scope: Construct, id: string, claimName: string): IPersistentVolumeClaim {\n    return new ImportedPersistentVolumeClaim(scope, id, claimName);\n  }\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'persistentvolumeclaims';\n\n  /**\n   * Storage requirement of this claim.\n   */\n  public readonly storage?: Size;\n\n  /**\n   * Volume mode requirement of this claim.\n   */\n  public readonly volumeMode: PersistentVolumeMode;\n\n  /**\n   * Storage class requirment of this claim.\n   */\n  public readonly storageClassName?: string;\n\n  private readonly _accessModes?: PersistentVolumeAccessMode[];\n\n  private _volume?: pv.IPersistentVolume;\n\n  public constructor(scope: Construct, id: string, props: PersistentVolumeClaimProps = { }) {\n    super(scope, id);\n\n    this.storage = props.storage;\n    this.volumeMode = props.volumeMode ?? PersistentVolumeMode.FILE_SYSTEM;\n    this.storageClassName = props.storageClassName;\n    this._accessModes = props.accessModes;\n\n    if (props.volume) {\n      this.bind(props.volume);\n    }\n\n    this.apiObject = new k8s.KubePersistentVolumeClaim(this, 'Resource', {\n      metadata: props.metadata,\n      spec: Lazy.any({ produce: () => this._toKube() }),\n    });\n  }\n\n  /**\n   * Access modes requirement of this claim.\n   */\n  public get accessModes(): PersistentVolumeAccessMode[] | undefined {\n    return this._accessModes ? [...this._accessModes] : undefined;\n  }\n\n  /**\n   * PV this claim is bound to. Undefined means the claim is not bound\n   * to any specific volume.\n   */\n  public get volume(): pv.IPersistentVolume | undefined {\n    return this._volume;\n  }\n\n  /**\n   * Bind a claim to a specific volume.\n   * Note that you must also bind the volume to the claim.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#binding\n   *\n   * @param vol The PV to bind to.\n   */\n  public bind(vol: pv.IPersistentVolume) {\n    if (this._volume && this._volume.name !== vol.name) {\n      throw new Error(`Cannot bind claim '${this.name}' to volume '${vol.name}' since it is already bound to volume '${this._volume.name}'`);\n    }\n    this._volume = vol;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.PersistentVolumeClaimSpec {\n    const storage = this.storage ? k8s.Quantity.fromString(this.storage.toGibibytes() + 'Gi') : undefined;\n    return {\n      volumeName: this.volume ? this.volume.name : undefined,\n      accessModes: this.accessModes?.map(a => a.toString()),\n      resources: storage ? { requests: { storage } } : undefined,\n      volumeMode: this.volumeMode,\n      storageClassName: this.storageClassName,\n    };\n  }\n\n}\n\n/**\n * Access Modes.\n */\nexport enum PersistentVolumeAccessMode {\n\n  /**\n   * The volume can be mounted as read-write by a single node.\n   * ReadWriteOnce access mode still can allow multiple pods to access\n   * the volume when the pods are running on the same node.\n   */\n  READ_WRITE_ONCE = 'ReadWriteOnce',\n\n  /**\n   * The volume can be mounted as read-only by many nodes.\n   */\n  READ_ONLY_MANY = 'ReadOnlyMany',\n\n  /**\n   * The volume can be mounted as read-write by many nodes.\n   */\n  READ_WRITE_MANY = 'ReadWriteMany',\n\n  /**\n   * The volume can be mounted as read-write by a single Pod.\n   * Use ReadWriteOncePod access mode if you want to ensure that\n   * only one pod across whole cluster can read that PVC or write to it.\n   * This is only supported for CSI volumes and Kubernetes version 1.22+.\n   */\n  READ_WRITE_ONCE_POD = 'ReadWriteOncePod'\n\n}\n\n/**\n * Volume Modes.\n */\nexport enum PersistentVolumeMode {\n\n  /**\n   * Volume is ounted into Pods into a directory.\n   * If the volume is backed by a block device and the device is empty,\n   * Kubernetes creates a filesystem on the device before mounting it\n   * for the first time.\n   */\n  FILE_SYSTEM = 'Filesystem',\n\n  /**\n   * Use a volume as a raw block device. Such volume is presented into a Pod as a block device,\n   * without any filesystem on it. This mode is useful to provide a Pod the fastest possible way\n   * to access a volume, without any filesystem layer between the Pod\n   * and the volume. On the other hand, the application running in\n   * the Pod must know how to handle a raw block device\n   */\n  BLOCK = 'Block'\n}\n"]}

package/lib/role-binding.d.ts

@@ -0,0 +1,138 @@
+import { ApiObject } from 'cdk8s';
+import { Construct, IConstruct } from 'constructs';
+import { Resource, ResourceProps } from './base';
+import * as role from './role';
+/**
+ * Subject contains a reference to the object or user identities a role binding
+ * applies to. This can either hold a direct API object reference, or a value
+ * for non-objects such as user and group names.
+ */
+export interface SubjectConfiguration {
+    /**
+     * APIGroup holds the API group of the referenced subject. Defaults to "" for
+     * ServiceAccount subjects. Defaults to "rbac.authorization.k8s.io" for User
+     * and Group subjects.
+     */
+    readonly apiGroup?: string;
+    /**
+     * Kind of object being referenced. Values defined by this API group are
+     * "User", "Group", and "ServiceAccount". If the Authorizer does not
+     * recognized the kind value, the Authorizer should report an error.
+     */
+    readonly kind: string;
+    /**
+     * Name of the object being referenced.
+     */
+    readonly name: string;
+    /**
+     * Namespace of the referenced object.  If the object kind is non-namespace,
+     * such as "User" or "Group", and this value is not empty the Authorizer
+     * should report an error.
+     */
+    readonly namespace?: string;
+}
+/**
+ * Represents an object that can be used as a role binding subject.
+ */
+export interface ISubject extends IConstruct {
+    /**
+     * Return the subject configuration.
+     */
+    toSubjectConfiguration(): SubjectConfiguration;
+}
+/**
+ * Properties for `RoleBinding`.
+ */
+export interface RoleBindingProps extends ResourceProps {
+    /**
+     * The role to bind to. A RoleBinding can reference a Role or a ClusterRole.
+     */
+    readonly role: role.IRole;
+}
+/**
+ * A RoleBinding grants permissions within a specific namespace to a user or
+ * set of users.
+ */
+export declare class RoleBinding extends Resource {
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "rolebindings";
+    readonly role: role.IRole;
+    private readonly _subjects;
+    constructor(scope: Construct, id: string, props: RoleBindingProps);
+    /**
+     * Adds a subject to the role.
+     * @param subjects The subjects to add
+     */
+    addSubjects(...subjects: ISubject[]): void;
+    get subjects(): ISubject[];
+    private synthesizeRoleRef;
+    private synthesizeSubjects;
+}
+/**
+ * Properties for `ClusterRoleBinding`.
+ */
+export interface ClusterRoleBindingProps extends ResourceProps {
+    /**
+     * The role to bind to.
+     */
+    readonly role: role.IClusterRole;
+}
+/**
+ * A ClusterRoleBinding grants permissions cluster-wide to a user or
+ * set of users.
+ */
+export declare class ClusterRoleBinding extends Resource {
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "clusterrolebindings";
+    readonly role: role.IClusterRole;
+    private readonly _subjects;
+    constructor(scope: Construct, id: string, props: ClusterRoleBindingProps);
+    /**
+     * Adds a subject to the role.
+     * @param subjects The subjects to add
+     */
+    addSubjects(...subjects: ISubject[]): void;
+    get subjects(): ISubject[];
+    private synthesizeRoleRef;
+    private synthesizeSubjects;
+}
+/**
+ * Represents a user.
+ */
+export declare class User extends Construct implements ISubject {
+    /**
+     * Reference a user in the cluster by name.
+     */
+    static fromName(scope: Construct, id: string, name: string): User;
+    readonly apiGroup: string | undefined;
+    readonly kind: string;
+    readonly name: string;
+    private constructor();
+    /**
+     * @see ISubect.toSubjectConfiguration()
+     */
+    toSubjectConfiguration(): SubjectConfiguration;
+}
+/**
+ * Represents a group.
+ */
+export declare class Group extends Construct implements ISubject {
+    /**
+     * Reference a group by name.
+     */
+    static fromName(scope: Construct, id: string, name: string): Group;
+    readonly apiGroup: string | undefined;
+    readonly kind: string;
+    readonly name: string;
+    private constructor();
+    /**
+     * @see ISubect.toSubjectConfiguration()
+     */
+    toSubjectConfiguration(): SubjectConfiguration;
+}

package/lib/role-binding.js

@@ -0,0 +1,165 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Group = exports.User = exports.ClusterRoleBinding = exports.RoleBinding = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const base_1 = require("./base");
+const k8s = require("./imports/k8s");
+const utils_1 = require("./utils");
+/**
+ * A RoleBinding grants permissions within a specific namespace to a user or
+ * set of users.
+ */
+class RoleBinding extends base_1.Resource {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.resourceType = 'rolebindings';
+        this.role = props.role;
+        this._subjects = new Array();
+        this.apiObject = new k8s.KubeRoleBinding(this, 'Resource', {
+            metadata: props.metadata,
+            subjects: cdk8s_1.Lazy.any({ produce: () => this.synthesizeSubjects() }),
+            roleRef: cdk8s_1.Lazy.any({ produce: () => this.synthesizeRoleRef() }),
+        });
+    }
+    /**
+     * Adds a subject to the role.
+     * @param subjects The subjects to add
+     */
+    addSubjects(...subjects) {
+        for (const subject of subjects) {
+            this._subjects.push(subject);
+        }
+    }
+    get subjects() {
+        return [...this._subjects];
+    }
+    synthesizeRoleRef() {
+        return {
+            apiGroup: this.role.apiGroup,
+            kind: this.role.kind,
+            name: this.role.name,
+        };
+    }
+    synthesizeSubjects() {
+        return this._subjects.map(subject => subject.toSubjectConfiguration()).map((subject) => utils_1.filterUndefined({
+            apiGroup: subject.apiGroup === 'core' ? '' : subject.apiGroup,
+            kind: subject.kind,
+            name: subject.name,
+            namespace: subject.namespace,
+        }));
+    }
+}
+exports.RoleBinding = RoleBinding;
+_a = JSII_RTTI_SYMBOL_1;
+RoleBinding[_a] = { fqn: "cdk8s-plus-31.RoleBinding", version: "2.0.0" };
+/**
+ * A ClusterRoleBinding grants permissions cluster-wide to a user or
+ * set of users.
+ */
+class ClusterRoleBinding extends base_1.Resource {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.resourceType = 'clusterrolebindings';
+        this.role = props.role;
+        this._subjects = new Array();
+        this.apiObject = new k8s.KubeClusterRoleBinding(this, 'Resource', {
+            metadata: props.metadata,
+            subjects: cdk8s_1.Lazy.any({ produce: () => this.synthesizeSubjects() }),
+            roleRef: cdk8s_1.Lazy.any({ produce: () => this.synthesizeRoleRef() }),
+        });
+    }
+    /**
+     * Adds a subject to the role.
+     * @param subjects The subjects to add
+     */
+    addSubjects(...subjects) {
+        for (const subject of subjects) {
+            this._subjects.push(subject);
+        }
+    }
+    get subjects() {
+        return [...this._subjects];
+    }
+    synthesizeRoleRef() {
+        return {
+            apiGroup: this.role.apiGroup,
+            kind: this.role.kind,
+            name: this.role.name,
+        };
+    }
+    synthesizeSubjects() {
+        return this._subjects.map(subject => subject.toSubjectConfiguration()).map((subject) => utils_1.filterUndefined({
+            apiGroup: subject.apiGroup === 'core' ? '' : subject.apiGroup,
+            kind: subject.kind,
+            name: subject.name,
+            namespace: subject.namespace,
+        }));
+    }
+}
+exports.ClusterRoleBinding = ClusterRoleBinding;
+_b = JSII_RTTI_SYMBOL_1;
+ClusterRoleBinding[_b] = { fqn: "cdk8s-plus-31.ClusterRoleBinding", version: "2.0.0" };
+/**
+ * Represents a user.
+ */
+class User extends constructs_1.Construct {
+    constructor(scope, id, name) {
+        super(scope, id);
+        this.apiGroup = 'rbac.authorization.k8s.io';
+        this.kind = 'User';
+        this.name = name;
+    }
+    /**
+     * Reference a user in the cluster by name.
+     */
+    static fromName(scope, id, name) {
+        return new User(scope, id, name);
+    }
+    /**
+     * @see ISubect.toSubjectConfiguration()
+     */
+    toSubjectConfiguration() {
+        return {
+            kind: this.kind,
+            name: this.name,
+            apiGroup: this.apiGroup,
+        };
+    }
+}
+exports.User = User;
+_c = JSII_RTTI_SYMBOL_1;
+User[_c] = { fqn: "cdk8s-plus-31.User", version: "2.0.0" };
+/**
+ * Represents a group.
+ */
+class Group extends constructs_1.Construct {
+    constructor(scope, id, name) {
+        super(scope, id);
+        this.apiGroup = 'rbac.authorization.k8s.io';
+        this.kind = 'Group';
+        this.name = name;
+    }
+    /**
+     * Reference a group by name.
+     */
+    static fromName(scope, id, name) {
+        return new Group(scope, id, name);
+    }
+    /**
+     * @see ISubect.toSubjectConfiguration()
+     */
+    toSubjectConfiguration() {
+        return {
+            kind: this.kind,
+            name: this.name,
+            apiGroup: this.apiGroup,
+        };
+    }
+}
+exports.Group = Group;
+_d = JSII_RTTI_SYMBOL_1;
+Group[_d] = { fqn: "cdk8s-plus-31.Group", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"role-binding.js","sourceRoot":"","sources":["../src/role-binding.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, Lazy } from 'cdk8s';\nimport { Construct, IConstruct } from 'constructs';\nimport { Resource, ResourceProps } from './base';\nimport * as k8s from './imports/k8s';\nimport * as role from './role';\nimport { filterUndefined } from './utils';\n\n/**\n * Subject contains a reference to the object or user identities a role binding\n * applies to. This can either hold a direct API object reference, or a value\n * for non-objects such as user and group names.\n */\nexport interface SubjectConfiguration {\n\n  /**\n   * APIGroup holds the API group of the referenced subject. Defaults to \"\" for\n   * ServiceAccount subjects. Defaults to \"rbac.authorization.k8s.io\" for User\n   * and Group subjects.\n   */\n  readonly apiGroup?: string;\n\n  /**\n   * Kind of object being referenced. Values defined by this API group are\n   * \"User\", \"Group\", and \"ServiceAccount\". If the Authorizer does not\n   * recognized the kind value, the Authorizer should report an error.\n   */\n  readonly kind: string;\n\n  /**\n   * Name of the object being referenced.\n   */\n  readonly name: string;\n\n  /**\n   * Namespace of the referenced object.  If the object kind is non-namespace,\n   * such as \"User\" or \"Group\", and this value is not empty the Authorizer\n   * should report an error.\n   */\n  readonly namespace?: string;\n\n}\n\n/**\n * Represents an object that can be used as a role binding subject.\n */\nexport interface ISubject extends IConstruct {\n\n  /**\n   * Return the subject configuration.\n   */\n  toSubjectConfiguration(): SubjectConfiguration;\n\n}\n\n/**\n * Properties for `RoleBinding`.\n */\nexport interface RoleBindingProps extends ResourceProps {\n  /**\n   * The role to bind to. A RoleBinding can reference a Role or a ClusterRole.\n   */\n  readonly role: role.IRole;\n}\n\n/**\n * A RoleBinding grants permissions within a specific namespace to a user or\n * set of users.\n */\nexport class RoleBinding extends Resource {\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'rolebindings';\n\n  public readonly role: role.IRole;\n\n  private readonly _subjects: Array<ISubject>;\n\n  constructor(scope: Construct, id: string, props: RoleBindingProps) {\n    super(scope, id);\n\n    this.role = props.role;\n\n    this._subjects = new Array<ISubject>();\n\n    this.apiObject = new k8s.KubeRoleBinding(this, 'Resource', {\n      metadata: props.metadata,\n      subjects: Lazy.any({ produce: () => this.synthesizeSubjects() }),\n      roleRef: Lazy.any({ produce: () => this.synthesizeRoleRef() }),\n    });\n  }\n\n  /**\n   * Adds a subject to the role.\n   * @param subjects The subjects to add\n   */\n  public addSubjects(...subjects: ISubject[]): void {\n    for (const subject of subjects) {\n      this._subjects.push(subject);\n    }\n  }\n\n  public get subjects() {\n    return [...this._subjects];\n  }\n\n  private synthesizeRoleRef(): k8s.RoleRef {\n    return {\n      apiGroup: this.role.apiGroup,\n      kind: this.role.kind,\n      name: this.role.name,\n    };\n  }\n\n  private synthesizeSubjects(): k8s.Subject[] {\n    return this._subjects.map(subject => subject.toSubjectConfiguration()).map((subject) => filterUndefined({\n      apiGroup: subject.apiGroup === 'core' ? '' : subject.apiGroup,\n      kind: subject.kind,\n      name: subject.name,\n      namespace: subject.namespace,\n    }));\n  }\n}\n\n/**\n * Properties for `ClusterRoleBinding`.\n */\nexport interface ClusterRoleBindingProps extends ResourceProps {\n  /**\n   * The role to bind to.\n   */\n  readonly role: role.IClusterRole;\n}\n\n/**\n * A ClusterRoleBinding grants permissions cluster-wide to a user or\n * set of users.\n */\nexport class ClusterRoleBinding extends Resource {\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'clusterrolebindings';\n\n  public readonly role: role.IClusterRole;\n\n  private readonly _subjects: Array<ISubject>;\n\n  constructor(scope: Construct, id: string, props: ClusterRoleBindingProps) {\n    super(scope, id);\n\n    this.role = props.role;\n\n    this._subjects = new Array<ISubject>();\n\n    this.apiObject = new k8s.KubeClusterRoleBinding(this, 'Resource', {\n      metadata: props.metadata,\n      subjects: Lazy.any({ produce: () => this.synthesizeSubjects() }),\n      roleRef: Lazy.any({ produce: () => this.synthesizeRoleRef() }),\n    });\n  }\n\n  /**\n   * Adds a subject to the role.\n   * @param subjects The subjects to add\n   */\n  public addSubjects(...subjects: ISubject[]): void {\n    for (const subject of subjects) {\n      this._subjects.push(subject);\n    }\n  }\n\n  public get subjects() {\n    return [...this._subjects];\n  }\n\n  private synthesizeRoleRef(): k8s.RoleRef {\n    return {\n      apiGroup: this.role.apiGroup,\n      kind: this.role.kind,\n      name: this.role.name,\n    };\n  }\n\n  private synthesizeSubjects(): k8s.Subject[] {\n    return this._subjects.map(subject => subject.toSubjectConfiguration()).map((subject) => filterUndefined({\n      apiGroup: subject.apiGroup === 'core' ? '' : subject.apiGroup,\n      kind: subject.kind,\n      name: subject.name,\n      namespace: subject.namespace,\n    }));\n  }\n}\n\n/**\n * Represents a user.\n */\nexport class User extends Construct implements ISubject {\n\n  /**\n   * Reference a user in the cluster by name.\n   */\n  public static fromName(scope: Construct, id: string, name: string) {\n    return new User(scope, id, name);\n  }\n\n  public readonly apiGroup: string | undefined = 'rbac.authorization.k8s.io';\n  public readonly kind: string = 'User';\n  public readonly name: string;\n\n  private constructor(scope: Construct, id: string, name: string) {\n    super(scope, id);\n    this.name = name;\n  }\n\n  /**\n   * @see ISubect.toSubjectConfiguration()\n   */\n  public toSubjectConfiguration(): SubjectConfiguration {\n    return {\n      kind: this.kind,\n      name: this.name,\n      apiGroup: this.apiGroup,\n    };\n  }\n}\n\n/**\n * Represents a group.\n */\nexport class Group extends Construct implements ISubject {\n\n  /**\n   * Reference a group by name.\n   */\n  public static fromName(scope: Construct, id: string, name: string) {\n    return new Group(scope, id, name);\n  }\n\n  public readonly apiGroup: string | undefined = 'rbac.authorization.k8s.io';\n  public readonly kind: string = 'Group';\n  public readonly name: string;\n\n  private constructor(scope: Construct, id: string, name: string) {\n    super(scope, id);\n    this.name = name;\n  }\n\n  /**\n   * @see ISubect.toSubjectConfiguration()\n   */\n  public toSubjectConfiguration(): SubjectConfiguration {\n    return {\n      kind: this.kind,\n      name: this.name,\n      apiGroup: this.apiGroup,\n    };\n  }\n\n}\n"]}