@weave-js/core 0.10.0 → 0.12.0

package/lib/middlewares/bulkhead/index.js

@@ -1,10 +1,10 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
-
-const { WeaveQueueSizeExceededError } = require('../../errors')
+const { Constants } = require('../../metrics');
+const { WeaveQueueSizeExceededError } = require('../../errors');
 
 /**
  * @typedef {import('../../types').Runtime} Runtime
@@ -18,47 +18,47 @@ const { WeaveQueueSizeExceededError } = require('../../errors')
  */
 module.exports = (runtime) => {
   const wrapBulkheadMiddleware = function (handler, action) {
-    const bulkheadOptions = runtime.options.bulkhead
+    const bulkheadOptions = runtime.options.bulkhead;
 
     if (bulkheadOptions.enabled) {
-      const queue = []
-      let currentlyInFlight = 0
+      const queue = [];
+      let currentlyInFlight = 0;
 
       const callNext = () => {
-        if (queue.length === 0) return
-        if (currentlyInFlight >= bulkheadOptions.concurrentCalls) return
+        if (queue.length === 0) return;
+        if (currentlyInFlight >= bulkheadOptions.concurrentCalls) return;
 
-        const item = queue.shift()
+        const item = queue.shift();
 
-        currentlyInFlight++
+        currentlyInFlight++;
         handler(item.context)
           .then(result => {
-            currentlyInFlight--
-            item.resolve(result)
-            callNext()
+            currentlyInFlight--;
+            item.resolve(result);
+            callNext();
           })
           .catch(error => {
-            currentlyInFlight--
-            callNext()
-            return item.reject(error)
-          })
-      }
+            currentlyInFlight--;
+            callNext();
+            return item.reject(error);
+          });
+      };
 
       return function bulkheadMiddlware (context, serviceInjections) {
         // Execute action immediately
         if (currentlyInFlight < bulkheadOptions.concurrentCalls) {
-          currentlyInFlight++
+          currentlyInFlight++;
           return handler(context, serviceInjections)
             .then(result => {
-              currentlyInFlight--
-              callNext()
-              return result
+              currentlyInFlight--;
+              callNext();
+              return result;
             })
             .catch(error => {
-              currentlyInFlight--
-              callNext()
-              return Promise.reject(error)
-            })
+              currentlyInFlight--;
+              callNext();
+              return Promise.reject(error);
+            });
         }
 
         // Reject the action if the max queue size is reached.
@@ -67,22 +67,23 @@ module.exports = (runtime) => {
             action: action.name,
             limit: bulkheadOptions.maxQueueSize,
             size: queue.length
-          }))
+          }));
         }
 
         // Queue the request
-        return new Promise((resolve, reject) => queue.push({ resolve, reject, context }))
-      }
+        return new Promise((resolve, reject) => queue.push({ resolve, reject, context }));
+      };
     }
-    return handler
-  }
+    return handler;
+  };
 
   return {
     created () {
       if (runtime.options.metrics.enabled) {
         // todo: add bulkhead metrics
+        runtime.metrics.register({ type: 'gauge', name: Constants.BULKHEAD_REQUESTS_IN_FLIGHT, description: 'Number of in flight requests.' });
       }
     },
     localAction: wrapBulkheadMiddleware
-  }
-}
+  };
+};

package/lib/middlewares/cache/index.js

@@ -0,0 +1,106 @@
+const { isString, isFunction } = require('@weave-js/utils');
+
+module.exports = (runtime) => {
+  return {
+    localAction: (handler, action) => {
+      const cacheOptions = runtime.options.cache;
+      const cacheActionOptions = {
+        enabled: !!action.cache
+      };
+
+      if (isString(action.cache)) {
+        cacheActionOptions.keys = action.cache.split(' ');
+      } else if (action.cache && Array.isArray(action.cache.keys)) {
+        cacheActionOptions.keys = action.cache.keys;
+      }
+
+      if (cacheActionOptions.enabled) {
+        const cache = runtime.cache;
+        const isEnabledFunction = isFunction(action.cache.condition);
+
+        return function cacheMiddleware (context, serviceInjections) {
+          // handle enabled function
+          if (isEnabledFunction) {
+            if (!action.cache.enabled.call(null, context)) {
+              // Enabled function returns "false". Cache is disabled.
+              return handler(context, serviceInjections);
+            }
+          }
+
+          // Generate cache hash
+          const cacheHashKey = cache.getCachingKey(
+            action.name,
+            context.data,
+            context.meta,
+            cacheActionOptions.keys
+          );
+
+          context.isCachedResult = false;
+
+          // Disable caching by meta property.
+          if (context.meta.$noCache === true) {
+            return handler(context, serviceInjections);
+          }
+
+          // The cache adapter is not connected yet. In this case, we call the handler regular
+          if (cache.isConnected === false) {
+            cache.log('Cache adapter is not connected yet. Call handler...');
+            return handler(context, serviceInjections);
+          }
+
+          if (cacheOptions.lock.enabled) {
+            let cachePromise;
+            if (cacheOptions.lock.staleTime && cache.getWithTTl) {
+
+            } else {
+              cachePromise = runtime.cache.get(cacheHashKey);
+            }
+
+            return cachePromise.then((cachedResult) => {
+              if (cachedResult !== null) {
+                // Found a cached value. Skip calling handler and return our value
+                context.isCachedResult = true;
+                return cachedResult;
+              }
+
+              return cache.lock(cacheHashKey).then((release) => {
+                return cache.get(cacheHashKey).then(cachedResult => {
+                  if (cachedResult !== null) {
+                    // Found a cached value. Skip calling handler and return our value
+                    context.isCachedResult = true;
+                    return release().then(() => {
+                      return cachedResult;
+                    });
+                  }
+
+                  return handler(context).then((result) => {
+                    // Cache the value
+                    cache.set(cacheHashKey, result, action.cache.ttl).then(() => {
+                      // release the lock
+                      release();
+                    });
+                    return result;
+                  });
+                });
+              });
+            });
+          }
+
+          // Not using cache lock
+          return runtime.cache.get(cacheHashKey).then((cachedResult) => {
+            if (cachedResult !== null) {
+              context.isCachedResult = true;
+              return cachedResult;
+            }
+
+            return handler(context, serviceInjections).then((result) => {
+              runtime.cache.set(cacheHashKey, result, action.cache.ttl);
+              return result;
+            });
+          });
+        };
+      }
+      return handler;
+    }
+  };
+};

package/lib/middlewares/circuit-breaker/index.js

@@ -1,143 +1,168 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
+const {
+  CIRCUIT_CLOSED,
+  CIRCUIT_HALF_OPENED,
+  CIRCUIT_HALF_OPEN_WAITING,
+  CIRCUIT_OPENED
+} = require('../../constants').circuitBreakerStates;
 
 module.exports = (runtime) => {
-  const storage = new Map()
-  let log = null
-  let circuitBreakerTimer = null
+  const storage = new Map();
+  let log = null;
+  let circuitBreakerTimer = null;
 
   function createWindowTimer (windowTime) {
-    circuitBreakerTimer = setInterval(() => clearEndpointStore(), windowTime)
-    circuitBreakerTimer.unref()
+    circuitBreakerTimer = setInterval(() => clearEndpointStore(), windowTime);
+    circuitBreakerTimer.unref();
   }
 
   function clearEndpointStore () {
-    storage.forEach(item => {
+    storage.forEach((item) => {
       if (item.callCounter === 0) {
-        storage.delete(item.name)
-        return
+        storage.delete(item.name);
+        return;
       }
 
-      item.callCounter = 0
-      item.failureCouter = 0
-    })
+      item.callCounter = 0;
+      item.failureCouter = 0;
+    });
   }
 
   function getEndpointState (endpoint, options) {
-    let item = storage.get(endpoint.name)
+    let item = storage.get(endpoint.name);
     if (!item) {
       item = {
         endpoint,
         options,
         callCounter: 0,
         failureCouter: 0,
-        state: 'CIRCUIT_BREAKER_CLOSED',
+        state: CIRCUIT_CLOSED,
         circuitBreakerTimer: null
-      }
-      storage.set(endpoint.name, item)
+      };
+      storage.set(endpoint.name, item);
     }
 
-    return item
+    return item;
   }
 
-  function success (item, options) {
-    item.callCounter++
+  function onSuccess (item, options) {
+    item.callCounter++;
 
-    if (item.state === 'CIRCUIT_BREAKER_HALF_OPENED') {
-      closeCircuitBreaker(item, options)
+    if (item.state === CIRCUIT_HALF_OPENED) {
+      closeCircuitBreaker(item);
     } else {
-      checkThreshold(item, options)
+      checkThreshold(item, options);
     }
   }
 
-  function failure (item, error, options) {
-    item.callCounter++
-    item.failureCouter++
+  function onFailure (item, options) {
+    item.callCounter++;
+    item.failureCouter++;
 
-    checkThreshold(item, options)
+    checkThreshold(item, options);
   }
 
   function checkThreshold (item, options) {
     if (item.failureCouter >= options.maxFailures) {
-      openCircuitBreaker(item)
+      openCircuitBreaker(item);
     }
   }
 
   function openCircuitBreaker (item) {
-    item.state = 'CIRCUIT_BREAKER_OPEN'
-    item.endpoint.state = false
-    item.circuitBreakerTimer = setTimeout(() => halfOpenCircuitBreaker(item), item.options.halfOpenTimeout)
-
-    log.debug(`Circuit breaker has been opened for endpoint '${item.endpoint.name}'`)
+    item.state = CIRCUIT_OPENED;
+    item.endpoint.state = false;
+    item.circuitBreakerTimer = setTimeout(() => halfOpenCircuitBreaker(item), item.options.halfOpenTimeout);
+    item.circuitBreakerTimer.unref();
+    log.debug(`Circuit breaker has been opened for endpoint '${item.endpoint.name}'`);
   }
 
   function halfOpenCircuitBreaker (item) {
-    item.state = 'CIRCUIT_BREAKER_HALF_OPEN'
-    item.endpoint.state = true
+    item.state = CIRCUIT_HALF_OPENED;
+    item.endpoint.state = true;
+
+    log.debug(`Circuit breaker has been half opened for endpoint '${item.endpoint.name}'`);
 
-    log.debug(`Circuit breaker has been half opened for endpoint '${item.endpoint.name}'`)
+    if (item.circuitBreakerTimer) {
+      clearTimeout(item.circuitBreakerTimer);
+      item.circuitBreakerTimer = null;
+    }
   }
 
-  function closeCircuitBreaker (item, options) {
-    item.failureCouter = 0
-    item.callCounter = 0
-    item.state = 'CIRCUIT_BREAKER_CLOSED'
-    item.endpoint.state = true
+  function handleHalfOpen (item) {
+    item.state = CIRCUIT_HALF_OPEN_WAITING;
+    item.endpoint.state = false;
+    item.circuitBreakerTimer = setTimeout(() => halfOpenCircuitBreaker(item), item.options.halfOpenTimeout);
+    item.circuitBreakerTimer.unref();
+  }
+
+  function closeCircuitBreaker (item) {
+    item.failureCouter = 0;
+    item.callCounter = 0;
+    item.state = CIRCUIT_CLOSED;
+    item.endpoint.state = true;
 
     if (item.circuitBreakerTimer) {
-      clearTimeout(item.circuitBreakerTimer)
-      item.circuitBreakerTimer = null
+      clearTimeout(item.circuitBreakerTimer);
+      item.circuitBreakerTimer = null;
     }
 
-    log.debug(`Circuit breaker has been closed for endpoint '${item.endpoint.name}'`)
+    log.debug(`Circuit breaker has been closed for endpoint '${item.endpoint.name}'`);
   }
 
   function wrapCircuitBreakerMiddleware (handler, action) {
-    const options = Object.assign({}, runtime.options.circuitBreaker, action.circuitBreaker || {})
+    const options = Object.assign({}, runtime.options.circuitBreaker, action.circuitBreaker || {});
 
     if (options.enabled) {
       return function curcuitBreakerMiddleware (context, serviceInjections) {
-        const endpoint = context.endpoint
-        const item = getEndpointState(endpoint, options)
+        const endpoint = context.endpoint;
+        const item = getEndpointState(endpoint, options);
+
+        // handle half open states
+        if (item.state === CIRCUIT_HALF_OPENED) {
+          handleHalfOpen(item, context);
+        }
 
         return handler(context, serviceInjections)
           .then(result => {
-            const item = getEndpointState(endpoint, options)
-            success(item, options)
+            const item = getEndpointState(endpoint, options);
+            onSuccess(item, options);
 
-            return result
+            return result;
           })
           .catch(error => {
-            failure(item, error, options)
+            if (item && (!error.nodeId || error.nodeId === context.nodeId)) {
+              onFailure(item, options);
+            }
 
-            return Promise.reject(error)
-          })
-      }
+            return Promise.reject(error);
+          });
+      };
     }
-    return handler
+    return handler;
   }
 
   return {
     created () {
-      log = runtime.createLogger('circuit-breaker')
+      log = runtime.createLogger('circuit-breaker');
 
       if (runtime.options.metrics.enabled) {
         // todo: add circuit breaker metrics
       }
     },
     started () {
-      const { enabled, windowTime } = this.options.circuitBreaker
+      const { enabled, windowTime } = this.options.circuitBreaker;
       if (enabled) {
-        createWindowTimer(windowTime)
+        createWindowTimer(windowTime);
       }
     },
     localAction: wrapCircuitBreakerMiddleware,
     remoteAction: wrapCircuitBreakerMiddleware,
     brokerStopped () {
-      clearInterval(circuitBreakerTimer)
+      clearInterval(circuitBreakerTimer);
     }
-  }
-}
+  };
+};

package/lib/middlewares/context-tracker/index.js

@@ -1,107 +1,107 @@
-const { WeaveGracefulStopTimeoutError } = require('../../errors')
+const { WeaveGracefulStopTimeoutError } = require('../../errors');
 
 module.exports = (runtime) => {
   function addContext (context) {
     if (context.service) {
       // local actions
-      context.service._trackedContexts.push(context)
+      context.service._trackedContexts.push(context);
     } else {
       // remote actions
-      context.service._trackedContexts.push(context)
+      context.service._trackedContexts.push(context);
     }
   }
 
   function removeContext (context) {
     if (context.service) {
       // local actions
-      const index = context.service._trackedContexts.indexOf(context)
+      const index = context.service._trackedContexts.indexOf(context);
       if (index !== -1) {
-        context.service._trackedContexts.splice(index, 1)
+        context.service._trackedContexts.splice(index, 1);
       }
     } else {
-      const index = context.service._trackedContexts.indexOf(context)
+      const index = context.service._trackedContexts.indexOf(context);
       if (index !== -1) {
-        context.service._trackedContexts.splice(index, 1)
+        context.service._trackedContexts.splice(index, 1);
       }
     }
   }
 
   function wrapContextTrackerMiddleware (actionHandler) {
     return function ContextTrackerMiddleware (context, serviceInjections) {
-      const isTracked = context.options.track === true ? context.options.track : runtime.options.contextTracking.enabled
+      const isTracked = context.options.track === true ? context.options.track : runtime.options.contextTracking.enabled;
 
       if (!isTracked) {
-        return actionHandler(context, serviceInjections)
+        return actionHandler(context, serviceInjections);
       }
 
-      addContext(context)
+      addContext(context);
 
       return actionHandler(context, serviceInjections)
         .then(result => {
-          removeContext(context)
-          return result
+          removeContext(context);
+          return result;
         })
         .catch(error => {
-          removeContext(context)
-          throw error
-        })
-    }
+          removeContext(context);
+          throw error;
+        });
+    };
   }
 
   const waitingForActiveContexts = (contextList, log, shutdownTimeout, service) => {
     return new Promise((resolve) => {
       if (contextList.length === 0) {
-        resolve()
+        resolve();
       }
 
-      let isTimedOut = false
+      let isTimedOut = false;
       const timeout = setTimeout(() => {
-        isTimedOut = true
-        log.error(new WeaveGracefulStopTimeoutError(service))
-        contextList = []
-        resolve()
-      }, shutdownTimeout)
+        isTimedOut = true;
+        log.error(new WeaveGracefulStopTimeoutError(service));
+        contextList = [];
+        resolve();
+      }, shutdownTimeout);
 
-      let isFirstCheck = true
+      let isFirstCheck = true;
       const checkContexts = () => {
         if (contextList.length === 0) {
-          clearTimeout(timeout)
-          resolve()
+          clearTimeout(timeout);
+          resolve();
         } else {
           if (isFirstCheck) {
-            log.info(`Waiting for ${contextList.length} open Contexts...`)
-            isFirstCheck = false
+            log.info(`Waiting for ${contextList.length} open Contexts...`);
+            isFirstCheck = false;
           }
 
           if (!isTimedOut) {
-            setTimeout(checkContexts, 100)
+            setTimeout(checkContexts, 100);
           }
         }
-      }
-      setImmediate(checkContexts)
-    })
-  }
+      };
+      setImmediate(checkContexts);
+    });
+  };
 
   return {
     created () {
       // init context-store
-      runtime.state.trackedContexts = []
+      runtime.state.trackedContexts = [];
     },
     serviceStarting (service) {
-      service._trackedContexts = []
+      service._trackedContexts = [];
     },
 
     // Before a local service stopping
     serviceStopping (service) {
-      return waitingForActiveContexts(service._trackedContexts, service.log, service.settings.$shutdownTimeout || service.broker.options.contextTracking.shutdownTimeout, service)
+      return waitingForActiveContexts(service._trackedContexts, service.log, service.settings.$shutdownTimeout || service.broker.options.contextTracking.shutdownTimeout, service);
     },
 
     // Before broker stopping
     stopping () {
-      return waitingForActiveContexts(runtime.state.trackedContexts, runtime.log, runtime.options.contextTracking.shutdownTimeout)
+      return waitingForActiveContexts(runtime.state.trackedContexts, runtime.log, runtime.options.contextTracking.shutdownTimeout);
     },
     localAction: wrapContextTrackerMiddleware,
     remoteAction: wrapContextTrackerMiddleware,
     localEvent: wrapContextTrackerMiddleware
-  }
-}
+  };
+};

package/lib/middlewares/error-handler/index.js

@@ -1,10 +1,10 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
 
-const { WeaveError } = require('../../errors')
+const { WeaveError } = require('../../errors');
 
 module.exports = (runtime) => {
   const wrapErrorHandlerMiddleware = function (handler) {
@@ -12,24 +12,24 @@ module.exports = (runtime) => {
       return handler(context, serviceInjections)
         .catch(error => {
           if (!(error instanceof Error)) {
-            error = new WeaveError(error, 500)
+            error = new WeaveError(error, 500);
           }
 
           if (runtime.nodeId !== context.nodeId) {
-            runtime.transport.removePendingRequestsById(context.id)
+            runtime.transport.removePendingRequestsById(context.id);
           }
 
-          runtime.log.debug(`The action ${context.action.name} is rejected`, { requestId: context.id }, error)
-          return runtime.handleError(error)
-        })
-        // .catch(error => {
-        //   runtime.log.error(error)
-        // })
-    }
-  }
+          runtime.log.debug(`The action ${context.action.name} is rejected`, { requestId: context.id }, error);
+          return runtime.handleError(error);
+        });
+      // .catch(error => {
+      //   runtime.log.error(error)
+      // })
+    };
+  };
 
   return {
     localAction: wrapErrorHandlerMiddleware,
     remoteAction: wrapErrorHandlerMiddleware
-  }
-}
+  };
+};

package/lib/middlewares/index.js

@@ -1,5 +1,5 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
  */
@@ -7,6 +7,7 @@
 module.exports = {
   ActionHooks: require('./action-hooks'),
   Bulkhead: require('./bulkhead'),
+  Cache: require('./cache'),
   CircuitBreaker: require('./circuit-breaker'),
   ErrorHandler: require('./error-handler'),
   Metrics: require('./metrics'),
@@ -15,4 +16,4 @@ module.exports = {
   Timeout: require('./timeout'),
   ContextTracker: require('./context-tracker'),
   Validator: require('./validator')
-}
+};