zookeeper 0.2.2 → 0.3.0

data/lib/zookeeper/callbacks.rb

@@ -0,0 +1,89 @@
+module ZookeeperCallbacks
+  class Callback
+    attr_reader :proc, :completed, :context
+
+    def initialize
+      @completed = false
+      @proc = Proc.new do |hash|
+        initialize_context(hash)
+        yield if block_given?
+        @completed = true
+      end
+    end
+    
+    def call(*args)
+      puts "call passed #{args.inspect}"
+      @proc.call(*args)
+    end
+    
+    def completed?
+      @completed
+    end
+    
+    def initialize_context(hash)
+      @context = nil
+    end
+  end
+  
+  class WatcherCallback < Callback
+    ## wexists, awexists, wget, awget, wget_children, awget_children
+    attr_reader :type, :state, :path
+    
+    def initialize_context(hash)
+      @type, @state, @path, @context = hash[:type], hash[:state], hash[:path], hash[:context]
+    end
+  end
+
+  class DataCallback < Callback
+    ## aget, awget
+    attr_reader :return_code, :data, :stat
+
+    def initialize_context(hash)
+      @return_code, @data, @stat, @context = hash[:rc], hash[:data], hash[:stat], hash[:context]
+    end
+  end
+
+  class StringCallback < Callback
+    ## acreate, async
+    attr_reader :return_code, :path
+
+    def initialize_context(hash)
+      @return_code, @path, @context = hash[:rc], hash[:path], hash[:context]
+    end
+  end
+
+  class StringsCallback < Callback
+    ## aget_children, awget_children
+    attr_reader :return_code, :children, :stat
+
+    def initialize_context(hash)
+      @return_code, @children, @stat, @context = hash[:rc], hash[:children], hash[:stat], hash[:context]
+    end
+  end
+
+  class StatCallback < Callback
+    ## aset, aexists, awexists
+    attr_reader :return_code, :stat
+
+    def initialize_context(hash)
+      @return_code, @stat, @context = hash[:rc], hash[:stat], hash[:context]
+    end
+  end
+
+  class VoidCallback < Callback
+    ## adelete, aset_acl, add_auth
+    attr_reader :return_code
+    
+    def initialize_context(hash)
+      @return_code, @context = hash[:rc], hash[:context]
+    end
+  end
+
+  class ACLCallback < Callback
+    ## aget_acl
+    attr_reader :return_code, :acl, :stat
+    def initialize_context(hash)
+      @return_code, @acl, @stat, @context = hash[:rc], hash[:acl], hash[:stat], hash[:context]
+    end
+  end
+end

data/lib/zookeeper/constants.rb

@@ -0,0 +1,54 @@
+module ZookeeperConstants
+  # file type masks
+  ZOO_EPHEMERAL = 1
+  ZOO_SEQUENCE  = 2
+  
+  # session state
+  ZOO_EXPIRED_SESSION_STATE  = -112
+  ZOO_AUTH_FAILED_STATE      = -113
+  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
+              
+  def print_events
+    puts "ZK events:"
+    ZookeeperConstants::constants.each do |c|
+      puts "\t #{c}" if c =~ /^ZOO..*EVENT$/
+    end
+  end
+
+  def print_states
+    puts "ZK states:"
+    ZookeeperConstants::constants.each do |c|
+      puts "\t #{c}" if c =~ /^ZOO..*STATE$/
+    end
+  end
+
+  def event_by_value(v)
+    return unless v
+    ZookeeperConstants::constants.each do |c|
+      next unless c =~ /^ZOO..*EVENT$/
+      if eval("ZookeeperConstants::#{c}") == v
+        return c
+      end
+    end
+  end
+  
+  def state_by_value(v)
+    return unless v
+    ZookeeperConstants::constants.each do |c|
+      next unless c =~ /^ZOO..*STATE$/
+      if eval("ZookeeperConstants::#{c}") == v
+        return c
+      end
+    end
+  end
+end

data/lib/zookeeper/exceptions.rb

@@ -0,0 +1,91 @@
+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 < Exception
+    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
+    
+    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,12 @@
+module ZookeeperStat
+  class Stat
+    attr_reader :version, :exists
+    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
+  end
+end

data/lib/zookeeper.rb

@@ -1,78 +1,234 @@
 # Ruby wrapper for the Zookeeper C API
-# Phillip Pearson <pp@myelin.co.nz>
 
 require 'zookeeper_c'
-
-class ZkStat
-  attr_reader :version
-  def initialize(ary)
-    @czxid, @mzxid, @ctime, @mtime, @version, @cversion, @aversion, @ephemeralOwner = ary
-  end
-end
+require 'thread'
+require 'zookeeper/callbacks'
+require 'zookeeper/constants'
+require 'zookeeper/exceptions'
+require 'zookeeper/stat'
+require 'zookeeper/acls'
 
 class Zookeeper < CZookeeper
-  def initialize(host)
+  include ZookeeperCallbacks
+  include ZookeeperConstants
+  include ZookeeperExceptions
+  include ZookeeperACLs
+  include ZookeeperStat
+
+  ZKRB_GLOBAL_CB_REQ   = -1
+
+  # debug levels
+  ZOO_LOG_LEVEL_ERROR  = 1
+  ZOO_LOG_LEVEL_WARN   = 2
+  ZOO_LOG_LEVEL_INFO   = 3
+  ZOO_LOG_LEVEL_DEBUG  = 4
+  
+  def initialize(host, timeout = 10)
+    @watcher_reqs = { ZKRB_GLOBAL_CB_REQ => { :watcher => get_default_global_watcher } }
+    @completion_reqs = {}
+    @req_mutex = Mutex.new
+    @current_req_id = 1
     super(host)
-    @watchers = {} # path => [ block, block, ... ]
+    
+    if timeout > 0
+      time_to_stop = Time.now + timeout
+      until state == Zookeeper::ZOO_CONNECTED_STATE
+        break if Time.now > time_to_stop
+        sleep 0.1
+      end
+
+      return nil if state != Zookeeper::ZOO_CONNECTED_STATE
+    end
+
+    setup_dispatch_thread!
   end
+  
+public  
+  def get(options = {})
+    assert_supported_keys(options, [:path, :watcher, :watcher_context, :callback, :callback_context])
+    assert_required_keys(options, [:path])
+    
+    req_id = setup_call(options)
+    rc, value, stat = super(req_id, options[:path], options[:callback], options[:watcher])
 
-  def exists(path, &blk)
-    (@watchers[path] ||= []) << blk if blk
-    ZkStat.new(super(path, !!blk))
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:data => value, :stat => Stat.new(stat))
   end
+  
+  def set(options = {})
+    assert_supported_keys(options, [:path, :data, :version, :callback, :callback_context])
+    assert_required_keys(options, [:path])
+    options[:version] ||= -1
 
-  def stat(path, &blk)
-    exists(path, &blk)
-  rescue Zookeeper::NoNodeError
-    nil
+    req_id = setup_call(options)
+    rc, stat = super(req_id, options[:path], options[:data], options[:callback], options[:version])
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:stat => Stat.new(stat))
   end
+  
+  def get_children(options = {})
+    assert_supported_keys(options, [:path, :callback, :callback_context, :watcher, :watcher_context])
+    assert_required_keys(options, [:path])
+
+    req_id = setup_call(options)
+    rc, children, stat = super(req_id, options[:path], options[:callback], options[:watcher])
 
-  def get(path)
-    value, stat = super
-    [value, ZkStat.new(stat)]
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:children => children, :stat => Stat.new(stat))
   end
 
-  def try_acquire(path, value)
-    # create the parent node if it doesn't exist already
-    create(path, "lock node", 0) unless stat(path)
+  def stat(options = {})
+    assert_supported_keys(options, [:path, :callback, :callback_context, :watcher, :watcher_context])
+    assert_required_keys(options, [:path])
+
+    req_id = setup_call(options)
+    rc, stat = exists(req_id, options[:path], options[:callback], options[:watcher])
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:stat => Stat.new(stat))
+  end
+  
+  def create(options = {})
+    assert_supported_keys(options, [:path, :data, :acl, :ephemeral, :sequence, :callback, :callback_context])
+    assert_required_keys(options, [:path])
+    
+    flags = 0
+    flags |= ZOO_EPHEMERAL if options[:ephemeral]
+    flags |= ZOO_SEQUENCE if options[:sequence]
 
-    # attempt to obtain the lock
-    realpath = create("#{path}/lock-", value, Zookeeper::ZOO_EPHEMERAL | Zookeeper::ZOO_SEQUENCE)
-    #puts "created lock node #{realpath}"
+    options[:acl] ||= ZOO_OPEN_ACL_UNSAFE
+    
+    req_id = setup_call(options)
+    rc, newpath = super(req_id, options[:path], options[:data], options[:callback], options[:acl], flags)
+    
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:path => newpath) 
+  end
+  
+  def delete(options = {})
+    assert_supported_keys(options, [:path, :version, :callback, :callback_context])
+    assert_required_keys(options, [:path])
+    options[:version] ||= -1
+    
+    req_id = setup_call(options)
+    rc = super(req_id, options[:path], options[:version], options[:callback])
+    
+    { :req_id => req_id, :rc => rc }
+  end
 
-    # see if we got it
-    serial = /lock-(\d+)$/.match(realpath).captures[0].to_i
-    have_lock = true
-    ls(path).each do |child|
-      if m = /lock-(\d+)$/.match(child)
-        if m.captures[0].to_i < serial
-          have_lock = false
-          break
-        end
+  def set_acl(options = {})
+    assert_supported_keys(options, [:path, :acl, :version, :callback, :callback_context])
+    assert_required_keys(options, [:path, :acl])
+    options[:version] ||= -1
+    
+    req_id = setup_call(options)
+    rc = super(req_id, options[:path], options[:acl], options[:callback], options[:version])
+    
+    { :req_id => req_id, :rc => rc }
+  end
+  
+  def get_acl(options = {})
+    assert_supported_keys(options, [:path, :callback, :callback_context])
+    assert_required_keys(options, [:path])
+    
+    req_id = setup_call(options)
+    rc, acls, stat = super(req_id, options[:path], options[:callback])
+    
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:acl => acls, :stat => Stat.new(stat))
+  end
+
+private
+  def setup_dispatch_thread!
+    @dispatcher = Thread.new {
+      while true do
+        dispatch_next_callback
+        sleep 0.1
       end
-    end
+    }
+  end
 
-    # call block
-    yield(have_lock)
+  def dispatch_next_callback
+    hash = get_next_event
+    return nil unless hash
+
+    is_completion = hash.has_key?(:rc)
+    
+    hash[:stat] = Stat.new(hash[:stat]) if hash.has_key?(:stat)
+    hash[:acl] = hash[:acl].map { |acl| ACL.new(acl) } if hash[:acl]
+    
+    callback_context = is_completion ? get_completion(hash[:req_id]) : get_watcher(hash[:req_id])
+    callback = is_completion ? callback_context[:callback] : callback_context[:watcher]
+    hash[:context] = callback_context[:context]
+    
+    # TODO: Eventually enforce derivation from Zookeeper::Callback
+    if callback.respond_to?(:call)
+      callback.call(hash)
+    else
+      puts "dispatch_next_callback found non-callback => #{callback.inspect}"
+    end
+  end
+  
+  def setup_call(opts)
+    req_id = nil
+    @req_mutex.synchronize {
+      req_id = @current_req_id
+      @current_req_id += 1
+      setup_completion(req_id, opts) if opts[:callback]
+      setup_watcher(req_id, opts) if opts[:watcher]
+    }
+    req_id
+  end
+  
+  def setup_watcher(req_id, call_opts)
+    @watcher_reqs[req_id] = { :watcher => call_opts[:watcher],
+                              :context => call_opts[:watcher_context] }
+  end
 
-    # release the lock
-    #puts "deleting #{realpath}"
-    delete(realpath, stat(realpath).version)
+  def setup_completion(req_id, call_opts)
+    @completion_reqs[req_id] = { :callback => call_opts[:callback],
+                                 :context => call_opts[:callback_context] }
+  end
+  
+  def get_watcher(req_id)
+    @req_mutex.synchronize {
+      req_id != ZKRB_GLOBAL_CB_REQ ? @watcher_reqs.delete(req_id) : @watcher_reqs[req_id]
+    }
+  end
+  
+  def get_completion(req_id)
+    @req_mutex.synchronize { @completion_reqs.delete(req_id) }
   end
 
-  def watcher(type, state, path)
-    raise Exception("watchers don't work in ruby yet") # ... until I figure out how to synchronize access to the Ruby interpreter
+public
+  # TODO: Sanitize user mistakes by unregistering watchers from ops that
+  # don't return ZOK (except wexists)?  Make users clean up after themselves for now.
+  def unregister_watcher(req_id)
+    @req_mutex.synchronize {
+      @watcher_reqs.delete(req_id)
+    }
+  end
 
-    return unless type == ZOO_SESSION_EVENT
+private
+  def get_default_global_watcher
+    Proc.new { |args|
+      puts "Ruby ZK Global CB called type=#{event_by_value(args[:type])} state=#{state_by_value(args[:state])}"
+    }
+  end
 
-    case state
-    when ZOO_CONNECTED_STATE
-      puts "ruby watcher; got an event for #{path}"
+  def assert_supported_keys(args, supported)
+    unless (args.keys - supported).empty?
+      raise ZookeeperException::BadArguments,
+            "Supported arguments are: #{supported.inspect}, but arguments #{args.keys.inspect} were supplied instead"
+    end
+  end
 
-    when ZOO_AUTH_FAILED_STATE
-      raise Exception, "auth failure"
-    when ZOO_EXPIRED_SESSION_STATE
-      raise Exception, "session expired"
+  def assert_required_keys(args, required)
+    unless (required - args.keys).empty?
+      raise ZookeeperException::BadArguments,
+            "Required arguments are: #{required.inspect}, but only the arguments #{args.keys.inspect} were supplied."
     end
   end
 end
+

data/test/test_basic.rb

@@ -1,63 +1,40 @@
+require 'rubygems'
+
 HERE = File.expand_path(File.dirname(__FILE__))
 
 require "#{HERE}/../lib/zookeeper"
 
 z = Zookeeper.new("localhost:2181")
 
-puts "root: #{z.get_children("/").inspect}"
+puts "root: #{z.get_children(:path => "/").inspect}"
 
 path = "/testing_node"
 
 puts "working with path #{path}"
 
-stat = z.stat(path)
+h = z.stat(:path => path)
+stat = h[:stat]
 puts "exists? #{stat.inspect}"
 
-unless stat.nil?
-  z.get_children(path).each do |o|
+if stat.exists
+  z.get_children(:path => path)[:children].each do |o|
     puts "  child object: #{o}"
   end
-  puts "delete: #{z.delete(path, stat.version).inspect}"
+  puts "delete: #{z.delete(:path => path, :version => stat.version).inspect}"
 end
 
-puts "create: #{z.create(path, "initial value", 0).inspect}"
+puts "create: #{z.create(:path => path, :data => 'initial value').inspect}"
 
-value, stat = z.get(path)
+v = z.get(:path => path)
+value, stat = v[:data], v[:stat]
 puts "current value #{value}, stat #{stat.inspect}"
 
-puts "set: #{z.set(path, "this is a test", stat.version).inspect}"
+puts "set: #{z.set(:path => path, :data => 'this is a test', :version => stat.version).inspect}"
 
-value, stat = z.get(path)
+v = z.get(:path => path)
+value, stat = v[:data], v[:stat]
 puts "new value: #{value.inspect} #{stat.inspect}"
 
-puts "delete: #{z.delete(path, stat.version).inspect}"
-
-begin
-  puts "exists? #{z.exists(path)}"
-  raise Exception, "it shouldn't exist"
-rescue Zookeeper::NoNodeError
-  puts "doesn't exist - good, because we just deleted it!"
-end
-
-puts "trying a watcher"
-puts z
-if s = z.stat("/test"); z.delete("/test", s.version); end
-z.create("/test", "foo", 0)
-z.exists("/test") do
-  puts "callback!!!"
-end
-puts "now changing it"
-z.set("/test", "bar", 0)
-sleep 1
-puts "did the watcher say something?"
-
-puts "let's try using a lock"
-z.try_acquire("/test_lock", "this is the content of the lock file") do |have_lock|
-  puts have_lock ? "we have the lock!" : "failed to obtain lock :("
-  if have_lock
-    puts "sleeping"
-    sleep 5
-  end
-end
-puts "done with locking..."
+puts "delete: #{z.delete(:path => path, :version => stat.version).inspect}"
 
+puts "exists? #{z.stat(:path => path)[:stat].exists}"

data/test/test_callback1.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'zookeeper'
+
+def wait_until(timeout=10, &block)
+  time_to_stop = Time.now + timeout
+  until yield do
+    break if Time.now > time_to_stop
+    sleep 0.1
+  end
+end
+
+puts 'Initializing Zookeeper'
+
+zk = Zookeeper.new('localhost:2181')
+
+if zk.state != Zookeeper::ZOO_CONNECTED_STATE
+  puts 'Unable to connect to Zookeeper!'
+  Kernel.exit
+end
+
+def callback(args)
+  puts "CALLBACK EXECUTED, args = #{args.inspect}"
+  puts args.return_code == Zookeeper::ZOK ? "TEST PASSED IN CALLBACK" : "TEST FAILED IN CALLBACK"
+end
+
+ccb = Zookeeper::VoidCallback.new do
+  callback(ccb)
+end
+
+resp = zk.create(:path => '/test', :data => "new data", :sequence => true, :callback => ccb)
+puts "#{resp.inspect}"
+puts "TEST FAILED [create]" unless resp[:rc] == Zookeeper::ZOK
+ 
+wait_until { ccb.completed? }
+
+puts ccb.completed? ? "TEST PASSED" : "TEST FAILED"

data/test/test_esoteric.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'zookeeper'
+zk = Zookeeper.new('localhost:2181')
+
+puts "get acl #{zk.get_acl(:path => '/').inspect}"
+puts "zerror #{zk.zerror(Zookeeper::ZBADVERSION)}"
+