ruby_skynet 0.8.1 → 1.0.0

data/lib/ruby_skynet/zookeeper/cached_registry.rb

@@ -0,0 +1,75 @@
+require 'thread_safe'
+require 'semantic_logger'
+require 'ruby_skynet/zookeeper/registry'
+
+#
+# CachedRegistry
+#
+# Store information in ZooKeeper and subscribe to future changes
+# and keep a local copy of the information in ZooKeeper
+#
+# Notifies registered subscribers when information has changed
+#
+# All paths specified are relative to the root_path. As such the root key
+# is never returned, nor is it required when a key is supplied as input.
+# For example, with a root_path of /foo/bar, any paths passed in will leave
+# out the root_path: host/name
+#
+# Keeps a local copy in memory of all descendant values of the supplied root_path
+# Supports high-frequency calls to retrieve registry data
+# The in-memory cache will be kept in synch with any changes on the server
+module RubySkynet
+  module Zookeeper
+    class CachedRegistry < Registry
+      # Logging instance for this class
+      include SemanticLogger::Loggable
+
+      # Create a CachedRegistry instance to manage information within the Registry
+      # and keep a local cached copy of the data in the Registry to support
+      # high-speed or frequent reads.
+      #
+      # Writes are sent to ZooKeeper and then replicated back to the local cache
+      # only once ZooKeeper has updated its store
+      #
+      # See RubySkynet::Zookeeper::Registry for the complete list of options
+      #
+      def initialize(params)
+        @cache = ThreadSafe::Hash.new
+        # Supplied block to load the current keys from the Registry
+        super(params) do |key, value, version|
+          @cache[key] = value
+        end
+
+        on_create {|key, value|          @cache[key] = value}
+        on_update {|key, value, version| @cache[key] = value}
+        on_delete {|key|                 @cache.delete(key)}
+      end
+
+      # Retrieve the latest value from a specific key from the registry
+      def [](key)
+        @cache[key]
+      end
+
+      # Iterate over every key, value pair in the registry at the root_path
+      #
+      # Example:
+      #   registry.each_pair {|k,v| puts "#{k} => #{v}"}
+      def each_pair(&block)
+        # Have to duplicate the cache otherwise concurrent changes to the
+        # registry will interfere with the iterator
+        @cache.dup.each_pair(&block)
+      end
+
+      # Returns [Array<String>] all keys in the registry
+      def keys
+        @cache.keys
+      end
+
+      # Returns a copy of the registry as a Hash
+      def to_h
+        @cache.dup
+      end
+
+    end
+  end
+end

data/lib/ruby_skynet/zookeeper/extensions/java_base.rb

@@ -0,0 +1,27 @@
+# This monkey-patch must be removed when ticket #44 has been included in
+# an updated ZooKeeper Gem
+#   Ticket:       https://github.com/slyphon/zookeeper/issues/44
+#   Pull Request: https://github.com/slyphon/zookeeper/pull/45
+
+module Zookeeper
+  class JavaBase
+
+    def get(req_id, path, callback, watcher)
+      handle_keeper_exception do
+        watch_cb = watcher ? create_watcher(req_id, path) : false
+
+        if callback
+          jzk.getData(path, watch_cb, JavaCB::DataCallback.new(req_id), event_queue)
+          [Code::Ok, nil, nil]    # the 'nil, nil' isn't strictly necessary here
+        else # sync
+          stat = JZKD::Stat.new
+          value = jzk.getData(path, watch_cb, stat)
+          data = String.from_java_bytes(value) unless value.nil?
+
+          [Code::Ok, data, stat.to_hash]
+        end
+      end
+    end
+
+  end
+end

data/lib/ruby_skynet/zookeeper/json/deserializer.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+require 'multi_json'
+module RubySkynet
+  module Zookeeper
+    module Json
+
+      # Deserialize from JSON entries in Zookeeper
+      module Deserializer
+        def self.deserialize(value)
+          return value if value.nil? || (value == '')
+
+          if value.strip.start_with?('{') || value.strip.start_with?('[{')
+            symbolize(MultiJson.load(value))
+          else
+            symbolize_string(value)
+          end
+        end
+
+        # Returns the supplied value symbolized
+        def self.symbolize(v)
+          if v.is_a?(Hash)
+            symbolize_hash(v)
+          elsif v.is_a?(Array)
+            symbolize_array(v)
+          elsif v.is_a?(String)
+            symbolize_string(v)
+          else
+            v
+          end
+        end
+
+        # Returns a new hash updated with keys and values that are strings
+        # starting with ':' are turned into symbols
+        def self.symbolize_hash(hash)
+          h = hash.dup
+          hash.each_pair do |k, v|
+            # Convert values in the hash
+            h[k] = symbolize(v)
+
+            # Convert key to a symbol if it is a symbol string
+            h[k[1..-1].to_sym] = h.delete(k) if k.is_a?(String) && k.start_with?(':')
+          end
+          h
+        end
+
+        # Returns a new Array with any symbols strings returned as symbols
+        def self.symbolize_array(a)
+          a.collect {|v| symbolize(v)}
+        end
+
+        # Returns a new string with the string parsed and symbol string converted to a symbol
+        def self.symbolize_string(s)
+          # JSON Parser cannot parse non-hash/array values
+          value = YAML.load(s)
+          # Now check for symbols which are strings starting with ':'
+          value.is_a?(String) && value.start_with?(':') ? value[1..-1].to_sym : value
+        rescue Exception
+          s
+        end
+
+      end
+    end
+  end
+end

data/lib/ruby_skynet/zookeeper/json/serializer.rb

@@ -0,0 +1,57 @@
+require 'multi_json'
+module RubySkynet
+  module Zookeeper
+    module Json
+
+      # Serialize to JSON for storing in Doozer
+      module Serializer
+        def self.serialize(value)
+          if value.is_a?(Hash) || value.is_a?(Array)
+            MultiJson.encode(desymbolize(value))
+          elsif value.is_a?(Symbol)
+            desymbolize_symbol(value)
+          else
+            value.to_s
+          end
+        end
+
+        # Returns the supplied value with symbols converted to a string prefixed
+        # with ':'
+        def self.desymbolize(v)
+          if v.is_a?(Hash)
+            desymbolize_hash(v)
+          elsif v.is_a?(Array)
+            desymbolize_array(v)
+          elsif v.is_a?(Symbol)
+            desymbolize_symbol(v)
+          else
+            v.to_s
+          end
+        end
+
+        # Returns a new hash with all symbol keys and values as strings starting with ':'
+        def self.desymbolize_hash(hash)
+          h = hash.dup
+          hash.each_pair do |k, v|
+            # Convert values in the hash
+            h[k] = desymbolize(v)
+
+            # Convert key to a string if it is a symbol
+            h[desymbolize_symbol(k)] = h.delete(k) if k.is_a?(Symbol)
+          end
+          h
+        end
+
+        # Returns a new Array with any symbols returned as symbol strings
+        def self.desymbolize_array(a)
+          a.collect {|v| desymbolize(v)}
+        end
+
+        def self.desymbolize_symbol(s)
+          ":#{s}"
+        end
+
+      end
+    end
+  end
+end