@ydkn/pulumi-components 0.4.4 → 0.4.6

package/lib/externalDns/operator.ts

@@ -1,165 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as k8s from "@pulumi/kubernetes";
-import { ComponentResource } from "../common";
-import * as helm from "../kubernetes/helm";
-
-export interface CloudflareArgs {
-  /**
-   * Cloudflare API token
-   */
-  apiToken: pulumi.Input<string>;
-  /**
-   * Proxy records
-   */
-  proxied?: pulumi.Input<boolean>;
-}
-
-export interface ExternalDnsArgs {
-  /**
-   * Optional: Namespace
-   */
-  namespace?: pulumi.Input<string>;
-  /**
-   * Cluster name
-   */
-  clusterName: pulumi.Input<string>;
-  /**
-   * Optional: Number of replicas
-   */
-  replicas?: pulumi.Input<number>;
-  /**
-   * Optional: Cloudflare configuration
-   */
-  cloudflare?: pulumi.Input<CloudflareArgs>;
-}
-
-export class ExternalDns extends ComponentResource {
-  private static crdBranch = "master";
-
-  private readonly crd: k8s.yaml.ConfigFile;
-  private readonly providerSecret?: k8s.core.v1.Secret;
-  private readonly helmRelease: helm.v3.Release;
-  public readonly namespace: pulumi.Output<string>;
-
-  /**
-   * Create a new external-dns resource.
-   * @param name The name of external-dns resource.
-   * @param args A bag of arguments to control the external-dns creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: ExternalDnsArgs, opts?: pulumi.ComponentResourceOptions) {
-    super("external-dns", name, args, opts);
-
-    opts = this.opts(k8s.Provider);
-
-    if (args.replicas === undefined) {
-      args.replicas = 1;
-    }
-
-    this.crd = new k8s.yaml.ConfigFile(
-      name,
-      {
-        file: [
-          "https://raw.githubusercontent.com/kubernetes-sigs/external-dns",
-          ExternalDns.crdBranch,
-          "docs/contributing/crd-source/crd-manifest.yaml",
-        ].join("/"),
-      },
-      opts
-    );
-
-    this.namespace = args.namespace
-      ? pulumi.output(args.namespace)
-      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
-
-    const helmValues = {
-      fullnameOverride: name,
-      logLevel: "info",
-      logFormat: "json",
-      policy: "sync",
-      registry: "txt",
-      txtOwnerId: args.clusterName,
-      txtPrefix: "_external-dns.",
-      sources: ["crd", "service", "ingress"],
-      extraArgs: ["--publish-internal-services", "--publish-host-ip"] as pulumi.Input<pulumi.Input<string>[]>,
-      env: [] as pulumi.Input<pulumi.Input<any>[]>,
-      provider: undefined as string | undefined,
-      serviceMonitor: { enabled: true },
-      affinity: {
-        podAntiAffinity: {
-          preferredDuringSchedulingIgnoredDuringExecution: [
-            {
-              weight: 100,
-              podAffinityTerm: {
-                labelSelector: {
-                  matchExpressions: [
-                    { key: "app.kubernetes.io/name", operator: "In", values: ["external-dns"] },
-                    { key: "app.kubernetes.io/instance", operator: "In", values: [name] },
-                  ],
-                },
-                topologyKey: "kubernetes.io/hostname",
-              },
-            },
-          ],
-        },
-      },
-      resources: {
-        requests: { memory: "48Mi" },
-        limits: { memory: "64Mi" },
-      },
-    };
-
-    if (args.cloudflare !== undefined) {
-      this.providerSecret = new k8s.core.v1.Secret(
-        name,
-        {
-          metadata: { namespace: this.namespace, name: pulumi.interpolate`${name}-cloudflare` },
-          stringData: {
-            cloudflare_api_token: pulumi.all([args.cloudflare]).apply(([cloudflare]) => cloudflare.apiToken),
-          },
-        },
-        opts
-      );
-
-      helmValues.provider = "cloudflare";
-
-      helmValues.extraArgs = pulumi.all([helmValues.extraArgs, args.cloudflare]).apply(([extraArgs, cloudflare]) => {
-        if (cloudflare.proxied) {
-          extraArgs.push("--cloudflare-proxied");
-        }
-
-        return extraArgs;
-      });
-
-      helmValues.env = pulumi.all([helmValues.env, args.cloudflare]).apply(([env, cloudflare]) => {
-        if (this.providerSecret !== undefined) {
-          env.push({
-            name: "CF_API_TOKEN",
-            valueFrom: {
-              secretKeyRef: {
-                name: this.providerSecret.metadata.name,
-                key: "cloudflare_api_token",
-              },
-            },
-          });
-        }
-
-        return env;
-      });
-    }
-
-    this.helmRelease = new helm.v3.Release(
-      name,
-      {
-        name,
-        namespace: this.namespace,
-        repositoryOpts: { repo: "https://kubernetes-sigs.github.io/external-dns" },
-        chart: "external-dns",
-        values: helmValues,
-      },
-      opts
-    );
-
-    this.registerOutputs();
-  }
-}

package/lib/fcos/config.ts

@@ -1,237 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as path from "path";
-import * as fs from "fs";
-import * as compress from "zlib";
-import { ComponentResource } from "../common";
-
-export interface UserArgs {
-  name: pulumi.Input<string>;
-  groups?: pulumi.Input<pulumi.Input<string>[]>;
-  sshAuthorizedKeys?: pulumi.Input<pulumi.Input<string>[]>;
-  passwordHash?: pulumi.Input<string>;
-}
-
-export interface PartitionArgs {
-  label: pulumi.Input<string>;
-  size: pulumi.Input<number>;
-  start?: pulumi.Input<number>;
-  number?: pulumi.Input<number>;
-  resize?: pulumi.Input<boolean>;
-}
-
-export interface DiskArgs {
-  device: pulumi.Input<string>;
-  partitions: pulumi.Input<pulumi.Input<PartitionArgs>[]>;
-  wipeTable?: pulumi.Input<boolean>;
-}
-
-export interface FilesystemArgs {
-  device: pulumi.Input<string>;
-  path: pulumi.Input<string>;
-  format: pulumi.Input<string>;
-  label?: pulumi.Input<string>;
-}
-
-export interface FilesArgs {
-  path: pulumi.Input<string>;
-  contents: pulumi.Input<string>;
-  mode?: pulumi.Input<number>;
-}
-
-export interface SystemdUnitArgs {
-  name: pulumi.Input<string>;
-  enabled?: pulumi.Input<boolean>;
-  mask?: pulumi.Input<boolean>;
-  contents?: pulumi.Input<string>;
-}
-
-export interface IgnitionArgs {
-  modules?: pulumi.Input<pulumi.Input<string>[]>;
-  packages?: pulumi.Input<pulumi.Input<string>[]>;
-  users?: pulumi.Input<pulumi.Input<UserArgs>[]>;
-  disks?: pulumi.Input<pulumi.Input<DiskArgs>[]>;
-  filesystems?: pulumi.Input<pulumi.Input<FilesystemArgs>[]>;
-  files?: pulumi.Input<pulumi.Input<FilesArgs>[]>;
-  systemdUnits?: pulumi.Input<pulumi.Input<SystemdUnitArgs>[]>;
-}
-
-export interface ConfigArgs extends IgnitionArgs {
-  hostname: pulumi.Input<string>;
-}
-
-export class Config extends ComponentResource {
-  public readonly ignitionConfig: pulumi.Output<string>;
-
-  /**
-   * Create a new FCOS config resource.
-   * @param name The name of the FCOS config resource.
-   * @param args A bag of arguments to control the FCOS config creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: ConfigArgs, opts?: pulumi.ComponentResourceOptions) {
-    super("fcos:config", name, args, opts);
-
-    this.ignitionConfig = pulumi
-      .all([
-        this.defaultConfig(),
-        args.hostname,
-        args.modules,
-        args.packages,
-        args.users,
-        args.disks,
-        args.filesystems,
-        args.files,
-        args.systemdUnits,
-      ])
-      .apply(([config, hostname, modules, packages, users, disks, filesystems, files, systemdUnits]) => {
-        if (hostname !== undefined) {
-          config.storage.files.push({
-            path: "/etc/hostname",
-            contents: this.storageContents(hostname),
-            mode: 0o644,
-          });
-        }
-
-        for (const module of modules || []) {
-          config.storage.files.push({
-            path: `/etc/modules-load.d/${module}.conf`,
-            contents: this.storageContents(module),
-            mode: 0o644,
-          });
-        }
-
-        for (const pkg of packages || []) {
-          config.storage.files.push({ path: `/etc/rpm-opstree-install/${pkg}` });
-        }
-
-        for (const user of users || []) {
-          config.passwd.users.push(user);
-        }
-
-        for (const disk of disks || []) {
-          config.storage.disks.push({
-            device: disk.device,
-            partitions: disk.partitions.map((partition: PartitionArgs) => {
-              return {
-                label: partition.label,
-                size_mib: partition.size,
-                start_mib: partition.start,
-                number: partition.number,
-                resize: partition.resize,
-              };
-            }),
-            wipe_table: disk.wipeTable,
-          });
-        }
-
-        for (const filesystem of filesystems || []) {
-          config.storage.filesystems.push({
-            device: filesystem.device,
-            path: filesystem.path,
-            format: filesystem.format,
-            label: filesystem.label,
-          });
-
-          const checkSystemdName = filesystem.device.replace(/-/g, "\\x2d").replace(/^\//, "").replace(/\//g, "-");
-
-          config.systemd.units.push({
-            name: `${filesystem.path.replace(/^\//, "").replace(/\//g, "-")}.mount`,
-            enabled: true,
-            contents: [
-              "[Unit]",
-              "Before=local-fs.target",
-              `Requires=systemd-fsck@${checkSystemdName}.service`,
-              `After=systemd-fsck@${checkSystemdName}.service`,
-              "[Mount]",
-              `Where=${filesystem.path}`,
-              `What=${filesystem.device}`,
-              `Type=${filesystem.format}`,
-              "[Install]",
-              "RequiredBy=local-fs.target",
-            ].join("\n"),
-          });
-        }
-
-        for (const file of files || []) {
-          config.storage.files.push({
-            path: file.path,
-            contents: this.storageContents(file.contents),
-            mode: file.mode ?? 0o644,
-          });
-        }
-
-        for (const unit of systemdUnits || []) {
-          config.systemd.units.push(unit);
-        }
-
-        return JSON.stringify(config);
-      });
-
-    this.registerOutputs();
-  }
-
-  private defaultConfig(): any {
-    return {
-      ignition: { version: "3.3.0" },
-      passwd: {
-        users: [],
-      },
-      storage: {
-        disks: [],
-        filesystems: [],
-        directories: [{ path: "/etc/rpm-opstree-install" }],
-        files: [
-          {
-            path: "/etc/sysctl.d/20-silence-audit.conf",
-            contents: this.storageContents("kernel.printk=4"),
-            mode: 0o644,
-          },
-          {
-            overwrite: true,
-            path: "/etc/sysctl.d/10-fs-inotify.conf",
-            contents: this.storageContents(
-              "fs.inotify.max_user_instances = 8192\nfs.inotify.max_user_watches = 524288"
-            ),
-          },
-          {
-            overwrite: true,
-            path: "/etc/sysctl.d/90-ipv4-ip-forward.conf",
-            contents: this.storageContents("net.ipv4.ip_forward = 1"),
-          },
-          {
-            overwrite: true,
-            path: "/etc/sysctl.d/90-ipv6-ip-forwarding.conf",
-            contents: this.storageContents("net.ipv6.conf.all.forwarding = 1"),
-          },
-          { overwrite: false, path: "/etc/systemd/resolved.conf", append: [this.storageContents("LLMNR=no")] },
-          {
-            path: "/usr/local/sbin/rpm-opstree-install",
-            contents: this.storageContents(this.assetContent("rpm-opstree-install.sh")),
-            mode: 0o755,
-          },
-        ],
-      },
-      systemd: {
-        units: [
-          {
-            name: "rpm-ostree-install.service",
-            enabled: true,
-            contents: this.assetContent("rpm-ostree-install.service"),
-          },
-        ],
-      },
-    };
-  }
-
-  private assetContent(filename: string): string {
-    // eslint-disable-next-line security/detect-non-literal-fs-filename
-    return fs.readFileSync(path.join(__dirname, "assets", filename), "utf-8");
-  }
-
-  private storageContents(data: string): { compression: string; source: string } {
-    return {
-      compression: "gzip",
-      source: `data:;base64,${compress.gzipSync(Buffer.from(data), { level: 9 }).toString("base64")}`,
-    };
-  }
-}

package/lib/fcos/host.ts

@@ -1,91 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as tls from "@pulumi/tls";
-import { ComponentResource } from "../common";
-import { UserArgs, ConfigArgs, Config } from "./config";
-
-export interface HostUserArgs {
-  /**
-   * Username
-   */
-  name: pulumi.Input<string>;
-  /**
-   * Optional: Groups
-   */
-  groups?: pulumi.Input<pulumi.Input<string>[]>;
-}
-
-export interface HostArgs extends ConfigArgs {
-  /**
-   * Optional: Users with SSH access
-   */
-  sshUsers?: pulumi.Input<pulumi.Input<HostUserArgs>[]>;
-}
-
-export class Host extends ComponentResource {
-  public readonly sshPrivateKeys: pulumi.Output<{ [key: string]: tls.PrivateKey }>;
-  public readonly ignitionConfig: pulumi.Output<string>;
-
-  /**
-   * Create a new FCOS host resource.
-   * @param name The name of the FCOS host resource.
-   * @param args A bag of arguments to control the FCOS host creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: HostArgs, opts?: pulumi.ComponentResourceOptions) {
-    super("fcos:host", name, args, opts);
-
-    const emptyOpts = this.opts();
-
-    this.sshPrivateKeys = pulumi.all([args.sshUsers]).apply(([sshUsers]) => {
-      const sshPrivateKeys: { [key: string]: tls.PrivateKey } = {};
-
-      for (const sshUser of sshUsers || []) {
-        sshPrivateKeys[sshUser.name] = new tls.PrivateKey(
-          `${name}-${sshUser.name}`,
-          { algorithm: "ED25519" },
-          emptyOpts
-        );
-      }
-
-      return sshPrivateKeys;
-    });
-
-    this.ignitionConfig = new Config(
-      name,
-      {
-        ...args,
-        modules: pulumi.all([args.modules]).apply(([modules]) => (modules || []).concat("wireguard")),
-        packages: pulumi
-          .all([args.packages])
-          .apply(([packages]) => (packages || []).concat("netcat", "tcpdump", "iperf3", "htop", "golang-gvisor")),
-        users: pulumi
-          .all([args.users, args.sshUsers, this.sshPrivateKeys])
-          .apply(([users, sshUsers, sshPrivateKeys]) => {
-            const allUsers: pulumi.Input<UserArgs>[] = [];
-
-            for (const user of users || []) {
-              allUsers.push(user);
-            }
-
-            for (const sshUser of sshUsers || []) {
-              allUsers.push({
-                name: sshUser.name,
-                groups: sshUser.groups,
-                sshAuthorizedKeys: sshPrivateKeys[sshUser.name].publicKeyOpenssh.apply((key) => [key.trim()]),
-              });
-            }
-
-            return allUsers;
-          }),
-        systemdUnits: pulumi
-          .all([args.systemdUnits])
-          .apply(([systemdUnits]) =>
-            (systemdUnits || []).concat({ mask: true, name: "docker.service" }, { mask: true, name: "docker.socket" })
-          ),
-      },
-      emptyOpts
-    ).ignitionConfig;
-
-    this.registerOutputs();
-  }
-}

package/lib/fcos/index.ts

@@ -1,27 +0,0 @@
-import {
-  PartitionArgs,
-  DiskArgs,
-  FilesystemArgs,
-  UserArgs,
-  FilesArgs,
-  SystemdUnitArgs,
-  IgnitionArgs,
-  ConfigArgs,
-  Config,
-} from "./config";
-import { HostUserArgs, HostArgs, Host } from "./host";
-
-export {
-  PartitionArgs,
-  DiskArgs,
-  FilesystemArgs,
-  UserArgs,
-  FilesArgs,
-  SystemdUnitArgs,
-  IgnitionArgs,
-  ConfigArgs,
-  Config,
-  HostUserArgs,
-  HostArgs,
-  Host,
-};