@ydkn/pulumi-components 0.4.4 → 0.4.6

package/lib/rook/blockPool.ts

@@ -1,80 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as k8s from "@pulumi/kubernetes";
-import { ComponentResource } from "../common";
-
-export interface BlockPoolSpecReplicatedArgs {
-  size?: pulumi.Input<number>;
-}
-
-export interface BlockPoolSpecArgs {
-  failureDomain?: pulumi.Input<string>;
-  replicated?: pulumi.Input<BlockPoolSpecReplicatedArgs>;
-}
-
-export interface BlockPoolArgs {
-  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
-  spec: pulumi.Input<BlockPoolSpecArgs>;
-  clusterId: pulumi.Input<string>;
-  defaultStorageClass?: pulumi.Input<boolean>;
-}
-
-export class BlockPool extends ComponentResource {
-  private readonly cephBlockPool: k8s.apiextensions.CustomResource;
-  private readonly storageClass: k8s.storage.v1.StorageClass;
-
-  /**
-   * Create a new ceph block pool resource.
-   * @param name The name of the ceph block pool resource.
-   * @param args A bag of arguments to control the ceph block pool creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: BlockPoolArgs, opts?: pulumi.ComponentResourceOptions) {
-    super("rook:ceph:block-pool", name, args, opts);
-
-    opts = this.opts(k8s.Provider);
-
-    this.cephBlockPool = new k8s.apiextensions.CustomResource(
-      name,
-      {
-        apiVersion: "ceph.rook.io/v1",
-        kind: "CephBlockPool",
-        metadata: args.metadata,
-        spec: args.spec,
-      },
-      opts
-    );
-
-    this.storageClass = new k8s.storage.v1.StorageClass(
-      name,
-      {
-        metadata: pulumi.all([args.metadata, args.defaultStorageClass]).apply(([metadata, defaultStorageClass]) => {
-          return {
-            ...metadata,
-            annotations: {
-              ...metadata.annotations,
-              "storageclass.kubernetes.io/is-default-class": defaultStorageClass ? "true" : "false",
-            },
-          };
-        }),
-        provisioner: pulumi.interpolate`${args.clusterId}.rbd.csi.ceph.com`,
-        parameters: {
-          pool: this.cephBlockPool.metadata.name,
-          clusterID: args.clusterId,
-          imageFormat: "2",
-          imageFeatures: "layering",
-          "csi.storage.k8s.io/provisioner-secret-name": "rook-csi-rbd-provisioner",
-          "csi.storage.k8s.io/provisioner-secret-namespace": this.cephBlockPool.metadata.namespace,
-          "csi.storage.k8s.io/controller-expand-secret-name": "rook-csi-rbd-provisioner",
-          "csi.storage.k8s.io/controller-expand-secret-namespace": this.cephBlockPool.metadata.namespace,
-          "csi.storage.k8s.io/node-stage-secret-name": "rook-csi-rbd-node",
-          "csi.storage.k8s.io/node-stage-secret-namespace": this.cephBlockPool.metadata.namespace,
-          "csi.storage.k8s.io/fstype": "ext4",
-        },
-        reclaimPolicy: "Delete",
-        allowVolumeExpansion: true,
-        mountOptions: [],
-      },
-      opts
-    );
-  }
-}

package/lib/rook/cluster.ts

@@ -1,168 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as k8s from "@pulumi/kubernetes";
-import * as fs from "fs";
-import * as path from "path";
-import { ComponentResource } from "../common";
-import * as kubernetes from "../kubernetes";
-import { Dashboard } from "../grafana";
-
-export interface StorageNodeDeviceArg {
-  name: pulumi.Input<string>;
-}
-
-export interface StorageNodeArg {
-  name: pulumi.Input<string>;
-  devices: pulumi.Input<pulumi.Input<StorageNodeDeviceArg>[]>;
-}
-
-export interface PlacementArgs extends k8s.types.input.core.v1.Affinity {
-  tolerations?: pulumi.Input<pulumi.Input<k8s.types.input.core.v1.Toleration>[]>;
-  topologySpreadConstraints?: pulumi.Input<pulumi.Input<k8s.types.input.core.v1.TopologySpreadConstraint>[]>;
-}
-
-export interface StorageClassDeviceSetsArg {
-  name: pulumi.Input<string>;
-  count: pulumi.Input<number>;
-  preparePlacement?: pulumi.Input<PlacementArgs>;
-  placement?: pulumi.Input<PlacementArgs>;
-  portable?: pulumi.Input<boolean>;
-  encrypted?: pulumi.Input<boolean>;
-  volumeClaimTemplates: pulumi.Input<pulumi.Input<k8s.core.v1.PersistentVolumeClaimArgs>[]>;
-}
-
-export interface MonitorArgs {
-  count?: pulumi.Input<number>;
-  volumeClaimTemplate?: pulumi.Input<k8s.core.v1.PersistentVolumeClaimArgs>;
-}
-
-export interface ManagerArgs {
-  count?: pulumi.Input<number>;
-}
-
-export interface ClusterArgs {
-  namespace?: pulumi.Input<string>;
-  clusterName?: pulumi.Input<string>;
-  deviceFilter?: pulumi.Input<string>;
-  devicePathFilter?: pulumi.Input<string>;
-  storageNodes?: pulumi.Input<pulumi.Input<StorageNodeArg>[]>;
-  storageClassDeviceSets?: pulumi.Input<pulumi.Input<StorageClassDeviceSetsArg>[]>;
-  hostname?: pulumi.Input<string>;
-  ingressClassName?: pulumi.Input<string>;
-  mon?: pulumi.Input<MonitorArgs>;
-  mgr?: pulumi.Input<ManagerArgs>;
-}
-
-export class Cluster extends ComponentResource {
-  private readonly helmChart: kubernetes.helm.v3.Chart;
-  private readonly grafanaDashboard: Dashboard;
-  public readonly namespace: pulumi.Output<string>;
-
-  /**
-   * Create a new rook ceph cluster resource.
-   * @param name The name of the rook ceph cluster resource.
-   * @param args A bag of arguments to control the rook ceph cluster creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: ClusterArgs, opts?: pulumi.ComponentResourceOptions) {
-    super("rook:ceph:cluster", name, args, opts);
-
-    opts = this.opts(k8s.Provider);
-
-    if (args.clusterName === undefined) {
-      args.clusterName = "ceph";
-    }
-
-    this.namespace = args.namespace
-      ? pulumi.output(args.namespace)
-      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
-
-    this.helmChart = new kubernetes.helm.v3.Chart(
-      name,
-      {
-        namespace: this.namespace,
-        fetchOpts: { repo: "https://charts.rook.io/release" },
-        chart: "rook-ceph-cluster",
-        values: {
-          fullnameOverride: name,
-          operatorNamespace: this.namespace,
-          clusterName: args.clusterName,
-          configOverride: [
-            "[global]",
-            "mon_allow_pool_delete = true",
-            "osd_pool_default_size = 3",
-            "osd_pool_default_min_size = 2",
-          ].join("\n"),
-          cephClusterSpec: {
-            mon: {
-              count: pulumi.all([args.mon]).apply(([mon]) => mon?.count ?? 3),
-              allowMultiplePerNode: false,
-              volumeClaimTemplate: pulumi.all([args.mon]).apply(([mon]) => mon?.volumeClaimTemplate),
-            },
-            mgr: {
-              count: pulumi.all([args.mgr]).apply(([mgr]) => mgr?.count ?? 2),
-            },
-            // network: { dualStack: true }, // TODO see https://github.com/rook/rook/issues/7522
-            removeOSDsIfOutAndSafeToRemove: true,
-            continueUpgradeAfterChecksEvenIfNotHealthy: true,
-            crashCollector: { disable: true },
-            logCollector: { enabled: false },
-            storage: {
-              useAllDevices: false,
-              deviceFilter: args.deviceFilter,
-              devicePathFilter: args.devicePathFilter,
-              nodes: args.storageNodes,
-              storageClassDeviceSets: args.storageClassDeviceSets,
-            },
-            resources: {
-              mgr: { requests: { cpu: "100m", memory: "256Mi" }, limits: { cpu: "1000m", memory: "1024Mi" } },
-              mon: { requests: { cpu: "100m", memory: "256Mi" }, limits: { cpu: "1000m", memory: "1024Mi" } },
-              osd: { requests: { cpu: "100m", memory: "512Mi" }, limits: { cpu: "2000m", memory: "2048Mi" } },
-              prepareosd: { requests: { cpu: "100m", memory: "128Mi" }, limits: { cpu: "500m", memory: "256Mi" } },
-              "mgr-sidecar": { requests: { cpu: "50m", memory: "32Mi" }, limits: { cpu: "100m", memory: "48Mi" } },
-              crashcollector: { requests: { cpu: "10m", memory: "32Mi" }, limits: { cpu: "100m", memory: "48Mi" } },
-              logcollector: { requests: { cpu: "10m", memory: "32Mi" }, limits: { cpu: "100m", memory: "64Mi" } },
-              cleanup: { requests: { cpu: "10m", memory: "32Mi" }, limits: { cpu: "100m", memory: "64Mi" } },
-            },
-          },
-          ingress: {
-            dashboard: {
-              ingressClassName: args.ingressClassName,
-              host: { name: args.hostname },
-              annotations: {
-                "traefik.ingress.kubernetes.io/router.entrypoints": "websecure",
-                "traefik.ingress.kubernetes.io/router.tls": "true",
-                "cert-manager.io/cluster-issuer": "letsencrypt",
-              },
-              tls: [{ secretName: `${name}-ingress-tls`, hosts: [args.hostname] }],
-            },
-          },
-          monitoring: { enabled: true, createPrometheusRules: false },
-          toolbox: { enabled: true },
-        },
-        transformations: [
-          kubernetes.transformations.filter([
-            { group: "ceph.rook.io", kind: "CephBlockPool" },
-            { group: "ceph.rook.io", kind: "CephFilesystem" },
-            { group: "ceph.rook.io", kind: "CephObjectStore" },
-            { group: "storage.k8s.io", kind: "StorageClass" },
-          ]),
-        ],
-      },
-      {},
-      opts
-    );
-
-    this.grafanaDashboard = new Dashboard(
-      `${name}-grafana-dashboard`,
-      {
-        metadata: { namespace: this.namespace, name: pulumi.interpolate`${name}-grafana-dashboard` },
-        name: "rook-ceph",
-        // eslint-disable-next-line security/detect-non-literal-fs-filename
-        data: fs.readFileSync(path.join(__dirname, "assets", "dashboard.json"), "utf-8"),
-      },
-      opts
-    );
-
-    this.registerOutputs();
-  }
-}

package/lib/rook/filesystem.ts

@@ -1,140 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as k8s from "@pulumi/kubernetes";
-import { ComponentResource } from "../common";
-
-export interface FilesystemReplicatedArgs {
-  size?: pulumi.Input<number>;
-}
-
-export interface FilesystemDataPoolArgs {
-  name: pulumi.Input<string>;
-  failureDomain?: pulumi.Input<string>;
-  replicated?: pulumi.Input<FilesystemReplicatedArgs>;
-}
-
-export interface FilesystemArgs {
-  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
-  dataPools: pulumi.Input<pulumi.Input<FilesystemDataPoolArgs>[]>;
-  clusterId: pulumi.Input<string>;
-  defaultStorageClass?: pulumi.Input<boolean>;
-  preserveFilesystemOnDelete?: pulumi.Input<boolean>;
-}
-
-export class Filesystem extends ComponentResource {
-  private readonly filesystem: k8s.apiextensions.CustomResource;
-
-  /**
-   * Create a new ceph block pool resource.
-   * @param name The name of the ceph block pool resource.
-   * @param args A bag of arguments to control the ceph block pool creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: FilesystemArgs, opts?: pulumi.ComponentResourceOptions) {
-    super("rook:ceph:filesystem", name, args, opts);
-
-    opts = this.opts(k8s.Provider);
-
-    this.filesystem = new k8s.apiextensions.CustomResource(
-      name,
-      {
-        apiVersion: "ceph.rook.io/v1",
-        kind: "CephFilesystem",
-        metadata: args.metadata,
-        spec: {
-          preserveFilesystemOnDelete: args.preserveFilesystemOnDelete ?? false,
-          metadataServer: {
-            activeCount: 1,
-            activeStandby: true,
-            resources: {
-              requests: { memory: "384Mi" },
-              limits: { memory: "512Mi" },
-            },
-            priorityClassName: "system-cluster-critical",
-            placement: {
-              podAntiAffinity: {
-                preferredDuringSchedulingIgnoredDuringExecution: [
-                  {
-                    weight: 100,
-                    podAffinityTerm: {
-                      labelSelector: {
-                        matchExpressions: [
-                          {
-                            key: "app.kubernetes.io/component",
-                            operator: "In",
-                            values: ["cephfilesystems.ceph.rook.io"],
-                          },
-                          {
-                            key: "app.kubernetes.io/part-of",
-                            operator: "In",
-                            values: [name],
-                          },
-                        ],
-                      },
-                      topologyKey: "kubernetes.io/hostname",
-                    },
-                  },
-                ],
-              },
-            },
-          },
-          metadataPool: {
-            replicated: { size: 3 },
-          },
-          dataPools: pulumi.all([args.dataPools]).apply(([dataPools]) => {
-            return dataPools.map((dataPool) =>
-              pulumi.all([dataPool]).apply(([dataPool]) => {
-                return {
-                  name: dataPool.name,
-                  failureDomain: dataPool.failureDomain ?? "host",
-                  replicated: dataPool.replicated,
-                };
-              })
-            );
-          }),
-        },
-      },
-      opts
-    );
-
-    pulumi
-      .all([args.metadata, args.defaultStorageClass, args.dataPools])
-      .apply(([metadata, defaultStorageClass, dataPools]) => {
-        dataPools.forEach((dataPool) =>
-          pulumi.all([dataPool]).apply(([dataPool]) => {
-            return new k8s.storage.v1.StorageClass(
-              `${name}-${dataPool.name}`,
-              {
-                metadata: {
-                  ...metadata,
-                  name: `${metadata.name}-${dataPool.name}`,
-                  annotations: {
-                    ...metadata.annotations,
-                    "storageclass.kubernetes.io/is-default-class": defaultStorageClass ? "true" : "false",
-                  },
-                },
-                provisioner: pulumi.interpolate`${args.clusterId}.cephfs.csi.ceph.com`,
-                parameters: {
-                  fsName: pulumi.all([args.metadata]).apply(([metadata]) => metadata.name!),
-                  pool: pulumi
-                    .all([args.metadata])
-                    .apply(([metadata]) => pulumi.interpolate`${metadata.name}-${dataPool.name}`),
-                  clusterID: args.clusterId,
-                  "csi.storage.k8s.io/provisioner-secret-name": "rook-csi-cephfs-provisioner",
-                  "csi.storage.k8s.io/provisioner-secret-namespace": this.filesystem.metadata.namespace,
-                  "csi.storage.k8s.io/controller-expand-secret-name": "rook-csi-cephfs-provisioner",
-                  "csi.storage.k8s.io/controller-expand-secret-namespace": this.filesystem.metadata.namespace,
-                  "csi.storage.k8s.io/node-stage-secret-name": "rook-csi-cephfs-node",
-                  "csi.storage.k8s.io/node-stage-secret-namespace": this.filesystem.metadata.namespace,
-                  "csi.storage.k8s.io/fstype": "ext4",
-                },
-                reclaimPolicy: "Delete",
-                allowVolumeExpansion: true,
-                mountOptions: [],
-              },
-              opts
-            );
-          })
-        );
-      });
-  }
-}

package/lib/rook/operator.ts

@@ -1,175 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as k8s from "@pulumi/kubernetes";
-import * as yaml from "js-yaml";
-import { ComponentResource } from "../common";
-import * as kubernetes from "../kubernetes";
-
-export interface CephArgs {
-  namespace?: pulumi.Input<string>;
-  replicas?: pulumi.Input<number>;
-  kubeletDirPath?: pulumi.Input<string>;
-}
-
-export class Ceph extends ComponentResource {
-  private readonly helmRelease: kubernetes.helm.v3.Release;
-  public readonly namespace: pulumi.Output<string>;
-
-  /**
-   * Create a new rook ceph operator resource.
-   * @param name The name of the rook ceph operator resource.
-   * @param args A bag of arguments to control the rook ceph operator creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: CephArgs, opts?: pulumi.ComponentResourceOptions) {
-    super("rook:ceph", name, args, opts);
-
-    opts = this.opts(k8s.Provider);
-
-    if (args.replicas === undefined) {
-      args.replicas = 1;
-    }
-
-    this.namespace = args.namespace
-      ? pulumi.output(args.namespace)
-      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
-
-    this.helmRelease = new kubernetes.helm.v3.Release(
-      name,
-      {
-        name,
-        namespace: this.namespace,
-        repositoryOpts: { repo: "https://charts.rook.io/release" },
-        chart: "rook-ceph",
-        values: {
-          fullnameOverride: name,
-          unreachableNodeTolerationSeconds: 300,
-          pspEnable: false,
-          csi: {
-            enableCephfsSnapshotter: false,
-            enableRBDSnapshotter: false,
-            provisionerReplicas: args.replicas,
-            kubeletDirPath: args.kubeletDirPath,
-            provisionerTolerations: [
-              { key: "node-role.kubernetes.io/master", operator: "Exists", effect: "NoSchedule" },
-              { key: "node-role.kubernetes.io/control-plane", operator: "Exists", effect: "NoSchedule" },
-            ],
-            nfs: { enabled: false },
-            csiRBDProvisionerResource: yaml.dump([
-              {
-                name: "csi-provisioner",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-resizer",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-attacher",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-snapshotter",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-rbdplugin",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "liveness-prometheus",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-            ]),
-            csiRBDPluginResource: yaml.dump([
-              {
-                name: "driver-registrar",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-rbdplugin",
-                resource: { requests: { memory: "48Mi" }, limits: { memory: "64Mi" } },
-              },
-              {
-                name: "liveness-prometheus",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-            ]),
-            csiCephFSProvisionerResource: yaml.dump([
-              {
-                name: "csi-provisioner",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-resizer",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-attacher",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-cephfsplugin",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "liveness-prometheus",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-            ]),
-            csiCephFSPluginResource: yaml.dump([
-              {
-                name: "driver-registrar",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-cephfsplugin",
-                resource: { requests: { memory: "48Mi" }, limits: { memory: "64Mi" } },
-              },
-              {
-                name: "liveness-prometheus",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-            ]),
-            csiNFSProvisionerResource: yaml.dump([
-              {
-                name: "csi-provisioner",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-nfsplugin",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "liveness-prometheus",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-            ]),
-            csiNFSPluginResource: yaml.dump([
-              {
-                name: "driver-registrar",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-              {
-                name: "csi-nfsplugin",
-                resource: { requests: { memory: "48Mi" }, limits: { memory: "64Mi" } },
-              },
-              {
-                name: "liveness-prometheus",
-                resource: { requests: { memory: "32Mi" }, limits: { memory: "48Mi" } },
-              },
-            ]),
-            enableLiveness: true,
-          },
-          monitoring: { enabled: true },
-          resources: {
-            requests: { memory: "128Mi" },
-            limits: { memory: "512Mi" },
-          },
-        },
-      },
-      opts
-    );
-
-    this.registerOutputs();
-  }
-}

package/lib/samba/avahiService.ts

@@ -1,44 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as k8s from "@pulumi/kubernetes";
-import * as avahi from "../avahi";
-
-export interface AvahiServiceArgs {
-  labelName: pulumi.Input<string>;
-  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
-  hostname: pulumi.Input<string>;
-  serverName: pulumi.Input<string>;
-  deviceModel: pulumi.Input<string>;
-}
-
-export class AvahiService extends avahi.AvahiService {
-  /**
-   * Create a new CUPS avahi service resource.
-   * @param name The name of the CUPS avahi service resource.
-   * @param args A bag of arguments to control the CUPS avahi service creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: AvahiServiceArgs, opts?: pulumi.CustomResourceOptions) {
-    super(
-      name,
-      {
-        labelName: args.labelName,
-        metadata: args.metadata,
-        name: args.serverName,
-        services: [
-          {
-            type: "_smb._tcp",
-            port: 445,
-            hostname: args.hostname,
-          },
-          {
-            type: "_device-info._tcp",
-            port: 9,
-            txtRecords: [pulumi.interpolate`model=${args.deviceModel}`],
-            hostname: args.hostname,
-          },
-        ],
-      },
-      opts
-    );
-  }
-}