zookeeper 0.9.3-java

data/lib/zookeeper/common/queue_with_pipe.rb

@@ -0,0 +1,78 @@
+module ZookeeperCommon
+  # Ceci n'est pas une pipe
+  class QueueWithPipe
+    extend Forwardable
+
+    def_delegators :@queue, :clear
+    
+    # raised when close has been called, and pop() is performed
+    # 
+    class ShutdownException < StandardError; end
+
+    # @private
+    KILL_TOKEN = Object.new unless defined?(KILL_TOKEN)
+
+    def initialize
+#       r, w = IO.pipe
+#       @pipe = { :read => r, :write => w }
+      @queue = Queue.new
+
+      # with the EventMachine client, we want to let EM handle clearing the
+      # event pipe, so we set this to false
+#       @clear_reads_on_pop = true
+
+      @mutex = Mutex.new
+      @closed = false
+      @graceful = false
+    end
+
+    def push(obj)
+      logger.debug { "#{self.class}##{__method__} obj: #{obj.inspect}, kill_token? #{obj == KILL_TOKEN}" }
+      @queue.push(obj)
+    end
+
+    def pop(non_blocking=false)
+      raise ShutdownException if closed?  # this may get us in trouble
+
+      rv = @queue.pop(non_blocking)
+
+      if rv == KILL_TOKEN
+        close
+        raise ShutdownException
+      end
+
+      rv
+    end
+
+    # close the queue and causes ShutdownException to be raised on waiting threads
+    def graceful_close!
+      @mutex.synchronize do
+        return if @graceful or @closed
+        logger.debug { "#{self.class}##{__method__} gracefully closing" }
+        @graceful = true
+        push(KILL_TOKEN)
+      end
+      nil
+    end
+
+    def close
+      @mutex.synchronize do
+        return if @closed
+        @closed = true
+      end
+    end
+
+    def closed?
+      @mutex.synchronize { !!@closed }
+    end
+
+    private
+      def clear_reads_on_pop?
+        @clear_reads_on_pop
+      end
+
+      def logger
+        Zookeeper.logger
+      end
+  end
+end

data/lib/zookeeper/constants.rb

@@ -0,0 +1,57 @@
+module ZookeeperConstants
+  # file type masks
+  ZOO_EPHEMERAL = 1
+  ZOO_SEQUENCE  = 2
+  
+  # session state
+  ZOO_EXPIRED_SESSION_STATE  = -112
+  ZOO_AUTH_FAILED_STATE      = -113
+  ZOO_CLOSED_STATE           = 0
+  ZOO_CONNECTING_STATE       = 1
+  ZOO_ASSOCIATING_STATE      = 2
+  ZOO_CONNECTED_STATE        = 3
+  
+  # watch types
+  ZOO_CREATED_EVENT      = 1
+  ZOO_DELETED_EVENT      = 2
+  ZOO_CHANGED_EVENT      = 3
+  ZOO_CHILD_EVENT        = 4
+  ZOO_SESSION_EVENT      = -1
+  ZOO_NOTWATCHING_EVENT  = -2
+
+  # only used by the C extension
+  ZOO_LOG_LEVEL_ERROR = 1
+  ZOO_LOG_LEVEL_WARN  = 2
+  ZOO_LOG_LEVEL_INFO  = 3
+  ZOO_LOG_LEVEL_DEBUG = 4
+
+  # used to find the name for a numeric event
+  # @private
+  EVENT_TYPE_NAMES = {
+    1   => 'created',
+    2   => 'deleted',
+    3   => 'changed',
+    4   => 'child',
+    -1  => 'session',
+    -2  => 'notwatching',
+  }
+
+  # used to pretty print the state name
+  # @private
+  STATE_NAMES = {
+    -112 => 'expired_session',
+    -113 => 'auth_failed',
+    0    => 'closed',
+    1    => 'connecting',
+    2    => 'associating',
+    3    => 'connected',
+  }
+              
+  def event_by_value(v)
+    (name = EVENT_TYPE_NAMES[v]) ?  "ZOO_#{name.upcase}_EVENT" : ''
+  end
+
+  def state_by_value(v)
+    (name = STATE_NAMES[v]) ?  "ZOO_#{name.upcase}_STATE" : ''
+  end
+end

data/lib/zookeeper/em_client.rb

@@ -0,0 +1,55 @@
+require 'zookeeper'
+require 'eventmachine'
+
+module ZookeeperEM 
+  class Client < Zookeeper
+    # @private
+    # the EM Connection instance we receive once we call EM.watch on our selectable_io
+    attr_reader :em_connection
+
+    def initialize(*a, &b)
+      @on_close       = EM::DefaultDeferrable.new
+      @on_attached    = EM::DefaultDeferrable.new
+      @em_connection  = nil
+      logger.debug { "ZookeeperEM::Client obj_id %x: init" % [object_id] }
+      super(*a, &b)
+      on_attached.succeed
+    end
+
+    # EM::DefaultDeferrable that will be called back when our em_connection has been detached
+    # and we've completed the close operation
+    def on_close(&block)
+      @on_close.callback(&block) if block
+      @on_close
+    end
+
+    # called after we've successfully registered our selectable_io to be
+    # managed by the EM reactor
+    def on_attached(&block)
+      @on_attached.callback(&block) if block
+      @on_attached
+    end
+
+    def dispatch_next_callback(hash)
+      EM.schedule do
+        if running? and not closed?
+          logger.debug { "#{self.class}##{__method__} dispatch_next_callback: #{hash.inspect}: reactor_thread? #{EM.reactor_thread?}, running? #{running?}, closed? #{closed?}" }
+          super(hash) 
+        end
+      end
+    end
+
+    def close(&block)
+      on_close(&block)
+      super()
+      on_close.succeed
+    end
+
+    # Because eventmachine is single-threaded, and events are dispatched on the
+    # reactor thread we just delegate this to EM.reactor_thread?
+    def event_dispatch_thread?
+      EM.reactor_thread?
+    end
+  end # Client
+end # ZookeeperEM
+

data/lib/zookeeper/exceptions.rb

@@ -0,0 +1,100 @@
+module ZookeeperExceptions
+  # exceptions/errors
+  ZOK                    =  0
+  ZSYSTEMERROR           = -1
+  ZRUNTIMEINCONSISTENCY  = -2
+  ZDATAINCONSISTENCY     = -3
+  ZCONNECTIONLOSS        = -4
+  ZMARSHALLINGERROR      = -5
+  ZUNIMPLEMENTED         = -6
+  ZOPERATIONTIMEOUT      = -7
+  ZBADARGUMENTS          = -8
+  ZINVALIDSTATE          = -9
+  
+  # api errors
+  ZAPIERROR                 = -100
+  ZNONODE                   = -101
+  ZNOAUTH                   = -102
+  ZBADVERSION               = -103
+  ZNOCHILDRENFOREPHEMERALS  = -108
+  ZNODEEXISTS               = -110
+  ZNOTEMPTY                 = -111
+  ZSESSIONEXPIRED           = -112
+  ZINVALIDCALLBACK          = -113
+  ZINVALIDACL               = -114
+  ZAUTHFAILED               = -115
+  ZCLOSING                  = -116
+  ZNOTHING                  = -117
+  ZSESSIONMOVED             = -118
+
+  class ZookeeperException < StandardError
+    class EverythingOk            < ZookeeperException; end
+    class SystemError             < ZookeeperException; end
+    class RunTimeInconsistency    < ZookeeperException; end
+    class DataInconsistency       < ZookeeperException; end
+    class ConnectionLoss          < ZookeeperException; end
+    class MarshallingError        < ZookeeperException; end
+    class Unimplemented           < ZookeeperException; end
+    class OperationTimeOut        < ZookeeperException; end
+    class BadArguments            < ZookeeperException; end
+    class InvalidState            < ZookeeperException; end
+    class ApiError                < ZookeeperException; end
+    class NoNode                  < ZookeeperException; end
+    class NoAuth                  < ZookeeperException; end
+    class BadVersion              < ZookeeperException; end
+    class NoChildrenForEphemerals < ZookeeperException; end
+    class NodeExists              < ZookeeperException; end
+    class NotEmpty                < ZookeeperException; end
+    class SessionExpired          < ZookeeperException; end
+    class InvalidCallback         < ZookeeperException; end
+    class InvalidACL              < ZookeeperException; end
+    class AuthFailed              < ZookeeperException; end
+    class Closing                 < ZookeeperException; end
+    class Nothing                 < ZookeeperException; end
+    class SessionMoved            < ZookeeperException; end
+    
+    # these are Ruby client exceptions
+    class ConnectionClosed        < ZookeeperException; end
+    class NotConnected            < ZookeeperException; end 
+    class ShuttingDownException   < ZookeeperException; end
+    class DataTooLargeException   < ZookeeperException; end
+
+    # yes, make an alias, this is the way zookeeper refers to it
+    ExpiredSession = SessionExpired
+    
+    def self.by_code(code)
+      case code
+        when ZOK then EverythingOk
+        when ZSYSTEMERROR then SystemError
+        when ZRUNTIMEINCONSISTENCY then RunTimeInconsistency
+        when ZDATAINCONSISTENCY then DataInconsistency
+        when ZCONNECTIONLOSS then ConnectionLoss
+        when ZMARSHALLINGERROR then MarshallingError
+        when ZUNIMPLEMENTED then Unimplemented
+        when ZOPERATIONTIMEOUT then OperationTimeOut
+        when ZBADARGUMENTS then BadArguments
+        when ZINVALIDSTATE then InvalidState
+        when ZAPIERROR then ApiError
+        when ZNONODE then NoNode
+        when ZNOAUTH then NoAuth
+        when ZBADVERSION then BadVersion
+        when ZNOCHILDRENFOREPHEMERALS then NoChildrenForEphemerals 
+        when ZNODEEXISTS then NodeExists              
+        when ZNOTEMPTY then NotEmpty                
+        when ZSESSIONEXPIRED then SessionExpired          
+        when ZINVALIDCALLBACK then InvalidCallback         
+        when ZINVALIDACL then InvalidACL
+        when ZAUTHFAILED then AuthFailed
+        when ZCLOSING then Closing
+        when ZNOTHING then Nothing
+        when ZSESSIONMOVED then SessionMoved
+      else Exception.new("no exception defined for code #{code}")
+      end
+    end
+    
+    def self.raise_on_error(code)
+      exc = self.by_code(code)
+      raise exc unless exc == EverythingOk
+    end
+  end
+end

data/lib/zookeeper/stat.rb

@@ -0,0 +1,21 @@
+module ZookeeperStat
+  class Stat
+    attr_reader :version, :exists, :czxid, :mzxid, :ctime, :mtime, :cversion, :aversion, :ephemeralOwner, :dataLength, :numChildren, :pzxid
+
+    alias :ephemeral_owner :ephemeralOwner
+    alias :num_children :numChildren
+    alias :data_length :dataLength
+
+    def initialize(val)
+      @exists = !!val
+      @czxid, @mzxid, @ctime, @mtime, @version, @cversion, @aversion,
+          @ephemeralOwner, @dataLength, @numChildren, @pzxid = val if val.is_a?(Array)
+      val.each { |k,v| instance_variable_set "@#{k}", v } if val.is_a?(Hash)
+      raise ArgumentError unless (val.is_a?(Hash) or val.is_a?(Array) or val.nil?)
+    end
+
+    def exists?
+      @exists
+    end
+  end
+end

data/lib/zookeeper/version.rb

@@ -0,0 +1,6 @@
+# this "namespacing" is retarded. fix this in 1.0
+# @private
+module ZookeeperVersion
+  VERSION = '0.9.3'
+  DRIVER_VERSION = '3.3.5'
+end

data/notes.txt

@@ -0,0 +1,14 @@
+Notes on this fork of http://github.com/twitter/zookeeper
+
+The main purpose of this fork is to provide JRuby compatibility with the MRI driver of the original. We have been using an early fork with an incomplete binding to the C client, and had recently bumped up against a fairly serious bug with handling events. The twitter/zookeeper driver solved this problem but was lacking JRuby support (which is a core piece of our environment).
+
+I've packaged the Java client (and its dependency on log4j) as gems that are installed separately from this codebase to cut down on the size of the zookeeper gem. If this poses a problem (for instance, if the original goal was to have an all-in-one install with no external dependencies), it would be trivial to package those jars along with this code.
+
+In the course of writing the wrapper for JRuby, I've written nearly-complete specs for all of the public API methods: get, set, get_children, stat, create, delete, get_acl, and set_acl. The reason I say they're "nearly" complete is that I have no use for set_acl, and quite honestly, couldn't figure out how to make it work. 
+
+I'm planning on writing a companion gem, 'ZK', that would take some of the higher-level constructs that we'd written around the lower-level driver to implement features like locking and queues, and also to provide a more ruby-like interface.
+
+I'd like to reorganize this codebase in a number of ways, most of all to move all of the various classes and modules under a common "Zookeeper" namespace, however I thought that would be a radical enough change where I'd want to discuss/coordinate with you on how exactly to do it.
+
+
+

data/spec/c_zookeeper_spec.rb

@@ -0,0 +1,50 @@
+# tests the CZookeeper, obviously only available when running under MRI
+require 'spec_helper'
+
+if Module.const_defined?(:CZookeeper)
+  describe CZookeeper do
+    def pop_all_events
+      [].tap do |rv|
+        begin
+          rv << @event_queue.pop(non_blocking=true)
+        rescue ThreadError
+        end
+      end
+    end
+
+    def wait_until_connected(timeout=2)
+      wait_until(timeout) { @czk.state == ZookeeperConstants::ZOO_CONNECTED_STATE }
+    end
+
+    describe do
+      before do
+        @event_queue = ZookeeperCommon::QueueWithPipe.new
+        @czk = CZookeeper.new('localhost:2181', @event_queue)
+      end
+
+      after do
+        @czk.close rescue Exception
+        @event_queue.close rescue Exception
+      end
+
+      it %[should be in connected state within a reasonable amount of time] do
+        wait_until_connected.should be_true
+      end
+
+      describe :after_connected do
+        before do
+          wait_until_connected.should be_true
+        end
+
+        it %[should have a connection event after being connected] do
+          event = wait_until(2) { @event_queue.pop }
+          event.should be
+          event[:req_id].should == ZookeeperCommon::ZKRB_GLOBAL_CB_REQ
+          event[:type].should   == ZookeeperConstants::ZOO_SESSION_EVENT
+          event[:state].should  == ZookeeperConstants::ZOO_CONNECTED_STATE
+        end
+      end
+    end
+  end
+end
+

data/spec/chrooted_connection_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'shared/connection_examples'
+
+describe 'Zookeeper chrooted' do
+  let(:path) { "/_zkchroottest_" }
+  let(:data) { "underpants" } 
+  let(:chroot_path) { '/slyphon-zookeeper-chroot' }
+
+  let(:connection_string) { "localhost:2181#{chroot_path}" }
+
+  before do
+    @zk = Zookeeper.new(connection_string)
+  end
+
+  after do
+    @zk and @zk.close
+  end
+
+  def zk
+    @zk
+  end
+
+  describe 'non-existent' do
+    describe 'with existing parent' do
+      let(:chroot_path) { '/one-level' }
+
+      describe 'create' do
+        before do
+          with_open_zk do |z|
+            rm_rf(z, chroot_path)
+          end
+        end
+
+        it %[should successfully create the path] do
+          rv = zk.create(:path => '/', :data => '')
+          rv[:rc].should be_zero
+          rv[:path].should == ''
+        end
+      end
+    end
+
+    describe 'with missing parent' do
+      let(:chroot_path) { '/deeply/nested/path' }
+
+      describe 'create' do
+        before do
+          with_open_zk do |z|
+            rm_rf(z, chroot_path)
+          end
+        end
+
+        it %[should return ZNONODE] do
+          rv = zk.create(:path => '/', :data => '')
+          rv[:rc].should_not be_zero
+          rv[:rc].should == ZookeeperExceptions::ZNONODE
+        end
+      end
+    end
+  end
+
+
+  describe do
+    before :all do
+      Zookeeper.logger.warn "running before :all"
+
+      with_open_zk do |z|
+        z.create(:path => chroot_path, :data => '')
+      end
+    end
+
+    after :all do
+      with_open_zk do |z|
+        rm_rf(z, chroot_path)
+      end
+    end
+
+    it_should_behave_like "connection"
+  end
+end
+
+