@adobe/aio-cli-plugin-app 8.2.0 → 8.5.0

package/src/lib/actions-watcher.js

@@ -9,7 +9,7 @@ the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTA
 OF ANY KIND, either express or implied. See the License for the specific language
 governing permissions and limitations under the License.
 */
-
+const upath = require('upath')
 const chokidar = require('chokidar')
 const aioLogger = require('@adobe/aio-lib-core-logging')('@adobe/aio-cli-plugin-app:actions-watcher', { provider: 'debug' })
 const buildActions = require('./build-actions')
@@ -58,12 +58,13 @@ module.exports = async (watcherOptions) => {
  * Builds and deploy the app.
  *
  * @param {WatcherOptions} watcherOptions the options for the watcher
+ * @param {Array<string>} filterActions add filters to deploy only specified OpenWhisk actions
  */
-async function buildAndDeploy (watcherOptions) {
+async function buildAndDeploy (watcherOptions, filterActions) {
   const { config, isLocal, log } = watcherOptions
 
-  await buildActions(config)
-  await deployActions(config, isLocal, log)
+  await buildActions(config, filterActions)
+  await deployActions(config, isLocal, log, filterActions)
 }
 
 /**
@@ -75,30 +76,62 @@ async function buildAndDeploy (watcherOptions) {
 function createChangeHandler (watcherOptions) {
   const { watcher, log } = watcherOptions
 
-  let running = false
-  let changed = false
+  let deploymentInProgress = false
+  let fileChanged = false
+  let undeployedFile = ''
 
   return async (filePath) => {
-    if (running) {
+    aioLogger.debug('Code change triggered...')
+    if (deploymentInProgress) {
       aioLogger.debug(`${filePath} has changed. Deploy in progress. This change will be deployed after completion of current deployment.`)
-      changed = true
+      undeployedFile = filePath
+      fileChanged = true
       return
     }
-    running = true
+    deploymentInProgress = true
     try {
       aioLogger.debug(`${filePath} has changed. Redeploying actions.`)
-      await buildAndDeploy(watcherOptions)
-      aioLogger.debug('Deployment successful.')
+      const filterActions = getActionNameFromPath(filePath, watcherOptions)
+      if (!filterActions.length) {
+        log('  -> A non-action file was changed, restart is required to deploy...')
+      } else {
+        await buildAndDeploy(watcherOptions, filterActions)
+        aioLogger.debug('Deployment successful')
+      }
     } catch (err) {
       log('  -> Error encountered while deploying actions. Stopping auto refresh.')
       aioLogger.debug(err)
       await watcher.close()
     }
-    if (changed) {
+    if (fileChanged) {
       aioLogger.debug('Code changed during deployment. Triggering deploy again.')
-      changed = running = false
-      await createChangeHandler(watcherOptions)(filePath)
+      fileChanged = deploymentInProgress = false
+      await createChangeHandler(watcherOptions)(undeployedFile)
     }
-    running = false
+    deploymentInProgress = false
   }
 }
+
+/**
+ * Util function which returns the actionName from the filePath.
+ *
+ * @param {string} filePath  path of the file
+ * @param {WatcherOptions} watcherOptions the options for the watcher
+ * @returns {Array<string>}  All of the actions which match the modified path
+ */
+function getActionNameFromPath (filePath, watcherOptions) {
+  const actionNames = []
+  const unixFilePath = upath.toUnix(filePath)
+  const { config } = watcherOptions
+  Object.entries(config.manifest.full.packages).forEach(([, pkg]) => {
+    if (pkg.actions) {
+      Object.entries(pkg.actions).forEach(([actionName, action]) => {
+        const unixActionFunction = upath.toUnix(action.function)
+        if (unixActionFunction.includes(unixFilePath)) {
+          actionNames.push(actionName)
+        }
+      })
+    }
+  })
+  return actionNames
+}

package/src/lib/build-actions.js

@@ -17,12 +17,13 @@ const { buildActions } = require('@adobe/aio-lib-runtime')
  * Builds actions.
  *
  * @param {object} config see src/lib/config-loader.js
+ * @param {Array<string>} filterActions add filters to deploy only specified OpenWhisk actions
  */
-module.exports = async (config) => {
+module.exports = async (config, filterActions) => {
   utils.runScript(config.hooks['pre-app-build'])
   const script = await utils.runScript(config.hooks['build-actions'])
   if (!script) {
-    await buildActions(config)
+    await buildActions(config, filterActions)
   }
   utils.runScript(config.hooks['post-app-build'])
 }

package/src/lib/deploy-actions.js

@@ -17,15 +17,22 @@ const { deployActions } = require('@adobe/aio-lib-runtime')
  * Deploys actions.
  *
  * @param {object} config see src/lib/config-loader.js
- * @param {boolean} isLocal=false set to true if it's a local deploy
+ * @param {boolean} isLocal default false, set to true if it's a local deploy
  * @param {Function} [log] a log function
+ * @param {boolean} filter true if a filter by built actions is desired.
  */
 /** @private */
-module.exports = async (config, isLocal = false, log = () => {}) => {
+module.exports = async (config, isLocal = false, log = () => {}, filter = false) => {
   utils.runScript(config.hooks['pre-app-deploy'])
   const script = await utils.runScript(config.hooks['deploy-actions'])
   if (!script) {
-    const entities = await deployActions(config, { isLocalDev: isLocal }, log)
+    const deployConfig = {
+      isLocalDev: isLocal,
+      filterEntities: {
+        byBuiltActions: filter
+      }
+    }
+    const entities = await deployActions(config, deployConfig, log)
     if (entities.actions) {
       const web = entities.actions.filter(utils.createWebExportFilter(true))
       const nonWeb = entities.actions.filter(utils.createWebExportFilter(false))

package/src/lib/log-forwarding.js

@@ -0,0 +1,267 @@
+/*
+Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License.
+*/
+
+const rtLib = require('@adobe/aio-lib-runtime')
+const { writeAio, writeEnv } = require('./import')
+const crypto = require('crypto')
+const fs = require('fs-extra')
+const path = require('path')
+
+const SECRET_FIELD_TYPE = 'password'
+const CHECKSUM_DIR = 'dist'
+const CHECKSUM_FILE = 'log-forwarding-config.sha256'
+const IGNORED_REMOTE_SETTINGS = ['updated_at']
+
+class LogForwarding {
+  constructor (aioConfig) {
+    this.aioConfig = aioConfig
+  }
+
+  async init () {
+    rtLib.utils.checkOpenWhiskCredentials({ ow: this.aioConfig.runtime })
+    this.logForwarding = await getRTLogForwarding(this.aioConfig.runtime)
+    return this
+  }
+
+  getLocalConfig () {
+    const config = this.aioConfig.project.workspace.log_forwarding
+    try {
+      return this.getConfigFromJson(config)
+    } catch (e) {
+      throw new Error('Incorrect local log forwarding configuration. ' + e.message)
+    }
+  }
+
+  getLocalConfigWithSecrets () {
+    const config = this.getLocalConfig()
+    const destination = config.getDestination()
+    const settings = config.getSettings()
+    if (config.isDefined()) {
+      const destinationSettings = this.logForwarding.getDestinationSettings(destination)
+      const missingSecrets = []
+      destinationSettings.forEach(e => {
+        if (e.type === SECRET_FIELD_TYPE) {
+          const secretVarName = getSecretVarName(destination, e.name)
+          if (process.env[secretVarName] !== undefined) {
+            settings[e.name] = process.env[secretVarName]
+          } else {
+            missingSecrets.push(secretVarName)
+          }
+        }
+      })
+      if (missingSecrets.length > 0) {
+        throw new Error('Required secrets are missing in environment variables: ' + missingSecrets.join(', ') + '. ' +
+          'Make sure these variables are set in .env file')
+      }
+    }
+    return new LogForwardingConfig(destination, settings)
+  }
+
+  async getServerConfig () {
+    try {
+      return this.getConfigFromJson(await this.logForwarding.get())
+    } catch (e) {
+      throw new Error('Incorrect log forwarding configuration on server. ' + e.message)
+    }
+  }
+
+  /**
+   * Convert JSON config to Log Forwarding object
+   *
+   * @param {object} configJson Config in JSON format
+   * @returns {LogForwardingConfig} Config
+   */
+  getConfigFromJson (configJson) {
+    let destination
+    let settings
+
+    if (configJson !== undefined && configJson !== null && !Array.isArray(configJson) && typeof configJson === 'object') {
+      const destinations = Object.keys(configJson)
+      if (destinations.length === 1) {
+        destination = destinations[0]
+        settings = configJson[destination]
+      } else {
+        throw new Error(`Configuration has ${destinations.length} destinations. Exactly one must be defined.`)
+      }
+    }
+    return new LogForwardingConfig(destination, settings)
+  }
+
+  getSupportedDestinations () {
+    return this.logForwarding.getSupportedDestinations()
+  }
+
+  getSettingsConfig (destination) {
+    return this.logForwarding.getDestinationSettings(destination)
+  }
+
+  async updateLocalConfig (lfConfig) {
+    const destination = lfConfig.getDestination()
+    const destinationSettings = this.logForwarding.getDestinationSettings(destination)
+    const projectConfig = {
+      project: this.aioConfig.project
+    }
+
+    const nonSecretSettings = {}
+    const secretSettings = {}
+
+    const settings = lfConfig.getSettings()
+    Object.keys(settings)
+      .filter(e => !IGNORED_REMOTE_SETTINGS.includes(e))
+      .forEach(k => {
+        const destFieldSettings = destinationSettings.find(i => i.name === k)
+        if (destFieldSettings.type === SECRET_FIELD_TYPE) {
+          secretSettings[getSecretVarName(destination, k)] = settings[k]
+        } else {
+          nonSecretSettings[k] = settings[k]
+        }
+      })
+
+    projectConfig.project.workspace.log_forwarding = {
+      [destination]: nonSecretSettings
+    }
+    const interactive = false
+    const merge = true
+    await writeAio(projectConfig, '', { interactive, merge })
+    await writeEnv({}, '', { interactive, merge }, secretSettings)
+  }
+
+  isLocalConfigChanged () {
+    if (fs.pathExistsSync(path.join(CHECKSUM_DIR, CHECKSUM_FILE))) {
+      const oldChecksum = fs.readFileSync(path.join(CHECKSUM_DIR, CHECKSUM_FILE)).toString()
+      const config = this.getLocalConfigWithSecrets()
+      const newChecksum = getChecksum(config)
+      return oldChecksum !== newChecksum
+    } else {
+      return true
+    }
+  }
+
+  async updateServerConfig (lfConfig) {
+    const res = await this.logForwarding.setDestination(lfConfig.getDestination(), lfConfig.getSettings())
+    const checksum = getChecksum(lfConfig)
+    fs.ensureDirSync(CHECKSUM_DIR)
+    fs.writeFile(path.join(CHECKSUM_DIR, CHECKSUM_FILE), checksum, { flags: 'w' })
+    return res
+  }
+}
+
+class LogForwardingConfig {
+  constructor (destination, settings) {
+    this.destination = destination
+    this.settings = settings
+  }
+
+  getDestination () {
+    return this.destination
+  }
+
+  getSettings () {
+    return this.settings
+  }
+
+  getMergedConfig (config) {
+    const newSettings = {}
+    Object.keys(this.settings).forEach(k => {
+      newSettings[k] = config.settings[k] !== undefined ? config.settings[k] : this.settings[k]
+    })
+    return new LogForwardingConfig(this.destination, newSettings)
+  }
+
+  isDefined () {
+    return this.destination !== undefined
+  }
+
+  isDefault () {
+    return !this.isDefined() || this.getDestination() === 'adobe_io_runtime'
+  }
+
+  isEqual (config) {
+    return (this.isDefault() && config.isDefault()) ||
+      (this.destination === config.getDestination() && shallowEqual(this.settings, config.settings))
+  }
+}
+
+/**
+ * Init Log Forwarding
+ *
+ * @param {object} aioConfig aio Config
+ * @returns {Promise<LogForwarding>} Log Forwarding
+ */
+async function init (aioConfig) {
+  const lf = new LogForwarding(aioConfig)
+  return await lf.init()
+}
+
+/**
+ * Get Runtime Log Forwarding
+ *
+ * @param {object} rtConfig Runtime config
+ * @returns {Promise<LogForwarding>} Log Forwarding
+ */
+async function getRTLogForwarding (rtConfig) {
+  const rt = await rtLib.init({
+    ...rtConfig,
+    api_key: rtConfig.auth
+  })
+  return rt.logForwarding
+}
+
+/**
+ * Compare to log forwarding configs
+ *
+ * @param {LogForwardingConfig} config1 Config
+ * @param {LogForwardingConfig} config2 Config
+ * @returns {boolean} Are configs equal
+ */
+function shallowEqual (config1, config2) {
+  // updated_at exists on server only and does not impact actual configuration
+  const keys1 = Object.keys(config1).filter(e => !IGNORED_REMOTE_SETTINGS.includes(e))
+  const keys2 = Object.keys(config2).filter(e => !IGNORED_REMOTE_SETTINGS.includes(e))
+  if (keys1.length !== keys2.length) {
+    return false
+  }
+  for (const key of keys1) {
+    if (config1[key] !== config2[key]) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * Get secret variable name for the given destination and settings field
+ *
+ * @param {string} destination Destination
+ * @param {string} fieldName Field name
+ * @returns {string} Variable name
+ */
+function getSecretVarName (destination, fieldName) {
+  return destination.toUpperCase() + '__' + fieldName.toUpperCase()
+}
+
+/**
+ * Generate checksum for the config
+ *
+ * @param {LogForwardingConfig} config Config
+ * @returns {string} Checksum
+ */
+function getChecksum (config) {
+  return crypto.createHash('sha256')
+    .update(JSON.stringify(config))
+    .digest('hex')
+}
+
+module.exports = {
+  init,
+  LogForwardingConfig
+}

package/src/lib/run-dev.js

@@ -122,7 +122,7 @@ async function runDev (config, dataDir, options = {}, log = () => {}) {
     // Deploy Phase - deploy actions
     if (withBackend) {
       log('redeploying actions..')
-      await deployActions(devConfig, isLocal, log)
+      await deployActions(devConfig, isLocal, log, true)
     }
 
     // Deploy Phase - serve the web UI

package/src/lib/vscode.js

@@ -47,7 +47,9 @@ function update (config) {
         'app-config': config,
         'env-file': config.envFile,
         'frontend-url': props.frontEndUrl,
-        'skip-prompt': true
+        'skip-prompt': true,
+        // by default yeoman runs the install, we control installation from the app plugin
+        'skip-install': true
       }
     })
     await env.runGenerator(gen)