@itentialopensource/adapter-utils 4.48.16 → 5.0.0

package/lib/requestHandler.js

@@ -1,7 +1,8 @@
+/* eslint-disable no-param-reassign */
 /* @copyright Itential, LLC 2018 */
 
 // Set globals
-/* global log g_redis */
+/* global log */
 /* eslint consistent-return: warn */
 /* eslint global-require: warn */
 /* eslint import/no-dynamic-require: warn */
@@ -9,15 +10,19 @@
 /* NodeJS internal utilities */
 const fs = require('fs');
 const path = require('path');
-const AsyncLockCl = require('async-lock');
+const jsonQuery = require('json-query');
 
 // The schema validator
 const AjvCl = require('ajv');
+const { request } = require('http');
 
 /* Fetch in the other needed components for the this Class */
 const RestHandlerCl = require(path.join(__dirname, '/restHandler.js'));
-const PropUtilCl = require(path.join(__dirname, '/propertyUtil.js'));
+const CacheHandlerCl = require(path.join(__dirname, '/cacheHandler.js'));
+const BrokerHandlerCl = require(path.join(__dirname, '/brokerHandler.js'));
+const GenericHandlerCl = require(path.join(__dirname, '/genericHandler.js'));
 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'));
 
@@ -29,11 +34,7 @@ let propUtilInst = null;
 let transUtilInst = null;
 const NS_PER_SEC = 1e9;
 let username = null;
-
-// used for local cache or a temp if using redis
-let cache = {};
-const cachelock = 0;
-let clock = null;
+let healthcheckpath = null;
 
 // INTERNAL FUNCTIONS
 /**
@@ -60,10 +61,12 @@ function validateProperties(properties) {
     const combinedProps = propUtilInst.mergeProperties(properties, propUtilInst.setDefaults(propertySchema));
 
     // validate the entity against the schema
-    const ajvInst = new AjvCl();
+    const ajvInst = new AjvCl({ strictSchema: false, allowUnionTypes: true });
     const validate = ajvInst.compile(propertySchema);
     const result = validate(combinedProps);
 
+    log.info(`request is ${request}`); // for lint
+
     // if invalid properties throw an error
     if (!result) {
       // create the generic part of an error object
@@ -141,7 +144,7 @@ function walkThroughActionFiles(directory) {
             const allActions = propUtilInst.mergeProperties(actions, defActions);
 
             // validate the entity against the schema
-            const ajvInst = new AjvCl();
+            const ajvInst = new AjvCl({ strictSchema: false, allowUnionTypes: true });
             const validate = ajvInst.compile(actionSchema);
             const result = validate(allActions);
 
@@ -261,58 +264,6 @@ function walkThroughActionFiles(directory) {
   }
 }
 
-/**
- * @summary Method to check if the entity is in the cache
- *
- * @function isEntityCached
- * @param {String} entityType - the entity type to check for
- * @param {String/Array} entityId - the specific entity we are looking for
- *
- * @return {Array of Enumeration} - whether the entity was
- *                   'found' - entity was found
- *                   'notfound' - entity was not found
- *                   'needupdate' - update cache and try again
- */
-function isEntityCached(entityType, entityId) {
-  const origin = `${id}-requestHandler-isEntityCached`;
-  log.trace(origin);
-  let entityIds = entityId;
-  const results = [];
-
-  // go through the cache
-  if (cache[entityType]) {
-    const now = new Date().getTime();
-
-    // see if the cache is valid
-    if ((cache[entityType].updated) && (cache[entityType].updated >= now - 300000)) {
-      // entityId is not an Array, make it one
-      if (!Array.isArray(entityIds)) {
-        entityIds = [entityId];
-      }
-
-      for (let e = 0; e < entityIds.length; e += 1) {
-        // see if the device is in the cache
-        if (cache[entityType].list.includes(entityIds[e])) {
-          log.trace(`${origin}: Entity ${entityIds[e]} found in cache`);
-          results.push('found');
-        } else {
-          log.trace(`${origin}: Entity ${entityIds[e]} not found in cache`);
-          results.push('notfound');
-        }
-      }
-
-      return results;
-    }
-
-    log.warn(`${origin}: Entity Cache out of date`);
-    return ['needupdate'];
-  }
-
-  // Entity not found in cache
-  log.warn(`${origin}: Entity not in cache`);
-  return ['needupdate'];
-}
-
 /**
  * @summary Method for metric db calls and tests
  *
@@ -374,6 +325,27 @@ function dbCalls(collectionName, entity, action, data, callback) {
   }
 }
 
+/*
+ * INTERNAL FUNCTION: get data from source(s) - nested
+ */
+function getDataFromSources(loopField, sources) {
+  let fieldValue = loopField;
+
+  // go through the sources to find the field
+  for (let s = 0; s < sources.length; s += 1) {
+    // find the field value using jsonquery
+    const nestedValue = jsonQuery(loopField, { data: sources[s] }).value;
+
+    // if we found in source - set and no need to check other sources
+    if (nestedValue) {
+      fieldValue = nestedValue;
+      break;
+    }
+  }
+
+  return fieldValue;
+}
+
 class RequestHandler {
   /**
    * Request Handler
@@ -406,8 +378,6 @@ class RequestHandler {
 
       // save the adapter base directory
       this.adapterBaseDir = directory;
-      this.clockInst = new AsyncLockCl();
-      clock = this.clockInst;
 
       // set up the properties I care about
       this.refreshProperties(properties);
@@ -415,10 +385,13 @@ class RequestHandler {
       // instantiate other runtime components
       this.connector = new ConnectorCl(this.myid, this.props, this.transUtil, this.propUtil, this.dbUtil);
       this.restHandler = new RestHandlerCl(this.myid, this.props, this.connector, this.transUtil);
+      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);
     } catch (e) {
       // handle any exception
       const origin = `${this.myid}-requestHandler-constructor`;
-      return this.transUtil.checkAndThrow(e, origin, 'Could not start Adapter Runtime Library');
+      this.transUtil.checkAndThrow(e, origin, 'Could not start Adapter Runtime Library');
     }
   }
 
@@ -443,7 +416,6 @@ class RequestHandler {
     try {
       // validate the properties that came in against library property schema
       this.props = validateProperties(properties);
-
       // get the list of failover codes
       this.failoverCodes = [];
 
@@ -452,13 +424,6 @@ class RequestHandler {
         this.failoverCodes = this.props.request.failover_codes;
       }
 
-      // get the cache location
-      this.cacheLocation = 'local';
-
-      if (this.props.cache_location) {
-        this.cacheLocation = this.props.cache_location;
-      }
-
       this.saveMetric = this.props.save_metric || false;
 
       // set the username (required - default is null)
@@ -466,6 +431,13 @@ class RequestHandler {
         username = this.props.authentication.username;
       }
 
+      // set the healthcheck path (required - default is null)
+      if (this.props.healthcheck) {
+        if (typeof this.props.healthcheck.URI_Path === 'string') {
+          healthcheckpath = this.props.healthcheck.URI_Path;
+        }
+      }
+
       // if this is truly a refresh and we have a connector or rest handler, refresh them
       if (this.connector) {
         this.connector.refreshProperties(properties);
@@ -473,6 +445,15 @@ class RequestHandler {
       if (this.restHandler) {
         this.restHandler.refreshProperties(properties);
       }
+      if (this.cacheHandler) {
+        this.cacheHandler.refreshProperties(properties);
+      }
+      if (this.brokerHandler) {
+        this.brokerHandler.refreshProperties(properties);
+      }
+      if (this.genericHandler) {
+        this.genericHandler.refreshProperties(properties);
+      }
     } catch (e) {
       // handle any exception
       return this.transUtil.checkAndThrow(e, origin, 'Properties may not have been updated properly');
@@ -544,6 +525,264 @@ class RequestHandler {
     }
   }
 
+  /**
+   * @summary Make the provided call(s) - could be one of many
+   *
+   * @function iapMakeGenericCall
+   * @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)
+   * @param {string} filterName - any filter to search on (required)
+   *
+   * @param {getCallback} callback - a callback function to return the result of the call
+   */
+  iapMakeGenericCall(callName, callProps, devResp, filterName, callback) {
+    const meth = 'requestHandler-iapMakeGenericCall';
+    const origin = `${this.myid}-${meth}`;
+    log.trace(`${origin}: ${callName}`);
+
+    try {
+      let uriPath = '';
+      let uriMethod = 'GET';
+      let callQuery = {};
+      let callBody = {};
+      let callHeaders = {};
+      let handleFail = 'fail';
+      let ostypePrefix = '';
+      let statusValue = 'true';
+      if (callProps.path) {
+        uriPath = `${callProps.path}`;
+
+        // make any necessary changes to the path
+        if (devResp !== null && callProps.requestFields && Object.keys(callProps.requestFields).length > 0) {
+          const rqKeys = Object.keys(callProps.requestFields);
+
+          // get the field from the provided device
+          for (let rq = 0; rq < rqKeys.length; rq += 1) {
+            const fieldValue = getDataFromSources(callProps.requestFields[rqKeys[rq]], devResp);
+
+            // put the value into the path - if it has been specified in the path
+            uriPath = uriPath.replace(`{${rqKeys[rq]}}`, fieldValue);
+          }
+        }
+      }
+      if (callProps.method) {
+        uriMethod = callProps.method;
+      }
+      if (callProps.query) {
+        callQuery = { ...callProps.query };
+        // go through the query params to check for variable values
+        const cpKeys = Object.keys(callQuery);
+        for (let cp = 0; cp < cpKeys.length; cp += 1) {
+          // if (callQuery[cpKeys[cp]].startsWith('{') && callQuery[cpKeys[cp]].endsWith('}')) {
+          // make any necessary changes to the query params
+          if (devResp !== null && callProps.requestFields && Object.keys(callProps.requestFields).length > 0) {
+            const rqKeys = Object.keys(callProps.requestFields);
+
+            // get the field from the provided device
+            for (let rq = 0; rq < rqKeys.length; rq += 1) {
+              if (callQuery[cpKeys[cp]] === rqKeys[rq]) {
+                const fieldValue = getDataFromSources(callProps.requestFields[rqKeys[rq]], devResp);
+                // put the value into the query - if it has been specified in the query
+                callQuery[cpKeys[cp]] = fieldValue;
+              }
+            }
+          }
+          // }
+        }
+      }
+      if (callProps.body) {
+        callBody = { ...callProps.body };
+
+        // go through the body fields to check for variable values
+        const cbKeys = Object.keys(callBody);
+        for (let cb = 0; cb < cbKeys.length; cb += 1) {
+          // if (callBody[cbKeys[cb]].startsWith('{') && callBody[cbKeys[cb]].endsWith('}')) {
+          // make any necessary changes to the query params
+          if (devResp !== null && callProps.requestFields && Object.keys(callProps.requestFields).length > 0) {
+            const rqKeys = Object.keys(callProps.requestFields);
+
+            // get the field from the provided device
+            for (let rq = 0; rq < rqKeys.length; rq += 1) {
+              if (callBody[cbKeys[cb]] === rqKeys[rq]) {
+                const fieldValue = getDataFromSources(callProps.requestFields[rqKeys[rq]], devResp);
+
+                // put the value into the query - if it has been specified in the query
+                callBody[cbKeys[cb]] = fieldValue;
+              }
+            }
+          }
+          // }
+        }
+      }
+      if (callProps.headers) {
+        callHeaders = { ...callProps.headers };
+
+        // go through the body fields to check for variable values
+        const chKeys = Object.keys(callHeaders);
+        for (let ch = 0; ch < chKeys.length; ch += 1) {
+          // if (callHeaders[chKeys[ch]].startsWith('{') && callHeaders[chKeys[ch]].endsWith('}')) {
+          // make any necessary changes to the query params
+          if (devResp !== null && callProps.requestFields && Object.keys(callProps.requestFields).length > 0) {
+            const rqKeys = Object.keys(callProps.requestFields);
+
+            // get the field from the provided device
+            for (let rq = 0; rq < rqKeys.length; rq += 1) {
+              if (callHeaders[chKeys[ch]] === rqKeys[rq]) {
+                const fieldValue = getDataFromSources(callProps.requestFields[rqKeys[rq]], devResp);
+
+                // put the value into the query - if it has been specified in the query
+                callHeaders[chKeys[ch]] = fieldValue;
+              }
+            }
+          }
+          // }
+        }
+      }
+      if (callProps.handleFailure) {
+        handleFail = callProps.handleFailure;
+      }
+      if (callProps.responseFields && callProps.responseFields.ostypePrefix) {
+        ostypePrefix = callProps.responseFields.ostypePrefix;
+      }
+      if (callProps.responseFields && callProps.responseFields.statusValue) {
+        statusValue = callProps.responseFields.statusValue;
+      }
+
+      // !! 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) => {
+        // if we received an error or their is no response on the results return an error
+        if (error) {
+          if (handleFail === 'fail') {
+            return callback(null, error);
+          }
+          return callback({}, null);
+        }
+        if (!result.response) {
+          if (handleFail === 'fail') {
+            const errorObj = this.formatErrorObject(this.myid, meth, 'Invalid Response', [callName], null, null, null);
+            log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+            return callback(null, errorObj);
+          }
+          return callback({}, null);
+        }
+
+        // get the response piece we care about from the response
+        const myResult = result;
+        if (callProps.responseDatakey) {
+          myResult.response = jsonQuery(callProps.responseDatakey, { data: myResult.response }).value;
+        }
+
+        // get the keys for the response fields
+        let rfKeys = [];
+        if (callProps.responseFields && Object.keys(callProps.responseFields).length > 0) {
+          rfKeys = Object.keys(callProps.responseFields);
+        }
+
+        // if we got an array returned (e.g. getDevicesFitered)
+        if (Array.isArray(myResult.response)) {
+          const listDevices = [];
+          for (let a = 0; a < myResult.response.length; a += 1) {
+            const thisDevice = myResult.response[a];
+            for (let rf = 0; rf < rfKeys.length; rf += 1) {
+              if (rfKeys[rf] !== 'ostypePrefix') {
+                let fieldValue = getDataFromSources(callProps.responseFields[rfKeys[rf]], [thisDevice, devResp, callProps.requestFields]);
+
+                // if the field is ostype - need to add prefix
+                if (rfKeys[rf] === 'ostype' && typeof fieldValue === 'string') {
+                  fieldValue = ostypePrefix + fieldValue;
+                }
+                // if there is a status to set, set it
+                if (rfKeys[rf] === 'status') {
+                  // if really looking for just a good response
+                  if (callProps.responseFields[rfKeys[rf]] === 'return2xx' && myResult.icode === statusValue.toString()) {
+                    thisDevice.isAlive = true;
+                  } else if (fieldValue.toString() === statusValue.toString()) {
+                    thisDevice.isAlive = true;
+                  } else {
+                    thisDevice.isAlive = false;
+                  }
+                }
+                // if we found a good value
+                thisDevice[rfKeys[rf]] = fieldValue;
+              }
+            }
+
+            // if there is no filter - add the device to the list
+            if (!filterName || filterName.length === 0) {
+              listDevices.push(thisDevice);
+            } else {
+              // if we have to match a filter
+              let found = false;
+              for (let f = 0; f < filterName.length; f += 1) {
+                if (thisDevice.name.indexOf(filterName[f]) >= 0) {
+                  found = true;
+                  break;
+                }
+              }
+              // matching device
+              if (found) {
+                listDevices.push(thisDevice);
+              }
+            }
+          }
+
+          // return the array of devices
+          return callback(listDevices, null);
+        }
+
+        // if this is not an array - just about everything else, just handle as a single object
+        let thisDevice = myResult.response;
+        for (let rf = 0; rf < rfKeys.length; rf += 1) {
+          // skip ostypePrefix since it is not a field
+          if (rfKeys[rf] !== 'ostypePrefix') {
+            let fieldValue = getDataFromSources(callProps.responseFields[rfKeys[rf]], [thisDevice, devResp, callProps.requestFields]);
+
+            // if the field is ostype - need to add prefix
+            if (rfKeys[rf] === 'ostype' && typeof fieldValue === 'string') {
+              fieldValue = ostypePrefix + fieldValue;
+            }
+            // if there is a status to set, set it
+            if (rfKeys[rf] === 'status') {
+              // if really looking for just a good response
+              if (callProps.responseFields[rfKeys[rf]] === 'return2xx' && myResult.icode === statusValue.toString()) {
+                thisDevice.isAlive = true;
+              } else if (fieldValue.toString() === statusValue.toString()) {
+                thisDevice.isAlive = true;
+              } else {
+                thisDevice.isAlive = false;
+              }
+            }
+            // if we found a good value
+            thisDevice[rfKeys[rf]] = fieldValue;
+          }
+        }
+
+        // if there is a filter - check the device is in the list
+        if (filterName && filterName.length > 0) {
+          let found = false;
+          for (let f = 0; f < filterName.length; f += 1) {
+            if (thisDevice.name.indexOf(filterName[f]) >= 0) {
+              found = true;
+              break;
+            }
+          }
+          // no matching device - clear the device
+          if (!found) {
+            thisDevice = {};
+          }
+        }
+
+        return callback(thisDevice, null);
+      });
+    } catch (e) {
+      const errorObj = this.formatErrorObject(this.myid, meth, 'Caught Exception', null, null, null, e);
+      log.error(`${origin}: ${errorObj.IAPerror.displayString}`);
+      return callback(null, errorObj);
+    }
+  }
+
   /**
    * @summary Method that identifies the actual request to be made and then
    * makes the call through the appropriate Handler
@@ -567,7 +806,6 @@ class RequestHandler {
     const origin = `${this.myid}-${meth}`;
     log.trace(`${origin}: ${entity}-${action}`);
     const overallTime = process.hrtime();
-
     try {
       // verify parameters passed are valid
       if (entity === null || entity === '') {
@@ -581,6 +819,18 @@ class RequestHandler {
         return callback(null, errorObj);
       }
 
+      if (this.props.cache.enabled && action !== 'getGenerics' && this.cacheHandler.isTaskCached(entity, action)) {
+        return this.retrieveEntitiesCache(entity, {}, (result, error) => {
+          if (error) {
+            return callback(null, error);
+          }
+          if (translate) {
+            return callback(result);
+          }
+          return callback('success');
+        });
+      }
+
       // Get the entity schema from the file system
       return this.propUtil.getEntitySchema(entity, action, this.props.choosepath, this.dbUtil, (entitySchema, entityError) => {
         // verify protocol for call
@@ -608,7 +858,6 @@ class RequestHandler {
               }
 
               newError.metrics.capabilityTime = overallEnd;
-              // console.log(newError); //can't test b/c no errors built into tests rn.
               // will call from adapterFunction.ejs only eventually since it will have all metrics here + the 2 missing ones.
               if (this.saveMetric) {
                 dbCalls('metrics', entity, action, newError.metrics, (saved) => {
@@ -683,6 +932,13 @@ class RequestHandler {
           log.debug(`${origin}: Using adapter properties for healthcheck information`);
         } else {
           log.debug(`${origin}: Using action and schema for healthcheck information`);
+          if (healthcheckpath) {
+            log.debug('Reading healthcheck URI from Service Instance Configuration.');
+            healthSchema.entitypath = healthcheckpath;
+            if (healthSchema.mockresponses && healthSchema.mockresponses[0] && healthSchema.mockresponses[0].name) {
+              healthSchema.mockresponses[0].name = healthcheckpath;
+            }
+          }
         }
 
         if (healthSchema && healthSchema.protocol) {
@@ -701,7 +957,6 @@ class RequestHandler {
               }
 
               newError.metrics.capabilityTime = overallEnd;
-              // console.log(newError); //can't test b/c no errors built into tests rn.
               // will call from adapterFunction.ejs only eventually since it will have all metrics here + the 2 missing ones.
               if (this.saveMetric) {
                 dbCalls('metrics', '.system', 'healthcheck', newError.metrics, (saved) => {
@@ -871,131 +1126,6 @@ class RequestHandler {
     }
   }
 
-  /**
-   * @summary Check the current cache to see if we know about a specific entity
-   *
-   * @function isEntityCached
-   * @param {String} entityType - the entity type to check for
-   * @param {String/Array} entityId - the specific entity we are looking for
-   *
-   * @return {Array of Enumeration} - whether the entity was
-   *                   'found' - entity was found
-   *                   'notfound' - entity was not found
-   *                   'error' - there was an error - check logs
-   *                   'needupdate' - update cache and try again
-   */
-  checkEntityCached(entityType, entityId, callback) {
-    const origin = `${this.myid}-requestHandler-checkEntityCached`;
-    log.trace(origin);
-
-    try {
-      if (this.cacheLocation === 'redis') {
-        const ckey = `${this.myid}__%%__cache`;
-
-        // get the cache from redis
-        return g_redis.get(ckey, (err, res) => {
-          if (err) {
-            log.error(`${origin}: Error on retrieve cache for ${ckey}`);
-            return callback(['error']);
-          }
-
-          // if there was no cache returned
-          if (!res) {
-            log.error(`${origin}: No cache for ${ckey}`);
-            return callback(['needupdate']);
-          }
-
-          // set the local cache to what we got from redis (temp storage)
-          cache = res;
-          return callback(isEntityCached(entityType, entityId));
-        });
-      }
-
-      return callback(isEntityCached(entityType, entityId));
-    } catch (e) {
-      log.error(`${origin}: Caught Exception ${e}`);
-      return callback(['error']);
-    }
-  }
-
-  /**
-   * @summary Adds the provided entity list to the cache
-   *
-   * @function addEntityCache
-   * @param {String} entityType - the entity type for the list
-   * @param {Array} entities - the list of entities to be added
-   *
-   * @param {Callback} callback - whether the cache was updated
-   */
-  addEntityCache(entityType, entities, callback) {
-    const meth = 'requestHandler-addEntityCache';
-    const origin = `${this.myid}-${meth}`;
-    log.trace(origin);
-    let storeEnt = entities;
-
-    if (!Array.isArray(entities)) {
-      storeEnt = [entities];
-    }
-
-    const entityEntry = {
-      list: storeEnt,
-      updated: new Date().getTime()
-    };
-
-    try {
-      // Lock the cache while adding items to it
-      return clock.acquire(cachelock, (done) => {
-        // if only storing locally, done
-        if (this.cacheLocation === 'local') {
-          // add the entities to the cache
-          cache[entityType] = entityEntry;
-          done(true, null);
-        } else {
-          // set the redis key
-          const ckey = `${this.myid}__%%__cache`;
-
-          // get the cache from redis
-          g_redis.get(ckey, (err, res) => {
-            if (err) {
-              log.error(`${origin}: Error on retrieve cache for ${ckey}`);
-              done(false, null);
-            } else {
-              cache = res;
-
-              // if no cache was found
-              if (!cache) {
-                cache = {};
-              }
-
-              // add the entities to the cache
-              cache[entityType] = entityEntry;
-
-              // store the cache in redis
-              g_redis.set(ckey, JSON.stringify(cache), (error) => {
-                if (error) {
-                  log.error(`${origin}: Cache: ${ckey} not stored in redis`);
-                  done(false, null);
-                } else {
-                  done(true, null);
-                }
-              });
-            }
-          });
-        }
-      }, (ret, error) => {
-        if (error) {
-          log.error(`${origin}: Error from retrieving entity cache: ${error}`);
-        }
-
-        return callback(ret, error);
-      });
-    } catch (e) {
-      // handle any exception
-      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Issue adding entity to cache');
-      return callback(null, errorObj);
-    }
-  }
-
   /**
    * @summary Provides a way for the adapter to tell north bound integrations
    * whether the adapter supports type and specific entity
@@ -1003,18 +1133,18 @@ class RequestHandler {
    * @function verifyCapability
    * @param {String} entityType - the entity type to check for
    * @param {String} actionType - the action type to check for
-   * @param {String/Array} entityId - the specific entity we are looking for
+   * @param {String/Array} entityId - the specific entity we are looking for only works
+   *                      if caching for that entityType is enabled. does not make API call!
    *
    * @return {Array of Enumeration} - whether the entity was
    *                   'found' - entity was found
    *                   'notfound' - entity was not found
    *                   'error' - there was an error - check logs
-   *                   'needupdate' - update cache and try again
    */
   verifyCapability(entityType, actionType, entityId, callback) {
     const origin = `${this.myid}-requestHandler-verifyCapability`;
     log.trace(origin);
-    const entitiesD = `${this.adapterBaseDir}/entities`;
+    const entitiesD = `${this.adapterBaseDir}/entities`; // causes verifyCapability errors
 
     try {
       // verify the entities directory exists
@@ -1025,7 +1155,6 @@ class RequestHandler {
 
       // get the entities this adapter supports
       const entities = fs.readdirSync(entitiesD);
-
       // go through the entities
       for (let e = 0; e < entities.length; e += 1) {
         // did we find the entity type?
@@ -1033,16 +1162,23 @@ class RequestHandler {
           // if we are only interested in the entity
           if (!actionType && !entityId) {
             return callback(['found']);
+            // return callback([true]);
           }
           // if we do not have an action, check for the specific entity
           if (!actionType) {
-            return this.checkEntityCached(entityType, entityId, callback);
+            return this.checkEntityCached(entityType, entityId, (data, error) => {
+              if (error) {
+                log.error(`${origin}: Failed check entity cached with error ${error}`);
+                return callback(null, error);
+              }
+              return callback(data);
+            });
           }
 
           // get the entity actions from the action file
           const actionFile = `${entitiesD}/${entities[e]}/action.json`;
           if (fs.existsSync(actionFile)) {
-            const actionJson = require(actionFile);
+            const actionJson = require(actionFile); // fails verify unit test, exists but can't require
             const { actions } = actionJson;
 
             // go through the actions for a match
@@ -1052,7 +1188,16 @@ class RequestHandler {
                 if (!entityId) {
                   return callback(['found']);
                 }
-                return this.checkEntityCached(entityType, entityId, callback);
+                return this.checkEntityCached(entityType, entityId, (data, error) => {
+                  if (error) {
+                    log.error(`${origin}: Failed check entity cached with error ${error}`);
+                    return callback(null, error);
+                  }
+                  if (data) {
+                    return callback(['found']);
+                  }
+                  return callback(['notfound']);
+                });
               }
             }
 
@@ -1168,13 +1313,439 @@ class RequestHandler {
       }
 
       // validate the action files for the adapter
-      return this.connector.makeTokenRequest('/none/token/path', useUser, reqBody, null, callProperties, callback);
+      return callback(this.connector.makeTokenRequest('/none/token/path', useUser, reqBody, null, callProperties, callback));
     } catch (e) {
       // handle any exception
       const errorObj = this.transUtil.checkAndReturn(e, origin, 'Issue getting token');
       return callback(null, errorObj);
     }
   }
+
+  /**
+   * @summary provide inventory information abbout the adapter
+   *
+   * @function getAdapterInventory
+   *
+   * @return {Object} - containing the adapter inventory information
+   */
+  getAdapterInventory(callback) {
+    const origin = `${this.myid}-requestHandler-getAdapterInventory`;
+    log.trace(origin);
+
+    try {
+      const adapterInv = {
+        issues: {}
+      };
+
+      // are the utils within the adapter
+      if (__dirname.indexOf(this.directory) === 0) {
+        adapterInv.issues.embedUtils = true;
+      } else {
+        adapterInv.issues.embedUtils = false;
+      }
+
+      // get the adapter package.json
+      if (fs.existsSync(path.join(this.directory, 'package.json'))) {
+        const adaptPackage = require(path.join(this.directory, 'package.json'));
+
+        // Namespace - package & directory
+        const [tempNS, tempName] = adaptPackage.name.split('/');
+        adapterInv.namespace = tempNS;
+        if (this.directory.indexOf(adapterInv.namespace) > 0) {
+          adapterInv.issues.inNamespace = true;
+        } else {
+          adapterInv.issues.inNamespace = false;
+        }
+
+        // Name - package & directory
+        adapterInv.name = tempName;
+        if (this.directory.indexOf(adapterInv.name) > 0) {
+          adapterInv.issues.inName = true;
+        } else {
+          adapterInv.issues.inName = false;
+        }
+
+        // Version - package
+        adapterInv.version = adaptPackage.version;
+      } else {
+        adapterInv.namespace = 'TBD';
+        adapterInv.issues.inNamespace = false;
+        adapterInv.name = 'TBD';
+        adapterInv.issues.inName = false;
+        adapterInv.version = 'TBD';
+      }
+
+      // get the adapter pronghorn.json
+      adapterInv.brokerDefined = false;
+      adapterInv.cacheDefined = false;
+      if (fs.existsSync(path.join(this.directory, 'pronghorn.json'))) {
+        const adaptPronghorn = require(path.join(this.directory, 'pronghorn.json'));
+
+        // Active WF Tasks - pronghorn.json
+        let wfCount = 0;
+        for (let i = 0; i < adaptPronghorn.methods.length; i += 1) {
+          if (adaptPronghorn.methods[i].task === true) {
+            wfCount += 1;
+          }
+          if (adaptPronghorn.methods[i].name === 'getDevicesFiltered') {
+            adapterInv.brokerDefined = true;
+          }
+          if (adaptPronghorn.methods[i].name === 'iapUpdateAdapterCache') {
+            adapterInv.cacheDefined = true;
+          }
+        }
+        adapterInv.activeWFTasks = wfCount;
+      } else {
+        adapterInv.activeWFTasks = -1;
+      }
+
+      // get the utils package.json
+      if (fs.existsSync('../package.json')) {
+        const utilsPackage = require('../package.json');
+
+        // Version of adapter-utils - utils package
+        adapterInv.utilVersion = utilsPackage.version;
+      } else {
+        adapterInv.utilVersion = 'TBD';
+      }
+
+      // return the results
+      return callback(adapterInv);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Issue getting Inventory information');
+      return callback(null, errorObj);
+    }
+  }
+
+  /* ********************************************** */
+  /*                                                */
+  /*           EXPOSES CACHE HANDLER                */
+  /*                                                */
+  /* ********************************************** */
+  /**
+   * @summary Check the current cache to see if we know about a specific entity
+   *
+   * @function checkEntityCached
+   * @param {String} entityType - the entity type to check for
+   * @param {String/Array} entityNames - the specific entity we are looking for
+   *
+   * @return {Array of Boolean} - for each entity name, whether found
+   */
+  checkEntityCached(entityType, entityNames, callback) {
+    const origin = `${this.myid}-requestHandler-checkEntityCached`;
+    log.trace(origin);
+
+    try {
+      return this.cacheHandler.isEntityCached(entityType, entityNames, callback);
+    } catch (e) {
+      // handle any exception
+      log.error('Check Entity Cached failed with error.');
+      return callback(false); // pretend no error and that it is not cached
+    }
+  }
+
+  /**
+   * @function checkEntityTypeCached
+   * @summary checks whether an entity type is currently cached
+   * @param {String} entityType - entity type to check
+   * @return {Boolean} - whether or not the entity type is in cache
+   */
+  checkEntityTypeCached(entityType, callback) {
+    const origin = `${this.myid}-requestHandler-checkEntityTypeCached`;
+    log.trace(origin);
+
+    try {
+      return this.cacheHandler.isEntityTypeToBeCached(entityType, callback);
+    } catch (e) {
+      // handle any exception
+      log.error('Check Entity Type Cached failed with error.');
+      return callback(false); // pretend no error and that it is not cached
+    }
+  }
+
+  /**
+   * @summary Adds the provided entity list to the cache
+   *
+   * @function addEntityCache
+   * @param {String/Array of Strings} entityType - the entity type(s) to populate
+   * @param {Integer} cacheLimit - limit of items to store in cache
+   * @param {Double} newFrequency - how often to update (in hours)
+   * @param {Callback} callback - whether the cache was updated or not
+   * @returns return of the callback
+   */
+  addEntityCache(entityType, entities, callback) {
+    const origin = `${this.myid}-requestHandler-addEntityCache`;
+    return callback(null, `${origin} ${entityType}:${entities} call has been deprecated with new cache handling!`);
+  }
+
+  /**
+   * @summary Populate the cache for the given entities
+   *
+   * @function populateEntityCache
+   * @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 return of the callback
+   */
+  populateEntityCache(entityTypes, callback) {
+    const origin = `${this.myid}-requestHandler-populateEntityCache`;
+    log.trace(origin);
+
+    return this.cacheHandler.populateCache(entityTypes).then((result) => callback(result, null)).catch((error) => callback(null, error));
+  }
+
+  /**
+   * @summary Retrieves data from cache for specified entity type
+   *
+   * @function retrieveEntitiesCache
+   * @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
+   */
+  retrieveEntitiesCache(entityType, options, callback) {
+    const origin = `${this.myid}-requestHandler-retrieveEntitiesCache`;
+    log.trace(origin);
+
+    if (!options) {
+      return callback(null, 'Options cannot be null!');
+    }
+    try {
+      return this.cacheHandler.retrieveCacheEntries(entityType, options, callback);
+    } catch (e) {
+      // handle any exception
+      return callback(null, 'Retrieve Cache Failed');
+    }
+  }
+
+  /* ********************************************** */
+  /*                                                */
+  /*          EXPOSES BROKER HANDLER                */
+  /*                                                */
+  /* ********************************************** */
+  /**
+   * @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 origin = `${this.myid}-requestHandler-hasEntities`;
+    log.trace(origin);
+
+    try {
+      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 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 origin = `${this.myid}-requestHandler-getDevice`;
+    log.trace(origin);
+
+    try {
+      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 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 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 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 origin = `${this.myid}-requestHandler-isAlive`;
+    log.trace(origin);
+
+    try {
+      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 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 origin = `${this.myid}-requestHandler-getConfig`;
+    log.trace(origin);
+
+    try {
+      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 the device count from the system
+   *
+   * @function iapGetDeviceCount
+   *
+   * @param {getCallback} callback - callback function to return the result
+   *                                    (count) or the error
+   */
+  iapGetDeviceCount(callback) {
+    const origin = `${this.myid}-requestHandler-iapGetDeviceCount`;
+    log.trace(origin);
+
+    try {
+      return this.brokerHandler.iapGetDeviceCount(callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Broker iapGetDeviceCount Failed');
+      return callback(null, errorObj);
+    }
+  }
+
+  /* ********************************************** */
+  /*                                                */
+  /*          EXPOSES GENERIC HANDLER               */
+  /*                                                */
+  /* ********************************************** */
+  /**
+   * 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 {getCallback} callback - a callback function to return the result (Generics)
+   *                 or the error
+   */
+  expandedGenericAdapterRequest(metadata, uriPath, restMethod, pathVars, queryData, requestBody, addlHeaders, callback) {
+    const origin = `${this.myid}-requestHandler-expandedGenericAdapterRequest`;
+    log.trace(origin);
+
+    try {
+      return this.genericHandler.expandedGenericAdapterRequest(metadata, uriPath, restMethod, pathVars, queryData, requestBody, addlHeaders, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Expanded Generic Adapter Request Failed');
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * 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 origin = `${this.myid}-requestHandler-genericAdapterRequest`;
+    log.trace(origin);
+
+    try {
+      return this.genericHandler.genericAdapterRequest(uriPath, restMethod, queryData, requestBody, addlHeaders, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Generic Adapter Request Failed');
+      return callback(null, errorObj);
+    }
+  }
+
+  /**
+   * 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 origin = `${this.myid}-requestHandler-genericAdapterRequestNoBasePath`;
+    log.trace(origin);
+
+    try {
+      return this.genericHandler.genericAdapterRequestNoBasePath(uriPath, restMethod, queryData, requestBody, addlHeaders, callback);
+    } catch (e) {
+      // handle any exception
+      const errorObj = this.transUtil.checkAndReturn(e, origin, 'Generic Adapter Request No Base Path Failed');
+      return callback(null, errorObj);
+    }
+  }
 }
 
 module.exports = RequestHandler;