@codiac.io/codiac-cli 1.2.174 → 1.2.202

package/dist/commands/asset/recycle.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPT_ME_DESIGNATOR = void 0;
+const tslib_1 = require("tslib");
+require("reflect-metadata");
+const core_1 = require("@oclif/core");
+const inquirer = require("inquirer");
+const _ = require("lodash");
+//const autocomplete = require("inquirer-autocomplete-prompt");
+const fuzzy = require("fuzzy");
+const codiac_relay_contracts_1 = require("@codiac.io/codiac-relay-contracts");
+const command_base_enterprise_1 = require("../../command-base-enterprise");
+let assetVersions = [];
+/** The value provided as input that indicates
+ * a user's desire to be prompted with a list from which choose the value(s),
+ * instead of entering them manually or taking a default. */
+exports.PROMPT_ME_DESIGNATOR = "?";
+class AssetRecycle extends command_base_enterprise_1.CommandBaseEnterprise {
+    run() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                var _a;
+                try {
+                    this.bootstrap();
+                    const { args, flags } = yield this.parse(AssetRecycle);
+                    (_a = this._relayContainer) === null || _a === void 0 ? void 0 : _a.ready$.subscribe(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        var _b;
+                        this._userCntx = yield this.establishTenantContext(this._userCntx);
+                        let enterprise = (yield this.establishEnterpriseContext(flags.enterpriseCode)).enterprise;
+                        let enterpriseCode = enterprise.code;
+                        let rootMap = yield this.getRootMap(enterpriseCode);
+                        // Select the asset(s) to deploy
+                        let assetVersions;
+                        if (flags.asset == exports.PROMPT_ME_DESIGNATOR) {
+                            let asset = yield this.promptForAsset(enterpriseCode);
+                            // let selected = await this.promptForVersion(enterpriseCode, asset, flags.version);
+                            assetVersions = [{ a: asset.name }];
+                        }
+                        else if (flags.asset) {
+                            let asset = yield this.promptForAsset(enterpriseCode, flags.asset);
+                            // let selected = await this.promptForVersion(enterpriseCode, asset, flags.version);
+                            assetVersions = [{ a: asset.name }];
+                            // if (!flags.version || flags.version == PROMPT_ME_DESIGNATOR) {
+                            // }
+                        }
+                        else {
+                            // Update sync codiac with what we've got here in the project.
+                            let requestedAssets = yield this.establishAssetContext(enterprise, flags.silent);
+                            assetVersions = requestedAssets.map(a => { return { a: a }; });
+                            // let versions = await this.declareAssetVersions(requestedAssets, enterpriseCode);
+                            // // We've updated Codiac.  Now trigger the deploy.
+                            // assetVersions = requestedAssets.map(a => {
+                            //   let version = versions.find(v => v.assetName == a);
+                            //   return { a: a, v: version ? version.assetVersion : undefined };
+                            // });
+                        }
+                        let cabinet = yield this.establishCabinet(flags.cabinetName);
+                        let cabCntx = new codiac_relay_contracts_1.CabinetScope(cabinet.enterpriseCode, cabinet.environment, cabinet.name);
+                        // Get the clusterdef so we can get cloud pvd creds
+                        let cluster = (_b = cabinet.cluster) !== null && _b !== void 0 ? _b : ((rootMap.clusters.length === 1) ? rootMap.clusters[0].name : undefined); // fall back to the one and only.
+                        if (cluster === undefined) {
+                            this.logger.warn(`Cannot confirm cloud provider credentials: cabinet has no cluster specified. Process will rely on cached credentials.`);
+                            // throw new Error(`Cannot determine cloud provider: cabinet has no cluster specified.`);
+                        }
+                        else {
+                            yield this.establishCloudProviderCreds(rootMap, cluster);
+                        }
+                        let assets = {
+                            enterpriseCode: cabCntx.enterprise,
+                            environment: cabCntx.environment,
+                            cabinetName: cabCntx.cabinet,
+                            assetNames: assetVersions.map(a => a.a)
+                        };
+                        this._ui.startSpinner(`Recycling assets in ${assets.cabinetName}...`);
+                        let result = yield this.relayClient.recycleAssets(assets);
+                        this._ui.stopSpinner((result.success === true) ? "SUCCESS" : (result.error) ? "ERROR" : "FAILED");
+                        if (result.error) {
+                            this.logger.error(`Error recycling assets in ${assets.cabinetName}: ${result.message}`, result.error);
+                            this._ui.userMessage(`Error recycling assets in ${assets.cabinetName}: ${result.message}`);
+                        }
+                        else if (result.success) {
+                            this.logger.notice(`Recycled assets in ${assets.cabinetName}`);
+                            // this._ui.userMessage(`Recycled assets in ${assets.cabinetName}`);  // The spinner is enough for the user message here.
+                        }
+                        else {
+                            this.logger.warn(`Failed without error recycling assets in ${assets.cabinetName}: ${result.message}`, result);
+                            this._ui.userMessage(`Failed without error recycling assets in ${assets.cabinetName}: ${result.message}`);
+                        }
+                        resolve();
+                    }));
+                }
+                catch (err) {
+                    this.handleError(err);
+                    reject(err);
+                }
+            }));
+        });
+    }
+    promptForAsset(enterprise, assetSearch) {
+        return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                // let ecrit = new EnterpriseCriteria();
+                // ecrit.code = new StringFilter();
+                // ecrit.code.$eq = enterprise;
+                let ecrit = { code: enterprise };
+                let readResult = yield this._codiacApi.Enterprise.tryReadMany(ecrit /* { code: { $eq: enterprise } }  */);
+                if (!readResult.output || readResult.output.length == 0) {
+                    throw new Error(`Could not find enterprise [${enterprise}].`);
+                }
+                else if (!readResult.output[0].assets || readResult.output[0].assets.length == 0) {
+                    throw new Error(`The current enterprise [${enterprise}] has no assets defined.`);
+                }
+                // console.log(`${readResult.output[0].assets.length} assets found`)
+                // Select from assets in the current enterprise
+                let assets = readResult.output[0].assets;
+                if (assetSearch && assetSearch != exports.PROMPT_ME_DESIGNATOR) {
+                    assets = assets.filter(a => a.name.startsWith(assetSearch));
+                }
+                // console.log(`${assets.length} assets found`)
+                let assSelect = yield inquirer.prompt({ type: 'list', name: 'asset', message: 'Select an Asset:', choices: assets.map(a => a.name) });
+                let selected = assets.find(a => a.name == assSelect.asset);
+                if (!selected)
+                    throw new Error(`User failed to select a valid asset to deploy.`);
+                resolve(selected);
+            }
+            catch (err) {
+                reject(err);
+            }
+        }));
+    }
+    searchVersions(answers, input) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                try {
+                    // Whatever voodoo they're doing inside the autocomplete plugin,
+                    // they're redefining "this", so we cant use it here.
+                    // Great, we'll just HACK UP a fucking module scoped variable to hold onto the goddamn list then.
+                    // let vers = this.getVersions();
+                    input = input || "";
+                    setTimeout(() => {
+                        let options = { extract: (ver) => { return ver.value; } };
+                        let results = fuzzy.filter(input, assetVersions, options);
+                        let filtered = results.map((fr) => fr.original);
+                        resolve(filtered);
+                    }, _.random(30, 500)); // why a random number?
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }));
+        });
+    }
+}
+exports.default = AssetRecycle;
+AssetRecycle.description = 'Deploys a given asset to a given cabinet.  Defaults to current version.';
+AssetRecycle.dependsOn = ["enterpriseCode", "cabinetName"];
+AssetRecycle.flags = {
+    // ...commandBase.globalFlags,
+    help: core_1.Flags.help({ char: 'h' }),
+    enterpriseCode: core_1.Flags.string({ char: 'e', required: false, description: `Code (name) of the enterprise to deploy` }),
+    cabinetName: core_1.Flags.string({ char: 'c', required: false, description: `Target cabinet name you want deploy` }),
+    asset: core_1.Flags.string({ char: 'a', required: false, description: `Search string for the name of the asset to deploy (use ${exports.PROMPT_ME_DESIGNATOR} to be prompted).` }),
+    version: core_1.Flags.string({ char: 'v', required: false, description: `Search string for the version of the asset to deploy  (use ${exports.PROMPT_ME_DESIGNATOR} to be prompted).` }),
+    silent: core_1.Flags.boolean({ char: 'y', dependsOn: AssetRecycle.dependsOn, required: false, description: `(Optional: defaults to false) Prevents confirmations of user-values that are remembered from prior runs. Requires: ${AssetRecycle.dependsOn}` })
+};
+AssetRecycle.args = {};
+// type FuzzyResult = {
+//     /** The rendered string (eg: '<b>lah'). */
+//     string: string,
+//     /** The index of the element in `arr` (eg: 2). */
+//     index: number,
+//     /** The original element in `arr`. */
+//     original: 'blah'
+// }
+//# sourceMappingURL=recycle.js.map

package/dist/commands/asset/view.d.ts

@@ -0,0 +1,188 @@
+/// <reference types="node" />
+import * as stream from "stream";
+import * as request from "request";
+import * as k8s from "@kubernetes/client-node";
+import { EnvironmentRoot, RootMap } from '../../apis/codiac-api/contracts';
+import { CommandBaseEnterprise } from '../../command-base-enterprise';
+import { ClusterWithIngress } from '@codiac.io/codiac-domain';
+import { AssetReplicaContext, K8sContainerContext } from '../../relay/contracts/contracts';
+import { LogOptions } from '../../apis/codiac-relay/contracts';
+import { IBetterLogger } from "@codiac.io/codiac-common";
+import { V1Pod } from "@kubernetes/client-node";
+/** The value provided as input that indicates
+ * a user's desire to be prompted with a list from which choose the value(s),
+ * instead of entering them manually or taking a default. */
+export declare const PROMPT_ME_DESIGNATOR = "?";
+export declare type TextValueParent = {
+    text: string;
+    value: string;
+    children?: TextValueParent[];
+};
+export declare type ScopePedigree = {
+    scope: string;
+    target: string;
+    parent?: ScopePedigree;
+};
+export declare type ScopedValuePedigree = {
+    scope: string;
+    target: string;
+    value?: string;
+    parent?: ScopedValuePedigree;
+};
+export declare enum AssetContentType {
+    "logs" = "logs",
+    "term" = "term",
+    "exec" = "exec",
+    "env" = "env",
+    "config" = "config",
+    "status" = "status"
+}
+export declare type AssetReplicaContentRequest = {
+    content: AssetContentType;
+} & AssetReplicaContext;
+export declare type ContentArguments = (LogOptions | ExecArgs | TermArgs | ConfigFileArgs);
+export declare enum InteractionModes {
+    "echo" = "echo",
+    "toscript" = "toscript",
+    "silent" = "silent"
+}
+export declare type AssetContentRequest = {
+    context: AssetReplicaContext;
+    contentType: AssetContentType;
+    k8sEntities: K8sContainerContext;
+    contentOptions: ContentArguments;
+    replicas?: k8s.V1Pod[] | undefined;
+};
+/** This belongs to k8s - not us, but @kubernetes/client-node has no enum or constants for these magic strings...
+ *
+ * @see https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-phase
+*/
+export declare enum K8S_POD_PHASES {
+    "Pending" = "Pending",
+    "Running" = "Running",
+    "Succeeded" = "Succeeded",
+    "Failed" = "Failed",
+    "Unknown" = "Unknown"
+}
+export default class AssetView extends CommandBaseEnterprise {
+    static description: string;
+    static aliases: string[];
+    static flags: {
+        help: import("@oclif/core/lib/interfaces").BooleanFlag<void>;
+        enterprise: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        asset: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        cabinet: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        replica: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        terminal: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        logsFollow: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        logsTail: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        configFile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        silent: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        echo: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        toscript: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        takeDefaults: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static strict: boolean;
+    static args: {
+        cmd: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    private get uiCloudPvd();
+    private _uiCloudPvd_backer;
+    private takeDefaults;
+    protected bootstrap(): void;
+    run(): Promise<void>;
+    private buildCandidate_silently;
+    private buildCandidate_interactively;
+    private promptForContentOptions;
+    private promptForLogOptions;
+    private promptForExecOptions;
+    private promptForTerminalOptions;
+    private promptForContentType;
+    private promptForAsset;
+    private promptForCabinet;
+    protected deriveEnvironmentFrom(enterprise: string, cabinet: string, rootMap: RootMap): EnvironmentRoot;
+    protected deriveClusterFrom(enterprise: string, environment: string, cabinet: string, rootMap: RootMap): ClusterWithIngress;
+    private buildSelectChoicesFrom;
+    /** sets each value to "scope|target".
+     *
+     * This is MOSTLY a COPY-PASTE from the CabinetList command!!!  This view is prob gonna be pretty common - consider promoting it to a shared utility. */
+    private buildCabinetTree;
+    /** Truncates the string to the given length with an ellipses as suffix */
+    private ellipsis;
+    /**
+     *
+     * @param enterprise
+     * @param environment
+     * @param cabinet
+     * @param asset
+     * @param ctrInPod (Optional, defaults to the first one in the spec) The name of the running container (not the image) inside the pod (relevant only when there's more than one).
+     * @param defaultValue
+     * @returns
+     */
+    protected promptForReplica(replicas: k8s.V1Pod[], ctrInPod: string | undefined, defaultValue?: string | undefined): Promise<K8sContainerContext>;
+    renderSelectedContent(context: AssetReplicaContext, contentType: AssetContentType, k8sEntities: K8sContainerContext, contentOptions?: ContentArguments | undefined, replicas?: k8s.V1Pod[] | undefined): Promise<void>;
+    protected getKubeConfig(context: AssetReplicaContext): Promise<k8s.KubeConfig>;
+    protected getK8sClient(context: AssetReplicaContext, kube?: k8s.KubeConfig | undefined): Promise<k8s.CoreV1Api>;
+    /** Gets the cluster cnxn specs from the relay, then makes the k8s call from the cli.
+     *
+     * Throws any errors. */
+    protected fetchReplicas(context: AssetReplicaContext, namespace: string, k8sClient?: k8s.CoreV1Api): Promise<V1Pod[]>;
+    protected watchStatus_NEW(context: AssetReplicaContext, namespace: string, replicas?: k8s.V1Pod[] | undefined): Promise<void>;
+    protected watchReplicaSet(context: AssetReplicaContext, namespace: string, replicaSets?: k8s.V1ReplicaSet[] | undefined): Promise<void>;
+    protected watchStatus(context: AssetReplicaContext, namespace: string, replicas?: k8s.V1Pod[] | undefined): Promise<void>;
+    /** Mutates canvas */
+    private renderReplicaStatusRow;
+    private renderCondition;
+    private renderPodState;
+    private unblockAndSleep;
+    /** Fetches pods if not already provided. */
+    protected showStatus(context: AssetReplicaContext, namespace: string, replicas?: k8s.V1Pod[] | undefined, k8sApi?: k8s.CoreV1Api): Promise<void>;
+    protected showLogs(context: Required<AssetReplicaContext>, logOptions?: LogOptions | undefined): Promise<void>;
+    /**
+     * @param context Fully qualified path, in terms of Codiac entities, to identify a single replica of an asset in a cabinet.
+     * @param execArgs Parameters identifying the ultimate command to run and the console behavior.
+     * @param K8sEntities The identifying names of the relevant kubernetes objects, corresponding to the asset replica context, that fully qualify the desired container. */
+    protected runExec(context: AssetReplicaContext, execArgs: ExecArgs, k8sEntities: Required<K8sContainerContext>): Promise<void>;
+    /** Parses the stream number from the incoming message,
+     * and writes the data to the designated target stream.
+     *
+     * (The k8s client prefixes the buffer with the stream number at position 0)
+     */
+    routeK8sWebSocketMessage(msg: any): void;
+}
+export declare class ExecArgs {
+    command: string | string[];
+    tty: boolean;
+    constructor(command: string | string[], tty?: boolean);
+}
+export declare class ConfigFileArgs {
+    rootPathName: string;
+    constructor(rootPathName: string);
+}
+export declare class TermArgs {
+    terminalStartup: "bash" | "sh" | string;
+    /**
+     *
+     * @param terminalStartup The type of terminal to open.  This command may change depending on what terminal or command shell types are available in the image.
+     */
+    constructor(terminalStartup: "bash" | "sh" | string);
+}
+/** Idnetifies a container, in a pod, in a namespace, in a cluster. */
+export declare class K8sContainerRef {
+    namespace: string;
+    podName: string;
+    /** This should be optional. When there's only one container in a pod,
+     * we should be able to derive this from the pod spec. */
+    containerName: string;
+    constructor(namespace: string, podName: string, 
+    /** This should be optional. When there's only one container in a pod,
+     * we should be able to derive this from the pod spec. */
+    containerName: string);
+}
+export declare class LogStreamer {
+    private logger;
+    constructor(logger: IBetterLogger);
+    go(requestOptions: request.Options, stream: stream.Writable): Promise<request.Request>;
+}