Log Forwarding management API
Log Forwarding destination provider
This class provides methods to call your RuntimeAPI APIs.
Before calling any method initialize the instance by calling the init method on it
with valid options argument
Promise.<string>Searches for a webpack config file, starting at the action path and working towards the root of the project. Will return the first one it finds.
Promise.<object>Loads a Webpack config file from the config path provided. Sets fields required for Runtime actions. Returns an object that can be passed to the Webpack library.
Promise.<ActionBuild>Will return data about an action ready to be built.
Array.<string>Will zip actions. By default only actions which were not built before will be zipped. Last built actions data will be used to validate which action needs zipping.
Promise.<object>Runs the command
Promise.<object>Promise.<OpenwhiskClient>Returns a Promise that resolves with a new RuntimeAPI object.
objectThis patches the Openwhisk client to handle a tunneling issue with openwhisk > v3.0.0 See https://github.com/tomas/needle/issues/406
Once openwhisk.js supports the use_proxy_from_env_var option (for needle), we can remove this patch.
objectPrints action logs.
Promise.<void>Promise.<Array.<IncludeEntry>>Gets the list of files matching the patterns defined by action.include
Prints activation logs messages.
objectFilters and prints action logs.
stringreturns path to main function as defined in package.json OR default of index.js note: file MUST exist, caller's responsibility, this method will throw if it does not exist
PromiseZip a file/folder using archiver
objectreturns key value pairs in an object from the key value array supplied. Used to create parameters object.
Arrayreturns key value array from the object supplied.
objectreturns JSON.parse of passed object, but handles exceptions, and numeric strings
Arrayreturns key value array from the parameters supplied. Used to create --param and --annotation key value pairs
Arrayreturns key value array from the json file supplied. Used to create --param-file and annotation-file key value pairs
objectreturns key value pairs in an object from the parameters supplied. Used to create --param and --annotation key value pairs
objectparses a package name string and returns the namespace and entity name for a package
Arrayreturns key value array from the params and/or param-file supplied with more precendence to params.
objectreturns key value object from the params and/or param-file supplied with more precendence to params.
objectreturns key value pairs from the parameters supplied. Used to create --param-file and --annotation-file key value pairs
objectCreates an object representation of a sequence.
objectobjectCreates a union of two objects
ArrayParse a path pattern
objectProcess inputs
objectCreate a key-value object from the input
stringGet the deployment yaml file path
stringGet the manifest yaml file path
objectGet the deployment trigger inputs.
objectGet the annotations for an action
Array.<OpenWhiskEntitiesRoute>Creates an array of route definitions from the given manifest-based package. See https://github.com/apache/openwhisk-wskdeploy/blob/master/parsers/manifest_parser.go#L1187
OpenWhiskEntitiesActionCreate a sequence object that is compatible with the OpenWhisk API from a parsed manifest object
OpenWhiskEntitiesActionCreate an action object compatible with the OpenWhisk API from an action object parsed from the manifest.
objectLoad the IMS credentials from the environment variables.
object | undefinedGet the inputs for the include-ims-credentials annotation. Throws an error if the imsAuthObject is incomplete.
OpenWhiskEntitiesProcess the manifest and deployment content and returns deployment entities.
DeploymentFileComponentsGet the deployment file components.
Deploy all processed entities: can deploy packages, actions, triggers, rules and apis.
Undeploy all processed entities: can undeploy packages, actions, triggers, rules and apis. Entity definitions do not need to be complete, only the names are needed for un-deployment.
Sync a project. This is a higher level function that can be used to sync a local manifest with deployed entities.
syncProject doesn't only deploy entities it might also undeploy entities that are not
defined in the manifest. This behavior can be disabled via the deleteEntities boolean
parameter.
Promise.<OpenWhiskEntities>Get deployed entities for a managed project. This methods retrieves all the deployed
entities for a given project name or project hash. This only works if the project was
deployed using the whisk-managed annotation. This annotation can be set
pre-deployement using [addManagedProjectAnnotations](#addmanagedprojectannotations).
Note that returned apis will always be empty as they don't support annotations and hence are not managed as part of a project.
Add the whisk-managed annotation to processed entities. This is needed for syncing
managed projects.
stringCompute the project hash based on the manifest content string. This is used for syncing managed projects.
Promise.<string>Retrieve the project hash from a deployed managed project.
Promise.<string>Retrieve the project hash from a deployed managed project.
stringPath relative to the root
stringAbsolute path
Checks the existence of required openwhisk credentials
objectReturns action URLs based on the manifest config
stringJoins url path parts
stringobjectChecks the validity of nodejs version in action definition and throws an error if invalid.
booleanChecks the validity of nodejs version in action definition returns true if valid.
stringReturns the action's build file name without the .zip extension
stringReturns the action name based on the zipFile name.
Creates an info banner for an activation.
Promise.<boolean>Will dump the previously actions built data information.
Array.<string>Gets a list of the supported runtime kinds from the apihost.
PatchedHttpsProxyAgent | HttpProxyAgentGet the proxy agent for the given endpoint
objectobjectobjectobjectobjectobjectArray.<ManifestPackage>The entry point to the information read from the manifest, this can be extracted using setPaths.
objectThe manifest package definition
objectThe manifest action definition
objectobjectThe manifest sequence definition TODO: see https://github.com/apache/openwhisk-wskdeploy/blob/master/specification/html/spec_sequences.md
objectThe manifest trigger definition TODO: see https://github.com/apache/openwhisk-wskdeploy/blob/master/specification/html/spec_triggers.md
objectThe manifest rule definition TODO: see https://github.com/apache/openwhisk-wskdeploy/blob/master/specification/html/spec_rules.md
objectThe manifest dependency definition TODO
objectThe OpenWhisk entities definitions, which are compatible with the openwhisk node
client module. Can be obtained using (processpackage)[#processpackage] (with onlyNames=true for un-deployment)
objectThe api entity definition
objectThe action entity definition TODO
objectThe rule entity definition TODO
objectThe trigger entity definition TODO
objectThe package entity definition TODO
Array.<object>The entry point to the information read from the deployment file, this can be extracted using setPaths. TODO
objectPromise.<\*>
* ~~[.setAdobeIoRuntime()](#LogForwarding+setAdobeIoRuntime) ⇒ Promise.<(\*\|undefined)>~~
* ~~[.setAzureLogAnalytics(customerId, sharedKey, logType)](#LogForwarding+setAzureLogAnalytics) ⇒ Promise.<(\*\|undefined)>~~
* ~~[.setSplunkHec(host, port, index, hecToken)](#LogForwarding+setSplunkHec) ⇒ Promise.<(\*\|undefined)>~~
* [.getSupportedDestinations()](#LogForwarding+getSupportedDestinations) ⇒ Array.<object>
* [.getDestinationSettings(destination)](#LogForwarding+getDestinationSettings) ⇒ Array.<object>
* [.setDestination(destination, config)](#LogForwarding+setDestination) ⇒ Promise.<\*>
* [.getErrors()](#LogForwarding+getErrors) ⇒ object
### logForwarding.get() ⇒ Promise.<\*>
Get current Log Forwarding settings
**Kind**: instance method of [LogForwarding](#LogForwarding)
**Returns**: Promise.<\*> - response from get API
### ~~logForwarding.setAdobeIoRuntime() ⇒ Promise.<(\*\|undefined)>~~
***Deprecated***
Set Log Forwarding to Adobe I/O Runtime (default behavior)
**Kind**: instance method of [LogForwarding](#LogForwarding)
**Returns**: Promise.<(\*\|undefined)> - response from set API
### ~~logForwarding.setAzureLogAnalytics(customerId, sharedKey, logType) ⇒ Promise.<(\*\|undefined)>~~
***Deprecated***
Set Log Forwarding to Azure Log Analytics
**Kind**: instance method of [LogForwarding](#LogForwarding)
**Returns**: Promise.<(\*\|undefined)> - response from set API
| Param | Type | Description |
| --- | --- | --- |
| customerId | string | customer ID |
| sharedKey | string | shared key |
| logType | string | log type |
### ~~logForwarding.setSplunkHec(host, port, index, hecToken) ⇒ Promise.<(\*\|undefined)>~~
***Deprecated***
Set Log Forwarding to Splunk HEC
**Kind**: instance method of [LogForwarding](#LogForwarding)
**Returns**: Promise.<(\*\|undefined)> - response from set API
| Param | Type | Description |
| --- | --- | --- |
| host | string | host |
| port | string | port |
| index | string | index |
| hecToken | string | hec token |
### logForwarding.getSupportedDestinations() ⇒ Array.<object>
Get supported destinations
**Kind**: instance method of [LogForwarding](#LogForwarding)
**Returns**: Array.<object> - in format: { value: Array.<object>
Get destination settings
**Kind**: instance method of [LogForwarding](#LogForwarding)
**Returns**: Array.<object> - in format: { name: string | Destination name |
### logForwarding.setDestination(destination, config) ⇒ Promise.<\*>
Configure destination
**Kind**: instance method of [LogForwarding](#LogForwarding)
**Returns**: Promise.<\*> - response from set API
| Param | Type | Description |
| --- | --- | --- |
| destination | string | Destination name |
| config | object | value-pairs of settings, specific to the destination |
### logForwarding.getErrors() ⇒ object
Get log forwarding errors
**Kind**: instance method of [LogForwarding](#LogForwarding)
**Returns**: object - Errors in format { destination: 'Array.<object>
* [.getDestinationSettings(destination)](#LogForwardingLocalDestinationsProvider+getDestinationSettings) ⇒ Array.<object>
### logForwardingLocalDestinationsProvider.getSupportedDestinations() ⇒ Array.<object>
Get supported destinations
**Kind**: instance method of [LogForwardingLocalDestinationsProvider](#LogForwardingLocalDestinationsProvider)
**Returns**: Array.<object> - in format: { value: Array.<object>
Get destination settings
**Kind**: instance method of [LogForwardingLocalDestinationsProvider](#LogForwardingLocalDestinationsProvider)
**Returns**: Array.<object> - in format: { name: string | Destination name |
## RuntimeAPI
This class provides methods to call your RuntimeAPI APIs.
Before calling any method initialize the instance by calling the `init` method on it
with valid options argument
**Kind**: global class
### runtimeAPI.init(options) ⇒ [Promise.<OpenwhiskClient>](#OpenwhiskClient)
Initializes a RuntimeAPI object and returns it.
**Kind**: instance method of [RuntimeAPI](#RuntimeAPI)
**Returns**: [Promise.<OpenwhiskClient>](#OpenwhiskClient) - a RuntimeAPI object
| Param | Type | Description |
| --- | --- | --- |
| options | [OpenwhiskOptions](#OpenwhiskOptions) | options for initialization |
## Triggers
**Kind**: global class
* [Triggers](#Triggers)
* [new Triggers()](#new_Triggers_new)
* [.create(options)](#Triggers+create) ⇒ Promise.<object>
* [.delete(options)](#Triggers+delete) ⇒ Promise.<object>
### new Triggers()
A class to manage triggers
### triggers.create(options) ⇒ Promise.<object>
Creates a trigger and associated feeds
**Kind**: instance method of [Triggers](#Triggers)
**Returns**: Promise.<object> - the result of the create operation
| Param | Type | Description |
| --- | --- | --- |
| options | object | input options to create the trigger from manifest |
### triggers.delete(options) ⇒ Promise.<object>
Deletes a trigger and associated feeds
**Kind**: instance method of [Triggers](#Triggers)
**Returns**: Promise.<object> - the result of the delete operation
| Param | Type | Description |
| --- | --- | --- |
| options | object | options with the `name` of the trigger |
## getWebpackConfigPath(actionPath, root) ⇒ Promise.<string>
Searches for a webpack config file, starting at the action path and working
towards the root of the project. Will return the first one it finds.
**Kind**: global function
**Returns**: Promise.<string> - Webpack config file path, will be 'null' if not found
| Param | Type | Description |
| --- | --- | --- |
| actionPath | string | Path of the action |
| root | string | Root of the project |
## loadWebpackConfig(configPath, actionPath, tempBuildDir, outBuildFilename) ⇒ Promise.<object>
Loads a Webpack config file from the config path provided. Sets fields required
for Runtime actions. Returns an object that can be passed to the Webpack library.
**Kind**: global function
**Returns**: Promise.<object> - Webpack config, can be passed to the Webpack library
| Param | Type | Description |
| --- | --- | --- |
| configPath | string | Path of the Webpack config file |
| actionPath | string | Path of the action |
| tempBuildDir | string | Path of the output directory for the bundle |
| outBuildFilename | string | Name of the output file for the action |
## prepareToBuildAction(action, root, dist) ⇒ [Promise.<ActionBuild>](#ActionBuild)
Will return data about an action ready to be built.
**Kind**: global function
**Returns**: [Promise.<ActionBuild>](#ActionBuild) - Relevant data for the zip process..
| Param | Type | Description |
| --- | --- | --- |
| action | object | Data about the Action. |
| root | string | root of the project. |
| dist | string | Path to the minimized version of the action code |
## zipActions(buildsList, lastBuildsPath, distFolder) ⇒ Array.<string>
Will zip actions.
By default only actions which were not built before will be zipped.
Last built actions data will be used to validate which action needs zipping.
**Kind**: global function
**Returns**: Array.<string> - Array of zipped actions.
| Param | Type | Description |
| --- | --- | --- |
| buildsList | [Array.<ActionBuild>](#ActionBuild) | Array of data about actions available to be zipped. |
| lastBuildsPath | string | Path to the last built actions data. |
| distFolder | string | Path to the output root. |
## deployActions(config, [deployConfig], [logFunc]) ⇒ Promise.<object>
Runs the command
**Kind**: global function
**Returns**: Promise.<object> - deployedEntities
| Param | Type | Description |
| --- | --- | --- |
| config | object | app config |
| [deployConfig] | [DeployConfig](#DeployConfig) | deployment config |
| [logFunc] | object | custom logger function |
## deployWsk(scriptConfig, manifestContent, logFunc, filterEntities, useForce) ⇒ Promise.<object>
**Kind**: global function
**Returns**: Promise.<object> - deployedEntities
| Param | Type | Description |
| --- | --- | --- |
| scriptConfig | object | config |
| manifestContent | object | manifest |
| logFunc | object | custom logger function |
| filterEntities | object | entities (actions, sequences, triggers, rules etc) to be filtered |
| useForce | boolean | force deploy of actions |
### deployWsk~\_filterOutPackageEntity(pkgName, pkgEntity, filterItems, fullNameCheck) ⇒ object
**Kind**: inner method of [deployWsk](#deployWsk)
**Returns**: object - package object containing only the filterItems
| Param | Type | Description |
| --- | --- | --- |
| pkgName | object | name of the package |
| pkgEntity | object | package object from the manifest |
| filterItems | object | items (actions, sequences, triggers, rules etc) to be filtered |
| fullNameCheck | boolean | true if the items are part of packages (actions and sequences) |
## init(options) ⇒ [Promise.<OpenwhiskClient>](#OpenwhiskClient)
Returns a Promise that resolves with a new RuntimeAPI object.
**Kind**: global function
**Returns**: [Promise.<OpenwhiskClient>](#OpenwhiskClient) - a Promise with a RuntimeAPI object
| Param | Type | Description |
| --- | --- | --- |
| options | [OpenwhiskOptions](#OpenwhiskOptions) | options for initialization |
## patchOWForTunnelingIssue(ow, use_proxy_from_env_var) ⇒ object
This patches the Openwhisk client to handle a tunneling issue with openwhisk > v3.0.0
See https://github.com/tomas/needle/issues/406
Once openwhisk.js supports the use_proxy_from_env_var option (for needle), we can remove this patch.
**Kind**: global function
**Returns**: object - the patched openwhisk object
| Param | Type | Description |
| --- | --- | --- |
| ow | object | the Openwhisk object to patch |
| use_proxy_from_env_var | boolean | the needle option to add |
## printActionLogs(config, logger, limit, filterActions, strip, tail, fetchLogsInterval, startTime) ⇒ object
Prints action logs.
**Kind**: global function
**Returns**: object - activation timestamp of the last retrieved activation or null
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| config | object | | openwhisk config |
| logger | object | | an instance of a logger to emit messages to |
| limit | number | | maximum number of activations to fetch logs from |
| filterActions | Array | | array of actions to fetch logs from examples:- ['pkg1/'] = logs of all deployed actions under package pkg1 ['pkg1/action'] = logs of action 'action' under package 'pkg1' [] = logs of all actions in the namespace |
| strip | boolean | | if true, strips the timestamp which prefixes every log line |
| tail | boolean | false | if true, logs are fetched continuously |
| fetchLogsInterval | number | 10000 | number of seconds to wait before fetching logs again when tail is set to true |
| startTime | number | | time in milliseconds. Only logs after this time will be fetched |
## undeployActions(config, [logFunc])
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| config | object | app config |
| [logFunc] | object | custom logger function |
## undeployWsk(packageName, manifestContent, owOptions, logger) ⇒ Promise.<void>
**Kind**: global function
**Returns**: Promise.<void> - void
| Param | Type | Description |
| --- | --- | --- |
| packageName | string | name of the package to be undeployed |
| manifestContent | object | manifest |
| owOptions | object | openwhisk options |
| logger | object | custom logger function |
## getIncludesForAction(action) ⇒ Promise.<Array.<IncludeEntry>>
Gets the list of files matching the patterns defined by action.include
**Kind**: global function
**Returns**: Promise.<Array.<IncludeEntry>> - list of files matching the patterns defined by action.include
| Param | Type | Description |
| --- | --- | --- |
| action | [ManifestAction](#ManifestAction) | action object from manifest which defines includes |
## printLogs(activation, strip, logger)
Prints activation logs messages.
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| activation | object | the activation |
| strip | boolean | if true, strips the timestamp which prefixes every log line |
| logger | object | an instance of a logger to emit messages to |
## printFilteredActionLogs(runtime, logger, limit, filterActions, strip, startTime) ⇒ object
Filters and prints action logs.
**Kind**: global function
**Returns**: object - activation timestamp of the last retrieved activation or null
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| runtime | object | | runtime (openwhisk) object |
| logger | object | | an instance of a logger to emit messages to (may optionally provide logFunc and bannerFunc to customize logging) |
| limit | number | | maximum number of activations to fetch logs from |
| filterActions | Array | | array of actions to fetch logs from ['pkg1/'] = logs of all deployed actions under package pkg1 ['pkg1/action'] = logs of action 'action' under package 'pkg1' [] = logs of all actions in the namespace |
| strip | boolean | false | if true, strips the timestamp which prefixes every log line |
| startTime | number | 0 | time in milliseconds. Only logs after this time will be fetched |
* [printFilteredActionLogs(runtime, logger, limit, filterActions, strip, startTime)](#printFilteredActionLogs) ⇒ object
* [~isSequenceActivation(activation)](#printFilteredActionLogs..isSequenceActivation) ⇒ boolean
* [~printActivationLogs(activation, runtime)](#printFilteredActionLogs..printActivationLogs)
* [~printSequenceLogs(activation, runtime)](#printFilteredActionLogs..printSequenceLogs)
* [~printLogs(activation, runtime)](#printFilteredActionLogs..printLogs)
### printFilteredActionLogs~isSequenceActivation(activation) ⇒ boolean
Check if an activation entry is for a sequence.
**Kind**: inner method of [printFilteredActionLogs](#printFilteredActionLogs)
**Returns**: boolean - isSequenceActivation
| Param | Type | Description |
| --- | --- | --- |
| activation | \* | activation log entry |
### printFilteredActionLogs~printActivationLogs(activation, runtime)
Print activation logs
**Kind**: inner method of [printFilteredActionLogs](#printFilteredActionLogs)
| Param | Type | Description |
| --- | --- | --- |
| activation | object | activation object |
| runtime | object | runtime object |
### printFilteredActionLogs~printSequenceLogs(activation, runtime)
Print sequence logs
**Kind**: inner method of [printFilteredActionLogs](#printFilteredActionLogs)
| Param | Type | Description |
| --- | --- | --- |
| activation | object | sequence activation |
| runtime | object | runtime object |
### printFilteredActionLogs~printLogs(activation, runtime)
Print logs
**Kind**: inner method of [printFilteredActionLogs](#printFilteredActionLogs)
| Param | Type | Description |
| --- | --- | --- |
| activation | object | activation |
| runtime | object | runtime |
## getActionEntryFile(pkgJsonPath) ⇒ string
returns path to main function as defined in package.json OR default of index.js
note: file MUST exist, caller's responsibility, this method will throw if it does not exist
**Kind**: global function
**Returns**: string - path to the entry file
| Param | Type | Description |
| --- | --- | --- |
| pkgJsonPath | string | : path to a package.json file |
## zip(filePath, out, pathInZip) ⇒ Promise
Zip a file/folder using archiver
**Kind**: global function
**Returns**: Promise - returns with a blank promise when done
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| filePath | string | | path of file.folder to zip |
| out | string | | output path |
| pathInZip | boolean | false | internal path in zip |
## createKeyValueObjectFromArray(inputsArray) ⇒ object
returns key value pairs in an object from the key value array supplied. Used to create parameters object.
**Kind**: global function
**Returns**: object - An object of key value pairs in this format : {Your key1 : 'Your Value 1' , Your key2: 'Your value 2'}
| Param | Type | Description |
| --- | --- | --- |
| inputsArray | Array | Array in the form of [{'key':'key1', 'value': 'value1'}] |
## createKeyValueArrayFromObject(object) ⇒ Array
returns key value array from the object supplied.
**Kind**: global function
**Returns**: Array - An array of key value pairs in this format : [{key : 'Your key 1' , value: 'Your value 1'}, {key : 'Your key 2' , value: 'Your value 2'} ]
| Param | Type | Description |
| --- | --- | --- |
| object | object | JSON object |
## safeParse(val) ⇒ object
returns JSON.parse of passed object, but handles exceptions, and numeric strings
**Kind**: global function
**Returns**: object - the parsed object
| Param | Type | Description |
| --- | --- | --- |
| val | string | value to parse |
## createKeyValueArrayFromFlag(flag) ⇒ Array
returns key value array from the parameters supplied. Used to create --param and --annotation key value pairs
**Kind**: global function
**Returns**: Array - An array of key value pairs in this format : [{key : 'Your key 1' , value: 'Your value 1'}, {key : 'Your key 2' , value: 'Your value 2'} ]
| Param | Type | Description |
| --- | --- | --- |
| flag | Array | value from flags.param or flags.annotation |
## createKeyValueArrayFromFile(file) ⇒ Array
returns key value array from the json file supplied. Used to create --param-file and annotation-file key value pairs
**Kind**: global function
**Returns**: Array - An array of key value pairs in this format : [{key : 'Your key 1' , value: 'Your value 1'}, {key : 'Your key 2' , value: 'Your value 2'} ]
| Param | Type | Description |
| --- | --- | --- |
| file | string | from flags['param-file'] or flags['annotation-file] |
## createKeyValueObjectFromFlag(flag) ⇒ object
returns key value pairs in an object from the parameters supplied. Used to create --param and --annotation key value pairs
**Kind**: global function
**Returns**: object - An object of key value pairs in this format : {Your key1 : 'Your Value 1' , Your key2: 'Your value 2'}
| Param | Type | Description |
| --- | --- | --- |
| flag | Array | from flags.param or flags.annotation |
## parsePackageName(name) ⇒ object
parses a package name string and returns the namespace and entity name for a package
**Kind**: global function
**Returns**: object - An object { namespace: string, name: string }
| Param | Type | Description |
| --- | --- | --- |
| name | string | package name |
## getKeyValueArrayFromMergedParameters(params, paramFilePath) ⇒ Array
returns key value array from the params and/or param-file supplied with more precendence to params.
**Kind**: global function
**Returns**: Array - An array of key value pairs in this format : [{key : 'Your key 1' , value: 'Your value 1'}, {key : 'Your key 2' , value: 'Your value 2'} ]
| Param | Type | Description |
| --- | --- | --- |
| params | Array | from flags.param or flags.annotation |
| paramFilePath | string | from flags['param-file'] or flags['annotation-file'] |
## getKeyValueObjectFromMergedParameters(params, paramFilePath) ⇒ object
returns key value object from the params and/or param-file supplied with more precendence to params.
**Kind**: global function
**Returns**: object - An object of key value pairs in this format : {Your key1 : 'Your Value 1' , Your key2: 'Your value 2'}
| Param | Type | Description |
| --- | --- | --- |
| params | Array | from flags.param or flags.annotation |
| paramFilePath | string | from flags['param-file'] or flags['annotation-file'] |
## createKeyValueObjectFromFile(file) ⇒ object
returns key value pairs from the parameters supplied. Used to create --param-file and --annotation-file key value pairs
**Kind**: global function
**Returns**: object - An object of key value pairs in this format : {Your key1 : 'Your Value 1' , Your key2: 'Your value 2'}
| Param | Type | Description |
| --- | --- | --- |
| file | string | from flags['param-file'] or flags['annotation-file'] |
## createComponentsFromSequence(sequenceAction) ⇒ object
Creates an object representation of a sequence.
**Kind**: global function
**Returns**: object - the object representation of the sequence
| Param | Type | Description |
| --- | --- | --- |
| sequenceAction | Array | the sequence action array |
## ~~createComponentsFromSequence(sequenceAction) ⇒ object~~
***Deprecated***
**Kind**: global function
**Returns**: object - the object representation of the sequence
| Param | Type | Description |
| --- | --- | --- |
| sequenceAction | Array | the sequence action array |
## returnUnion(firstObject, secondObject) ⇒ object
Creates a union of two objects
**Kind**: global function
**Returns**: object - the union of both objects
| Param | Type | Description |
| --- | --- | --- |
| firstObject | object | the object to merge into |
| secondObject | object | the object to merge from |
## parsePathPattern(path) ⇒ Array
Parse a path pattern
**Kind**: global function
**Returns**: Array - array of matches
| Param | Type | Description |
| --- | --- | --- |
| path | string | the path to parse |
## processInputs(input, params) ⇒ object
Process inputs
**Kind**: global function
**Returns**: object - the processed inputs
| Param | Type | Description |
| --- | --- | --- |
| input | object | the input object to process |
| params | object | the parameters for the input to process |
## createKeyValueInput(input) ⇒ object
Create a key-value object from the input
**Kind**: global function
**Returns**: object - the processed input as a key-value object
| Param | Type | Description |
| --- | --- | --- |
| input | object | the input to process |
## getDeploymentPath() ⇒ string
Get the deployment yaml file path
**Kind**: global function
**Returns**: string - the deployment yaml path
## getManifestPath() ⇒ string
Get the manifest yaml file path
**Kind**: global function
**Returns**: string - the manifest yaml path
## returnDeploymentTriggerInputs(deploymentPackages) ⇒ object
Get the deployment trigger inputs.
**Kind**: global function
**Returns**: object - the deployment trigger inputs
| Param | Type | Description |
| --- | --- | --- |
| deploymentPackages | [DeploymentPackages](#DeploymentPackages) | the deployment packages |
## returnAnnotations(action) ⇒ object
Get the annotations for an action
**Kind**: global function
**Returns**: object - the action annotation entities
| Param | Type | Description |
| --- | --- | --- |
| action | [ManifestAction](#ManifestAction) | the action manifest object |
## createApiRoutes(pkg, pkgName, apiName, allowedActions, allowedSequences, pathOnly) ⇒ [Array.<OpenWhiskEntitiesRoute>](#OpenWhiskEntitiesRoute)
Creates an array of route definitions from the given manifest-based package.
See https://github.com/apache/openwhisk-wskdeploy/blob/master/parsers/manifest_parser.go#L1187
**Kind**: global function
**Returns**: [Array.<OpenWhiskEntitiesRoute>](#OpenWhiskEntitiesRoute) - the array of route entities
| Param | Type | Description |
| --- | --- | --- |
| pkg | [ManifestPackage](#ManifestPackage) | The package definition from the manifest. |
| pkgName | string | The name of the package. |
| apiName | string | The name of the HTTP API definition from the manifest. |
| allowedActions | Array | List of action names allowed to be used in routes. |
| allowedSequences | Array | List of sequence names allowed to be used in routes. |
| pathOnly | boolean | Skip action, method and response type in route definitions. |
## createSequenceObject(fullName, manifestSequence, packageName) ⇒ [OpenWhiskEntitiesAction](#OpenWhiskEntitiesAction)
Create a sequence object that is compatible with the OpenWhisk API from a parsed manifest object
**Kind**: global function
**Returns**: [OpenWhiskEntitiesAction](#OpenWhiskEntitiesAction) - a sequence object describing the action entity
| Param | Type | Description |
| --- | --- | --- |
| fullName | string | the full sequence name prefixed with the package, e.g. `pkg/sequence` |
| manifestSequence | [ManifestSequence](#ManifestSequence) | a sequence object as defined in a valid manifest file |
| packageName | string | the package name of the sequence, which will be set to for actions in the sequence |
## createActionObject(fullName, manifestAction) ⇒ [OpenWhiskEntitiesAction](#OpenWhiskEntitiesAction)
Create an action object compatible with the OpenWhisk API from an action object parsed from the manifest.
**Kind**: global function
**Returns**: [OpenWhiskEntitiesAction](#OpenWhiskEntitiesAction) - the action entity object
| Param | Type | Description |
| --- | --- | --- |
| fullName | string | the full action name prefixed with the package, e.g. `pkg/action` |
| manifestAction | [ManifestAction](#ManifestAction) | the action object as parsed from the manifest |
## loadIMSCredentialsFromEnv() ⇒ object
Load the IMS credentials from the environment variables.
**Kind**: global function
**Returns**: object - the IMS auth object
## getIncludeIMSCredentialsAnnotationInputs(thisAction, imsAuthObject) ⇒ object \| undefined
Get the inputs for the include-ims-credentials annotation.
Throws an error if the imsAuthObject is incomplete.
**Kind**: global function
**Returns**: object \| undefined - the inputs or undefined with a warning
| Param | Type | Description |
| --- | --- | --- |
| thisAction | object | the action to process |
| imsAuthObject | object | the IMS auth object |
## processPackage(packages, deploymentPackages, deploymentTriggers, params, [namesOnly], [owOptions]) ⇒ [OpenWhiskEntities](#OpenWhiskEntities)
Process the manifest and deployment content and returns deployment entities.
**Kind**: global function
**Returns**: [OpenWhiskEntities](#OpenWhiskEntities) - deployment entities
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| packages | [ManifestPackages](#ManifestPackages) | | the manifest packages |
| deploymentPackages | [DeploymentPackages](#DeploymentPackages) | | the deployment packages |
| deploymentTriggers | object | | the deployment triggers |
| params | object | | the package params |
| [namesOnly] | boolean | false | if false, set the namespaces as well |
| [owOptions] | object | | additional OpenWhisk options |
## setPaths(flags) ⇒ [DeploymentFileComponents](#DeploymentFileComponents)
Get the deployment file components.
**Kind**: global function
**Returns**: [DeploymentFileComponents](#DeploymentFileComponents) - fileComponents
| Param | Type | Description |
| --- | --- | --- |
| flags | object | (manifest + deployment) |
## deployPackage(entities, ow, logger, imsOrgId)
Deploy all processed entities: can deploy packages, actions, triggers, rules and apis.
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| entities | [OpenWhiskEntitiesAction](#OpenWhiskEntitiesAction) | the processed entities |
| ow | object | the OpenWhisk client |
| logger | object | the logger |
| imsOrgId | string | the IMS Org ID |
## undeployPackage(entities, ow, logger)
Undeploy all processed entities: can undeploy packages, actions, triggers, rules and apis.
Entity definitions do not need to be complete, only the names are needed for un-deployment.
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| entities | object | the processed entities, only names are enough for undeploy |
| ow | object | the OpenWhisk object |
| logger | object | the logger |
## syncProject(projectName, manifestPath, manifestContent, entities, ow, logger, imsOrgId, deleteEntities)
Sync a project. This is a higher level function that can be used to sync a local
manifest with deployed entities.
`syncProject` doesn't only deploy entities it might also undeploy entities that are not
defined in the manifest. This behavior can be disabled via the `deleteEntities` boolean
parameter.
**Kind**: global function
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| projectName | string | | the project name |
| manifestPath | string | | the manifest path |
| manifestContent | string | | the manifest content, needed to compute hash |
| entities | [OpenWhiskEntities](#OpenWhiskEntities) | | the entities, extracted via `processPackage` |
| ow | object | | the OpenWhisk object |
| logger | object | | the logger |
| imsOrgId | string | | the IMS Org ID |
| deleteEntities | boolean | true | set to true to delete entities |
## getProjectEntities(project, isProjectHash, ow) ⇒ [Promise.<OpenWhiskEntities>](#OpenWhiskEntities)
Get deployed entities for a managed project. This methods retrieves all the deployed
entities for a given project name or project hash. This only works if the project was
deployed using the `whisk-managed` annotation. This annotation can be set
pre-deployement using `[addManagedProjectAnnotations](#addmanagedprojectannotations)`.
Note that returned apis will always be empty as they don't support annotations and
hence are not managed as part of a project.
**Kind**: global function
**Returns**: [Promise.<OpenWhiskEntities>](#OpenWhiskEntities) - the deployed project entities
| Param | Type | Description |
| --- | --- | --- |
| project | string | the project name or hash |
| isProjectHash | boolean | set to true if the project is a hash, and not the name |
| ow | object | the OpenWhisk client object |
## addManagedProjectAnnotations(entities, manifestPath, projectName, projectHash)
Add the `whisk-managed` annotation to processed entities. This is needed for syncing
managed projects.
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| entities | [OpenWhiskEntities](#OpenWhiskEntities) | the processed entities |
| manifestPath | string | the manifest path |
| projectName | string | the project name |
| projectHash | string | the project hash |
## getProjectHash(manifestContent) ⇒ string
Compute the project hash based on the manifest content string. This is used
for syncing managed projects.
**Kind**: global function
**Returns**: string - the project hash
| Param | Type | Description |
| --- | --- | --- |
| manifestContent | string | the manifest content |
## findProjectHashOnServer(ow, projectName) ⇒ Promise.<string>
Retrieve the project hash from a deployed managed project.
**Kind**: global function
**Returns**: Promise.<string> - the project hash, or '' if not found
| Param | Type | Description |
| --- | --- | --- |
| ow | object | the OpenWhisk client object |
| projectName | string | the project name |
## ~~findProjectHashOnServer(ow, projectName) ⇒ Promise.<string>~~
***Deprecated***
Retrieve the project hash from a deployed managed project.
**Kind**: global function
**Returns**: Promise.<string> - the project hash, or '' if not found
| Param | Type | Description |
| --- | --- | --- |
| ow | object | the OpenWhisk client object |
| projectName | string | the project name |
## \_relApp(root, p) ⇒ string
Path relative to the root
**Kind**: global function
**Returns**: string - relative path
| Param | Type | Description |
| --- | --- | --- |
| root | string | root path |
| p | string | path |
## \_absApp(root, p) ⇒ string
Absolute path
**Kind**: global function
**Returns**: string - absolute path
| Param | Type | Description |
| --- | --- | --- |
| root | string | root path |
| p | string | path |
## checkOpenWhiskCredentials(config)
Checks the existence of required openwhisk credentials
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| config | object | openwhisk config |
## getActionUrls(appConfig, isRemoteDev, _isLocalDev, legacy) ⇒ object
Returns action URLs based on the manifest config
**Kind**: global function
**Returns**: object - urls of actions
| Param | Type | Default | Description |
| --- | --- | --- | --- |
| appConfig | object | | app config |
| isRemoteDev | boolean | false | remote dev |
| _isLocalDev | boolean | false | local dev UNUSED |
| legacy | boolean | false | default false add backwards compatibility for urls keys. |
## urlJoin(...args) ⇒ string
Joins url path parts
**Kind**: global function
**Returns**: string - joined url
| Param | Type | Description |
| --- | --- | --- |
| ...args | string | url parts |
## removeProtocolFromURL(url) ⇒ string
**Kind**: global function
**Returns**: string - url
| Param | Type | Description |
| --- | --- | --- |
| url | string | url |
## replacePackagePlaceHolder(config) ⇒ object
**Kind**: global function
**Returns**: object - sanitized config
| Param | Type | Description |
| --- | --- | --- |
| config | object | config |
## ~~validateActionRuntime(action)~~
***Deprecated***
Checks the validity of nodejs version in action definition and throws an error if invalid.
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| action | object | action object |
## isSupportedActionKind(action) ⇒ boolean
Checks the validity of nodejs version in action definition returns true if valid.
**Kind**: global function
**Returns**: boolean - true if action kind is supported
| Param | Type | Description |
| --- | --- | --- |
| action | object | action object |
## getActionZipFileName(pkgName, actionName, defaultPkg) ⇒ string
Returns the action's build file name without the .zip extension
**Kind**: global function
**Returns**: string - name of zip file for the action contents
| Param | Type | Description |
| --- | --- | --- |
| pkgName | string | name of the package |
| actionName | string | name of the action |
| defaultPkg | boolean | true if pkgName is the default/first package |
## getActionNameFromZipFile(zipFile) ⇒ string
Returns the action name based on the zipFile name.
**Kind**: global function
**Returns**: string - name of the action or empty string.
| Param | Type | Description |
| --- | --- | --- |
| zipFile | string | name of the zip file |
## activationLogBanner(logFunc, activation, activationLogs)
Creates an info banner for an activation.
**Kind**: global function
| Param | Type | Description |
| --- | --- | --- |
| logFunc | object | custom logger function |
| activation | object | activation metadata |
| activationLogs | Array.<string> | the logs of the activation (may selectively suppress banner if there are no log lines) |
## dumpActionsBuiltInfo(lastBuiltActionsPath, actionBuildData, prevBuildData) ⇒ Promise.<boolean>
Will dump the previously actions built data information.
**Kind**: global function
**Returns**: Promise.<boolean> - If the contentHash already belongs to the deploymentLogs file
| Param | Type | Description |
| --- | --- | --- |
| lastBuiltActionsPath | string | Path to the deployments logs |
| actionBuildData | object | Object which contains action name and contentHash. |
| prevBuildData | object | Object which contains info about all the previously built actions |
## getSupportedServerRuntimes(apihost) ⇒ Array.<string>
Gets a list of the supported runtime kinds from the apihost.
**Kind**: global function
**Returns**: Array.<string> - a list of runtime kinds supported by the runtime apihost
| Param | Type | Description |
| --- | --- | --- |
| apihost | string | the URL of the runtime apihost |
## getProxyAgent(endpoint, proxyUrl, proxyOptions) ⇒ PatchedHttpsProxyAgent \| HttpProxyAgent
Get the proxy agent for the given endpoint
**Kind**: global function
**Returns**: PatchedHttpsProxyAgent \| HttpProxyAgent - - The proxy agent
| Param | Type | Description |
| --- | --- | --- |
| endpoint | string | The endpoint to get the proxy agent for |
| proxyUrl | string | The proxy URL to use |
| proxyOptions | object | The proxy options to use |
## ActionBuild : object
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| actionName | string | The name of the action |
| buildHash | object | Map with key as the name of the action and value its contentHash |
| legacy | boolean | Indicate legacy action support |
| tempBuildDir | string | path of temp build |
| tempActionName | string | name of the action file. |
| outPath | string | zip output path |
## FilterEntities : object
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [actions] | Array | filter list of actions to deploy by provided array, e.g. ['name1', ..] |
| [byBuiltActions] | boolean | if true, trim actions from the manifest based on the already built actions |
| [sequences] | Array | filter list of sequences to deploy, e.g. ['name1', ..] |
| [triggers] | Array | filter list of triggers to deploy, e.g. ['name1', ..] |
| [rules] | Array | filter list of rules to deploy, e.g. ['name1', ..] |
| [apis] | Array | filter list of apis to deploy, e.g. ['name1', ..] |
| [dependencies] | Array | filter list of package dependencies to deploy, e.g. ['name1', ..] |
## DeployConfig : object
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [filterEntities] | [FilterEntities](#FilterEntities) | add filters to deploy only specified OpenWhisk entities |
| [useForce] | boolean | force deploy of actions |
## OpenwhiskOptions : object
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| apihost | string | Hostname and optional port for openwhisk platform |
| api_key | string | Authorisation key |
| [api] | string | Full API URL |
| [apiversion] | string | Api version |
| [namespace] | string | Namespace for resource requests |
| [ignore_certs] | boolean | Turns off server SSL/TLS certificate verification |
| [key] | string | Client key to use when connecting to the apihost |
| [retry] | [OpenwhiskRetryOptions](#OpenwhiskRetryOptions) | the retry options. Defaults to 2 retries, with a 200ms minTimeout. |
## OpenwhiskRetryOptions : object
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| retries | number | the number of retries for an OpenWhisk call |
| minTimeout | number | the minimum number of milliseconds to wait before a retry |
## OpenwhiskClient : object
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| actions | ow.Actions | actions |
| activations | ow.Activations | activations |
| namespaces | ow.Namespaces | namespaces |
| packages | ow.Packages | packages |
| rules | ow.Rules | rules |
| triggers | ow.Triggers | triggers |
| routes | ow.Routes | routes |
| logForwarding | [LogForwarding](#LogForwarding) | Log Forwarding management API |
## ManifestPackages : [Array.<ManifestPackage>](#ManifestPackage)
The entry point to the information read from the manifest, this can be extracted using
[setPaths](#setpaths).
**Kind**: global typedef
## ManifestPackage : object
The manifest package definition
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| version | string | the manifest package version |
| [license] | string | the manifest package license, e.g. Apache-2.0 |
| [actions] | [Array.<ManifestAction>](#ManifestAction) | Actions in the manifest package |
| [sequences] | [Array.<ManifestSequence>](#ManifestSequence) | Sequences in the manifest package |
| [triggers] | [Array.<ManifestTrigger>](#ManifestTrigger) | Triggers in the manifest package |
| [rules] | [Array.<ManifestRule>](#ManifestRule) | Rules in the manifest package |
| [dependencies] | [Array.<ManifestDependency>](#ManifestDependency) | Dependencies in the manifest package |
| [apis] | Array.<object> | Apis in the manifest package |
## ManifestAction : object
The manifest action definition
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [version] | string | the manifest action version |
| function | string | the path to the action code |
| runtime | string | the runtime environment or kind in which the action executes, e.g. 'nodejs:18' |
| [main] | string | the entry point to the function |
| [inputs] | object | the list of action default parameters |
| [limits] | Array.<object> | limits for the action |
| [web] | string | indicate if an action should be exported as web, can take the value of: true | false | yes | no | raw |
| [raw-http] | boolean | indicate if an action should be exported as raw web action, this option is only valid if `web` or `web-export` is set to true |
| [docker] | string | the docker container to run the action into |
| [annotations] | Array.<object> | the manifest action annotations |
## IncludeEntry : object
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| dest | string | destination for included files |
| sources | Array | list of files that matched pattern |
## ManifestSequence : object
The manifest sequence definition
TODO: see https://github.com/apache/openwhisk-wskdeploy/blob/master/specification/html/spec_sequences.md
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| actions | string | Comma separated list of actions in the sequence |
## ManifestTrigger : object
The manifest trigger definition
TODO: see https://github.com/apache/openwhisk-wskdeploy/blob/master/specification/html/spec_triggers.md
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [inputs] | object | inputs like cron and trigger_payload |
| [feed] | string | feed associated with the trigger. |
| [annotations] | object | annotations |
## ManifestRule : object
The manifest rule definition
TODO: see https://github.com/apache/openwhisk-wskdeploy/blob/master/specification/html/spec_rules.md
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| trigger | string | trigger name |
| action | string | action name |
## ManifestDependency : object
The manifest dependency definition
TODO
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| location | string | package to bind to |
| [inputs] | object | package parameters |
## OpenWhiskEntities : object
The OpenWhisk entities definitions, which are compatible with the `openwhisk` node
client module. Can be obtained using (processpackage)[#processpackage] (with `onlyNames=true` for un-deployment)
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| apis | [Array.<OpenWhiskEntitiesRoute>](#OpenWhiskEntitiesRoute) | the array of route entities |
| actions | [Array.<OpenWhiskEntitiesAction>](#OpenWhiskEntitiesAction) | the array of action entities |
| triggers | [Array.<OpenWhiskEntitiesTrigger>](#OpenWhiskEntitiesTrigger) | the array of trigger entities |
| rules | [Array.<OpenWhiskEntitiesRule>](#OpenWhiskEntitiesRule) | the array of rule entities |
| pkgAndDeps | [Array.<OpenWhiskEntitiesPackage>](#OpenWhiskEntitiesPackage) | the array of package entities |
## OpenWhiskEntitiesRoute : object
The api entity definition
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| name | string | the api name |
| basepath | string | the api basepath |
| relpath | string | the api relpath |
| action | string | the action name behind the api |
| responsettype | string | the response type, e.g. 'json' |
| operation | string | the http method, e.g 'get' |
## OpenWhiskEntitiesAction : object
The action entity definition
TODO
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| action | string | blank |
| name | string | name |
| exec | object | exec object |
## OpenWhiskEntitiesRule : object
The rule entity definition
TODO
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| trigger | string | trigger name |
| action | string | action name |
## OpenWhiskEntitiesTrigger : object
The trigger entity definition
TODO
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [feed] | string | feed associated with the trigger |
| [annotations] | object | annotations |
| [parameters] | object | parameters |
## OpenWhiskEntitiesPackage : object
The package entity definition
TODO
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| [publish] | boolean | true for shared package |
| [parameters] | object | parameters |
## DeploymentPackages : Array.<object>
The entry point to the information read from the deployment file, this can be extracted using
[setPaths](#setpaths).
TODO
**Kind**: global typedef
## DeploymentFileComponents : object
**Kind**: global typedef
**Properties**
| Name | Type | Description |
| --- | --- | --- |
| packages | [ManifestPackages](#ManifestPackages) | Packages in the manifest |
| deploymentTriggers | object | Trigger names and their inputs in the deployment manifest |
| deploymentPackages | [DeploymentPackages](#DeploymentPackages) | Packages in the deployment manifest |
| manifestPath | string | Path to manifest |
| manifestContent | object | Parsed manifest object |
| projectName | string | Name of the project |
## Insecure Connection
```bash
NODE_TLS_REJECT_UNAUTHORIZED=0