infinispan 0.13.0 → 0.14.0

package/lib/listeners.js

@@ -12,15 +12,38 @@
 
   module.exports = listeners;
 
+  /**
+   * Creates the listener management subsystem for a protocol instance.
+   * @param {Object} protocol Protocol instance with encode/decode methods.
+   * @returns {Object} Listener manager with add, remove, find, and dispatch methods.
+   */
   function listeners(protocol) {
     var logger = u.logger('listeners');
     var listeners = u.keyValueMap();
 
+    /**
+     * Sends a request with a pre-write hook executed before sending.
+     * @param {Object} transport Transport instance.
+     * @param {Object} ctx Request context.
+     * @param {number} op Operation code.
+     * @param {Function} body Body encoder function.
+     * @param {Function} decoder Response decoder function.
+     * @param {Object} opts Operation options.
+     * @param {Function} preWrite Hook function called before writing.
+     * @returns {Promise} Promise resolved with the decoded response.
+     */
     function futurePreWrite(transport, ctx, op, body, decoder, opts, preWrite) {
       f.actions(protocol.stepsHeaderBody(ctx, op, body, opts), codec.bytesEncoded)(ctx);
       return transport.writeCommand(ctx, decoder, preWrite);
     }
 
+    /**
+     * Creates a pre-write hook that registers a listener before sending the add request.
+     * @param {string} event Event type name.
+     * @param {Function} listener Callback function for the event.
+     * @param {string} listenerId Listener identifier.
+     * @returns {Function} Pre-write hook function accepting a connection.
+     */
     function preWriteAddListener(event, listener, listenerId) {
       return function(conn) {
         // Listener needs to be registered in advance since events might come
@@ -28,16 +51,32 @@
         // is enabled. To avoid leaking listeners, remove listener if there's
         // any problem.
         emitterAddListener(event, listener, listenerId, conn);
-      }
+      };
     }
 
+    /**
+     * Creates a new event emitter and registers it in the listeners map.
+     * @param {string} listenerId Listener identifier.
+     * @param {Object} conn Connection associated with this listener.
+     * @param {string} event Event type name.
+     * @param {Function} callback Callback function for the event.
+     * @returns {EventEmitter} Newly created event emitter.
+     */
     function createEmitter(listenerId, conn, event, callback) {
       var emitter = new events.EventEmitter();
       logger.tracef('Create listener emitter for connection %s and listener with listenerId=%s', conn, listenerId);
-      listeners.put(listenerId, {emitter: emitter, conn: conn, event: event, callback: callback});
+      listeners.put(listenerId, {id: listenerId, emitter: emitter, conn: conn, event: event, callback: callback});
       return emitter;
     }
 
+    /**
+     * Adds a listener callback to an existing or new emitter for the given listener id.
+     * @param {string} event Event type name.
+     * @param {Function} callback Callback function for the event.
+     * @param {string} listenerId Listener identifier.
+     * @param {Object} [conn] Connection associated with this listener.
+     * @returns {void}
+     */
     function emitterAddListener(event, callback, listenerId, conn) {
       var l = listeners.get(listenerId);
       var emitter = f.existy(l) ? l.emitter : createEmitter(listenerId, conn, event, callback);
@@ -98,13 +137,21 @@
 
           logger.error('No emitter exists for listener %s', listenerId);
           return true;
-        }
+        };
       },
       getListenersAt: function (addr) {
         return _.filter(listeners.values(), function(listener) {
           return _.isEqual(addr, listener.conn.getAddress());
         });
       },
+      /**
+       * Replaces the protocol instance used by the listener subsystem.
+       * @param {Object} newProtocol Replacement protocol instance.
+       * @returns {void}
+       */
+      setProtocol: function(newProtocol) {
+        protocol = newProtocol;
+      },
     };
     return listen;
   }

package/lib/near-cache.js

@@ -0,0 +1,99 @@
+'use strict';
+
+(function() {
+
+  var u = require('./utils');
+
+  module.exports = nearCache;
+
+  /**
+   * Creates a near cache with LRU eviction.
+   * @param {number} maxEntries Maximum number of entries to store.
+   * @returns {Object} Near cache instance with get, put, remove, clear, and size methods.
+   */
+  function nearCache(maxEntries) {
+    var logger = u.logger('near-cache');
+    var cache = new Map();
+
+    /**
+     * Moves a key to the end of the Map iteration order (most recently used).
+     * @param {string} key The cache key to touch.
+     * @param {*} value The cached value.
+     * @returns {void}
+     */
+    function touch(key, value) {
+      cache.delete(key);
+      cache.set(key, value);
+    }
+
+    /**
+     * Evicts the least recently used entry if the cache exceeds maxEntries.
+     * @returns {void}
+     */
+    function evict() {
+      while (cache.size > maxEntries) {
+        var oldest = cache.keys().next().value;
+        logger.tracef('Near cache evicting key=%s (size=%d, max=%d)', oldest, cache.size, maxEntries);
+        cache.delete(oldest);
+      }
+    }
+
+    return {
+      /**
+       * Get a value from the near cache.
+       * @param {string} key Cache key.
+       * @returns {Object|undefined} Cached entry with value (and optionally metadata), or undefined on miss.
+       */
+      get: function(key) {
+        var entry = cache.get(key);
+        if (entry !== undefined) {
+          touch(key, entry);
+          logger.tracef('Near cache hit for key=%s', key);
+          return entry;
+        }
+        logger.tracef('Near cache miss for key=%s', key);
+        return undefined;
+      },
+      /**
+       * Put a value into the near cache.
+       * @param {string} key Cache key.
+       * @param {Object} entry Cached entry object.
+       * @returns {void}
+       */
+      put: function(key, entry) {
+        cache.set(key, entry);
+        evict();
+        logger.tracef('Near cache put key=%s (size=%d)', key, cache.size);
+      },
+      /**
+       * Remove a key from the near cache.
+       * @param {string} key Cache key to remove.
+       * @returns {boolean} True if the key was present.
+       */
+      remove: function(key) {
+        var removed = cache.delete(key);
+        if (removed) {
+          logger.tracef('Near cache invalidated key=%s', key);
+        }
+        return removed;
+      },
+      /**
+       * Clear all entries from the near cache.
+       * @returns {void}
+       */
+      clear: function() {
+        var oldSize = cache.size;
+        cache.clear();
+        logger.tracef('Near cache cleared (%d entries removed)', oldSize);
+      },
+      /**
+       * Get the number of entries in the near cache.
+       * @returns {number} Current cache size.
+       */
+      size: function() {
+        return cache.size;
+      }
+    };
+  }
+
+}.call(this));