ruby_doozer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3820705ac3d8550a61d136be5b7134c806dab86e
+  data.tar.gz: 35612961ac704ed090141234b65ab42490f1998c
+SHA512:
+  metadata.gz: 86f04267b25ba51ef9c7a935b45b41265c8faa124df655d7d10c626e93bc3d462637ab6a6b5f0d7c85678ce935a1e995897379c07ef723f5476daaafbe430ff2
+  data.tar.gz: 7890530ad60348d8483ee03208b67a10a89a76e86144618742ab0dccd09399bb23aad84fd2a5ae8357bef7d83bf56a8e32c072ee9ada47a50c8241a475531793

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+group :test do
+  gem "shoulda"
+  gem "mocha", :require => false
+end
+
+gem "rake"
+gem "semantic_logger"
+gem "resilient_socket"
+gem "ruby_protobuf"

data/Gemfile.lock

@@ -0,0 +1,42 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
+    atomic (1.0.1)
+    bourne (1.4.0)
+      mocha (~> 0.13.2)
+    i18n (0.6.1)
+    metaclass (0.0.1)
+    mocha (0.13.3)
+      metaclass (~> 0.0.1)
+    multi_json (1.7.2)
+    rake (10.0.4)
+    resilient_socket (0.4.0)
+      semantic_logger
+    ruby_protobuf (0.4.11)
+    semantic_logger (2.0.0)
+      sync_attr
+      thread_safe
+    shoulda (3.4.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (~> 1.0, >= 1.4.1)
+    shoulda-context (1.0.2)
+    shoulda-matchers (1.5.4)
+      activesupport (>= 3.0.0)
+      bourne (~> 1.3)
+    sync_attr (0.1.1)
+    thread_safe (0.1.0)
+      atomic
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mocha
+  rake
+  resilient_socket
+  ruby_protobuf
+  semantic_logger
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2012 Clarity Services, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,111 @@
+ruby_doozer
+===========
+
+Ruby Client calling [doozerd](https://github.com/skynetservices/doozerd)
+
+* http://github.com/skynetservices/ruby_doozer
+
+### Example
+
+```ruby
+require 'rubygems'
+require 'ruby_doozer'
+
+client = RubyDoozer::Client.new(:server => '127.0.0.1:8046')
+client.set('/test/foo', 'value')
+result = client.get('/test/foo')
+client.close
+```
+
+### Logging
+
+Since ruby_skynet uses SemanticLogger, trace level logging of all TCP/IP
+calls can be enabled as follows:
+
+```ruby
+require 'rubygems'
+require 'ruby_skynet'
+
+SemanticLogger::Logger.default_level = :trace
+SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('skynet.log')
+
+class EchoService
+  include RubySkynet::Base
+end
+
+client = EchoService.new
+p client.echo(:hello => 'world')
+```
+
+### Notes
+
+ruby_doozer has been tested against the doozer fork https://github.com/skynetservices/doozerd
+which was originally forked from: https://github.com/4ad/doozerd.
+
+### Dependencies
+
+- Ruby MRI 1.8.7 (or above), Ruby 1.9.3,  Or JRuby 1.6.3 (or above)
+- [SemanticLogger](http://github.com/ClarityServices/semantic_logger)
+- [ResilientSocket](https://github.com/ClarityServices/resilient_socket)
+- [ruby_protobuf](https://github.com/macks/ruby-protobuf)
+- [multi_json](https://github.com/intridea/multi_json)
+
+### Install
+
+    gem install ruby_doozer
+
+Development
+-----------
+
+Want to contribute to Ruby Doozer?
+
+First clone the repo and run the tests:
+
+    git clone git://github.com/skynetservices/ruby_doozer.git
+    cd ruby_doozer
+    rake test
+
+Feel free to submit an issue and we'll try to resolve it.
+
+Contributing
+------------
+
+Once you've made your great commits:
+
+1. [Fork](http://help.github.com/forking/) ruby_doozer
+2. Create a topic branch - `git checkout -b my_branch`
+3. Push to your branch - `git push origin my_branch`
+4. Create an [Issue](http://github.com/skynetservices/ruby_doozer/issues) with a link to your branch
+5. That's it!
+
+Meta
+----
+
+* Code: `git clone git://github.com/skynetservices/ruby_doozer.git`
+* Home: <https://github.com/skynetservices/ruby_doozer>
+* Bugs: <http://github.com/skynetservices/ruby_doozer/issues>
+* Gems: <http://rubygems.org/gems/ruby_doozer>
+
+This project uses [Semantic Versioning](http://semver.org/).
+
+Authors
+-------
+
+Reid Morrison :: reidmo@gmail.com :: @reidmorrison
+
+License
+-------
+
+Copyright 2013 Clarity Services, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,42 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'rubygems'
+require 'rubygems/package'
+require 'rake/clean'
+require 'rake/testtask'
+require 'date'
+require 'semantic_logger'
+require 'ruby_doozer/version'
+
+desc "Build gem"
+task :gem  do |t|
+  gemspec = Gem::Specification.new do |spec|
+    spec.name        = 'ruby_doozer'
+    spec.version     = RubyDoozer::VERSION
+    spec.platform    = Gem::Platform::RUBY
+    spec.authors     = ['Reid Morrison']
+    spec.email       = ['reidmo@gmail.com']
+    spec.homepage    = 'https://github.com/ClarityServices/ruby_doozer'
+    spec.date        = Date.today.to_s
+    spec.summary     = "Doozer Ruby Client"
+    spec.description = "Ruby Client for doozer"
+    spec.files       = FileList["./**/*"].exclude(/\.gem$/, /\.log$/,/nbproject/).map{|f| f.sub(/^\.\//, '')}
+    spec.license     = "Apache License V2.0"
+    spec.has_rdoc    = true
+    spec.add_dependency 'semantic_logger'
+    spec.add_dependency 'resilient_socket'
+    spec.add_dependency 'ruby_protobuf'
+  end
+  Gem::Package.build gemspec
+end
+
+desc "Run Test Suite"
+task :test do
+  Rake::TestTask.new(:functional) do |t|
+    t.test_files = FileList['test/*_test.rb']
+    t.verbose    = true
+  end
+
+  Rake::Task['functional'].invoke
+end

data/lib/ruby_doozer.rb

@@ -0,0 +1,3 @@
+module RubyDoozer
+  autoload :Client,   'ruby_doozer/client'
+end

data/lib/ruby_doozer/client.rb

@@ -0,0 +1,206 @@
+require 'semantic_logger'
+require 'resilient_socket'
+require 'ruby_doozer/exceptions'
+require 'ruby_doozer/msg.pb'
+
+module RubyDoozer
+  class Client
+
+    include SemanticLogger::Loggable
+
+    # Create a resilient client connection to a Doozer server
+    def initialize(params={})
+      # User configurable options
+      params[:read_timeout]           ||= 5
+      params[:connect_timeout]        ||= 3
+      params[:connect_retry_interval] ||= 0.1
+      params[:connect_retry_count]    ||= 3
+
+      # Server name and port where Doozer is running
+      # Defaults to 127.0.0.1:8046
+      params[:server] ||= '127.0.0.1:8046' unless params[:servers]
+
+      # Disable buffering the send since it is a RPC call
+      params[:buffered] = false
+
+      logger.trace "Socket Connection parameters", params.dup
+
+      # For each new connection
+      params[:on_connect] = Proc.new do |socket|
+        # Reset user_data on each connection
+        socket.user_data = 0
+      end
+
+      @socket = ResilientSocket::TCPClient.new(params)
+    end
+
+    # Close this client connection to doozer
+    def close
+      @socket.close if @socket
+    end
+
+    # Returns the current Doozer revision
+    def current_revision
+      invoke(Request.new(:verb => Request::Verb::REV)).rev
+    end
+
+    # Set a value in Doozer
+    #   path:  Path to the value to be set
+    #   value: Value to set
+    #   rev:   Revision at which to set the value
+    #         If not supplied it will replace the latest version on the server
+    #
+    # Returns the new revision of the updated value
+    #
+    # It is recommended to set the revision so that multiple clients do not
+    # attempt to update the value at the same time.
+    # Setting the revision also allows the call to be retried automatically
+    # in the event of a network failure
+    def set(path, value, rev=-1)
+      invoke(Request.new(:path => path, :value => value, :rev => rev, :verb => Request::Verb::SET), false).rev
+    end
+
+    # Sets the current value at the supplied path
+    def []=(path,value)
+      set(path, value)
+    end
+
+    # Return the value at the supplied path and revision
+    def get(path, rev = nil)
+      invoke(Request.new(:path => path, :rev => rev, :verb => Request::Verb::GET))
+    end
+
+    # Returns just the value at the supplied path, not the revision
+    def [](path)
+      get(path).value
+    end
+
+    # Deletes the file at path if rev is greater than or equal to the file's revision.
+    # Returns nil when the file was removed
+    # Raises an exception if an attempt to remove the file and its revision
+    #   is greater than that supplied
+    def delete(path, rev=-1)
+      invoke(Request.new(:path => path, :rev => rev, :verb => Request::Verb::DEL))
+      nil
+    end
+
+    # Returns the directory in the supplied path
+    # Use offset to get the next
+    # returns nil if no further paths are available
+    def directory(path, offset = 0, rev = nil)
+      begin
+        invoke(Request.new(:path => path, :rev => rev, :offset => offset, :verb => Request::Verb::GETDIR))
+      rescue RubyDoozer::ResponseError => exc
+        raise exc unless exc.message.include?('RANGE')
+        nil
+      end
+    end
+
+    def stat(path, rev = nil)
+      invoke(Request.new(:path => path, :rev => rev, :verb => Request::Verb::STAT))
+    end
+
+    def access(secret)
+      invoke(Request.new(:path => secret, :verb => Request::Verb::ACCESS))
+    end
+
+    # Returns every entry in the supplied path
+    # path can also contain wildcard characters such as '*'
+    # Example:
+    #   hosts = []
+    #   walk('/ctl/node/*/addr', current_revision).each do |node|
+    #     hosts << node.value unless hosts.include? node.value
+    #   end
+    def walk(path, rev = nil, offset = 0)
+      paths = []
+      revision = rev || current_revision
+      # Resume walk on network connection failure
+      @socket.retry_on_connection_failure do
+        while true
+          send(Request.new(:path => path, :rev => revision , :offset => offset, :verb => Request::Verb::WALK))
+          response = read
+          if response.err_code
+            break if response.err_code == Response::Err::RANGE
+          else
+            raise ResponseError.new("#{Response::Err.name_by_value(response.err_code)}: #{response.err_detail}") if response.err_code != 0
+          end
+          paths << response
+          offset += 1
+        end
+      end
+      paths
+    end
+
+    # Returns [Array] of hostname [String] with each string
+    # representing another Doozer server that can be connected to
+    def doozer_hosts
+      hosts = []
+      walk('/ctl/node/*/addr', current_revision).each do |node|
+        hosts << node.value unless hosts.include? node.value
+      end
+    end
+
+    # Wait for changes to the supplied path
+    # Returns the next change to the supplied path
+    def wait(path, rev=current_revision, timeout=-1)
+      invoke(Request.new(:path => path, :rev => rev, :verb => Request::Verb::WAIT), true, timeout)
+    end
+
+    # Watch for any changes to the supplied path, calling the supplied block
+    # for every change
+    # Runs until an exception is thrown
+    #
+    # If a connection error occurs it will create a new connection to doozer
+    # and resubmit the wait. I.e. Will continue from where it left off
+    # without any noticeable effect to the supplied block
+    def watch(path, rev=current_revision)
+      loop do
+        result = wait(path, rev, -1)
+        yield result
+        rev = result.rev + 1
+      end
+    end
+
+    #####################
+    #protected
+
+    # Call the Doozer server
+    #
+    # When readonly ==> true the request is always retried on network failure
+    # When readonly ==> false the request is retried on network failure
+    #   _only_ if a rev has been supplied
+    #
+    # When modifier is true
+    def invoke(request, readonly=true, timeout=nil)
+      retry_read = readonly || !request.rev.nil?
+      response = nil
+      @socket.retry_on_connection_failure do
+        send(request)
+        response = read(timeout) if retry_read
+      end
+      # Network error on read must be sent back to caller since we do not
+      # know if the modification was made
+      response = read(timeout) unless retry_read
+      raise ResponseError.new("#{Response::Err.name_by_value(response.err_code)} (#{response.err_code}): #{response.err_detail}") if response.err_code != 0
+      response
+    end
+
+    # Send the protobuf Request to Doozer
+    def send(request)
+      request.tag = 0
+      data = request.serialize_to_string
+      # An additional header is added to the request indicating the size of the request
+      head = [data.length].pack("N")
+      @socket.write(head+data)
+    end
+
+    # Read the protobuf Response from Doozer
+    def read(timeout=nil)
+      # First strip the additional header indicating the size of the subsequent response
+      head = @socket.read(4,nil,timeout)
+      length = head.unpack("N")[0]
+      Response.new.parse_from_string(@socket.read(length))
+    end
+
+  end
+end

data/lib/ruby_doozer/exceptions.rb

@@ -0,0 +1,3 @@
+module RubyDoozer
+  class ResponseError < ::RuntimeError; end
+end

data/lib/ruby_doozer/msg.pb.rb

@@ -0,0 +1,116 @@
+### Generated by rprotoc. DO NOT EDIT!
+### <proto file: doozerd/server/msg.proto>
+# package server;
+#
+# // see doc/proto.md
+# message Request {
+#   optional int32 tag = 1;
+#
+#   enum Verb {
+#       GET      = 1;
+#       SET      = 2;
+#       DEL      = 3;
+#       REV      = 5;
+#       WAIT     = 6;
+#       NOP      = 7;
+#       WALK     = 9;
+#       GETDIR   = 14;
+#       STAT     = 16;
+#       ACCESS   = 99;
+#   }
+#   optional Verb verb = 2;
+#
+#   optional string path = 4;
+#   optional bytes value = 5;
+#   optional int32 other_tag = 6;
+#
+#   optional int32 offset = 7;
+#
+#   optional int64 rev = 9;
+# }
+#
+# // see doc/proto.md
+# message Response {
+#   optional int32 tag = 1;
+#   optional int32 flags = 2;
+#
+#   optional int64 rev = 3;
+#   optional string path = 5;
+#   optional bytes value = 6;
+#   optional int32 len = 8;
+#
+#   enum Err {
+#     // don't use value 0
+#     OTHER        = 127;
+#     TAG_IN_USE   = 1;
+#     UNKNOWN_VERB = 2;
+#     READONLY     = 3;
+#     TOO_LATE     = 4;
+#     REV_MISMATCH = 5;
+#     BAD_PATH     = 6;
+#     MISSING_ARG  = 7;
+#     RANGE        = 8;
+#     NOTDIR       = 20;
+#     ISDIR        = 21;
+#     NOENT        = 22;
+#   }
+#   optional Err err_code = 100;
+#   optional string err_detail = 101;
+# }
+
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/service'
+require 'protobuf/message/extend'
+
+module RubyDoozer
+  class Request < ::Protobuf::Message
+    defined_in __FILE__
+    optional :int32, :tag, 1
+    class Verb < ::Protobuf::Enum
+      defined_in __FILE__
+      GET = value(:GET, 1)
+      SET = value(:SET, 2)
+      DEL = value(:DEL, 3)
+      REV = value(:REV, 5)
+      WAIT = value(:WAIT, 6)
+      NOP = value(:NOP, 7)
+      WALK = value(:WALK, 9)
+      GETDIR = value(:GETDIR, 14)
+      STAT = value(:STAT, 16)
+      ACCESS = value(:ACCESS, 99)
+    end
+    optional :Verb, :verb, 2
+    optional :string, :path, 4
+    optional :bytes, :value, 5
+    optional :int32, :other_tag, 6
+    optional :int32, :offset, 7
+    optional :int64, :rev, 9
+  end
+  class Response < ::Protobuf::Message
+    defined_in __FILE__
+    optional :int32, :tag, 1
+    optional :int32, :flags, 2
+    optional :int64, :rev, 3
+    optional :string, :path, 5
+    optional :bytes, :value, 6
+    optional :int32, :len, 8
+    class Err < ::Protobuf::Enum
+      defined_in __FILE__
+      OTHER = value(:OTHER, 127)
+      TAG_IN_USE = value(:TAG_IN_USE, 1)
+      UNKNOWN_VERB = value(:UNKNOWN_VERB, 2)
+      READONLY = value(:READONLY, 3)
+      TOO_LATE = value(:TOO_LATE, 4)
+      REV_MISMATCH = value(:REV_MISMATCH, 5)
+      BAD_PATH = value(:BAD_PATH, 6)
+      MISSING_ARG = value(:MISSING_ARG, 7)
+      RANGE = value(:RANGE, 8)
+      NOTDIR = value(:NOTDIR, 20)
+      ISDIR = value(:ISDIR, 21)
+      NOENT = value(:NOENT, 22)
+    end
+    optional :Err, :err_code, 100
+    optional :string, :err_detail, 101
+  end
+end

data/lib/ruby_doozer/version.rb

@@ -0,0 +1,3 @@
+module RubyDoozer #:nodoc
+  VERSION = "0.1.0"
+end

data/test/client_test.rb

@@ -0,0 +1,70 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'ruby_doozer/client'
+
+# NOTE:
+# This test assumes that doozerd is running locally on the default port of 8046
+
+# Unit Test for RubyDoozer::Client
+class ClientTest < Test::Unit::TestCase
+  context RubyDoozer::Client do
+
+    context "without server" do
+      should "raise exception when cannot reach doozer server after 5 retries" do
+        exception = assert_raise ResilientSocket::ConnectionFailure do
+          RubyDoozer::Client.new(
+            # Bad server address to test exception is raised
+            :server                 => 'localhost:9999',
+            :connect_retry_interval => 0.1,
+            :connect_retry_count    => 5)
+        end
+        assert_match /After 5 connection attempts to host 'localhost:9999': Errno::ECONNREFUSED/, exception.message
+      end
+
+    end
+
+    context "with client connection" do
+      setup do
+        @client = RubyDoozer::Client.new(:server => 'localhost:8046')
+      end
+
+      def teardown
+        if @client
+          @client.close
+          @client.delete('/test/foo')
+        end
+      end
+
+      should "return current revision" do
+        assert @client.current_revision >= 0
+      end
+
+      should "successfully set and get data" do
+        new_revision = @client.set('/test/foo', 'value')
+        result = @client.get('/test/foo')
+        assert_equal 'value', result.value
+        assert_equal new_revision, result.rev
+      end
+
+      should "successfully set and get data using array operators" do
+        @client['/test/foo'] = 'value2'
+        result = @client['/test/foo']
+        assert_equal 'value2', result
+      end
+
+      should "fetch directories in a path" do
+        @path = '/'
+        count = 0
+        until @client.directory(@path, count).nil?
+          count += 1
+        end
+        assert count > 0
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: ruby_doozer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Reid Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: semantic_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resilient_socket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby_protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby Client for doozer
+email:
+- reidmo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ruby_doozer.rb
+- lib/ruby_doozer/client.rb
+- lib/ruby_doozer/exceptions.rb
+- lib/ruby_doozer/msg.pb.rb
+- lib/ruby_doozer/version.rb
+- test/client_test.rb
+homepage: https://github.com/ClarityServices/ruby_doozer
+licenses:
+- Apache License V2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Doozer Ruby Client
+test_files: []