slyphon-zookeeper 0.1.0-java

data/lib/zookeeper.rb

@@ -0,0 +1,180 @@
+# Ruby wrapper for the Zookeeper C API
+
+require 'thread'
+require 'zookeeper/common'
+require 'zookeeper/constants'
+require 'zookeeper/callbacks'
+require 'zookeeper/exceptions'
+require 'zookeeper/stat'
+require 'zookeeper/acls'
+require 'logger'
+
+if defined?(::JRUBY_VERSION)
+  $LOAD_PATH.unshift(File.expand_path('../java', File.dirname(__FILE__))).uniq!
+else
+  $LOAD_PATH.unshift(File.expand_path('../ext', File.dirname(__FILE__))).uniq!
+  require 'zookeeper_c'
+end
+
+require 'zookeeper_base'
+
+class Zookeeper < ZookeeperBase
+  def reopen(timeout=10, watcher=nil)
+    super
+  end
+
+  def initialize(host, timeout=10, watcher=nil)
+    super
+  end
+
+  def get(options = {})
+    assert_open
+    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])
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:data => value, :stat => Stat.new(stat))
+  end
+  
+  def set(options = {})
+    assert_open
+    assert_supported_keys(options, [:path, :data, :version, :callback, :callback_context])
+    assert_required_keys(options, [:path])
+    options[:version] ||= -1
+
+    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_open
+    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])
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:children => children, :stat => Stat.new(stat))
+  end
+
+  def stat(options = {})
+    assert_open
+    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_open
+    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]
+
+    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_open
+    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
+
+  def set_acl(options = {})
+    assert_open
+    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_open
+    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
+
+  def state
+    super
+  end
+
+  def connected?
+    super
+  end
+
+private
+  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
+
+  def connecting?
+    super
+  end
+
+  def associating?
+    super
+  end
+
+  # 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
+  
+  # must be supplied by parent class impl.
+  def assert_open
+    super
+  end
+
+end
+

data/lib/zookeeper/acls.rb

@@ -0,0 +1,40 @@
+module ZookeeperACLs
+  class Id
+    attr_reader :scheme, :id
+    def initialize(hash)
+      @scheme = hash[:scheme]
+      @id = hash[:id]
+    end
+
+    def to_hash
+      { :id => id, :scheme => scheme }
+    end
+  end
+    
+  class ACL
+    attr_reader :perms, :id
+    def initialize(hash)
+      @perms = hash[:perms]
+      v = hash[:id]
+      @id = v.kind_of?(Hash) ? Id.new(v) : v
+    end
+
+    def to_hash
+      { :perms => perms, :id => id.to_hash }
+    end
+  end
+  
+  ZOO_PERM_READ   = 0
+  ZOO_PERM_WRITE  = 1
+  ZOO_PERM_CREATE = 2
+  ZOO_PERM_DELETE = 4
+  ZOO_PERM_ADMIN  = 8
+  ZOO_PERM_ALL    = ZOO_PERM_READ | ZOO_PERM_WRITE | ZOO_PERM_CREATE | ZOO_PERM_DELETE | ZOO_PERM_ADMIN
+  
+  ZOO_ANYONE_ID_UNSAFE = Id.new(:scheme => "world", :id => "anyone")
+  ZOO_AUTH_IDS         = Id.new(:scheme => "auth", :id => "")
+
+  ZOO_OPEN_ACL_UNSAFE  = [ACL.new(:perms => ZOO_PERM_ALL,  :id => ZOO_ANYONE_ID_UNSAFE)]
+  ZOO_READ_ACL_UNSAFE  = [ACL.new(:perms => ZOO_PERM_READ, :id => ZOO_ANYONE_ID_UNSAFE)]
+  ZOO_CREATOR_ALL_ACL  = [ACL.new(:perms => ZOO_PERM_ALL,  :id => ZOO_AUTH_IDS)]
+end

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[:string], 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[:strings], 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/common.rb

@@ -0,0 +1,97 @@
+require 'zookeeper/exceptions'
+
+module ZookeeperCommon
+  # sigh, i guess define this here?
+  ZKRB_GLOBAL_CB_REQ   = -1
+
+  def self.included(mod)
+    mod.extend(ZookeeperCommon::ClassMethods)
+  end
+
+  module ClassMethods
+    def logger
+      @logger ||= Logger.new('/dev/null') # UNIX: YOU MUST USE IT!
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+  end
+
+protected
+  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
+
+  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 dispatch_next_callback
+    hash = get_next_event
+    return nil unless hash
+    
+    logger.debug {  "dispatch_next_callback got event: #{hash.inspect}" }
+
+    is_completion = hash.has_key?(:rc)
+    
+    hash[:stat] = ZookeeperStat::Stat.new(hash[:stat]) if hash.has_key?(:stat)
+    hash[:acl] = hash[:acl].map { |acl| ZookeeperACLs::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 assert_supported_keys(args, supported)
+    unless (args.keys - supported).empty?
+      raise ZookeeperExceptions::ZookeeperException::BadArguments,  # this heirarchy is kind of retarded
+            "Supported arguments are: #{supported.inspect}, but arguments #{args.keys.inspect} were supplied instead"
+    end
+  end
+
+  def assert_required_keys(args, required)
+    unless (required - args.keys).empty?
+      raise ZookeeperExceptions::ZookeeperException::BadArguments,
+            "Required arguments are: #{required.inspect}, but only the arguments #{args.keys.inspect} were supplied."
+    end
+  end
+
+  # supplied by parent class impl.
+  def logger
+    self.class.logger
+  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