@coalescesoftware/coa 1.0.155 → 1.0.156

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@coalescesoftware/coa",
-    "version": "1.0.155",
+    "version": "1.0.156",
     "license": "ISC",
     "author": "Coalesce Automation, Inc.",
     "main": "index.js",

package/src/CLIProfile.ts

@@ -0,0 +1,172 @@
+/* eslint-disable multiline-comment-style */
+import * as Shared from '@coalescesoftware/shared'
+import * as immer from 'immer'
+const os = require('os')
+const path = require('path');
+const ini = require('ini')
+const fs = require('fs')
+
+const RemoveCredentialsFromCLIProfile = (cliProfile:Partial<ICLIProfile>)=> {
+    return immer.produce(cliProfile, (draft)=> {
+        if (draft.snowflakePassword)
+            draft.snowflakePassword = '<REDACTED>'
+
+        if (draft.snowflakeAccount)
+            draft.snowflakeAccount = '<REDACTED>'
+    })
+}
+
+const RemoveCredentialsFromCLIProfiles = (cliProfiles:ICLIProfilesPartial)=> {
+    return immer.produce(cliProfiles, (draftState) => {
+        Object.keys(draftState).forEach((cliProfileName:string)=> {
+            draftState[cliProfileName] = RemoveCredentialsFromCLIProfile(cliProfiles[cliProfileName])
+        })
+    })
+}
+
+const CLILogger = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI_INTERNAL)
+export interface ICLIConfig {
+    token: string
+    runDetails: {
+        environmentID:string,
+        jobID?: number,
+        includeNodesSelector?: string,
+        excludeNodesSelector?: string,
+    }
+    userCredentials: Shared.Runner.ISnowflakeUserCredentials,
+    runtimeParameters:Shared.Runner.TRunTimeParametersStringType
+}
+
+export const GetDefaultLocationForCoaConfigFile = ():string=> {
+    const homedir = os.homedir()
+    const coaConfigLocation = path.join(homedir, ".coa/config")
+    CLILogger.info("using default location", coaConfigLocation)
+    return coaConfigLocation
+}
+
+//voodoo typescript magic in order to get runtime and compiletime ICLIProfile code
+//https://stackoverflow.com/questions/45670705/iterate-over-interface-properties-in-typescript
+export const ICLIProfileExample= {
+    profile:"Profile To Use",
+    environmentID:"Environment ID",
+    parameters: "Parameters",
+    snowflakeAccount: "Snowflake Account To Use",
+    snowflakeAuthType:"Snowflake Auth Type (Basic, KeyPair)",
+    snowflakeKeyPairPath: "Snowflake Key Pair Path",
+    snowflakeKeyPairPass: "Snowflake Key Pair Pass",
+    snowflakePassword:"Snowflake Password",
+    snowflakeRole:"Snowflake Role",
+    snowflakeUsername:"Snowflake Username",
+    snowflakeWarehouse: "Snowflake Warehouse",
+    token: "Coalesce Token",
+    jobID: "Coalesce JobID",
+    include: "Coalesce Node Selector",
+    exclude: "Coalesce Node Selector"
+}
+
+
+export type ICLIProfile = typeof ICLIProfileExample
+
+type ICLIProfiles = {[cliProfileName:string]: ICLIProfile}
+type ICLIProfilesPartial = {[cliProfileName:string]: Partial<ICLIProfile>}
+
+const ReadCLIProfiles = (filePath: string | null): Promise<ICLIProfiles> => {
+    let filePathToUse: string | null
+
+    if (!filePath) {
+        filePathToUse = GetDefaultLocationForCoaConfigFile()
+    } else {
+        filePathToUse = filePath
+    }
+
+    return fs.promises.readFile(filePathToUse,  'utf-8')
+        .then((file)=> {
+            return ini.parse(file)
+        })
+        .catch((err)=> {
+            CLILogger.error("unable to read cli profile file filePath:", filePath, err)
+            if (!filePath) //if no filepath was specified, silently proceed
+                return {}
+            else //unable to proceed couldnt read file
+                throw new Error(`unable to read cli profile:${filePathToUse}`)
+        })
+}
+const GetFinalCLIProfile = (commandLineOverrides,
+    configFileLocation:string|null
+    ):Promise<Partial<ICLIProfile>>=> {
+    let profileToUseOverride = commandLineOverrides.profile ? commandLineOverrides.profile: null
+    return ReadCLIProfiles(configFileLocation)
+    .then((cliProfiles:ICLIProfiles)=> {
+        const defaultCLIProfile = cliProfiles.default
+        let finalCLIProfile = {}
+
+        //if theres a default cli profile, start with that
+        if (defaultCLIProfile) {
+            finalCLIProfile = defaultCLIProfile
+        }
+
+        //if a profile has been specified, use that
+        const profileToUse: string = profileToUseOverride || //cli override
+            (!!defaultCLIProfile && defaultCLIProfile.profile)  //default profile exists
+            ||"" 
+
+        CLILogger.info("using profile", profileToUse, "cliProfiles", JSON.stringify(RemoveCredentialsFromCLIProfiles(cliProfiles)))
+        if (profileToUse) {
+            if (!(profileToUse in cliProfiles)) {
+                throw new Error(`unable to find profile ${profileToUse}`)
+            }
+            const coaConfigProfile: ICLIProfile = cliProfiles[profileToUse]
+            finalCLIProfile = { ...finalCLIProfile, ...coaConfigProfile }
+        }
+        finalCLIProfile = { ...finalCLIProfile, ...commandLineOverrides }
+        return finalCLIProfile
+    })
+}
+
+
+//Get CLI Config given command line overrides and a config file
+//config file location can be null - which means to use default location
+export const GetCLIConfig = (commandLineOverrides:Partial<ICLIProfile>, configFileLocation:string|null): Promise<ICLIConfig> => {
+    return GetFinalCLIProfile(commandLineOverrides,
+        configFileLocation
+        ).then((cliProfile: Partial<ICLIProfile>) => {
+        CLILogger.info("got final cli profile configFileLocation:", configFileLocation, JSON.stringify(RemoveCredentialsFromCLIProfile(cliProfile)))
+        const cliConfig = {
+            token: cliProfile.token,
+            runDetails: {
+                environmentID: cliProfile.environmentID,
+                jobID: cliProfile.jobID,
+                includeNodesSelector: cliProfile.include,
+                excludeNodesSelector: cliProfile.exclude 
+            },
+            userCredentials: {
+                snowflakeAccount: cliProfile.snowflakeAccount,
+                snowflakeAuthType: cliProfile.snowflakeAuthType,
+                snowflakePassword: cliProfile.snowflakePassword,
+                snowflakeKeyPairPath: cliProfile.snowflakeKeyPairPath,
+                snowflakeKeyPairPass: cliProfile.snowflakeKeyPairPass,
+                snowflakeRole: cliProfile.snowflakeRole,
+                snowflakeUsername: cliProfile.snowflakeUsername,
+                snowflakeWarehouse:cliProfile.snowflakeWarehouse 
+            },
+            runtimeParameters: cliProfile.parameters
+        }
+        Shared.Common.CleanupUndefinedValuesFromObject(cliConfig)
+        return cliConfig as ICLIConfig
+    })
+}
+
+// TODO: create a profile class that takes the cmd object in the constructor
+    // store contents of configuration file
+    // if no config file path option
+        // check if there's a valid configuration file in the current working directory or home directory
+        // if none exists
+            // create a configuration file with empty default profile
+            // prompt user to either rerun the command with valid config file, per-command flags for all profile values, or run `coa init` to go through prompts for creating a profile
+        // if a configuration file exists, but any required property holds a falsy value
+            // inform user which fields are missing and prompt to run `coa init` to fill out invalid fields
+    // method: validate configuration file
+    // method: get final profile for current command
+
+    // create a function getCLIProfile that returns a CLI profile, this should return a promise that resolve in CLI profile
+    // hardcode a profile

package/src/CommonCLI.ts

@@ -0,0 +1,133 @@
+import * as Shared from "@coalescesoftware/shared"
+import * as fs from "fs";
+import * as crypto from "crypto"
+import * as RunOutput from './RunOutput'
+
+const RunnerBackendLogger = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.RunnerBackend)
+const LogCLIInternal = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI_INTERNAL)
+
+export const CleanupCLIJob = (runCompletion: Promise<any>, firebase: any, logContext: Shared.Logging.LogContext, action: string) => {
+    const cleanupPromise = new Promise<void>((resolve, reject) => {
+        let promiseError = null
+        runCompletion
+            .catch((error) => {
+                promiseError = error
+            })
+            .finally(() => {
+                try {
+                    if (firebase) {
+                        Shared.Common.DeleteFirebaseInstance(firebase)
+                    }
+
+                } catch (error) {
+                    RunnerBackendLogger.errorContext(
+                        logContext,
+                        `Error during ${action}WithCLI Finally cleanup: `,
+                        error,
+                    )
+                }
+
+                if (promiseError) {
+                    reject(promiseError)
+                } else {
+                    resolve()
+                }
+            })
+    })
+
+    return cleanupPromise
+}
+
+const GetKeyPairKey = (keyPairPath: string, keyPairPass: string): Promise<Buffer | null> => {
+    return new Promise((resolve, reject) => {
+        Shared.Common.assert(Shared.Logging.LoggingArea.RunnerBackend, !!keyPairPath, "ERROR (GetKeyPairPath): invalid or missing keyPairPath")
+        const privateKeyFile = fs.readFileSync(keyPairPath);
+        const privateKeyObject = crypto.createPrivateKey({
+            key: privateKeyFile,
+            format: "pem",
+            passphrase: keyPairPass
+        });
+        const privateKey = privateKeyObject.export({
+            format: "pem",
+            type: "pkcs8"
+        });
+        if (!privateKey) {
+            reject(new Error("ERROR (GetKeyPairPath): invalid or missing privateKey"))
+        } else {
+            resolve(privateKey as Buffer)
+        }
+    })
+}
+
+export const GetUserConnectionForCLI = (
+    userID: string, 
+    runInfo: Shared.Runner.IRunInfo
+): Promise<Shared.ConnectionOperations.IUserConnection> => {
+    return new Promise((resolve, reject) => {
+        const output: Shared.ConnectionOperations.IUserConnection = {
+            connectionDetails: {
+                userID,
+                user: runInfo.userCredentials?.snowflakeUsername!,
+                role: runInfo.userCredentials?.snowflakeRole!,
+                warehouse: runInfo.userCredentials?.snowflakeWarehouse!,
+            },
+            connectionType: runInfo.userCredentials?.snowflakeAuthType!
+        }
+    
+        if (!runInfo.userCredentials?.snowflakeAuthType) {
+            reject(new Error("ERROR (GetUserConnectionForCLI): no auth type provided"))
+        } else if (runInfo.userCredentials?.snowflakeAuthType! === Shared.ConnectionOperations.EUserConnectionTypes.keyPair) {
+            GetKeyPairKey(
+                Shared.Common.getValueSafe(runInfo, [ "userCredentials", "snowflakeKeyPairPath" ], ""), 
+                Shared.Common.getValueSafe(runInfo, [ "userCredentials", "snowflakeKeyPairPass" ], "")
+            )
+            .then((keyPair) => {
+                output.connectionDetails.keyPair = keyPair
+                resolve(output)
+            })
+            .catch((err) => {
+                reject(err)
+            })
+        } else {
+            resolve(output)
+        }
+    })
+}
+
+////////
+// Runtime Parameters
+///////
+export const GetRuntimeParametersFromFirestore = (
+    firestore: any,
+    teamID: string,
+    environmentID: number,
+): Promise<Shared.Runner.TRunTimeParametersStringType> => {
+    return Shared.CommonOperations.getWorkspaceDocumentRefAdmin(
+        firestore,
+        teamID,
+        environmentID
+    ).get().then((workspace) => {
+            return workspace.get("runTimeParameters")
+        })
+}
+
+export const ValidateRuntimeParameters = (runtimeParameters) => {
+    try {
+        JSON.parse(runtimeParameters)
+    } catch (error) {
+        throw new Error(`Failed to parse runtime parameters: ${(error as any).message}`)
+    }
+}
+
+////////
+// Output File 
+///////
+export const FinishWithOutputFile = (logContextToUse: Shared.Logging.LogContext, outputFilePath: string | null, runCounter: number, token: string): Promise<void> => {
+    if (!outputFilePath) {
+        return Promise.resolve()
+    }
+    else {
+        LogCLIInternal.infoContext(logContextToUse, "saving run results to file", outputFilePath)
+        return RunOutput.SaveRunOutputToFile(outputFilePath, runCounter.toString(), token)
+    }
+}

package/src/Deploy.ts

@@ -0,0 +1,84 @@
+import * as Shared from "@coalescesoftware/shared"
+import * as CommonCLI from "./CommonCLI"
+const CryptoJS = require("crypto-js")
+const v8 = require("v8")
+
+Shared.Snowflake.CryptoJS = CryptoJS
+Shared.Snowflake.salt = CryptoJS.lib.WordArray.random(128 / 8);
+Shared.Snowflake.v8 = v8;
+
+const LogCLI = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI)
+
+/**
+ * 
+ * @param plan 
+ * @param config 
+ * @param token 
+ * @returns 
+ */
+export const DeployWithCLI = (
+    plan: Shared.DeployOperations.IPlan,
+    config: Shared.Runner.IRunInfo,
+    token: string,
+): Promise<Shared.SchedulerOperations.IRunCounterAndRunCompletion> => {
+    let firebase: any
+    let logContext: Shared.Logging.LogContext
+    let teamDetailsStored: Shared.ConnectionOperations.ITeamInfoAndFirebase
+    let RunSQL: Shared.RunStepHelpers.TRunSQL
+    let runInfo
+
+    return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(
+        token,
+        undefined,
+    ).then((teamDetails: Shared.ConnectionOperations.ITeamInfoAndFirebase) => {
+            teamDetailsStored = teamDetails
+            const { teamInfo, teamInfo: { fbUserID: userID, fbTeamID: teamID } } = teamDetails
+            firebase = teamDetails.firebase
+            const environmentID: number = +config.runDetails?.environmentID!
+            logContext = Shared.Logging.CreateLogContext(teamID, environmentID, userID)
+            
+            const connectionCache: Shared.Snowflake.ConnectionStorageClass = new Shared.Snowflake.ConnectionStorageClass()
+            RunSQL = Shared.SQLExecutorCreators.CreateRunSQLWithoutScheduler(
+                teamDetails,
+                connectionCache,
+            )
+
+            runInfo = Shared.DeployOperations.CreateDeployRequestObject(
+                plan.plan!,
+                plan.environmentState!,
+                teamInfo,
+                plan.gitInfo!,
+                plan.targetEnvironment,
+                plan.runtimeParameters,
+            )
+
+            runInfo.userCredentials = config.userCredentials
+            return CommonCLI.GetUserConnectionForCLI(
+                userID,
+                runInfo
+            )
+        })
+        .then((connection: Shared.ConnectionOperations.IUserConnection) => {
+            LogCLI.infoContext(logContext, "Deploy starting (CLI)")
+            return Shared.SchedulerOperations.BECLI_HandleDeploy(
+                runInfo,
+                teamDetailsStored,
+                RunSQL,
+                connection,
+            )
+        })
+        .then(({ runCounter, runCompletion }: Shared.SchedulerOperations.IRunCounterAndRunCompletion) => {
+            const cleanupPromise: Promise<void> = CommonCLI.CleanupCLIJob(
+                runCompletion,
+                firebase,
+                logContext,
+                "Deploy"
+            )
+
+            return {
+                runCounter,
+                runCompletion: cleanupPromise,
+                logContext,
+            }
+        })
+}