ruby_doozer 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d35c5108fdd5c6d848eba0575c8950f7112f67a
-  data.tar.gz: feab4e9400b886c736d5813ed362f14b0af171a1
+  metadata.gz: bb1a71fd888931d010aeffdf2a732c921672a28d
+  data.tar.gz: e31970bb09b093c59ee6e221dd302c4ce1a00d81
 SHA512:
-  metadata.gz: c13324138a81aeb313ea82361d1047309f751b0820a476c5d5e4ae5ee404856e5609e75c7eeb2db49f3cfb8fbff59644f6de357e02b984fda12544bb28c4155e
-  data.tar.gz: 37d8d12800d7a96ef2372a85be8f68c2df716e3f9f29c515d1b100c96bb7bc99cab677a4223c5dbdf013f17a4099f66c871b2d61a62316117d52b92a242a02ca
+  metadata.gz: a8a41f827035cf8a419c4eaa3f95965d6aa390660d6d0af404bd3971bbb7ffaaa0203ffd2bb5ad9e0ee770b9247d3c1425a5faebfe16e2279a63c55b7db46e81
+  data.tar.gz: 24666f05f96fda73696d672ff0d4b1a83b27d0e4ab5dca2248eb0bf3ea50aa2ee7dac854d446dccf1cc792c736231597fe4f4cb81ac2b7731484488523c51846

data/Rakefile

@@ -28,6 +28,7 @@ task :gem  do |t|
     spec.add_dependency 'ruby_protobuf', '>= 0.4.11'
     spec.add_dependency 'gene_pool', '>= 1.3.0'
     spec.add_dependency 'sync_attr', '>= 1.0.0'
+    spec.add_dependency 'multi_json', '>= 1.6.1'
   end
   Gem::Package.build gemspec
 end

data/lib/ruby_doozer.rb

@@ -4,4 +4,8 @@ module RubyDoozer
   autoload :Client,         'ruby_doozer/client'
   autoload :Registry,       'ruby_doozer/registry'
   autoload :CachedRegistry, 'ruby_doozer/cached_registry'
+  module Json
+    autoload :Serializer,   'ruby_doozer/json/serializer'
+    autoload :Deserializer, 'ruby_doozer/json/deserializer'
+  end
 end

data/lib/ruby_doozer/cached_registry.rb

@@ -10,8 +10,8 @@ require 'semantic_logger'
 #
 # Notifies registered subscribers when information has changed
 #
-# All paths specified are relative to the root_path. As such the root path
-# is never returned, nor is it required when a path is supplied as input.
+# 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
 #
@@ -23,7 +23,12 @@ module RubyDoozer
     # Logging instance for this class
     include SemanticLogger::Loggable
 
-    # Create a Registry instance to manage a path of information within doozer
+    # Create a Registry instance to manage information within doozer
+    # and keep a local cached copy of the data in doozer to support
+    # high-speed or frequent reads.
+    #
+    # Writes are sent to doozer and then replicate back to the local cache
+    # only once doozer has updated its store
     #
     # See RubyDoozer::Registry for complete list of options
     #
@@ -31,12 +36,12 @@ module RubyDoozer
       super
       @cache = ThreadSafe::Hash.new
 
-      path = "#{@root_path}/**"
+      key = "#{@root}/**"
       doozer_pool.with_connection do |doozer|
         @current_revision = doozer.current_revision
         # Fetch all the configuration information from Doozer and set the internal copy
-        doozer.walk(path, @current_revision) do |path, value, revision|
-          set_cached_value(relative_path(path), value)
+        doozer.walk(key, @current_revision) do |key, value, revision|
+          set_cached_value(relative_key(key), value)
         end
       end
 
@@ -44,9 +49,9 @@ module RubyDoozer
       monitor_thread
     end
 
-    # Retrieve the latest value from a specific path from the registry
-    def [](path)
-      @cache[path]
+    # 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
@@ -59,8 +64,8 @@ module RubyDoozer
       @cache.dup.each_pair(&block)
     end
 
-    # Returns [Array<String>] all paths in the registry
-    def paths
+    # Returns [Array<String>] all keys in the registry
+    def keys
       @cache.keys
     end
 
@@ -71,26 +76,26 @@ module RubyDoozer
 
     # When an entry is created the block will be called
     #  Parameters
-    #    path
-    #      The relative path to watch for changes
+    #    key
+    #      The relative key to watch for changes
     #    block
     #      The block to be called
     #
     #  Parameters passed to the block:
-    #    path
-    #      The path that was created
-    #      Supplying a path of '*' means all paths
+    #    key
+    #      The key that was created
+    #      Supplying a key of '*' means all paths
     #      Default: '*'
     #
     #    value
     #      New value from doozer
     #
     # Example:
-    #   registry.on_update do |path, value|
-    #     puts "#{path} was created with #{value}"
+    #   registry.on_update do |key, value, revision|
+    #     puts "#{key} was created with #{value}"
     #   end
-    def on_create(path='*', &block)
-      ((@create_subscribers ||= ThreadSafe::Hash.new)[path] ||= ThreadSafe::Array.new) << block
+    def on_create(key='*', &block)
+      ((@create_subscribers ||= ThreadSafe::Hash.new)[key] ||= ThreadSafe::Array.new) << block
     end
 
     ############################
@@ -113,30 +118,30 @@ module RubyDoozer
       @cache[doozer_path]
     end
 
-    # The path has been added or updated in the registry
-    def changed(path, value)
-      previous_value = get_cached_value(path)
+    # The key has been added or updated in the registry
+    def changed(key, value, revision)
+      previous_value = get_cached_value(key)
 
       # Update in memory copy
-      set_cached_value(path, value)
+      set_cached_value(key, value)
 
       # It is an update if we already have a value
       if previous_value
         # Call parent which will notify Updated Subscribers
         super
       else
-        logger.debug { "Created: #{path} => #{value}" }
+        logger.debug "Created: #{key}", value
 
         return unless @create_subscribers
 
         # Subscribers to specific paths
-        if subscribers = @create_subscribers[path]
-          subscribers.each{|subscriber| subscriber.call(path, value)}
+        if subscribers = @create_subscribers[key]
+          subscribers.each{|subscriber| subscriber.call(key, value, revision)}
         end
 
         # Any subscribers for all events?
         if all_subscribers = @create_subscribers['*']
-          all_subscribers.each{|subscriber| subscriber.call(path, value)}
+          all_subscribers.each{|subscriber| subscriber.call(key, value, revision)}
         end
       end
     end

data/lib/ruby_doozer/json/deserializer.rb

@@ -0,0 +1,62 @@
+require 'yaml'
+require 'multi_json'
+module RubyDoozer
+  module Json
+
+    # Deserialize from JSON entries in Doozer
+    module Deserializer
+      def self.deserialize(value)
+        return nil unless 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

data/lib/ruby_doozer/json/serializer.rb

@@ -0,0 +1,53 @@
+require 'multi_json'
+module RubyDoozer
+  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))
+        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

data/lib/ruby_doozer/registry.rb

@@ -2,6 +2,7 @@ require 'thread_safe'
 require 'gene_pool'
 require 'semantic_logger'
 require 'sync_attr'
+require 'ruby_doozer/json/deserializer'
 
 #
 # Registry
@@ -10,10 +11,10 @@ require 'sync_attr'
 #
 # Notifies registered subscribers when information has changed
 #
-# All paths specified are relative to the root_path. As such the root path
-# is never returned, nor is it required when a path 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
+# All paths specified are relative to the root. As such the root key
+# is never returned, nor is it required when a key is supplied as input.
+# For example, with a root of /foo/bar, any paths passed in will leave
+# out the root: host/name
 #
 module RubyDoozer
   class Registry
@@ -21,13 +22,13 @@ module RubyDoozer
     # Logging instance for this class
     include SemanticLogger::Loggable
 
-    attr_reader :doozer_config, :doozer_pool, :current_revision, :root_path
+    attr_reader :doozer_config, :doozer_pool, :current_revision, :root
 
-    # Create a Registry instance to manage a path of information within doozer
+    # Create a Registry instance to manage a information within doozer
     #
-    # :root_path [String]
-    #   Root path to load and then monitor for changes
-    #   It is not recommended to set the root_path to "/" as it will generate
+    # :root [String]
+    #   Root key to load and then monitor for changes
+    #   It is not recommended to set the root to "/" as it will generate
     #   significant traffic since it will also monitor Doozer Admin changes
     #   Mandatory
     #
@@ -84,15 +85,15 @@ module RubyDoozer
     #
     def initialize(params)
       params = params.dup
-      @root_path = params.delete(:root_path)
-      raise "Missing mandatory parameter :root_path" unless @root_path
+      @root = params.delete(:root) || params.delete(:root_path)
+      raise "Missing mandatory parameter :root" unless @root
 
-      # Add leading '/' to root_path if missing
-      @root_path = "/#{@root_path}" unless @root_path.start_with?('/')
+      # Add leading '/' to root if missing
+      @root = "/#{@root}" unless @root.start_with?('/')
 
       # Strip trailing '/' if supplied
-      @root_path = @root_path[0..-2] if @root_path.end_with?("/")
-      @root_path_with_trail = "#{@root_path}/"
+      @root = @root[0..-2] if @root.end_with?("/")
+      @root_with_trail = "#{@root}/"
 
       @doozer_config = params.delete(:doozer) || {}
       @doozer_config[:servers]                ||= ['127.0.0.1:8046']
@@ -102,6 +103,10 @@ module RubyDoozer
       @doozer_config[:connect_retry_count]    ||= 10
       @doozer_config[:server_selector]        ||= :random
 
+      # Allow the serializer and deserializer implementations to be replaced
+      @serializer   = params.delete(:serializer)   || RubyDoozer::Json::Serializer
+      @deserializer = params.delete(:deserializer) || RubyDoozer::Json::Deserializer
+
       # Connection pool settings
       @doozer_pool = GenePool.new(
         :name         =>"Doozer Connection Pool",
@@ -125,27 +130,28 @@ module RubyDoozer
     end
 
     # Retrieve the latest value from a specific path from the registry
-    def [](path)
-      doozer_pool.with_connection do |doozer|
-        doozer[full_path(path)]
+    def [](key)
+      value = doozer_pool.with_connection do |doozer|
+        doozer[full_key(key)]
       end
+      @deserializer.deserialize(value)
     end
 
-    # Replace the latest value at a specific path
-    def []=(path,value)
+    # Replace the latest value at a specific key
+    def []=(key,value)
       doozer_pool.with_connection do |doozer|
-        doozer[full_path(path)] = value
+        doozer[full_key(key)] = @serializer.serialize(value)
       end
     end
 
-    # Delete the value at a specific path
-    def delete(path)
+    # Delete the value at a specific key
+    def delete(key)
       doozer_pool.with_connection do |doozer|
-        doozer.delete(full_path(path))
+        doozer.delete(full_key(key))
       end
     end
 
-    # Iterate over every key, value pair in the registry at the root_path
+    # Iterate over every key, value pair in the registry at the root
     #
     # If :cache was set to false on the initializer this call will
     # make network calls to doozer to retrieve the current values
@@ -154,19 +160,19 @@ module RubyDoozer
     # Example:
     #   registry.each_pair {|k,v| puts "#{k} => #{v}"}
     def each_pair(&block)
-      path = "#{@root_path}/**"
+      key = "#{@root}/**"
       doozer_pool.with_connection do |doozer|
-        doozer.walk(path) do |path, value, revision|
-          block.call(relative_path(path), value)
+        doozer.walk(key) do |key, value, revision|
+          block.call(relative_key(key), @deserializer.deserialize(value))
         end
       end
     end
 
-    # Returns [Array<String>] all paths in the registry
-    def paths
-      paths = []
-      each_pair {|k,v| paths << k}
-      paths
+    # Returns [Array<String>] all keys in the registry
+    def keys
+      keys = []
+      each_pair {|k,v| keys << k}
+      keys
     end
 
     # Returns a copy of the registry as a Hash
@@ -189,103 +195,103 @@ module RubyDoozer
 
     # When an entry is updated the block will be called
     #  Parameters
-    #    path
-    #      The relative path to watch for changes
+    #    key
+    #      The relative key to watch for changes
     #    block
     #      The block to be called
     #
     #  Parameters passed to the block:
-    #    path
-    #      The path that was updated in doozer
-    #      Supplying a path of '*' means all paths
+    #    key
+    #      The key that was updated in doozer
+    #      Supplying a key of '*' means all paths
     #      Default: '*'
     #
     #    value
     #      New value from doozer
     #
     # Example:
-    #   registry.on_update do |path, value, old_value|
-    #     puts "#{path} was updated to #{value}"
+    #   registry.on_update do |key, value, revision|
+    #     puts "#{key} was updated to #{value}"
     #   end
-    def on_update(path='*', &block)
+    def on_update(key='*', &block)
       # Start monitoring thread if not already started
       monitor_thread
-      ((@update_subscribers ||= ThreadSafe::Hash.new)[path] ||= ThreadSafe::Array.new) << block
+      ((@update_subscribers ||= ThreadSafe::Hash.new)[key] ||= ThreadSafe::Array.new) << block
     end
 
     # When an entry is deleted the block will be called
     #  Parameters
-    #    path
-    #      The relative path to watch for changes
+    #    key
+    #      The relative key to watch for changes
     #    block
     #      The block to be called
     #
     #  Parameters passed to the block:
-    #    path
-    #      The path that was deleted from doozer
-    #      Supplying a path of '*' means all paths
+    #    key
+    #      The key that was deleted from doozer
+    #      Supplying a key of '*' means all paths
     #      Default: '*'
     #
     # Example:
-    #   registry.on_delete do |path|
-    #     puts "#{path} was deleted"
+    #   registry.on_delete do |key, revision|
+    #     puts "#{key} was deleted"
     #   end
-    def on_delete(path='*', &block)
+    def on_delete(key='*', &block)
       # Start monitoring thread if not already started
       monitor_thread
-      ((@delete_subscribers ||= ThreadSafe::Hash.new)[path] ||= ThreadSafe::Array.new) << block
+      ((@delete_subscribers ||= ThreadSafe::Hash.new)[key] ||= ThreadSafe::Array.new) << block
     end
 
     ############################
     protected
 
-    # Returns the full path given a relative path
-    def full_path(relative_path)
-      "#{@root_path}/#{relative_path}"
+    # Returns the full key given a relative key
+    def full_key(relative_key)
+      "#{@root}/#{relative_key}"
     end
 
-    # Returns the full path given a relative path
-    def relative_path(full_path)
-      full_path.sub(@root_path_with_trail, '')
+    # Returns the full key given a relative key
+    def relative_key(full_key)
+      full_key.sub(@root_with_trail, '')
     end
 
-    # The path has been added or updated in the registry
-    def changed(path, value)
-      logger.debug { "Updated: #{path} => #{value}" }
+    # The key has been added or updated in the registry
+    def changed(key, value, revision)
+      logger.debug "Updated: #{key}", value
 
       return unless @update_subscribers
 
       # Subscribers to specific paths
-      if subscribers = @update_subscribers[path]
-        subscribers.each{|subscriber| subscriber.call(path, value)}
+      if subscribers = @update_subscribers[key]
+        subscribers.each{|subscriber| subscriber.call(key, value, revision)}
       end
 
       # Any subscribers for all events?
       if all_subscribers = @update_subscribers['*']
-        all_subscribers.each{|subscriber| subscriber.call(path, value)}
+        all_subscribers.each{|subscriber| subscriber.call(key, value, revision)}
       end
     end
 
     # Existing data has been removed from the registry
-    def deleted(path)
-      logger.debug { "Deleted: #{path}" }
+    def deleted(key, revision)
+      logger.debug { "Deleted: #{key}" }
 
       return unless @delete_subscribers
 
       # Subscribers to specific paths
-      if subscribers = @delete_subscribers[path]
-        subscribers.each{|subscriber| subscriber.call(path)}
+      if subscribers = @delete_subscribers[key]
+        subscribers.each{|subscriber| subscriber.call(key, revision)}
       end
 
       # Any subscribers for all events?
       if all_subscribers = @delete_subscribers['*']
-        all_subscribers.each{|subscriber| subscriber.call(path)}
+        all_subscribers.each{|subscriber| subscriber.call(key, revision)}
       end
     end
 
     # Waits for any updates from Doozer and updates the internal service registry
     def watch_registry
-      watch_path = "#{@root_path}/**"
+      watch_path = "#{@root}/**"
       logger.info "Start monitoring #{watch_path}"
       # This thread must use its own dedicated doozer connection
       doozer = RubyDoozer::Client.new(@doozer_config)
@@ -299,23 +305,21 @@ module RubyDoozer
         # Update the current_revision with every change notification
         @current_revision = node.rev
 
-        # Remove the Root path
-        path = relative_path(node.path)
+        # Remove the Root key
+        key = relative_key(node.path)
 
         case node.flags
         when 4
-          changed(path, node.value)
+          changed(key,  @deserializer.deserialize(node.value), node.rev)
         when 8
-          deleted(path)
+          deleted(key, node.rev)
         else
           logger.error "Unknown flags returned by doozer:#{node.flags}"
         end
       end
       logger.info "Stopping monitoring thread normally"
 
-    # #TODO need more exception handling here
-
-    rescue Exception => exc
+    rescue ScriptError, NameError, StandardError, Exception => exc
       logger.error "Exception in monitoring thread", exc
     ensure
       doozer.close if doozer

data/lib/ruby_doozer/version.rb

@@ -1,3 +1,3 @@
 module RubyDoozer #:nodoc
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/test/cached_registry_test.rb

@@ -62,42 +62,55 @@ class CachedRegistryTest < Test::Unit::TestCase
       [nil, '*'].each do |monitor_path|
         context "with monitor_path:#{monitor_path}" do
           should "callback on create" do
+            created_revision = nil
             created_path = nil
             created_value = nil
-            @registry.on_create(monitor_path||'three') do |path, value|
+            @registry.on_create(monitor_path||'three') do |path, value, revision|
+              created_revision = revision
               created_path = path
               created_value = value
             end
             @registry['three'] = 'created'
             # Allow doozer to send back the change
-            sleep 0.5
+            sleep 0.3
             assert_equal 'three', created_path
             assert_equal 'created', created_value
+            assert_equal true, created_revision > 0
           end
 
           should "callback on update" do
+            updated_revision = nil
             updated_path = nil
             updated_value = nil
-            @registry.on_update(monitor_path||'bar') do |path, value|
+            @registry.on_update(monitor_path||'bar') do |path, value, revision|
+              updated_revision = revision
               updated_path = path
               updated_value = value
             end
+            # Allow monitoring thread to start
+            sleep 0.1
             @registry['bar'] = 'updated'
             # Allow doozer to send back the change
-            sleep 0.5
+            sleep 0.3
             assert_equal 'bar', updated_path
             assert_equal 'updated', updated_value
+            assert_equal true, updated_revision > 0
           end
 
           should "callback on delete" do
             deleted_path = nil
-            @registry.on_delete(monitor_path||'bar') do |path|
+            deleted_revision = nil
+            @registry.on_delete(monitor_path||'bar') do |path, revision|
               deleted_path = path
+              deleted_revision = revision
             end
+            # Allow monitoring thread to start
+            sleep 0.1
             # Allow doozer to send back the change
             @registry.delete('bar')
-            sleep 0.5
+            sleep 0.3
             assert_equal 'bar', deleted_path
+            assert_equal true, deleted_revision > 0
           end
         end
       end

data/test/registry_test.rb

@@ -65,9 +65,11 @@ class RegistryTest < Test::Unit::TestCase
       [nil, '*'].each do |monitor_path|
         context "with monitor_path:#{monitor_path}" do
           should "callback on update" do
+            updated_revision = nil
             updated_path = nil
             updated_value = nil
-            @registry.on_update(monitor_path||'bar') do |path, value|
+            @registry.on_update(monitor_path||'bar') do |path, value, revision|
+              updated_revision = revision
               updated_path = path
               updated_value = value
             end
@@ -78,12 +80,15 @@ class RegistryTest < Test::Unit::TestCase
             sleep 0.3
             assert_equal 'bar', updated_path
             assert_equal 'updated', updated_value
+            assert_equal true, updated_revision > 0
           end
 
           should "callback on delete" do
             deleted_path = nil
-            @registry.on_delete(monitor_path||'bar') do |path|
+            deleted_revision = nil
+            @registry.on_delete(monitor_path||'bar') do |path, revision|
               deleted_path = path
+              deleted_revision = revision
             end
             # Allow monitoring thread to start
             sleep 0.1
@@ -91,6 +96,7 @@ class RegistryTest < Test::Unit::TestCase
             @registry.delete('bar')
             sleep 0.3
             assert_equal 'bar', deleted_path
+            assert_equal true, deleted_revision > 0
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_doozer
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-03 00:00:00.000000000 Z
+date: 2013-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -80,6 +80,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.1
 description: Ruby Client for doozer
 email:
 - reidmo@gmail.com
@@ -96,6 +110,8 @@ files:
 - lib/ruby_doozer/cached_registry.rb
 - lib/ruby_doozer/client.rb
 - lib/ruby_doozer/exceptions.rb
+- lib/ruby_doozer/json/deserializer.rb
+- lib/ruby_doozer/json/serializer.rb
 - lib/ruby_doozer/msg.pb.rb
 - lib/ruby_doozer/registry.rb
 - lib/ruby_doozer/version.rb