@itentialopensource/adapter-utils 5.1.1 → 5.1.3

package/CHANGELOG.md

@@ -1,4 +1,22 @@
 
+## 5.1.3 [08-28-2023]
+
+* aws auth changes - for all aws auth
+
+See merge request itentialopensource/adapter-utils!270
+
+---
+
+## 5.1.2 [08-28-2023]
+
+* Resolve ADAPT-2852 - Broker authentication
+
+Closes ADAPT-2852
+
+See merge request itentialopensource/adapter-utils!269
+
+---
+
 ## 5.1.1 [08-22-2023]
 
 * fix scrubing arrays - was not making copy

package/lib/authenticationHandler.js

@@ -0,0 +1,263 @@
+/* @copyright Itential, LLC 2023 */
+
+// Set globals
+/* global log */
+/* eslint global-require:warn */
+/* eslint import/no-dynamic-require:warn */
+/* eslint-disable consistent-return */
+
+const aws4 = require('aws4');
+const AWS = require('aws-sdk');
+const http = require('http');
+const querystring = require('querystring');
+
+/*
+ * INTERNAL FUNCTION: update device broker properties from service instance config and adapter sample properties
+*/
+
+class AuthenticationHandler {
+  /**
+   * Adapter Authentication Handler
+   * @constructor
+   */
+  constructor(prongId, properties, reqH) {
+    this.myid = prongId;
+    this.allProps = properties;
+    this.requestHandlerInst = reqH;
+
+    // set up the properties I care about
+    this.refreshProperties(properties);
+  }
+
+  /**
+   * refreshProperties is used to set up all of the properties for the broker handler.
+   * It allows properties to be changed later by simply calling refreshProperties rather
+   * than having to restart the broker handler.
+   *
+   * @function refreshProperties
+   * @param {Object} properties - an object containing all of the properties
+   */
+  refreshProperties(properties) {
+    const origin = `${this.myid}-authenticationHandler-refreshProperties`;
+    log.trace(origin);
+
+    if (!properties) {
+      log.error(`${origin}: Authentication Handler received no properties!`);
+    }
+  }
+
+  /**
+   * @summary Gets the hcma authorization for the call
+   *
+   * @function getAWSAuthorization
+   * @param {string} method - the method for the action we are setting authorization for
+   * @param {object} requestObj - an object that contains all of the possible parts of the request (payload, uriPathVars,
+   *                              uriQuery, uriOptions and addlHeaders (optional). Can be a stringified Object.
+   * @param {string} uriPath - the path for the call. (required)
+   * @param {string} service - the AWS service we are talking to
+   * @param {object} [stsParams] - STS Parameters to use for authentication.
+   * @param {string} [roleName] - RoleName to authenticate against
+   *
+   *  @return {Object} the headers to add to the request
+   */
+  getAWSAuthorization(method, requestObj, uriPath, service, STSParams, roleName, callback) {
+    const origin = `${this.id}-adapter-getAuthorization`;
+    log.trace(origin);
+
+    // Form path
+    let uriPathTranslated = '';
+    if (requestObj.uriQuery && uriPath.indexOf('?') === -1) {
+      const query = requestObj.uriQuery;
+      uriPathTranslated = `${uriPath}?${querystring.stringify(query)}`;
+    } else if (requestObj.uriQuery && uriPath.endsWith('?')) {
+      const query = requestObj.uriQuery;
+      uriPathTranslated = `${uriPath}${querystring.stringify(query)}`;
+    } else {
+      uriPathTranslated = uriPath;
+    }
+
+    // set up the options for the AWS signature
+    const options = {
+      host: this.allProps.host,
+      method,
+      path: uriPathTranslated.replace(/\/\/+/g, '/'),
+      service,
+      region: this.allProps.region
+    };
+
+    // add any provided headers for the call
+    if (requestObj.addlHeaders) {
+      options.headers = requestObj.addlHeaders;
+    }
+    // remove ? if there is no query and the last character is ?
+    if (options.path.endsWith('?')) {
+      options.path = options.path.substring(0, options.path.length - 1);
+    }
+    // If there is a body (POST, PATCH, PUT) add the body to the call
+    if (method !== 'GET' && method !== 'DELETE') {
+      if (typeof requestObj.payload === 'string') {
+        options.body = requestObj.payload;
+      } else {
+        options.body = JSON.stringify(requestObj.payload);
+      }
+    }
+    // override anything set in callProperties
+    if (requestObj.callProperties) {
+      if (requestObj.callProperties.host) {
+        options.host = requestObj.callProperties.host;
+      }
+      if (requestObj.callProperties.region) {
+        options.region = requestObj.callProperties.region;
+      }
+    }
+    log.debug(`SIG OPTIONS: ${JSON.stringify(options)}`);
+
+    /* STS AUTHENTICATION */
+    if (STSParams) {
+      log.info('Using STS for AWS Authentication');
+
+      // set the original AWS access information (from properties)
+      AWS.config.update({
+        sessionToken: this.allProps.authentication.aws_session_token,
+        accessKeyId: this.allProps.authentication.aws_access_key,
+        secretAccessKey: this.allProps.authentication.aws_secret_key,
+        region: this.allProps.region
+      });
+
+      // use STS to get the AWS access information for the user defined in STWS Params
+      const sts = new AWS.STS();
+      const stsData = {
+        RoleArn: STSParams.RoleArn,
+        RoleSessionName: STSParams.RoleSessionName,
+        DurationSeconds: 3600
+      };
+      return sts.assumeRole(stsData, (err, data) => {
+        if (err) {
+          throw err;
+        }
+        // extract the user specific info from the response
+        const accessKeyId = data.Credentials.AccessKeyId;
+        const secretAccessKey = data.Credentials.SecretAccessKey;
+        const sessionToken = data.Credentials.SessionToken;
+
+        // call the signature with the user specific information
+        const authOpts = aws4.sign(options, { accessKeyId, secretAccessKey, sessionToken });
+        if (sessionToken) {
+          authOpts.headers['X-Amz-Security-Token'] = sessionToken;
+        }
+
+        // return the headers
+        return callback(authOpts.headers);
+      });
+    }
+
+    /* ADAPTER PROPERTIES AUTHENTICATION */
+    if (!roleName && !this.allProps.authentication.aws_iam_role) {
+      log.info('Using Adapter PROPERTIES for AWS Authentication');
+
+      // call the signature with the property information
+      const authOpts = aws4.sign(options, { accessKeyId: this.allProps.authentication.aws_access_key, secretAccessKey: this.allProps.authentication.aws_secret_key, sessionToken: this.allProps.authentication.aws_session_token });
+      if (this.allProps.authentication.aws_session_token) {
+        authOpts.headers['X-Amz-Security-Token'] = this.allProps.authentication.aws_session_token;
+      }
+
+      // return the headers
+      return callback(authOpts.headers);
+    }
+
+    /* ROLE NAME AUTHENTICATION */
+    log.info('Using roleName for AWS Authentication');
+
+    // set up information for token - this is always ec2!
+    const getTokenOptions = {
+      method: 'PUT',
+      url: 'http://169.254.169.254/latest/api/token',
+      headers: {
+        'X-aws-ec2-metadata-token-ttl-seconds': 21600
+      }
+    };
+
+    // get token from AWS internal server
+    const req1 = http.request(getTokenOptions, (res1) => {
+      let response = '';
+
+      // HERE??? - can we check status here or does this need to be in end???
+      if (res1.statusCode < 200 || res1.statusCode >= 300) {
+        return callback(null, new Error(`Invalid status code recieved: ${res1.statusCode}`));
+      }
+
+      // add data to the response
+      res1.on('data', (resp) => {
+        response += resp;
+      });
+
+      // process everything when the call finishes
+      res1.on('end', () => {
+        if (!response) {
+          return callback(null, 'No authentication token');
+        }
+
+        // get token and set up to make IAM role call - this is always ec2!
+        const tokenKey = response;
+        let myRole = roleName;
+        if (!roleName) {
+          myRole = this.allProps.authentication.aws_iam_role;
+        }
+        const toptions = {
+          method: 'GET',
+          hostname: '169.254.169.254',
+          path: `/latest/meta-data/iam/security-credentials/${myRole}`,
+          headers: {
+            'X-aws-ec2-metadata-token': tokenKey
+          }
+        };
+
+        // IAM Role call
+        const req2 = http.request(toptions, (res2) => {
+          let response2 = '';
+
+          // HERE??? - can we check status here or does this need to be in end???
+          if (res2.statusCode < 200 || res2.statusCode >= 300) {
+            return callback(null, new Error(`Invalid status code recieved: ${res2.statusCode}`));
+          }
+
+          // add data to the response
+          res2.on('data', (chunk) => {
+            response2 += chunk;
+          });
+
+          // process everything when the call finishes
+          res2.on('end', () => {
+            if (!response2) {
+              return callback(null, 'No authentication token');
+            }
+            try {
+              // get role keys from response so we can sign the request
+              const awsResponse = JSON.parse(response2);
+              const accessKeyId = awsResponse.AccessKeyId;
+              const secretAccessKey = awsResponse.SecretAccessKey;
+              const sessionToken = awsResponse.Token;
+
+              // sign the request
+              const authOpts = aws4.sign(options, { accessKeyId, secretAccessKey, sessionToken });
+              if (sessionToken) {
+                authOpts.headers['X-Amz-Security-Token'] = sessionToken;
+              }
+
+              // return the headers
+              return callback(authOpts.headers);
+            } catch (e) {
+              return callback(null, e);
+            }
+          });
+        });
+        req2.on('error', (err2) => callback(null, err2));
+        req2.end();
+      });
+    });
+    req1.on('error', (err1) => callback(null, err1));
+    req1.end();
+  }
+}
+
+module.exports = AuthenticationHandler;

package/lib/brokerHandler.js

@@ -102,13 +102,13 @@ class BrokerHandler {
    * @param {Callback} callback - A map where the entity is the key and the
    *                              value is true or false
    */
-  hasEntities(entityType, entityList, callback) {
+  hasEntities(entityType, entityList, callOptions, callback) {
     const origin = `${this.myid}-brokerHandler-hasEntities`;
     log.trace(origin);
 
     switch (entityType) {
       case 'Device':
-        return this.hasDevices(entityList, callback);
+        return this.hasDevices(entityList, callOptions, callback);
       default:
         return callback(null, `${this.myid} does not support entity ${entityType}`);
     }
@@ -121,7 +121,7 @@ class BrokerHandler {
    * @param {Callback} callback - A map where the device is the key and the
    *                              value is true or false
    */
-  hasDevices(deviceList, callback) {
+  hasDevices(deviceList, callOptions, callback) {
     const origin = `${this.myid}-brokerHandler-hasDevices`;
     log.trace(origin);
 
@@ -170,7 +170,7 @@ class BrokerHandler {
       return map;
     }, {});
     const apiCalls = deviceList.map((device) => new Promise((resolve) => {
-      this.getDevice(device, (result, error) => {
+      this.getDevice(device, callOptions, (result, error) => {
         if (error) {
           log.debug(`In map error: ${JSON.stringify(device)}`);
           return resolve({ name: device, found: false });
@@ -201,7 +201,7 @@ class BrokerHandler {
    * @param {getCallback} callback - a callback function to return the result
    *                                 (appliance) or the error
    */
-  getDevice(deviceName, callback) {
+  getDevice(deviceName, callOptions, callback) {
     const meth = 'brokerHandler-getDevice';
     const origin = `${this.myid}-${meth}`;
     log.trace(origin);
@@ -229,7 +229,7 @@ class BrokerHandler {
         }
       };
 
-      return this.getDevicesFiltered(opts, (devs, ferr) => {
+      return this.getDevicesFiltered(opts, callOptions, (devs, ferr) => {
         // if we received an error or their is no response on the results return an error
         if (ferr) {
           return callback(null, ferr);
@@ -243,9 +243,14 @@ class BrokerHandler {
         const callPromises = [];
         for (let i = 0; i < this.allProps.devicebroker.getDevice.length; i += 1) {
           // Perform component calls here.
+          const callProps = this.allProps.devicebroker.getDevice[i];
+          callProps.headers = {
+            ...(callProps.headers || {}),
+            ...(callOptions.headers || {})
+          };
           callPromises.push(
             new Promise((resolve, reject) => {
-              this.requestHandlerInst.iapMakeGenericCall('getDevice', this.allProps.devicebroker.getDevice[i], [devs.list[0]], [deviceName], (callRet, callErr) => {
+              this.requestHandlerInst.iapMakeGenericCall(callOptions, 'getDevice', callProps, [devs.list[0]], [deviceName], (callRet, callErr) => {
                 // return an error
                 if (callErr) {
                   reject(callErr);
@@ -288,7 +293,7 @@ class BrokerHandler {
    * @param {getCallback} callback - a callback function to return the result
    *                                 (appliances) or the error
    */
-  getDevicesFiltered(options, callback) {
+  getDevicesFiltered(options, callOptions, callback) {
     const meth = 'brokerHandler-getDevicesFiltered';
     const origin = `${this.myid}-${meth}`;
     log.trace(origin);
@@ -382,9 +387,14 @@ class BrokerHandler {
       const callPromises = [];
       for (let i = 0; i < this.allProps.devicebroker.getDevicesFiltered.length; i += 1) {
         // Perform component calls here.
+        const callProps = this.allProps.devicebroker.getDevicesFiltered[i];
+        callProps.headers = {
+          ...(callProps.headers || {}),
+          ...(callOptions.headers || {})
+        };
         callPromises.push(
           new Promise((resolve, reject) => {
-            this.requestHandlerInst.iapMakeGenericCall('getDevicesFiltered', this.allProps.devicebroker.getDevicesFiltered[i], [{ fake: 'fakedata' }], filterName, (callRet, callErr) => {
+            this.requestHandlerInst.iapMakeGenericCall(callOptions, 'getDevicesFiltered', callProps, [{ fake: 'fakedata' }], filterName, (callRet, callErr) => {
               // return an error
               if (callErr) {
                 console.debug(`in cache iap call failed with error ${callErr}`);
@@ -456,7 +466,7 @@ class BrokerHandler {
    * @param {configCallback} callback - callback function to return the result
    *                                    (appliance isAlive) or the error
    */
-  isAlive(deviceName, callback) {
+  isAlive(deviceName, callOptions, callback) {
     const meth = 'brokerHandler-isAlive';
     const origin = `${this.myid}-${meth}`;
     log.trace(origin);
@@ -483,7 +493,7 @@ class BrokerHandler {
           name: deviceName
         }
       };
-      return this.getDevicesFiltered(opts, (devs, ferr) => {
+      return this.getDevicesFiltered(opts, callOptions, (devs, ferr) => {
         // if we received an error or their is no response on the results return an error
         if (ferr) {
           return callback(null, ferr);
@@ -497,9 +507,14 @@ class BrokerHandler {
         const callPromises = [];
         for (let i = 0; i < this.allProps.devicebroker.isAlive.length; i += 1) {
           // Perform component calls here.
+          const callProps = this.allProps.devicebroker.isAlive[i];
+          callProps.headers = {
+            ...(callProps.headers || {}),
+            ...(callOptions.headers || {})
+          };
           callPromises.push(
             new Promise((resolve, reject) => {
-              this.requestHandlerInst.iapMakeGenericCall('isAlive', this.allProps.devicebroker.isAlive[i], [devs.list[0]], null, (callRet, callErr) => {
+              this.requestHandlerInst.iapMakeGenericCall(callOptions, 'isAlive', callProps, [devs.list[0]], null, (callRet, callErr) => {
                 // return an error
                 if (callErr) {
                   reject(callErr);
@@ -547,7 +562,7 @@ class BrokerHandler {
    * @param {configCallback} callback - callback function to return the result
    *                                    (appliance config) or the error
    */
-  getConfig(deviceName, format, callback) {
+  getConfig(deviceName, format, callOptions, callback) {
     const meth = 'brokerHandler-getConfig';
     const origin = `${this.myid}-${meth}`;
     log.trace(origin);
@@ -574,7 +589,7 @@ class BrokerHandler {
           name: deviceName
         }
       };
-      return this.getDevicesFiltered(opts, (devs, ferr) => {
+      return this.getDevicesFiltered(opts, callOptions, (devs, ferr) => {
         // if we received an error or their is no response on the results return an error
         if (ferr) {
           return callback(null, ferr);
@@ -588,9 +603,14 @@ class BrokerHandler {
         const callPromises = [];
         for (let i = 0; i < this.allProps.devicebroker.getConfig.length; i += 1) {
           // Perform component calls here.
+          const callProps = this.allProps.devicebroker.getConfig[i];
+          callProps.headers = {
+            ...(callProps.headers || {}),
+            ...(callOptions.headers || {})
+          };
           callPromises.push(
             new Promise((resolve, reject) => {
-              this.requestHandlerInst.iapMakeGenericCall('getConfig', this.allProps.devicebroker.getConfig[i], [devs.list[0]], null, (callRet, callErr) => {
+              this.requestHandlerInst.iapMakeGenericCall(callOptions, 'getConfig', callProps, [devs.list[0]], null, (callRet, callErr) => {
                 // return an error
                 if (callErr) {
                   reject(callErr);
@@ -642,7 +662,7 @@ class BrokerHandler {
    * @param {getCallback} callback - callback function to return the result
    *                                    (count) or the error
    */
-  iapGetDeviceCount(callback) {
+  iapGetDeviceCount(callOptions, callback) {
     const meth = 'brokerHandler-iapGetDeviceCount';
     const origin = `${this.myid}-${meth}`;
     log.trace(origin);
@@ -690,9 +710,14 @@ class BrokerHandler {
       const callPromises = [];
       for (let i = 0; i < this.allProps.devicebroker.getCount.length; i += 1) {
         // Perform component calls here.
+        const callProps = this.allProps.devicebroker.getCount[i];
+        callProps.headers = {
+          ...(callProps.headers || {}),
+          ...(callOptions.headers || {})
+        };
         callPromises.push(
           new Promise((resolve, reject) => {
-            this.requestHandlerInst.iapMakeGenericCall('getCount', this.allProps.devicebroker.getCount[i], [{ fake: 'fakedata' }], null, (callRet, callErr) => {
+            this.requestHandlerInst.iapMakeGenericCall(callOptions, 'getCount', callProps, [{ fake: 'fakedata' }], null, (callRet, callErr) => {
               // return an error
               if (callErr) {
                 reject(callErr);

package/lib/genericHandler.js

@@ -2,6 +2,7 @@
 
 // Set globals
 /* global log */
+/* eslint consistent-return: warn */
 
 /* NodeJS internal utilities */
 
@@ -40,18 +41,13 @@ class GenericHandler {
    * Makes the requested generic call
    *
    * @function expandedGenericAdapterRequest
-   * @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 {object} metadata - metadata for the call (optional).
+   * @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).
+   * @param {object} queryData - the parameters to be put on the url (optional).
+   * @param {object} requestBody - the body to add to the request (optional).
+   * @param {object} addlHeaders - additional headers to be put on the call (optional).
    * @param {getCallback} callback - a callback function to return the result (Generics)
    *                 or the error
    */
@@ -60,34 +56,6 @@ class GenericHandler {
     const origin = `${this.myid}-${meth}`;
     log.trace(origin);
 
-    // if metadata says not to use BasePath
-    if (metadata && metadata.basepath && metadata.basepath.toUpperCase() === 'NOBASE') {
-      return this.genericAdapterRequestNoBasePath(uriPath, restMethod, queryData, requestBody, addlHeaders, callback);
-    }
-    // use BasePath
-    return this.genericAdapterRequest(uriPath, restMethod, queryData, requestBody, addlHeaders, callback);
-  }
-
-  /**
-   * 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 = 'genericHandler-genericAdapterRequest';
-    const origin = `${this.myid}-${meth}`;
-    log.trace(origin);
-
     /* HERE IS WHERE YOU VALIDATE DATA */
     if (uriPath === undefined || uriPath === null || uriPath === '') {
       const errorObj = this.requestHandlerInst.formatErrorObject(this.myid, meth, 'Missing Data', ['uriPath'], null, null, null);
@@ -100,13 +68,23 @@ class GenericHandler {
       return callback(null, errorObj);
     }
 
+    // Need to add dynamic/runtime path values here
+    if (pathVars) {
+      const pathKeys = Object.keys(pathVars);
+
+      // replace each key found in the path with its value
+      for (let i = 0; i < pathKeys.length; i += 1) {
+        uriPath.replace(`{${pathKeys[i]}}`, pathVars[pathKeys[i]]);
+      }
+    }
+
     /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
     // remove any leading / and split the uripath into path variables
     let myPath = uriPath;
     while (myPath.indexOf('/') === 0) {
       myPath = myPath.substring(1);
     }
-    const pathVars = myPath.split('/');
+    const pathComp = myPath.split('/');
     const queryParamsAvailable = queryData;
     const queryParams = {};
     const bodyVars = requestBody;
@@ -122,7 +100,7 @@ class GenericHandler {
     // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders
     const reqObj = {
       payload: bodyVars,
-      uriPathVars: pathVars,
+      uriPathVars: pathComp,
       uriQuery: queryParams,
       uriOptions: {}
     };
@@ -130,6 +108,9 @@ class GenericHandler {
     if (addlHeaders) {
       reqObj.addlHeaders = addlHeaders;
     }
+    if (metadata && metadata.datatype) {
+      reqObj.datatype = metadata.datatype;
+    }
 
     // determine the call and return flag
     let action = 'getGenerics';
@@ -145,9 +126,51 @@ class GenericHandler {
       returnF = false;
     }
 
+    // Change the call and return flag if no base path
+    if (metadata && metadata.basepath && metadata.basepath.toUpperCase() === 'NOBASE') {
+      action = 'getGenericsNoBase';
+      returnF = true;
+      if (restMethod.toUpperCase() === 'POST') {
+        action = 'createGenericNoBase';
+      } else if (restMethod.toUpperCase() === 'PUT') {
+        action = 'updateGenericNoBase';
+      } else if (restMethod.toUpperCase() === 'PATCH') {
+        action = 'patchGenericNoBase';
+      } else if (restMethod.toUpperCase() === 'DELETE') {
+        action = 'deleteGenericNoBase';
+        returnF = false;
+      }
+    }
+
     try {
       // Make the call -
       // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
+      // See if AWS call requiring authentication
+      if (metadata && metadata.service) {
+        return this.requestHandlerInst.getAWSAuthorization(restMethod, reqObj, uriPath, metadata.service, null, null, (signature, authError) => {
+          if (authError) {
+            return callback(null, authError);
+          }
+          reqObj.addlHeaders = { ...reqObj.addlHeaders, ...signature };
+          this.requestHandlerInst.identifyRequest('.generic', action, reqObj, returnF, (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.myid, meth, 'Invalid Response', ['genericAdapterRequest'], 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);
+          });
+        });
+      }
       return this.requestHandlerInst.identifyRequest('.generic', action, reqObj, returnF, (irReturnData, irReturnError) => {
         // if we received an error or their is no response on the results
         // return an error
@@ -172,108 +195,36 @@ class GenericHandler {
     }
   }
 
+  /**
+   * 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).
+   * @param {object} requestBody - the body to add to the request (optional).
+   * @param {object} addlHeaders - additional headers to be put on the call (optional).
+   * @param {getCallback} callback - a callback function to return the result (Generics)
+   *                 or the error
+   */
+  genericAdapterRequest(uriPath, restMethod, queryData, requestBody, addlHeaders, callback) {
+    return this.expandedGenericAdapterRequest(null, uriPath, restMethod, null, queryData, requestBody, addlHeaders, callback);
+  }
+
   /**
    * 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 {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).
+   * @param {object} requestBody - the body to add to the request (optional).
+   * @param {object} addlHeaders - additional headers to be put on the call (optional).
    * @param {getCallback} callback - a callback function to return the result (Generics)
    *                 or the error
    */
   genericAdapterRequestNoBasePath(uriPath, restMethod, queryData, requestBody, addlHeaders, callback) {
-    const meth = 'genericHandler-genericAdapterRequestNoBasePath';
-    const origin = `${this.myid}-${meth}`;
-    log.trace(origin);
-
-    /* HERE IS WHERE YOU VALIDATE DATA */
-    if (uriPath === undefined || uriPath === null || uriPath === '') {
-      const errorObj = this.requestHandlerInst.formatErrorObject(this.myid, meth, 'Missing Data', ['uriPath'], null, null, null);
-      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-      return callback(null, errorObj);
-    }
-    if (restMethod === undefined || restMethod === null || restMethod === '') {
-      const errorObj = this.requestHandlerInst.formatErrorObject(this.myid, meth, 'Missing Data', ['restMethod'], null, null, null);
-      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-      return callback(null, errorObj);
-    }
-
-    /* HERE IS WHERE YOU SET THE DATA TO PASS INTO REQUEST */
-    // remove any leading / and split the uripath into path variables
-    let myPath = uriPath;
-    while (myPath.indexOf('/') === 0) {
-      myPath = myPath.substring(1);
-    }
-    const pathVars = myPath.split('/');
-    const queryParamsAvailable = queryData;
-    const queryParams = {};
-    const bodyVars = requestBody;
-
-    // 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];
-      }
-    });
-
-    // set up the request object - payload, uriPathVars, uriQuery, uriOptions, addlHeaders
-    const reqObj = {
-      payload: bodyVars,
-      uriPathVars: pathVars,
-      uriQuery: queryParams,
-      uriOptions: {}
-    };
-    // add headers if provided
-    if (addlHeaders) {
-      reqObj.addlHeaders = addlHeaders;
-    }
-
-    // determine the call and return flag
-    let action = 'getGenericsNoBase';
-    let returnF = true;
-    if (restMethod.toUpperCase() === 'POST') {
-      action = 'createGenericNoBase';
-    } else if (restMethod.toUpperCase() === 'PUT') {
-      action = 'updateGenericNoBase';
-    } else if (restMethod.toUpperCase() === 'PATCH') {
-      action = 'patchGenericNoBase';
-    } else if (restMethod.toUpperCase() === 'DELETE') {
-      action = 'deleteGenericNoBase';
-      returnF = false;
-    }
-
-    try {
-      // Make the call -
-      // identifyRequest(entity, action, requestObj, returnDataFlag, callback)
-      return this.requestHandlerInst.identifyRequest('.generic', action, reqObj, returnF, (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.myid, meth, 'Invalid Response', ['genericAdapterRequestNoBasePath'], 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.myid, meth, 'Caught Exception', null, null, null, ex);
-      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
-      return callback(null, errorObj);
-    }
+    return this.expandedGenericAdapterRequest({ basepath: 'NOBASE' }, uriPath, restMethod, null, queryData, requestBody, addlHeaders, callback);
   }
 }
 

package/lib/requestHandler.js

@@ -25,6 +25,7 @@ const ConnectorCl = require(path.join(__dirname, '/connectorRest.js'));
 const PropUtilCl = require(path.join(__dirname, '/propertyUtil.js'));
 const TransUtilCl = require(path.join(__dirname, '/translatorUtil.js'));
 const DBUtilCl = require(path.join(__dirname, '/dbUtil.js'));
+const AuthHandlerCl = require(path.join(__dirname, '/authenticationHandler.js'));
 
 let id = null;
 const allowFailover = 'AD.300';
@@ -388,6 +389,7 @@ class RequestHandler {
       this.brokerHandler = new BrokerHandlerCl(this.myid, this.props, this.directory, this);
       this.genericHandler = new GenericHandlerCl(this.myid, this.props, this);
       this.cacheHandler = new CacheHandlerCl(this.myid, this.props, this.directory, this);
+      this.authHandler = new AuthHandlerCl(this.myid, this.props, this);
     } catch (e) {
       // handle any exception
       const origin = `${this.myid}-requestHandler-constructor`;
@@ -529,6 +531,7 @@ class RequestHandler {
    * @summary Make the provided call(s) - could be one of many
    *
    * @function iapMakeGenericCall
+   * @param {object} metadata - metadata for the call (optional).
    * @param {string} callName - the name of the call (required)
    * @param {object} callProps - the proeprties for the broker call (required)
    * @param {object} devResp - the device details to extract needed inputs (required)
@@ -536,7 +539,7 @@ class RequestHandler {
    *
    * @param {getCallback} callback - a callback function to return the result of the call
    */
-  iapMakeGenericCall(callName, callProps, devResp, filterName, callback) {
+  iapMakeGenericCall(metadata, callName, callProps, devResp, filterName, callback) {
     const meth = 'requestHandler-iapMakeGenericCall';
     const origin = `${this.myid}-${meth}`;
     log.trace(`${origin}: ${callName}`);
@@ -651,7 +654,7 @@ class RequestHandler {
 
       // !! using Generic makes it easier on the Adapter Builder (just need to change the path)
       // !! you can also replace with a specific call if that is easier
-      return this.genericAdapterRequest(uriPath, uriMethod, callQuery, callBody, callHeaders, (result, error) => {
+      return this.expandedGenericAdapterRequest(metadata, uriPath, uriMethod, null, callQuery, callBody, callHeaders, (result, error) => {
         // if we received an error or their is no response on the results return an error
         if (error) {
           if (handleFail === 'fail') {
@@ -848,6 +851,23 @@ class RequestHandler {
 
         // Determine the Protocol so the appropriate handler can be called
         if (entitySchema.protocol.toUpperCase() === 'REST') {
+          // override the data types on the request
+          if (requestObj && requestObj.datatype) {
+            // must have a legitimate request data type
+            if (requestObj.datatype.request && (requestObj.datatype.request.toUpperCase() === 'JSON'
+                || requestObj.datatype.request.toUpperCase() === 'XML' || requestObj.datatype.request.toUpperCase() === 'URLENCODE'
+                || requestObj.datatype.request.toUpperCase() === 'URLQUERY' || requestObj.datatype.request.toUpperCase() === 'FORM'
+                || requestObj.datatype.request.toUpperCase() === 'JSON2XML' || requestObj.datatype.request.toUpperCase() === 'PLAIN')) {
+              entitySchema.requestDatatype = requestObj.datatype.request;
+            }
+            // must have a legitimate response data type
+            if (requestObj.datatype.response && (requestObj.datatype.response.toUpperCase() === 'JSON'
+                || requestObj.datatype.response.toUpperCase() === 'XML' || requestObj.datatype.response.toUpperCase() === 'URLENCODE'
+                || requestObj.datatype.response.toUpperCase() === 'XML2JSON' || requestObj.datatype.response.toUpperCase() === 'PLAIN')) {
+              entitySchema.responseDatatype = requestObj.datatype.response;
+            }
+          }
+
           return this.restHandler.genericRestRequest(entity, action, entitySchema, requestObj, translate, (result, error) => {
             const overallDiff = process.hrtime(overallTime);
             const overallEnd = `${Math.round(((overallDiff[0] * NS_PER_SEC) + overallDiff[1]) / 1000000)}ms`;
@@ -1537,7 +1557,30 @@ class RequestHandler {
     log.trace(origin);
 
     try {
-      return this.brokerHandler.hasEntities(entityType, entityList, callback);
+      return this.brokerHandler.hasEntities(entityType, entityList, {}, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker hasEntities Failed');
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Determines if this adapter supports any in a list of entities with custom auth
+   *
+   * @function hasEntitiesAuth
+   * @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
+   */
+  hasEntitiesAuth(entityType, entityList, callOptions, callback) {
+    const origin = `${this.myid}-requestHandler-hasEntitiesAuth`;
+    log.trace(origin);
+
+    try {
+      return this.brokerHandler.hasEntities(entityType, entityList, callOptions, callback);
     } catch (e) {
       // handle any exception
       const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker hasEntities Failed');
@@ -1559,7 +1602,29 @@ class RequestHandler {
     log.trace(origin);
 
     try {
-      return this.brokerHandler.getDevice(deviceName, callback);
+      return this.brokerHandler.getDevice(deviceName, {}, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker getDevice Failed');
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Get Appliance that match the deviceName with custom auth
+   *
+   * @function getDeviceAuth
+   * @param {String} deviceName - the deviceName to find (required)
+   *
+   * @param {getCallback} callback - a callback function to return the result
+   *                                 (appliance) or the error
+   */
+  getDeviceAuth(deviceName, callOptions, callback) {
+    const origin = `${this.myid}-requestHandler-getDeviceAuth`;
+    log.trace(origin);
+
+    try {
+      return this.brokerHandler.getDevice(deviceName, callOptions, callback);
     } catch (e) {
       // handle any exception
       const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker getDevice Failed');
@@ -1579,8 +1644,31 @@ class RequestHandler {
   getDevicesFiltered(options, callback) {
     const origin = `${this.myid}-requestHandler-getDevicesFiltered`;
     log.trace(origin);
+
+    try {
+      return this.brokerHandler.getDevicesFiltered(options, {}, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker getDevicesFiltered Failed');
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Get Appliances that match the filter with custom auth
+   *
+   * @function getDevicesFilteredAuth
+   * @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
+   */
+  getDevicesFilteredAuth(options, callOptions, callback) {
+    const origin = `${this.myid}-requestHandler-getDevicesFiltered`;
+    log.trace(origin);
+
     try {
-      return this.brokerHandler.getDevicesFiltered(options, callback);
+      return this.brokerHandler.getDevicesFiltered(options, callOptions, callback);
     } catch (e) {
       // handle any exception
       const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker getDevicesFiltered Failed');
@@ -1602,7 +1690,29 @@ class RequestHandler {
     log.trace(origin);
 
     try {
-      return this.brokerHandler.isAlive(deviceName, callback);
+      return this.brokerHandler.isAlive(deviceName, {}, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker isAlive Failed');
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Gets the status for the provided appliance with custom auth
+   *
+   * @function isAliveAuth
+   * @param {String} deviceName - the deviceName of the appliance. (required)
+   *
+   * @param {configCallback} callback - callback function to return the result
+   *                                    (appliance isAlive) or the error
+   */
+  isAliveAuth(deviceName, callOptions, callback) {
+    const origin = `${this.myid}-requestHandler-isAliveAuth`;
+    log.trace(origin);
+
+    try {
+      return this.brokerHandler.isAlive(deviceName, callOptions, callback);
     } catch (e) {
       // handle any exception
       const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker isAlive Failed');
@@ -1625,7 +1735,30 @@ class RequestHandler {
     log.trace(origin);
 
     try {
-      return this.brokerHandler.getConfig(deviceName, format, callback);
+      return this.brokerHandler.getConfig(deviceName, format, {}, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker getConfig Failed');
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Gets a config for the provided Appliance with custom auth
+   *
+   * @function getConfigAuth
+   * @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
+   */
+  getConfigAuth(deviceName, format, callOptions, callback) {
+    const origin = `${this.myid}-requestHandler-getConfigAuth`;
+    log.trace(origin);
+
+    try {
+      return this.brokerHandler.getConfig(deviceName, format, callOptions, callback);
     } catch (e) {
       // handle any exception
       const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker getConfig Failed');
@@ -1646,7 +1779,28 @@ class RequestHandler {
     log.trace(origin);
 
     try {
-      return this.brokerHandler.iapGetDeviceCount(callback);
+      return this.brokerHandler.iapGetDeviceCount({}, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker iapGetDeviceCount Failed');
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * @summary Gets the device count from the system with custom auth
+   *
+   * @function iapGetDeviceCount
+   *
+   * @param {getCallback} callback - callback function to return the result
+   *                                    (count) or the error
+   */
+  iapGetDeviceCountAuth(callOptions, callback) {
+    const origin = `${this.myid}-requestHandler-iapGetDeviceCountAuth`;
+    log.trace(origin);
+
+    try {
+      return this.brokerHandler.iapGetDeviceCount(callOptions, callback);
     } catch (e) {
       // handle any exception
       const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker iapGetDeviceCount Failed');
@@ -1746,6 +1900,39 @@ class RequestHandler {
       return callback(null, errorObj);
     }
   }
+
+  /* ********************************************** */
+  /*                                                */
+  /*          EXPOSES AUTH HANDLER               */
+  /*                                                */
+  /* ********************************************** */
+
+  /**
+   * @summary Gets the hcma authorization for the call
+   *
+   * @function getAWSAuthorization
+   * @param {string} method - the method for the action we are setting authorization for
+   * @param {object} requestObj - an object that contains all of the possible parts of the request (payload, uriPathVars,
+   *                              uriQuery, uriOptions and addlHeaders (optional). Can be a stringified Object.
+   * @param {string} uriPath - the path for the call. (required)
+   * @param {string} service - the AWS service we are talking to
+   * @param {object} [stsParams] - STS Parameters to use for authentication.
+   * @param {string} [roleName] - RoleName to authenticate against
+   *
+   *  @return {Object} the headers to add to the request
+   */
+  getAWSAuthorization(method, requestObj, uriPath, service, STSParams, roleName, callback) {
+    const origin = `${this.myid}-requestHandler-getAWSAuthentication`;
+    log.trace(origin);
+
+    try {
+      return this.authHandler.getAWSAuthorization(method, requestObj, uriPath, null, null, service, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'AWS Authentication Request Failed');
+      return callback(null, errorObj);
+    }
+  }
 }
 
 module.exports = RequestHandler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itentialopensource/adapter-utils",
-  "version": "5.1.1",
+  "version": "5.1.3",
   "description": "Itential Adapter Utility Libraries",
   "scripts": {
     "postinstall": "node utils/setup.js",
@@ -27,6 +27,8 @@
   "dependencies": {
     "ajv": "^8.12.0",
     "async-lock": "^1.4.0",
+    "aws-sdk": "^2.1363.0",
+    "aws4": "^1.9.1",
     "cookie": "^0.5.0",
     "crypto-js": "^4.1.1",
     "ejs": "^3.1.9",