zookeeper-ng 1.5

data/lib/zookeeper/forked.rb

@@ -0,0 +1,19 @@
+module Zookeeper
+  module Forked
+    # the includer provides an 'original_pid' method, which is set
+    # when the original 'owning' process creates the object. 
+    #
+    # @return [true] if the current PID differs from the original_pid value
+    # @return [false] if the current PID matches the original_pid value
+    #
+    def forked?
+      Process.pid != original_pid
+    end
+
+    # sets the `original_pid` to the current value
+    def update_pid!
+      self.original_pid = Process.pid
+    end
+  end # Forked
+end # Zookeeper
+

data/lib/zookeeper/latch.rb

@@ -0,0 +1,34 @@
+module Zookeeper
+  # a cross-thread gate of sorts.
+  class Latch
+    def initialize(count = 1)
+      @count = count
+      @mutex = Monitor.new
+      @cond = @mutex.new_cond
+    end
+
+    def release
+      @mutex.synchronize {
+        @count -= 1 if @count > 0
+        @cond.broadcast if @count.zero?
+      }
+    end
+
+    def await(timeout=nil)
+      @mutex.synchronize do
+        if timeout
+          time_to_stop = Time.now + timeout
+
+          while @count > 0
+            @cond.wait(timeout)
+            
+            break if (Time.now > time_to_stop)
+          end
+        else
+          @cond.wait_while { @count > 0 }
+        end
+      end
+    end
+  end
+end
+

data/lib/zookeeper/logger.rb

@@ -0,0 +1,39 @@
+module Zookeeper
+  module Logger
+    def self.wrapped_logger
+      if defined?(@@wrapped_logger)
+        @@wrapped_logger 
+      else
+        @@wrapped_logger = ::Logger.new(STDERR).tap { |l| l.level = ::Logger::FATAL }
+      end
+    end
+
+    def self.wrapped_logger=(log)
+      @@wrapped_logger = log
+    end
+
+    # @private
+    module ClassMethods
+      def logger
+        ::Zookeeper.logger || ForwardingLogger.for(::Zookeeper::Logger.wrapped_logger, _zk_logger_name)
+      end
+    end
+
+    def self.included(base)
+      # return false if base < self    # avoid infinite recursion
+      base.extend(ClassMethods)
+    end
+
+    private
+      def log_realtime(what)
+        logger.debug do
+          t = Benchmark.realtime { yield }
+          "#{what} took #{t} sec"
+        end
+      end
+
+      def logger
+        @logger ||= (::Zookeeper.logger || self.class.logger)
+      end
+  end # Logger
+end # Zookeeper

data/lib/zookeeper/logger/forwarding_logger.rb

@@ -0,0 +1,84 @@
+module Zookeeper
+  module Logger
+    # h/t _eric and Papertrail
+    # @private
+    class ForwardingLogger
+      attr_accessor :level, :formatter
+
+      @@mutex = Monitor.new unless defined?(@@mutex)
+      @@loggers = {} unless defined?(@@loggers)
+
+      def self.for(logger, name)
+        @@mutex.synchronize do
+          @@loggers.fetch(name) do |k|
+            @@loggers[k] = new(logger, :formatter => lambda { |m| "%25.25s: %s" % [k, m] })
+          end
+        end
+      end
+
+      def initialize(logger, options = {})
+        @level     = ::Logger::DEBUG
+        @logger    = logger
+        @formatter = options[:formatter]
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        severity ||= ::Logger::UNKNOWN
+        if !@logger || severity < @level
+          return true
+        end
+        
+        message = (message || (block && block.call) || progname).to_s
+        
+        if @formatter && @formatter.respond_to?(:call)
+          message = @formatter.call(message)
+        end
+
+        # If a newline is necessary then create a new message ending with a newline.
+        # Ensures that the original message is not mutated.
+        # message = "#{message}\n" unless message[-1] == ?\n
+        
+        @logger.add(severity, message)
+      end
+
+      def <<(msg); @logger << msg; end
+      def write(msg); @logger.write(msg); end
+      
+      def debug(progname = nil, &block)
+        add(::Logger::DEBUG, nil, progname, &block)
+      end
+      
+      def info(progname = nil, &block)
+        add(::Logger::INFO, nil, progname, &block)
+      end
+      
+      def warn(progname = nil, &block)
+        add(::Logger::WARN, nil, progname, &block)
+      end
+      
+      def error(progname = nil, &block)
+        add(::Logger::ERROR, nil, progname, &block)
+      end
+
+      def fatal(progname = nil, &block)
+        add(::Logger::FATAL, nil, progname, &block)
+      end
+
+      def unknown(progname = nil, &block)
+        add(::Logger::UNKNOWN, nil, progname, &block)
+      end
+      
+      def debug?; @level <= DEBUG; end
+
+      def info?; @level <= INFO; end
+
+      def warn?; @level <= WARN; end
+
+      def error?; @level <= ERROR; end
+
+      def fatal?; @level <= FATAL; end
+    end # ForwardingLogger
+  end # Logger
+end # Zookeeper
+
+

data/lib/zookeeper/monitor.rb

@@ -0,0 +1,19 @@
+module Zookeeper
+  # just like stdlib Monitor but provides the SAME API AS MUTEX, FFS!
+  class Monitor
+    include MonitorMixin
+
+    alias try_enter try_mon_enter
+    alias enter mon_enter
+    alias exit mon_exit
+
+    # here, HERE!
+    # *here* are the methods that are the same
+    # god *dammit*
+
+    alias lock mon_enter
+    alias unlock mon_exit
+    alias try_lock try_mon_enter
+  end
+end
+

data/lib/zookeeper/rake_tasks.rb

@@ -0,0 +1,165 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Zookeeper
+  # @private
+  module RakeTasks
+    def self.define_test_tasks_for(*rubies)
+      rubies.each do |r|
+
+        TestOneRuby.new(:name => r) do |tor|
+          yield tor if block_given?
+        end
+      end
+    end
+
+    class TestOneRuby < ::Rake::TaskLib
+      include ::Rake::DSL if defined?(::Rake::DSL)
+
+      DEFAULT_RVM_RUBY_NAME = '1.9.3'
+
+      # defaults to 'zk', test tasks will be built under this
+      attr_accessor :namespace
+
+      # the name of the task
+      # (tasks will be 'zk:1.9.3:run_rspec')
+      #
+      # this is mainly here so that the rvm ruby name rbx-2.0.testing 
+      # will have its tasks defined as 'zk:rbx'
+      attr_accessor :name
+
+      # what is the rvm name we should use for testing? (i.e. could be an alias)
+      # defaults to {#name}
+      attr_accessor :rvm_ruby_name
+
+      # any extra environment variables?
+      attr_accessor :env
+
+      # gemset name to use, deafults to the name of the gemspec in the top of the
+      # project directory (minus the .gempsec)
+      attr_accessor :gemset_name
+
+      # @private
+      attr_reader :ruby_with_gemset,       
+        :create_gemset_name,
+        :clobber_task_name,
+        :clean_task_name,
+        :build_task_name,
+        :bundle_task_name,
+        :rspec_task_name,
+        :phony_gemfile_link_name,
+        :phony_gemfile_lock_name
+
+
+      def self.default_gemset_name
+        ary = Dir['*.gemspec']
+        raise 'No gemspec found' if ary.empty?
+        ary.first[/(.+)\.gemspec\Z/, 1]
+      end
+
+      def initialize(opts={})
+        @namespace      = 'zk'
+        @name           = nil
+        @env            = {}
+        @rvm_ruby_name  = nil
+        @gemset_name    = nil
+
+        opts.each { |k,v| __send__(:"#{k}=", v) }
+
+        yield self if block_given?
+
+        @gemset_name    ||= self.class.default_gemset_name
+        
+        # XXX: add an exception just for me in here (yes, i know this is naughty)
+        #      or else i'd have to do this in every zk variant i want to test
+        #      (like i have to now)
+
+        unless @rvm_ruby_name
+          @rvm_ruby_name = 'rbx-2.0.testing' if @name == 'rbx'
+        end
+
+        @rvm_ruby_name  ||= name
+
+        @ruby_with_gemset         = "#{@rvm_ruby_name}@#{@gemset_name}"
+        @create_gemset_name       = "#{namespace}:#{name}:create_gemset"
+        @clobber_task_name        = "#{namespace}:#{name}:clobber"
+        @clean_task_name          = "#{namespace}:#{name}:clean"
+        @build_task_name          = "#{namespace}:#{name}:build"
+        @bundle_task_name         = "#{namespace}:#{name}:bundle_install"
+        @rspec_task_name          = "#{namespace}:#{name}:run_rspec"
+        @phony_gemfile_link_name  = "Gemfile.#{name}"
+        @phony_gemfile_lock_name  = "#{phony_gemfile_link_name}.lock"
+
+        define_tasks
+      end
+
+      private
+        def need_ext_build?
+          name != 'jruby' && File.directory?('./ext')
+        end
+
+        def define_tasks
+          file phony_gemfile_link_name do
+            # apparently, rake doesn't deal with symlinks intelligently :P
+            ln_s('Gemfile', phony_gemfile_link_name) unless File.symlink?(phony_gemfile_link_name)
+          end
+
+          task :clean do
+            rm_rf [phony_gemfile_lock_name, phony_gemfile_lock_name]
+          end
+
+          task create_gemset_name do
+            sh "rvm #{rvm_ruby_name} do rvm gemset create #{gemset_name}"
+          end
+
+          task clobber_task_name do
+            if need_ext_build?
+              cd 'ext' do
+                sh "rake clobber"
+              end
+            end
+          end
+
+          task clean_task_name do
+            if need_ext_build?
+              cd 'ext' do
+                sh "rake clean"
+              end
+            end
+          end
+
+          task build_task_name => [create_gemset_name, clean_task_name] do
+            if need_ext_build?
+              cd 'ext' do
+                sh "rvm #{ruby_with_gemset} do rake build"
+              end
+            end
+          end
+
+          task bundle_task_name => [phony_gemfile_link_name, build_task_name] do
+            sh "rvm #{ruby_with_gemset} do bundle install --gemfile #{phony_gemfile_link_name}"
+          end
+
+          task rspec_task_name => bundle_task_name do
+            sh "rvm #{ruby_with_gemset} do env BUNDLE_GEMFILE=#{phony_gemfile_link_name} bundle exec rspec spec --fail-fast"
+          end
+
+          task "#{namespace}:#{name}" => rspec_task_name
+
+          task "#{namespace}:test_all_rubies" => rspec_task_name
+
+          unless Rake::Task.task_defined?("#{namespace}:test_all")
+            task "#{namespace}:test_all" do
+              require 'benchmark'
+              t = Benchmark.realtime do
+                Rake::Task["#{namespace}:test_all_rubies"].invoke
+              end
+
+              $stderr.puts "Test run took: #{t} s"
+            end
+          end
+        end
+    end
+  end
+end
+

data/lib/zookeeper/request_registry.rb

@@ -0,0 +1,153 @@
+module Zookeeper
+  class RequestRegistry
+    include Constants
+    include Logger
+
+    # @param [Hash] opts
+    # @option opts [String] :chroot_path (nil) if given, will be used to
+    #   correct a discrepancy between the C and Java clients when using a
+    #   chrooted connection. If given, the chroot path will be stripped from
+    #   the string returned by a `create`. It should be an absolute path.
+    #
+    def initialize(watcher, opts={})
+      @mutex = Monitor.new
+
+      @default_watcher  = watcher
+
+      @current_req_id   = 0
+      @watcher_reqs     = {}
+      @completion_reqs  = {}
+
+      @chroot_path = opts[:chroot_path]
+    end
+
+    def default_watcher
+      @mutex.synchronize { @default_watcher }
+    end
+
+    def default_watcher=(blk)
+      @mutex.synchronize { @default_watcher = blk }
+    end
+
+    def setup_call(meth_name, opts)
+      req_id = nil
+      @mutex.synchronize {
+        req_id = @current_req_id
+        @current_req_id += 1
+        setup_completion(req_id, meth_name, opts) if opts[:callback]
+        setup_watcher(req_id, opts)               if opts[:watcher]
+      }
+      req_id
+    end
+
+    def get_context_for(hash)
+      return nil unless hash
+
+      is_session_event  = (hash[:type] == ZOO_SESSION_EVENT)
+
+      req_id  = hash.fetch(:req_id)
+
+      if hash.has_key?(:rc)
+        get_completion(req_id, :keep => is_session_event)
+      else
+        get_watcher(req_id, :keep => is_session_event)
+      end
+    end
+
+    def clear_watchers!
+      @mutex.synchronize { @watcher_reqs.clear }
+    end
+    
+    # if we're chrooted, this method will strip the chroot prefix from +path+
+    def strip_chroot_from(path)
+      return path unless (chrooted? and path and path.start_with?(@chroot_path))
+      path[@chroot_path.length..-1]
+    end
+
+    private
+      def get_completion(req_id, opts={})
+        @mutex.synchronize do
+          if opts[:keep] 
+            @completion_reqs[req_id]
+          else
+            @completion_reqs.delete(req_id)
+          end
+        end
+      end
+
+      # Return the watcher hash associated with the req_id. If the req_id
+      # is the ZKRB_GLOBAL_CB_REQ, then does not clear the req from the internal
+      # store, otherwise the req_id is removed.
+      #
+      def get_watcher(req_id, opts={})
+        @mutex.synchronize do
+          if Constants::ZKRB_GLOBAL_CB_REQ == req_id
+            { :watcher => @default_watcher, :watcher_context => nil }
+          elsif opts[:keep]
+            @watcher_reqs[req_id]
+          else
+            @watcher_reqs.delete(req_id)
+          end
+        end
+      end
+
+
+      def setup_watcher(req_id, call_opts)
+        @mutex.synchronize do
+          @watcher_reqs[req_id] = { 
+            :watcher => call_opts[:watcher],
+            :context => call_opts[:watcher_context] 
+          }
+        end
+      end
+
+      # as a hack, to provide consistency between the java implementation and the C
+      # implementation when dealing w/ chrooted connections, we override this in
+      # ext/zookeeper_base.rb to wrap the callback in a chroot-path-stripping block.
+      #
+      # we don't use meth_name here, but we need it in the C implementation
+      #
+      def setup_completion(req_id, meth_name, call_opts)
+        @mutex.synchronize do
+          @completion_reqs[req_id] = { 
+            :callback => maybe_wrap_callback(meth_name, call_opts[:callback]),
+            :context  => call_opts[:callback_context]
+          }
+        end
+      end
+
+      # this is a hack: to provide consistency between the C and Java drivers when
+      # using a chrooted connection, we wrap the callback in a block that will
+      # strip the chroot path from the returned path (important in an async create
+      # sequential call). This is the only place where we can hook *just* the C
+      # version. The non-async manipulation is handled in ZookeeperBase#create.
+      # 
+      # TODO: need to move the continuation setup into here, so that it can get 
+      #       added to the callback hash
+      #
+      def maybe_wrap_callback(meth_name, cb)
+        return cb unless cb and chrooted? and (meth_name == :create)
+
+        lambda do |hash|
+          # in this case the string will be the absolute zookeeper path (i.e.
+          # with the chroot still prepended to the path). Here's where we strip it off
+          hash[:string] = strip_chroot_from(hash[:string])
+
+          # call the original callback
+          cb.call(hash)
+        end
+      end
+      
+      def chrooted?
+        @chroot_path && !@chroot_path.empty?
+      end
+
+      def default_watcher_proc
+        Proc.new { |args|
+          logger.debug { "Ruby ZK Global CB called type=#{event_by_value(args[:type])} state=#{state_by_value(args[:state])}" }
+          true
+        }
+      end
+  end
+end
+