@itentialopensource/adapter-aws_cloudformation/adapter.js

This adapter integrates with system described as: Aws_cloudformation.

/* @copyright Itential, LLC 2019 (pre-modifications) */

/* eslint import/no-dynamic-require: warn */
/* eslint object-curly-newline: warn */
/* eslint no-underscore-dangle: warn  */
/* eslint camelcase: warn  */
/* eslint no-param-reassign: warn  */

// Set globals
/* global log */

/* Required libraries.  */
const path = require('path');

const callOptions = {
  service: 'cloudformation',
  datatype: {
    request: 'URLENCODE',
    response: 'XML2JSON'
  }
};
const authMethod = 'aws_authentication';

/* Fetch in the other needed components for the this Adaptor */
const AdapterBaseCl = require(path.join(__dirname, 'adapterBase.js'));

/*
 * INTERNAL FUNCTION: return stub results based on the path and method
 */
function processInArray(inArray, currentParams, key) {
  if (!inArray || !Array.isArray(inArray) || inArray.length === 0) {
    return;
  }

  // Go through the array to convert the items in it
  for (let i = 0; i < inArray.length; i += 1) {
    // are we dealing with just data
    if (typeof inArray[i] === 'string' || typeof inArray[i] === 'number' || typeof inArray[i] === 'boolean') {
      currentParams[`${key}.member.${i + 1}`] = inArray[i];
    } else if (typeof inArray[i] === 'object') {
      // got an object - need to add keys and values
      const objKeys = Object.keys(inArray[i]);

      for (let o = 0; o < objKeys.length; o += 1) {
        const thisKey = objKeys[o]; // Assume we get from data with proper casing
        const thisValue = inArray[i][objKeys[o]];

        if (Array.isArray(thisValue)) {
          processInArray(thisValue, currentParams, `${key}.member.${i + 1}.${thisKey}`);
        } else {
          currentParams[`${key}.member.${i + 1}.${thisKey}`] = thisValue;
        }
      }
    }
  }
}

/**
 * This is the adapter/interface into AwsCloudFormation
 */

/* GENERAL ADAPTER FUNCTIONS */
class AwsCloudFormation extends AdapterBaseCl {
  /**
   * AwsCloudFormation Adapter
   * @constructor
   */
  constructor(prongid, properties) {
    // make sure properties are set - so that we do not break
    const myProperties = properties;

    // service should exist and be ec2
    if (myProperties && !myProperties.service) {
      myProperties.service = callOptions.service;
    }
    // auth_method should now be aws_authentication
    if (myProperties && myProperties.authentication && (!myProperties.authentication.auth_method
       || myProperties.authentication.auth_method === 'no_authentication')) {
      myProperties.authentication.auth_method = authMethod;
    }

    // Instantiate the AdapterBase super class
    super(prongid, myProperties);

    /*
    const restFunctionNames = this.getWorkflowFunctions();

    // Dynamically bind emit functions
    for (let i = 0; i < restFunctionNames.length; i += 1) {
      // Bind function to have name fnNameEmit for fnName
      const version = restFunctionNames[i].match(/__v[0-9]+/);
      const baseFnName = restFunctionNames[i].replace(/__v[0-9]+/, '');
      const fnNameEmit = version ? `${baseFnName}Emit${version}` : `${baseFnName}Emit`;
      this[fnNameEmit] = function (...args) {
        // extract the callback
        const callback = args[args.length - 1];
        // slice the callback from args so we can insert our own
        const functionArgs = args.slice(0, args.length - 1);
        // create a random name for the listener
        const eventName = `${restFunctionNames[i]}:${Math.random().toString(36)}`;
        // tell the calling class to start listening
        callback({ event: eventName, status: 'received' });
        // store parent for use of this context later
        const parent = this;
        // store emission function
        const func = function (val, err) {
          parent.removeListener(eventName, func);
          parent.emit(eventName, val, err);
        };
        // Use apply to call the function in a specific context
        this[restFunctionNames[i]].apply(this, functionArgs.concat([func])); // eslint-disable-line prefer-spread
      };
    }

    // Uncomment if you have things to add to the constructor like using your own properties.
    // Otherwise the constructor in the adapterBase will be used.
    // Capture my own properties - they need to be defined in propertiesSchema.json
    // if (this.allProps && this.allProps.myownproperty) {
    //   mypropvariable = this.allProps.myownproperty;
    // }
    */
  }

  /**
   * @callback healthCallback
   * @param {Object} reqObj - the request to send into the healthcheck
   * @param {Callback} callback - The results of the call
   */
  healthCheck(reqObj, callback) {
    // you can modify what is passed into the healthcheck by changing things in the newReq
    let newReq = null;
    if (reqObj) {
      newReq = Object.assign(...reqObj);
    }
    super.healthCheck(newReq, callback);
  }

  /**
     * @iapGetAdapterWorkflowFunctions
     */
  iapGetAdapterWorkflowFunctions(inIgnore) {
    let myIgnore = [
      'healthCheck',
      'iapGetAdapterWorkflowFunctions',
      'hasEntities',
      'getAuthorization'
    ];
    if (!inIgnore && Array.isArray(inIgnore)) {
      myIgnore = inIgnore;
    } else if (!inIgnore && typeof inIgnore === 'string') {
      myIgnore = [inIgnore];
    }

    // The generic adapter functions should already be ignored (e.g. healthCheck)
    // you can add specific methods that you do not want to be workflow functions to ignore like below
    // myIgnore.push('myMethodNotInWorkflow');

    return super.iapGetAdapterWorkflowFunctions(myIgnore);
  }

  /**
     * iapUpdateAdapterConfiguration is used to update any of the adapter configuration files. This
     * allows customers to make changes to adapter configuration without having to be on the
     * file system.
     *
     * @function iapUpdateAdapterConfiguration
     * @param {string} configFile - the name of the file being updated (required)
     * @param {Object} changes - an object containing all of the changes = formatted like the configuration file (required)
     * @param {string} entity - the entity to be changed, if an action, schema or mock data file (optional)
     * @param {string} type - the type of entity file to change, (action, schema, mock) (optional)
     * @param {string} action - the action to be changed, if an action, schema or mock data file (optional)
     * @param {boolean} replace - true to replace entire mock data, false to merge/append
     * @param {Callback} callback - The results of the call
     */
  iapUpdateAdapterConfiguration(configFile, changes, entity, type, action, replace, callback) {
    const meth = 'adapter-iapUpdateAdapterConfiguration';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    super.iapUpdateAdapterConfiguration(configFile, changes, entity, type, action, replace, callback);
  }

  /**
      * @summary Suspends adapter
      *
      * @function iapSuspendAdapter
      * @param {Callback} callback - callback function
      */
  iapSuspendAdapter(mode, callback) {
    const meth = 'adapter-iapSuspendAdapter';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapSuspendAdapter(mode, callback);
    } catch (error) {
      log.error(`${origin}: ${error}`);
      return callback(null, error);
    }
  }

  /**
      * @summary Unsuspends adapter
      *
      * @function iapUnsuspendAdapter
      * @param {Callback} callback - callback function
      */
  iapUnsuspendAdapter(callback) {
    const meth = 'adapter-iapUnsuspendAdapter';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapUnsuspendAdapter(callback);
    } catch (error) {
      log.error(`${origin}: ${error}`);
      return callback(null, error);
    }
  }

  /**
      * @summary Get the Adapter Queue
      *
      * @function iapGetAdapterQueue
      * @param {Callback} callback - callback function
      */
  iapGetAdapterQueue(callback) {
    const meth = 'adapter-iapGetAdapterQueue';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    return super.iapGetAdapterQueue(callback);
  }

  /* SCRIPT CALLS */
  /**
     * See if the API path provided is found in this adapter
     *
     * @function iapFindAdapterPath
     * @param {string} apiPath - the api path to check on
     * @param {Callback} callback - The results of the call
     */
  iapFindAdapterPath(apiPath, callback) {
    const meth = 'adapter-iapFindAdapterPath';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    super.iapFindAdapterPath(apiPath, callback);
  }

  /**
   * @summary Runs troubleshoot scripts for adapter
   *
   * @function iapTroubleshootAdapter
   * @param {Object} props - the connection, healthcheck and authentication properties
   *
   * @param {Callback} callback - The results of the call
   */
  iapTroubleshootAdapter(props, callback) {
    const meth = 'adapter-iapTroubleshootAdapter';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapTroubleshootAdapter(props, this, callback);
    } catch (error) {
      log.error(`${origin}: ${error}`);
      return callback(null, error);
    }
  }

  /**
      * @summary runs healthcheck script for adapter
      *
      * @function iapRunAdapterHealthcheck
      * @param {Adapter} adapter - adapter instance to troubleshoot
      * @param {Callback} callback - callback function
      */
  iapRunAdapterHealthcheck(callback) {
    const meth = 'adapter-iapRunAdapterHealthcheck';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapRunAdapterHealthcheck(this, callback);
    } catch (error) {
      log.error(`${origin}: ${error}`);
      return callback(null, error);
    }
  }

  /**
      * @summary runs connectivity check script for adapter
      *
      * @function iapRunAdapterConnectivity
      * @param {Callback} callback - callback function
      */
  iapRunAdapterConnectivity(callback) {
    const meth = 'adapter-iapRunAdapterConnectivity';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapRunAdapterConnectivity(callback);
    } catch (error) {
      log.error(`${origin}: ${error}`);
      return callback(null, error);
    }
  }

  /**
    * @summary runs basicGet script for adapter
    *
    * @function iapRunAdapterBasicGet
    * @param {number} maxCalls - how many GET endpoints to test (optional)
    * @param {Callback} callback - callback function
    */
  iapRunAdapterBasicGet(maxCalls, callback) {
    const meth = 'adapter-iapRunAdapterBasicGet';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapRunAdapterBasicGet(maxCalls, callback);
    } catch (error) {
      log.error(`${origin}: ${error}`);
      return callback(null, error);
    }
  }

  /**
     * @summary moves entites into Mongo DB
     *
     * @function iapMoveAdapterEntitiesToDB
     * @param {getCallback} callback - a callback function to return the result (Generics)
     *                                  or the error
     */
  iapMoveAdapterEntitiesToDB(callback) {
    const meth = 'adapter-iapMoveAdapterEntitiesToDB';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapMoveAdapterEntitiesToDB(callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
     * @summary Deactivate adapter tasks
     *
     * @function iapDeactivateTasks
     *
     * @param {Array} tasks - List of tasks to deactivate
     * @param {Callback} callback
     */
  iapDeactivateTasks(tasks, callback) {
    const meth = 'adapter-iapDeactivateTasks';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapDeactivateTasks(tasks, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
     * @summary Activate adapter tasks that have previously been deactivated
     *
     * @function iapActivateTasks
     *
     * @param {Array} tasks - List of tasks to activate
     * @param {Callback} callback
     */
  iapActivateTasks(tasks, callback) {
    const meth = 'adapter-iapActivateTasks';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapActivateTasks(tasks, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /* CACHE CALLS */
  /**
     * @summary Populate the cache for the given entities
     *
     * @function iapPopulateEntityCache
     * @param {String/Array of Strings} entityType - the entity type(s) to populate
     * @param {Callback} callback - whether the cache was updated or not for each entity type
     *
     * @returns status of the populate
     */
  iapPopulateEntityCache(entityTypes, callback) {
    const meth = 'adapter-iapPopulateEntityCache';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapPopulateEntityCache(entityTypes, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
     * @summary Retrieves data from cache for specified entity type
     *
     * @function iapRetrieveEntitiesCache
     * @param {String} entityType - entity of which to retrieve
     * @param {Object} options - settings of which data to return and how to return it
     * @param {Callback} callback - the data if it was retrieved
     */
  iapRetrieveEntitiesCache(entityType, options, callback) {
    const meth = 'adapter-iapCheckEiapRetrieveEntitiesCachentityCached';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapRetrieveEntitiesCache(entityType, options, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /* BROKER CALLS */
  /**
   * @summary Determines if this adapter supports any in a list of entities
   *
   * @function hasEntities
   * @param {String} entityType - the entity type to check for
   * @param {Array} entityList - the list of entities we are looking for
   *
   * @param {Callback} callback - A map where the entity is the key and the
   *                              value is true or false
   */
  hasEntities(entityType, entityList, callback) {
    const meth = 'adapter-hasEntities';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.hasEntitiesAuth(entityType, entityList, callOptions, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
   * @summary Get Appliance that match the deviceName
   *
   * @function getDevice
   * @param {String} deviceName - the deviceName to find (required)
   *
   * @param {getCallback} callback - a callback function to return the result
   *                                 (appliance) or the error
   */
  getDevice(deviceName, callback) {
    const meth = 'adapter-getDevice';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.getDeviceAuth(deviceName, callOptions, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
   * @summary Get Appliances that match the filter
   *
   * @function getDevicesFiltered
   * @param {Object} options - the data to use to filter the appliances (optional)
   *
   * @param {getCallback} callback - a callback function to return the result
   *                                 (appliances) or the error
   */
  getDevicesFiltered(options, callback) {
    const meth = 'adapter-getDevicesFiltered';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      // if no filtering
      if (!options || !options.filter || !options.filter.name) {
        return super.getDevicesFilteredAuth({}, callOptions, callback);
      }

      // Need to do filtering here because AWS does not support filtering with contains
      return super.getDevicesFilteredAuth({}, callOptions, (devices, error) => {
        if (error) {
          return callback(null, error);
        }

        if (devices.list) {
          const filterDevices = [];
          for (let i = 0; i < devices.list.length; i += 1) {
            if (devices.list[i].name.includes(options.filter.name)) {
              filterDevices.push(devices.list[i]);
            }
          }
          return callback({ total: filterDevices.length, list: filterDevices });
        }

        return devices;
      });
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
   * @summary Gets the status for the provided appliance
   *
   * @function isAlive
   * @param {String} deviceName - the deviceName of the appliance. (required)
   *
   * @param {configCallback} callback - callback function to return the result
   *                                    (appliance isAlive) or the error
   */
  isAlive(deviceName, callback) {
    const meth = 'adapter-isAlive';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.isAliveAuth(deviceName, callOptions, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
   * @summary Gets a config for the provided Appliance
   *
   * @function getConfig
   * @param {String} deviceName - the deviceName of the appliance. (required)
   * @param {String} format - the desired format of the config. (optional)
   *
   * @param {configCallback} callback - callback function to return the result
   *                                    (appliance config) or the error
   */
  getConfig(deviceName, format, callback) {
    const meth = 'adapter-getConfig';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.getConfigAuth(deviceName, format, callOptions, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
   * @summary Gets the device count from the system
   *
   * @function iapGetDeviceCount
   *
   * @param {getCallback} callback - callback function to return the result
   *                                    (count) or the error
   */
  iapGetDeviceCount(callback) {
    const meth = 'adapter-iapGetDeviceCount';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapGetDeviceCountAuth(callOptions, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /* GENERIC ADAPTER REQUEST - allows extension of adapter without new calls being added */
  /**
     * Makes the requested generic call
     *
     * @function iapExpandedGenericAdapterRequest
     * @param {Object} metadata - metadata for the call (optional).
     *                 Can be a stringified Object.
     * @param {String} uriPath - the path of the api call - do not include the host, port, base path or version (optional)
     * @param {String} restMethod - the rest method (GET, POST, PUT, PATCH, DELETE) (optional)
     * @param {Object} pathVars - the parameters to be put within the url path (optional).
     *                 Can be a stringified Object.
     * @param {Object} queryData - the parameters to be put on the url (optional).
     *                 Can be a stringified Object.
     * @param {Object} requestBody - the body to add to the request (optional).
     *                 Can be a stringified Object.
     * @param {Object} addlHeaders - additional headers to be put on the call (optional).
     *                 Can be a stringified Object.
     * @param {getCallback} callback - a callback function to return the result (Generics)
     *                 or the error
     */
  iapExpandedGenericAdapterRequest(metadata, uriPath, restMethod, pathVars, queryData, requestBody, addlHeaders, callback) {
    const meth = 'adapter-iapExpandedGenericAdapterRequest';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.iapExpandedGenericAdapterRequest(metadata, uriPath, restMethod, pathVars, queryData, requestBody, addlHeaders, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
     * Makes the requested generic call
     *
     * @function genericAdapterRequest
     * @param {String} uriPath - the path of the api call - do not include the host, port, base path or version (required)
     * @param {String} restMethod - the rest method (GET, POST, PUT, PATCH, DELETE) (required)
     * @param {Object} queryData - the parameters to be put on the url (optional).
     *                 Can be a stringified Object.
     * @param {Object} requestBody - the body to add to the request (optional).
     *                 Can be a stringified Object.
     * @param {Object} addlHeaders - additional headers to be put on the call (optional).
     *                 Can be a stringified Object.
     * @param {getCallback} callback - a callback function to return the result (Generics)
     *                 or the error
     */
  genericAdapterRequest(uriPath, restMethod, queryData, requestBody, addlHeaders, callback) {
    const meth = 'adapter-genericAdapterRequest';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.genericAdapterRequest(uriPath, restMethod, queryData, requestBody, addlHeaders, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /**
     * Makes the requested generic call with no base path or version
     *
     * @function genericAdapterRequestNoBasePath
     * @param {String} uriPath - the path of the api call - do not include the host, port, base path or version (required)
     * @param {String} restMethod - the rest method (GET, POST, PUT, PATCH, DELETE) (required)
     * @param {Object} queryData - the parameters to be put on the url (optional).
     *                 Can be a stringified Object.
     * @param {Object} requestBody - the body to add to the request (optional).
     *                 Can be a stringified Object.
     * @param {Object} addlHeaders - additional headers to be put on the call (optional).
     *                 Can be a stringified Object.
     * @param {getCallback} callback - a callback function to return the result (Generics)
     *                 or the error
     */
  genericAdapterRequestNoBasePath(uriPath, restMethod, queryData, requestBody, addlHeaders, callback) {
    const meth = 'adapter-genericAdapterRequestNoBasePath';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    try {
      return super.genericAdapterRequestNoBasePath(uriPath, restMethod, queryData, requestBody, addlHeaders, callback);
    } catch (err) {
      log.error(`${origin}: ${err}`);
      return callback(null, err);
    }
  }

  /* INVENTORY CALLS */
  /**
     * @summary run the adapter lint script to return the results.
     *
     * @function iapRunAdapterLint
     * @param {Callback} callback - callback function
     */
  iapRunAdapterLint(callback) {
    const meth = 'adapter-iapRunAdapterLint';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    return super.iapRunAdapterLint(callback);
  }

  /**
     * @summary run the adapter test scripts (baseunit and unit) to return the results.
     *    can not run integration as there can be implications with that.
     *
     * @function iapRunAdapterTests
     * @param {Callback} callback - callback function
     */
  iapRunAdapterTests(callback) {
    const meth = 'adapter-iapRunAdapterTests';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    return super.iapRunAdapterTests(callback);
  }

  /**
     * @summary provide inventory information abbout the adapter
     *
     * @function iapGetAdapterInventory
     * @param {Callback} callback - callback function
     */
  iapGetAdapterInventory(callback) {
    const meth = 'adapter-iapGetAdapterInventory';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);

    return super.iapGetAdapterInventory(callback);
  }

  /**
   * @callback healthCallback
   * @param {Object} result - the result of the get request (contains an id and a status)
   */
  /**
   * @callback getCallback
   * @param {Object} result - the result of the get request (entity/ies)
   * @param {String} error - any error that occurred
   */
  /**
   * @callback createCallback
   * @param {Object} item - the newly created entity
   * @param {String} error - any error that occurred
   */
  /**
   * @callback updateCallback
   * @param {String} status - the status of the update action
   * @param {String} error - any error that occurred
   */
  /**
   * @callback deleteCallback
   * @param {String} status - the status of the delete action
   * @param {String} error - any error that occurred
   */

  /**
   * @summary Returns the summary information for stacks whose status matches the specified StackStatusFilter.
   *
   * @function listStacks
   * @param {string} nextToken - A string that identifies the next page of stacks that you want to retrieve.
   * @param {array} stackStatusFilter - The name or unique ID of the stack set whose description you want.
   * @param {getCallback} callback - a callback function to return the result
   */
  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
  listStacks(nextToken, stackStatusFilter, callback) {
    this.listStacksSTSRole(nextToken, stackStatusFilter, null, null, callback);
  }

  /**
   * @summary Returns the summary information for stacks whose status matches the specified StackStatusFilter.
   *
   * @function listStacksSTSRole
   * @param {string} nextToken - A string that identifies the next page of stacks that you want to retrieve.
   * @param {array} stackStatusFilter - The name or unique ID of the stack set whose description you want.
   * @param {object} [stsParams] - STS Parameters to use for authentication.
   * @param {string} [roleName] - RoleName to authenticate against
   * @param {getCallback} callback - a callback function to return the result
   */
  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
  listStacksSTSRole(nextToken, stackStatusFilter, stsParams, roleName, callback) {
    const meth = 'adapter-listStacksSTSRole';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);
    const action = 'ListStacks';
    const version = '2010-05-15';

    if (this.suspended && this.suspendMode === 'error') {
      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
      return callback(null, errorObj);
    }

    /* HERE IS WHERE YOU VALIDATE DATA */

    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
    const queryParamsAvailable = {
      NextToken: nextToken,
      Action: action,
      Version: version
    };
    if (stackStatusFilter && stackStatusFilter.length > 0) {
      processInArray(stackStatusFilter, queryParamsAvailable, 'StackStatusFilter');
    }

    const queryParams = {};
    const pathVars = [];
    const bodyVars = {};

    // loop in template. long callback arg name to avoid identifier conflicts
    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
      }
    });

    // if you want to expose addlHeaders to workflow, add it to the method signature here and in pronghorn.json
    let thisHeaderData = null;
    // if the additional headers was passed in as a string parse the json into an object
    if (thisHeaderData !== null && thisHeaderData.constructor === String) {
      try {
        // parse the additional headers object that was passed in
        thisHeaderData = JSON.parse(thisHeaderData);
      } catch (err) {
        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'addlHeaders string must be a stringified JSON', [], null, null, null);
        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
        return callback(null, errorObj);
      }
    }

    let callProperties = null;
    if (stsParams && stsParams.region) {
      callProperties = {};
      callProperties.region = stsParams.region;
      callProperties.host = `${this.allProps.service}.${stsParams.region}.amazonaws.com`;
      delete stsParams.region;
      if (Object.keys(stsParams).length === 0) {
        stsParams = null;
      }
    }

    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders
    const reqObj = {
      payload: bodyVars,
      uriPathVars: pathVars,
      uriQuery: queryParams,
      addlHeaders: thisHeaderData,
      authData: {
        stsParams,
        roleName
      },
      callProperties
    };

    try {
      // Make the call -
      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
      return this.requestHandlerInst.identifyRequest('Stack', 'listStacks', reqObj, true, (irReturnData, irReturnError) => {
        // if we received an error or their is no response on the results
        // return an error
        if (irReturnError) {
          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
          return callback(null, irReturnError);
        }
        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['listStacksSTSRole'], null, null, null);
          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
          return callback(null, errorObj);
        }

        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
        // return the response
        return callback(irReturnData, null);
      });
    } catch (ex) {
      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
      return callback(null, errorObj);
    }
  }

  /**
   * @summary Returns the description for the specified stack; if no stack name was specified, then it returns the description for all the stacks created.
   *
   * @function describeStacks
   * @param {string} stackName - The name or unique ID of the stack set whose description you want.
   * @param {string} nextToken - A string that identifies the next page of stacks that you want to retrieve.
   * @param {getCallback} callback - a callback function to return the result
   */
  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
  describeStacks(stackName, nextToken, callback) {
    this.describeStacksSTSRole(stackName, nextToken, null, null, callback);
  }

  /**
   * @summary Returns the description for the specified stack; if no stack name was specified, then it returns the description for all the stacks created.
   *
   * @function describeStacksSTSRole
   * @param {string} stackName - The name or unique ID of the stack set whose description you want.
   * @param {string} nextToken - A string that identifies the next page of stacks that you want to retrieve.
   * @param {object} [stsParams] - STS Parameters to use for authentication.
   * @param {string} [roleName] - RoleName to authenticate against
   * @param {getCallback} callback - a callback function to return the result
   */
  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
  describeStacksSTSRole(stackName, nextToken, stsParams, roleName, callback) {
    const meth = 'adapter-describeStacksSTSRole';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);
    const action = 'DescribeStacks';
    const version = '2010-05-15';

    if (this.suspended && this.suspendMode === 'error') {
      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
      return callback(null, errorObj);
    }

    /* HERE IS WHERE YOU VALIDATE DATA */

    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
    const queryParamsAvailable = {
      StackName: stackName,
      NextToken: nextToken,
      Action: action,
      Version: version
    };

    const queryParams = {};
    const pathVars = [];
    const bodyVars = {};

    // loop in template. long callback arg name to avoid identifier conflicts
    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
      }
    });

    // if you want to expose addlHeaders to workflow, add it to the method signature here and in pronghorn.json
    let thisHeaderData = null;
    // if the additional headers was passed in as a string parse the json into an object
    if (thisHeaderData !== null && thisHeaderData.constructor === String) {
      try {
        // parse the additional headers object that was passed in
        thisHeaderData = JSON.parse(thisHeaderData);
      } catch (err) {
        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'addlHeaders string must be a stringified JSON', [], null, null, null);
        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
        return callback(null, errorObj);
      }
    }

    let callProperties = null;
    if (stsParams && stsParams.region) {
      callProperties = {};
      callProperties.region = stsParams.region;
      callProperties.host = `${this.allProps.service}.${stsParams.region}.amazonaws.com`;
      delete stsParams.region;
      if (Object.keys(stsParams).length === 0) {
        stsParams = null;
      }
    }

    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders
    const reqObj = {
      payload: bodyVars,
      uriPathVars: pathVars,
      uriQuery: queryParams,
      addlHeaders: thisHeaderData,
      authData: {
        stsParams,
        roleName
      },
      callProperties
    };

    try {
      // Make the call -
      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
      return this.requestHandlerInst.identifyRequest('Stack', 'describeStacks', reqObj, true, (irReturnData, irReturnError) => {
        // if we received an error or their is no response on the results
        // return an error
        if (irReturnError) {
          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
          return callback(null, irReturnError);
        }
        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['describeStacksSTSRole'], null, null, null);
          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
          return callback(null, errorObj);
        }

        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
        // return the response
        return callback(irReturnData, null);
      });
    } catch (ex) {
      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
      return callback(null, errorObj);
    }
  }

  /**
   * @summary Creates a stack as specified in the template.
   *
   * @function createStack
   * @param {string} stackName - The name or the unique stack ID that is associated with the stack.
   * @param {array} capabilities - In some cases, you must explicitly acknowledge that your stack template contains certain capabilities in order for AWS CloudFormation to create the stack.
   * @param {string} clientRequestToken - A unique identifier for this CreateStack request.
   * @param {boolean} disableRollback - Set to true to disable rollback of the stack if stack creation failed.
   * @param {boolean} enableTerminationProtection - Set to true to disable rollback of the stack if stack creation failed.
   * @param {array} notificationARNs - The Simple Notification Service (SNS) topic ARNs to publish stack related events.
   * @param {string} onFailure - Determines what action will be taken if stack creation fails.
   * @param {array} parameters - A list of Parameter structures that specify input parameters for the stack.
   * @param {array} resourceTypes - The template resource types that you have permissions to work with for this create stack action.
   * @param {string} roleARN - The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that AWS CloudFormation assumes to roll back the stack.
   * @param {object} rollbackConfiguration - The rollback triggers for AWS CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards.
   * @param {string} stackPolicyBody - Structure containing the stack policy body.
   * @param {string} stackPolicyURL - Location of a file containing the stack policy.
   * @param {array} tags - Key-value pairs to associate with this stack.
   * @param {string} templateBody - Structure containing the template body with a minimum length of 1 byte and a maximum length of 51,200 bytes.
   * @param {string} templateURL - Location of file containing the template body.
   * @param {number} timeoutInMinutes - The amount of time that can pass before the stack status becomes CREATE_FAILED;.
   * @param {getCallback} callback - a callback function to return the result
   */
  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
  createStack(stackName, capabilities, clientRequestToken, disableRollback, enableTerminationProtection, notificationARNs, onFailure, parameters, resourceTypes, roleARN, rollbackConfiguration, stackPolicyBody, stackPolicyURL, tags, templateBody, templateURL, timeoutInMinutes, callback) {
    this.createStackSTSRole(stackName, capabilities, clientRequestToken, disableRollback, enableTerminationProtection, notificationARNs, onFailure, parameters, resourceTypes, roleARN, rollbackConfiguration, stackPolicyBody, stackPolicyURL, tags, templateBody, templateURL, timeoutInMinutes, null, null, callback);
  }

  /**
   * @summary Creates a stack as specified in the template.
   *
   * @function createStackSTSRole
   * @param {string} stackName - The name or the unique stack ID that is associated with the stack.
   * @param {array} capabilities - In some cases, you must explicitly acknowledge that your stack template contains certain capabilities in order for AWS CloudFormation to create the stack.
   * @param {string} clientRequestToken - A unique identifier for this CreateStack request.
   * @param {boolean} disableRollback - Set to true to disable rollback of the stack if stack creation failed.
   * @param {boolean} enableTerminationProtection - Set to true to disable rollback of the stack if stack creation failed.
   * @param {array} notificationARNs - The Simple Notification Service (SNS) topic ARNs to publish stack related events.
   * @param {string} onFailure - Determines what action will be taken if stack creation fails.
   * @param {array} parameters - A list of Parameter structures that specify input parameters for the stack.
   * @param {array} resourceTypes - The template resource types that you have permissions to work with for this create stack action.
   * @param {string} roleARN - The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that AWS CloudFormation assumes to roll back the stack.
   * @param {object} rollbackConfiguration - The rollback triggers for AWS CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards.
   * @param {string} stackPolicyBody - Structure containing the stack policy body.
   * @param {string} stackPolicyURL - Location of a file containing the stack policy.
   * @param {array} tags - Key-value pairs to associate with this stack.
   * @param {string} templateBody - Structure containing the template body with a minimum length of 1 byte and a maximum length of 51,200 bytes.
   * @param {string} templateURL - Location of file containing the template body.
   * @param {number} timeoutInMinutes - The amount of time that can pass before the stack status becomes CREATE_FAILED;.
   * @param {object} [stsParams] - STS Parameters to use for authentication.
   * @param {string} [roleName] - RoleName to authenticate against
   * @param {getCallback} callback - a callback function to return the result
   */
  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
  createStackSTSRole(stackName, capabilities, clientRequestToken, disableRollback, enableTerminationProtection, notificationARNs, onFailure, parameters, resourceTypes, roleARN, rollbackConfiguration, stackPolicyBody, stackPolicyURL, tags, templateBody, templateURL, timeoutInMinutes, stsParams, roleName, callback) {
    const meth = 'adapter-createStackSTSRole';
    const origin = `${this.id}-${meth}`;
    log.trace(origin);
    const action = 'CreateStack';
    const version = '2010-05-15';

    if (this.suspended && this.suspendMode === 'error') {
      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'AD.600', [], null, null, null);
      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
      return callback(null, errorObj);
    }

    /* HERE IS WHERE YOU VALIDATE DATA */
    if (stackName === undefined || stackName === null || stackName === '') {
      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Missing Data', ['stackName'], null, null, null);
      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
      return callback(null, errorObj);
    }

    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
    const queryParamsAvailable = {
      StackName: stackName,
      ClientRequestToken: clientRequestToken,
      DisableRollback: disableRollback,
      EnableTerminationProtection: enableTerminationProtection,
      OnFailure: onFailure,
      RoleARN: roleARN,
      RollbackConfiguration: rollbackConfiguration,
      StackPolicyBody: stackPolicyBody,
      StackPolicyURL: stackPolicyURL,
      TemplateBody: templateBody,
      TemplateURL: templateURL,
      TimeoutInMinutes: timeoutInMinutes,
      Action: action,
      Version: version
    };
    if (capabilities && capabilities.length > 0) {
      processInArray(capabilities, queryParamsAvailable, 'Capabilities');
    }
    if (notificationARNs && notificationARNs.length > 0) {
      processInArray(notificationARNs, queryParamsAvailable, 'NotificationARNs');
    }
    if (parameters && parameters.length > 0) {
      processInArray(parameters, queryParamsAvailable, 'Parameters');
    }
    if (resourceTypes && resourceTypes.length > 0) {
      processInArray(resourceTypes, queryParamsAvailable, 'ResourceTypes');
    }
    if (tags && tags.length > 0) {
      processInArray(tags, queryParamsAvailable, 'Tags');
    }

    const queryParams = {};
    const pathVars = [];
    const bodyVars = {};

    // loop in template. long callback arg name to avoid identifier conflicts
    Object.keys(queryParamsAvailable).forEach((thisKeyInQueryParamsAvailable) => {
      if (queryParamsAvailable[thisKeyInQueryParamsAvailable] !== undefined && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== null
          && queryParamsAvailable[thisKeyInQueryParamsAvailable] !== '') {
        queryParams[thisKeyInQueryParamsAvailable] = queryParamsAvailable[thisKeyInQueryParamsAvailable];
      }
    });

    // if you want to expose addlHeaders to workflow, add it to the method signature here and in pronghorn.json
    let thisHeaderData = null;
    // if the additional headers was passed in as a string parse the json into an object
    if (thisHeaderData !== null && thisHeaderData.constructor === String) {
      try {
        // parse the additional headers object that was passed in
        thisHeaderData = JSON.parse(thisHeaderData);
      } catch (err) {
        const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'addlHeaders string must be a stringified JSON', [], null, null, null);
        log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
        return callback(null, errorObj);
      }
    }

    let callProperties = null;
    if (stsParams && stsParams.region) {
      callProperties = {};
      callProperties.region = stsParams.region;
      callProperties.host = `${this.allProps.service}.${stsParams.region}.amazonaws.com`;
      delete stsParams.region;
      if (Object.keys(stsParams).length === 0) {
        stsParams = null;
      }
    }

    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders
    const reqObj = {
      payload: bodyVars,
      uriPathVars: pathVars,
      uriQuery: queryParams,
      addlHeaders: thisHeaderData,
      authData: {
        stsParams,
        roleName
      },
      callProperties
    };

    try {
      // Make the call -
      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
      return this.requestHandlerInst.identifyRequest('Stack', 'createStack', reqObj, true, (irReturnData, irReturnError) => {
        // if we received an error or their is no response on the results
        // return an error
        if (irReturnError) {
          /* HERE IS WHERE YOU CAN ALTER THE ERROR MESSAGE */
          return callback(null, irReturnError);
        }
        if (!Object.hasOwnProperty.call(irReturnData, 'response')) {
          const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Invalid Response', ['createStackSTSRole'], null, null, null);
          log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
          return callback(null, errorObj);
        }

        /* HERE IS WHERE YOU CAN ALTER THE RETURN DATA */
        // return the response
        return callback(irReturnData, null);
      });
    } catch (ex) {
      const errorObj = this.requestHandlerInst.formatErrorObject(this.id, meth, 'Caught Exception', null, null, null, ex);
      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
      return callback(null, errorObj);
    }
  }

  /**
   * @summary Updates a stack as specified in the template.
   *
   * @function updateStack
   * @param {string} stackName - The name or unique stack ID of the stack to update.
   * @param {array} capabilities - In some cases, you must explicitly acknowledge that your stack template contains certain capabilities in order for AWS CloudFormation to update the stack.
   * @param {string} clientRequestToken - A unique identifier for this UpdateStack request.
   * @param {array} notificationARNs - Amazon Simple Notification Service topic Amazon Resource Names (ARNs) that AWS CloudFormation associates with the stack.
   * @param {array} parameters - A list of Parameter structures that specify input parameters for the stack.
   * @param {array} resourceTypes - The template resource types that you have permissions to work with for this update stack action.
   * @param {string} roleARN - The Amazon Resource Name (ARN) of an AWS Identity and Access Management (IAM) role that AWS CloudFormation assumes to update the stack.
   * @param {object} rollbackConfiguration - The rollback triggers for AWS CloudFormation to monitor during stack creation and updating operations, and for the specified monitoring period afterwards.
   * @param {string} stackPolicyBody - Structure containing a new stack policy body.
   * @param {string} stackPolicyDuringUpdateBody - Structure containing the temporary overriding stack policy body.
   * @param {string} stackPolicyDuringUpdateURL - Location of a file containing the temporary overriding stack policy.
   * @param {string} stackPolicyURL - Location of a file containing the updated stack policy.
   * @param {array} tags - Key-value pairs to associate with this stack.
   * @param {string} templateBody - Structure containing the template body with a minimum length of 1 byte and a maximum length of 51,200 bytes.
   * @param {string} templateURL - Location of file containing the template body.
   * @param {boolean} usePreviousTemplate - Reuse the existing template that is associated with the stack that you are updating.
   * @param {getCallback} callback - a callback function to return the result
   */
  /* YOU CAN CHANGE THE PARAMETERS YOU TAKE IN HERE AND IN THE pronghorn.json FILE */
  updateStack(stackName, capabilities, clientRequestToken, notificationARNs, parameters, resourceTypes, roleARN, rollbackConfiguration, stackPolicyBody, stackPolicyDuringUpdateBody, stackPolicyDuringUpdateURL, stackPolicyURL, tags, templateBody, templateURL, usePreviousTemplate, callback) {
    this.updateStackSTSRole(stackName, capabilities, clientRequestToken, notificationARNs, parameters, resourceTypes, roleARN, rollbackConfiguration, stackPolicyBody, stackPolicyDuringUpdateBody, stackPolicyDuringUpdateURL, stackPolicyURL, tags, templateBody, templateURL, usePreviousTemplate, null, null, callback);
  }

  /**
   * @summary Updates a stack as specified in the template.
   *
   * @function updateStackSTSRole
   * @param {s