cdk8s-plus-34 0.0.1 → 2.0.0

package/lib/pv.js

@@ -0,0 +1,273 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GCEPersistentDiskPersistentVolume = exports.AzureDiskPersistentVolume = exports.AwsElasticBlockStorePersistentVolume = exports.PersistentVolumeReclaimPolicy = exports.PersistentVolume = 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");
+const pvc = require("./pvc");
+const volume = require("./volume");
+class ImportedPersistentVolume extends constructs_1.Construct {
+    constructor(scope, id, name) {
+        super(scope, id);
+        this.resourceType = 'persistentvolumes';
+        this._name = name;
+    }
+    get name() {
+        return this._name;
+    }
+    get apiVersion() {
+        return k8s.KubePersistentVolume.GVK.apiVersion;
+    }
+    get apiGroup() {
+        return '';
+    }
+    get kind() {
+        return k8s.KubePersistentVolume.GVK.kind;
+    }
+    get resourceName() {
+        return this.name;
+    }
+}
+/**
+ * A PersistentVolume (PV) is a piece of storage in the cluster that has been
+ * provisioned by an administrator or dynamically provisioned using Storage Classes.
+ * It is a resource in the cluster just like a node is a cluster resource.
+ * PVs are volume plugins like Volumes, but have a lifecycle independent of any
+ * individual Pod that uses the PV. This API object captures the details of the
+ * implementation of the storage, be that NFS, iSCSI, or a
+ * cloud-provider-specific storage system.
+ */
+class PersistentVolume extends base.Resource {
+    /**
+     * Imports a pv from the cluster as a reference.
+     */
+    static fromPersistentVolumeName(scope, id, volumeName) {
+        return new ImportedPersistentVolume(scope, id, volumeName);
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id);
+        this.resourceType = 'persistentvolumes';
+        this.storage = props.storage;
+        this.mode = props.volumeMode ?? pvc.PersistentVolumeMode.FILE_SYSTEM;
+        this.storageClassName = props.storageClassName;
+        this._accessModes = props.accessModes;
+        this.mountOptions = props.mountOptions;
+        this.reclaimPolicy = props.reclaimPolicy ?? PersistentVolumeReclaimPolicy.RETAIN;
+        if (props.claim) {
+            this.bind(props.claim);
+        }
+        this.apiObject = new k8s.KubePersistentVolume(this, 'Resource', {
+            metadata: props.metadata,
+            spec: cdk8s_1.Lazy.any({ produce: () => this._toKube() }),
+        });
+    }
+    /**
+     * Access modes requirement of this claim.
+     */
+    get accessModes() {
+        return this._accessModes ? [...this._accessModes] : undefined;
+    }
+    /**
+     * PVC this volume is bound to. Undefined means this volume is not yet
+     * claimed by any PVC.
+     */
+    get claim() {
+        return this._claim;
+    }
+    /**
+     * Reserve a `PersistentVolume` by creating a `PersistentVolumeClaim`
+     * that is wired to claim this volume.
+     *
+     * Note that this method will throw in case the volume is already claimed.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#reserving-a-persistentvolume
+     */
+    reserve() {
+        const claim = new pvc.PersistentVolumeClaim(this, `${this.name}PVC`, {
+            metadata: { name: `pvc-${this.name}`, namespace: this.metadata.namespace },
+            // the storage classes must match, otherwise the claim
+            // will use the default class (or no class at all), which may be different than the class
+            // of this volume. note that other requirements are not needed since
+            // when they are not defined, any volume satisifies them.
+            storageClassName: this.storageClassName,
+        });
+        this.bind(claim);
+        claim.bind(this);
+        return claim;
+    }
+    /**
+     * Bind a volume to a specific claim.
+     * Note that you must also bind the claim to the volume.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#binding
+     *
+     * @param claim The PVC to bind to.
+     */
+    bind(claim) {
+        if (this._claim && this._claim.name !== claim.name) {
+            throw new Error(`Cannot bind volume '${this.name}' to claim '${claim.name}' since it is already bound to claim '${this._claim.name}'`);
+        }
+        this._claim = claim;
+    }
+    asVolume() {
+        const claim = this.reserve();
+        return volume.Volume.fromPersistentVolumeClaim(this, 'Volume', claim);
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        const storage = this.storage ? k8s.Quantity.fromString(this.storage.toGibibytes() + 'Gi') : undefined;
+        return {
+            claimRef: this._claim ? { name: this._claim?.name } : undefined,
+            accessModes: this.accessModes?.map(a => a.toString()),
+            capacity: storage ? { storage } : undefined,
+            mountOptions: this.mountOptions?.map(o => o),
+            storageClassName: this.storageClassName,
+            persistentVolumeReclaimPolicy: this.reclaimPolicy,
+            volumeMode: this.mode,
+        };
+    }
+}
+exports.PersistentVolume = PersistentVolume;
+_a = JSII_RTTI_SYMBOL_1;
+PersistentVolume[_a] = { fqn: "cdk8s-plus-34.PersistentVolume", version: "2.0.0" };
+/**
+ * Reclaim Policies.
+ */
+var PersistentVolumeReclaimPolicy;
+(function (PersistentVolumeReclaimPolicy) {
+    /**
+     * The Retain reclaim policy allows for manual reclamation of the resource.
+     * When the PersistentVolumeClaim is deleted, the PersistentVolume still exists and the
+     * volume is considered "released". But it is not yet available for another claim
+     * because the previous claimant's data remains on the volume.
+     * An administrator can manually reclaim the volume with the following steps:
+     *
+     * 1. Delete the PersistentVolume. The associated storage asset in external
+     *    infrastructure (such as an AWS EBS, GCE PD, Azure Disk, or Cinder volume) still exists after the PV is deleted.
+     * 2. Manually clean up the data on the associated storage asset accordingly.
+     * 3. Manually delete the associated storage asset.
+     *
+     * If you want to reuse the same storage asset, create a new PersistentVolume
+     * with the same storage asset definition.
+     */
+    PersistentVolumeReclaimPolicy["RETAIN"] = "Retain";
+    /**
+     * For volume plugins that support the Delete reclaim policy, deletion removes both the
+     * PersistentVolume object from Kubernetes, as well as the associated storage asset in
+     * the external infrastructure, such as an AWS EBS, GCE PD, Azure Disk, or Cinder volume.
+     * Volumes that were dynamically provisioned inherit the reclaim policy of their StorageClass, which defaults to Delete.
+     * The administrator should configure the StorageClass according to users' expectations; otherwise,
+     * the PV must be edited or patched after it is created
+     */
+    PersistentVolumeReclaimPolicy["DELETE"] = "Delete";
+})(PersistentVolumeReclaimPolicy || (exports.PersistentVolumeReclaimPolicy = PersistentVolumeReclaimPolicy = {}));
+/**
+ * Represents an AWS Disk resource that is attached to a kubelet's host machine and
+ * then exposed to the pod.
+ *
+ * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
+ */
+class AwsElasticBlockStorePersistentVolume extends PersistentVolume {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.volumeId = props.volumeId;
+        this.readOnly = props.readOnly ?? false;
+        this.fsType = props.fsType ?? 'ext4';
+        this.partition = props.partition;
+    }
+    /**
+     * @internal
+     */
+    _toKube() {
+        const spec = super._toKube();
+        return {
+            ...spec,
+            awsElasticBlockStore: {
+                volumeId: this.volumeId,
+                fsType: this.fsType,
+                partition: this.partition,
+                readOnly: this.readOnly,
+            },
+        };
+    }
+}
+exports.AwsElasticBlockStorePersistentVolume = AwsElasticBlockStorePersistentVolume;
+_b = JSII_RTTI_SYMBOL_1;
+AwsElasticBlockStorePersistentVolume[_b] = { fqn: "cdk8s-plus-34.AwsElasticBlockStorePersistentVolume", version: "2.0.0" };
+/**
+ * AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.
+ */
+class AzureDiskPersistentVolume extends PersistentVolume {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.diskName = props.diskName;
+        this.diskUri = props.diskUri;
+        this.cachingMode = props.cachingMode ?? volume.AzureDiskPersistentVolumeCachingMode.NONE;
+        this.fsType = props.fsType ?? 'ext4';
+        this.azureKind = props.kind ?? volume.AzureDiskPersistentVolumeKind.SHARED;
+        this.readOnly = props.readOnly ?? false;
+    }
+    /**
+     * @internal
+     *
+     * @see https://github.com/kubernetes/examples/blob/master/staging/volumes/azure_disk/README.md
+     */
+    _toKube() {
+        const spec = super._toKube();
+        return {
+            ...spec,
+            azureDisk: {
+                diskName: this.diskName,
+                diskUri: this.diskUri,
+                cachingMode: this.cachingMode,
+                fsType: this.fsType,
+                kind: this.azureKind,
+                readOnly: this.readOnly,
+            },
+        };
+    }
+}
+exports.AzureDiskPersistentVolume = AzureDiskPersistentVolume;
+_c = JSII_RTTI_SYMBOL_1;
+AzureDiskPersistentVolume[_c] = { fqn: "cdk8s-plus-34.AzureDiskPersistentVolume", version: "2.0.0" };
+/**
+ * GCEPersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine
+ * and then exposed to the pod. Provisioned by an admin.
+ *
+ * @see https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
+ */
+class GCEPersistentDiskPersistentVolume extends PersistentVolume {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.pdName = props.pdName;
+        this.readOnly = props.readOnly ?? false;
+        this.fsType = props.fsType ?? 'ext4';
+        this.partition = props.partition;
+    }
+    /**
+     * @internal
+     *
+     * @see https://github.com/kubernetes/examples/blob/master/staging/volumes/azure_disk/README.md
+     */
+    _toKube() {
+        const spec = super._toKube();
+        return {
+            ...spec,
+            gcePersistentDisk: {
+                pdName: this.pdName,
+                fsType: this.fsType,
+                partition: this.partition,
+                readOnly: this.readOnly,
+            },
+        };
+    }
+}
+exports.GCEPersistentDiskPersistentVolume = GCEPersistentDiskPersistentVolume;
+_d = JSII_RTTI_SYMBOL_1;
+GCEPersistentDiskPersistentVolume[_d] = { fqn: "cdk8s-plus-34.GCEPersistentDiskPersistentVolume", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pv.js","sourceRoot":"","sources":["../src/pv.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject, Lazy, Size } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport * as base from './base';\nimport * as k8s from './imports/k8s';\nimport * as pvc from './pvc';\nimport * as volume from './volume';\n\n/**\n * Contract of a `PersistentVolumeClaim`.\n */\nexport interface IPersistentVolume extends base.IResource {\n}\n\n/**\n * Properties for `PersistentVolume`.\n */\nexport interface PersistentVolumeProps extends base.ResourceProps {\n\n  /**\n   * Contains all ways the volume can be mounted.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes\n   * @default - No access modes.\n   */\n  readonly accessModes?: pvc.PersistentVolumeAccessMode[];\n\n  /**\n   * What is the storage capacity of this volume.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources\n   * @default - No specified.\n   */\n  readonly storage?: Size;\n\n  /**\n   * Part of a bi-directional binding between PersistentVolume and PersistentVolumeClaim.\n   * Expected to be non-nil when bound.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#binding\n   * @default - Not bound to a specific claim.\n   */\n  readonly claim?: pvc.IPersistentVolumeClaim;\n\n  /**\n   * A list of mount options, e.g. [\"ro\", \"soft\"]. Not validated - mount will simply fail if one is invalid.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#mount-options\n   * @default - No options.\n   */\n  readonly mountOptions?: string[];\n\n  /**\n   * When a user is done with their volume, they can delete the PVC objects from the API that\n   * allows reclamation of the resource. The reclaim policy tells the cluster what to do with\n   * the volume after it has been released of its claim.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#reclaiming\n   * @default PersistentVolumeReclaimPolicy.RETAIN\n   */\n  readonly reclaimPolicy?: PersistentVolumeReclaimPolicy;\n\n  /**\n   * Name of StorageClass to which this persistent volume belongs.\n   *\n   * @default - Volume does not belong to any storage class.\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?: pvc.PersistentVolumeMode;\n\n}\n\nclass ImportedPersistentVolume extends Construct implements IPersistentVolume {\n\n  private readonly _name: string;\n\n  public readonly resourceType = 'persistentvolumes';\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.KubePersistentVolume.GVK.apiVersion;\n  }\n\n  public get apiGroup(): string {\n    return '';\n  }\n\n  public get kind(): string {\n    return k8s.KubePersistentVolume.GVK.kind;\n  }\n\n  public get resourceName(): string {\n    return this.name;\n  }\n\n}\n\n/**\n * A PersistentVolume (PV) is a piece of storage in the cluster that has been\n * provisioned by an administrator or dynamically provisioned using Storage Classes.\n * It is a resource in the cluster just like a node is a cluster resource.\n * PVs are volume plugins like Volumes, but have a lifecycle independent of any\n * individual Pod that uses the PV. This API object captures the details of the\n * implementation of the storage, be that NFS, iSCSI, or a\n * cloud-provider-specific storage system.\n */\nexport class PersistentVolume extends base.Resource implements IPersistentVolume, volume.IStorage {\n\n  /**\n   * Imports a pv from the cluster as a reference.\n   */\n  public static fromPersistentVolumeName(scope: Construct, id: string, volumeName: string): IPersistentVolume {\n    return new ImportedPersistentVolume(scope, id, volumeName);\n  }\n\n  /**\n   * @see base.Resource.apiObject\n   */\n  protected readonly apiObject: ApiObject;\n\n  public readonly resourceType = 'persistentvolumes';\n\n  private _claim?: pvc.IPersistentVolumeClaim;\n\n  /**\n   * Storage size of this volume.\n   */\n  public readonly storage?: Size;\n\n  /**\n   * Volume mode of this volume.\n   */\n  public readonly mode: pvc.PersistentVolumeMode;\n\n  /**\n    * Storage class this volume belongs to.\n    */\n  public readonly storageClassName?: string;\n\n  /**\n   * Access modes requirement of this claim.\n   */\n  private readonly _accessModes?: pvc.PersistentVolumeAccessMode[];\n\n  /**\n   * Mount options of this volume.\n   */\n  public readonly mountOptions?: string[];\n\n  /**\n   * Reclaim policy of this volume.\n   */\n  public readonly reclaimPolicy: PersistentVolumeReclaimPolicy;\n\n  protected constructor(scope: Construct, id: string, props: PersistentVolumeProps = { }) {\n    super(scope, id);\n\n    this.storage = props.storage;\n    this.mode = props.volumeMode ?? pvc.PersistentVolumeMode.FILE_SYSTEM;\n    this.storageClassName = props.storageClassName;\n    this._accessModes = props.accessModes;\n    this.mountOptions = props.mountOptions;\n    this.reclaimPolicy = props.reclaimPolicy ?? PersistentVolumeReclaimPolicy.RETAIN;\n\n    if (props.claim) {\n      this.bind(props.claim);\n    }\n\n    this.apiObject = new k8s.KubePersistentVolume(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(): pvc.PersistentVolumeAccessMode[] | undefined {\n    return this._accessModes ? [...this._accessModes] : undefined;\n  }\n\n  /**\n   * PVC this volume is bound to. Undefined means this volume is not yet\n   * claimed by any PVC.\n   */\n  public get claim(): pvc.IPersistentVolumeClaim | undefined {\n    return this._claim;\n  }\n\n  /**\n   * Reserve a `PersistentVolume` by creating a `PersistentVolumeClaim`\n   * that is wired to claim this volume.\n   *\n   * Note that this method will throw in case the volume is already claimed.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#reserving-a-persistentvolume\n   */\n  public reserve(): pvc.PersistentVolumeClaim {\n    const claim = new pvc.PersistentVolumeClaim(this, `${this.name}PVC`, {\n      metadata: { name: `pvc-${this.name}`, namespace: this.metadata.namespace },\n\n      // the storage classes must match, otherwise the claim\n      // will use the default class (or no class at all), which may be different than the class\n      // of this volume. note that other requirements are not needed since\n      // when they are not defined, any volume satisifies them.\n      storageClassName: this.storageClassName,\n    });\n\n    this.bind(claim);\n    claim.bind(this);\n\n    return claim;\n  }\n\n  /**\n   * Bind a volume to a specific claim.\n   * Note that you must also bind the claim to the volume.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#binding\n   *\n   * @param claim The PVC to bind to.\n   */\n  public bind(claim: pvc.IPersistentVolumeClaim) {\n    if (this._claim && this._claim.name !== claim.name) {\n      throw new Error(`Cannot bind volume '${this.name}' to claim '${claim.name}' since it is already bound to claim '${this._claim.name}'`);\n    }\n    this._claim = claim;\n  }\n\n  public asVolume(): volume.Volume {\n    const claim = this.reserve();\n    return volume.Volume.fromPersistentVolumeClaim(this, 'Volume', claim);\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.PersistentVolumeSpec {\n    const storage = this.storage ? k8s.Quantity.fromString(this.storage.toGibibytes() + 'Gi') : undefined;\n\n    return {\n      claimRef: this._claim ? { name: this._claim?.name } : undefined,\n      accessModes: this.accessModes?.map(a => a.toString()),\n      capacity: storage ? { storage } : undefined,\n      mountOptions: this.mountOptions?.map(o => o),\n      storageClassName: this.storageClassName,\n      persistentVolumeReclaimPolicy: this.reclaimPolicy,\n      volumeMode: this.mode,\n    };\n  }\n\n}\n\n/**\n * Reclaim Policies.\n */\nexport enum PersistentVolumeReclaimPolicy {\n\n  /**\n   * The Retain reclaim policy allows for manual reclamation of the resource.\n   * When the PersistentVolumeClaim is deleted, the PersistentVolume still exists and the\n   * volume is considered \"released\". But it is not yet available for another claim\n   * because the previous claimant's data remains on the volume.\n   * An administrator can manually reclaim the volume with the following steps:\n   *\n   * 1. Delete the PersistentVolume. The associated storage asset in external\n   *    infrastructure (such as an AWS EBS, GCE PD, Azure Disk, or Cinder volume) still exists after the PV is deleted.\n   * 2. Manually clean up the data on the associated storage asset accordingly.\n   * 3. Manually delete the associated storage asset.\n   *\n   * If you want to reuse the same storage asset, create a new PersistentVolume\n   * with the same storage asset definition.\n   */\n  RETAIN = 'Retain',\n\n  /**\n   * For volume plugins that support the Delete reclaim policy, deletion removes both the\n   * PersistentVolume object from Kubernetes, as well as the associated storage asset in\n   * the external infrastructure, such as an AWS EBS, GCE PD, Azure Disk, or Cinder volume.\n   * Volumes that were dynamically provisioned inherit the reclaim policy of their StorageClass, which defaults to Delete.\n   * The administrator should configure the StorageClass according to users' expectations; otherwise,\n   * the PV must be edited or patched after it is created\n   */\n  DELETE = 'Delete',\n\n}\n\n/**\n * Properties for `AwsElasticBlockStorePersistentVolume`.\n */\nexport interface AwsElasticBlockStorePersistentVolumeProps extends PersistentVolumeProps {\n\n  /**\n   * Unique ID of the persistent disk resource in AWS (Amazon EBS volume). More info: https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n   */\n  readonly volumeId: string;\n\n  /**\n   * Filesystem type of the volume that you want to mount.\n   * Tip: Ensure that the filesystem type is supported by the host operating system.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n   * @default 'ext4'\n   */\n  readonly fsType?: string;\n\n  /**\n    * The partition in the volume that you want to mount. If omitted, the default is to mount by volume name.\n    * Examples: For volume /dev/sda1, you specify the partition as \"1\".\n    * Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).\n    *\n    * @default - No partition.\n    */\n  readonly partition?: number;\n\n  /**\n    * Specify \"true\" to force and set the ReadOnly property in VolumeMounts to \"true\".\n    *\n    * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n    * @default false\n    */\n  readonly readOnly?: boolean;\n\n}\n\n/**\n * Represents an AWS Disk resource that is attached to a kubelet's host machine and\n * then exposed to the pod.\n *\n * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n */\nexport class AwsElasticBlockStorePersistentVolume extends PersistentVolume {\n\n  /**\n   * Volume id of this volume.\n   */\n  public readonly volumeId: string;\n\n  /**\n   * Whether or not it is mounted as a read-only volume.\n   */\n  public readonly readOnly: boolean;\n\n  /**\n   * File system type of this volume.\n   */\n  public readonly fsType: string;\n\n  /**\n   * Partition of this volume.\n   */\n  public readonly partition?: number;\n\n  constructor(scope: Construct, id: string, props: AwsElasticBlockStorePersistentVolumeProps) {\n    super(scope, id, props);\n\n    this.volumeId = props.volumeId;\n    this.readOnly = props.readOnly ?? false;\n    this.fsType = props.fsType ?? 'ext4';\n    this.partition = props.partition;\n  }\n\n  /**\n   * @internal\n   */\n  public _toKube(): k8s.PersistentVolumeSpec {\n    const spec = super._toKube();\n    return {\n      ...spec,\n      awsElasticBlockStore: {\n        volumeId: this.volumeId,\n        fsType: this.fsType,\n        partition: this.partition,\n        readOnly: this.readOnly,\n      },\n    };\n  }\n}\n\n/**\n * Properties for `AzureDiskPersistentVolume`.\n */\nexport interface AzureDiskPersistentVolumeProps extends PersistentVolumeProps {\n\n  /**\n   * The Name of the data disk in the blob storage\n   */\n  readonly diskName: string;\n\n  /**\n   * The URI the data disk in the blob storage\n   */\n  readonly diskUri: string;\n\n  /**\n   * Host Caching mode.\n   *\n   * @default - AzureDiskPersistentVolumeCachingMode.NONE.\n   */\n  readonly cachingMode?: volume.AzureDiskPersistentVolumeCachingMode;\n\n  /**\n    * Filesystem type to mount. Must be a filesystem type supported by the host operating system.\n    *\n    * @default 'ext4'\n    */\n  readonly fsType?: string;\n\n  /**\n    * Kind of disk.\n    *\n    * @default AzureDiskPersistentVolumeKind.SHARED\n    */\n  readonly kind?: volume.AzureDiskPersistentVolumeKind;\n\n  /**\n    * Force the ReadOnly setting in VolumeMounts.\n    *\n    * @default false\n    */\n  readonly readOnly?: boolean;\n\n}\n\n/**\n * AzureDisk represents an Azure Data Disk mount on the host and bind mount to the pod.\n */\nexport class AzureDiskPersistentVolume extends PersistentVolume {\n\n  /**\n   * Disk name of this volume.\n   */\n  public readonly diskName: string;\n\n  /**\n   * Disk URI of this volume.\n   */\n  public readonly diskUri: string;\n\n  /**\n   * Whether or not it is mounted as a read-only volume.\n   */\n  public readonly readOnly: boolean;\n\n  /**\n   * Caching mode of this volume.\n   */\n  public readonly cachingMode: volume.AzureDiskPersistentVolumeCachingMode;\n\n  /**\n   * File system type of this volume.\n   */\n  public readonly fsType: string;\n\n  /**\n   * Azure kind of this volume.\n   */\n  public readonly azureKind: volume.AzureDiskPersistentVolumeKind;\n\n  constructor(scope: Construct, id: string, props: AzureDiskPersistentVolumeProps) {\n    super(scope, id, props);\n\n    this.diskName = props.diskName;\n    this.diskUri = props.diskUri;\n    this.cachingMode = props.cachingMode ?? volume.AzureDiskPersistentVolumeCachingMode.NONE;\n    this.fsType = props.fsType ?? 'ext4';\n    this.azureKind = props.kind ?? volume.AzureDiskPersistentVolumeKind.SHARED;\n    this.readOnly = props.readOnly ?? false;\n  }\n\n  /**\n   * @internal\n   *\n   * @see https://github.com/kubernetes/examples/blob/master/staging/volumes/azure_disk/README.md\n   */\n  public _toKube(): k8s.PersistentVolumeSpec {\n    const spec = super._toKube();\n    return {\n      ...spec,\n      azureDisk: {\n        diskName: this.diskName,\n        diskUri: this.diskUri,\n        cachingMode: this.cachingMode,\n        fsType: this.fsType,\n        kind: this.azureKind,\n        readOnly: this.readOnly,\n      },\n    };\n  }\n}\n\n/**\n * Properties for `GCEPersistentDiskPersistentVolume`.\n */\nexport interface GCEPersistentDiskPersistentVolumeProps extends PersistentVolumeProps {\n\n  /**\n   * Unique name of the PD resource in GCE. Used to identify the disk in GCE.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\n   */\n  readonly pdName: string;\n\n  /**\n   * Filesystem type of the volume that you want to mount.\n   * Tip: Ensure that the filesystem type is supported by the host operating system.\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n   * @default 'ext4'\n   */\n  readonly fsType?: string;\n\n  /**\n   * The partition in the volume that you want to mount. If omitted, the default is to mount by volume name.\n   * Examples: For volume /dev/sda1, you specify the partition as \"1\".\n   * Similarly, the volume partition for /dev/sda is \"0\" (or you can leave the property empty).\n   *\n   * @default - No partition.\n   */\n  readonly partition?: number;\n\n  /**\n   * Specify \"true\" to force and set the ReadOnly property in VolumeMounts to \"true\".\n   *\n   * @see https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore\n   * @default false\n   */\n  readonly readOnly?: boolean;\n\n}\n\n/**\n * GCEPersistentDisk represents a GCE Disk resource that is attached to a kubelet's host machine\n * and then exposed to the pod. Provisioned by an admin.\n *\n * @see https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk\n */\nexport class GCEPersistentDiskPersistentVolume extends PersistentVolume {\n\n  /**\n   * PD resource in GCE of this volume.\n   */\n  public readonly pdName: string;\n\n  /**\n   * Whether or not it is mounted as a read-only volume.\n   */\n  public readonly readOnly: boolean;\n\n  /**\n   * File system type of this volume.\n   */\n  public readonly fsType: string;\n\n  /**\n   * Partition of this volume.\n   */\n  public readonly partition?: number;\n\n  constructor(scope: Construct, id: string, props: GCEPersistentDiskPersistentVolumeProps) {\n    super(scope, id, props);\n\n    this.pdName = props.pdName;\n    this.readOnly = props.readOnly ?? false;\n    this.fsType = props.fsType ?? 'ext4';\n    this.partition = props.partition;\n\n  }\n\n  /**\n   * @internal\n   *\n   * @see https://github.com/kubernetes/examples/blob/master/staging/volumes/azure_disk/README.md\n   */\n  public _toKube(): k8s.PersistentVolumeSpec {\n    const spec = super._toKube();\n    return {\n      ...spec,\n      gcePersistentDisk: {\n        pdName: this.pdName,\n        fsType: this.fsType,\n        partition: this.partition,\n        readOnly: this.readOnly,\n      },\n    };\n  }\n}"]}

package/lib/pvc.d.ts

@@ -0,0 +1,163 @@
+import { Size, ApiObject } from 'cdk8s';
+import { Construct } from 'constructs';
+import * as base from './base';
+import * as k8s from './imports/k8s';
+import * as pv from './pv';
+/**
+ * Contract of a `PersistentVolumeClaim`.
+ */
+export interface IPersistentVolumeClaim extends base.IResource {
+}
+/**
+ * Properties for `PersistentVolumeClaim`.
+ */
+export interface PersistentVolumeClaimProps extends base.ResourceProps {
+    /**
+     * Contains the access modes the volume should support.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1
+     * @default - No access modes requirement.
+     */
+    readonly accessModes?: PersistentVolumeAccessMode[];
+    /**
+     * Minimum storage size the volume should have.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources
+     * @default - No storage requirement.
+     */
+    readonly storage?: Size;
+    /**
+     * Name of the StorageClass required by the claim.
+     * When this property is not set, the behavior is as follows:
+     *
+     * - If the admission plugin is turned on, the storage class marked as default will be used.
+     * - If the admission plugin is turned off, the pvc can only be bound to volumes without a storage class.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1
+     * @default - Not set.
+     */
+    readonly storageClassName?: string;
+    /**
+     * Defines what type of volume is required by the claim.
+     *
+     * @default VolumeMode.FILE_SYSTEM
+     */
+    readonly volumeMode?: PersistentVolumeMode;
+    /**
+     * The PersistentVolume backing this claim.
+     *
+     * The control plane still checks that storage class, access modes,
+     * and requested storage size on the volume are valid.
+     *
+     * Note that in order to guarantee a proper binding, the volume should
+     * also define a `claimRef` referring to this claim. Otherwise, the volume may be
+     * claimed be other pvc's before it gets a chance to bind to this one.
+     *
+     * If the volume is managed (i.e not imported), you can use `pv.claim()` to easily
+     * create a bi-directional bounded claim.
+     *
+     * @see https://kubernetes.io/docs/concepts/storage/persistent-volumes/#binding.
+     * @default - No specific volume binding.
+     */
+    readonly volume?: pv.IPersistentVolume;
+}
+/**
+ * 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
+ */
+export declare class PersistentVolumeClaim extends base.Resource implements IPersistentVolumeClaim {
+    /**
+     * Imports a pvc from the cluster as a reference.
+     */
+    static fromClaimName(scope: Construct, id: string, claimName: string): IPersistentVolumeClaim;
+    /**
+     * @see base.Resource.apiObject
+     */
+    protected readonly apiObject: ApiObject;
+    readonly resourceType = "persistentvolumeclaims";
+    /**
+     * Storage requirement of this claim.
+     */
+    readonly storage?: Size;
+    /**
+     * Volume mode requirement of this claim.
+     */
+    readonly volumeMode: PersistentVolumeMode;
+    /**
+     * Storage class requirment of this claim.
+     */
+    readonly storageClassName?: string;
+    private readonly _accessModes?;
+    private _volume?;
+    constructor(scope: Construct, id: string, props?: PersistentVolumeClaimProps);
+    /**
+     * Access modes requirement of this claim.
+     */
+    get accessModes(): PersistentVolumeAccessMode[] | undefined;
+    /**
+     * PV this claim is bound to. Undefined means the claim is not bound
+     * to any specific volume.
+     */
+    get volume(): pv.IPersistentVolume | undefined;
+    /**
+     * 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: pv.IPersistentVolume): void;
+    /**
+     * @internal
+     */
+    _toKube(): k8s.PersistentVolumeClaimSpec;
+}
+/**
+ * Access Modes.
+ */
+export declare enum 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.
+     */
+    READ_WRITE_ONCE = "ReadWriteOnce",
+    /**
+     * The volume can be mounted as read-only by many nodes.
+     */
+    READ_ONLY_MANY = "ReadOnlyMany",
+    /**
+     * The volume can be mounted as read-write by many nodes.
+     */
+    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+.
+     */
+    READ_WRITE_ONCE_POD = "ReadWriteOncePod"
+}
+/**
+ * Volume Modes.
+ */
+export declare enum 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.
+     */
+    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
+     */
+    BLOCK = "Block"
+}