zk 0.9.1 → 1.0.0.rc.1

data/lib/z_k/extensions.rb

@@ -1,155 +0,0 @@
-module ZK
-  module Extensions
-    # some extensions to the ZookeeperCallbacks classes, mainly convenience
-    # interrogators
-    module Callbacks
-      module Callback
-        # allow access to the connection that fired this callback
-        attr_accessor :zk
-
-        def self.included(mod)
-          mod.extend(ZK::Extensions::Callbacks::Callback::ClassMethods)
-        end
-
-        module ClassMethods
-          # allows for easier construction of a user callback block that will be
-          # called with the callback object itself as an argument. 
-          #
-          # *args, if given, will be passed on *after* the callback
-          #
-          # @example
-          #   
-          #   WatcherCallback.create do |cb|
-          #     puts "watcher callback called with argument: #{cb.inspect}"
-          #   end
-          #
-          #   "watcher callback called with argument: #<ZookeeperCallbacks::WatcherCallback:0x1018a3958 @state=3, @type=1, ...>"
-          #
-          #
-          def create(*args, &block)
-            # honestly, i have no idea how this could *possibly* work, but it does...
-            cb_inst = new { block.call(cb_inst) }
-          end
-        end
-      end
-
-      module WatcherCallbackExt
-        include ZookeeperConstants
-
-        EVENT_NAME_MAP = {
-          1   => 'created',
-          2   => 'deleted', 
-          3   => 'changed',
-          4   => 'child',
-          -1  => 'session',
-          -2  => 'notwatching',
-        }.freeze
-
-        STATES = %w[connecting associating connected auth_failed expired_session].freeze unless defined?(STATES)
-
-        EVENT_TYPES = %w[created deleted changed child session notwatching].freeze unless defined?(EVENT_TYPES)
-
-        STATES.each do |state|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def state_#{state}?
-              @state == ZOO_#{state.upcase}_STATE
-            end
-          RUBY
-        end
-
-        EVENT_TYPES.each do |ev|
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def node_#{ev}?
-              @type == ZOO_#{ev.upcase}_EVENT
-            end
-          RUBY
-        end
-
-        alias :node_not_watching? :node_notwatching?
-
-        # has this watcher been called because of a change in connection state?
-        def state_event?
-          path.nil? or path.empty?
-        end
-        alias session_event? state_event?
-
-        # has this watcher been called because of a change to a zookeeper node?
-        def node_event?
-          path and not path.empty?
-        end
-
-        # cause this watch to be re-registered
-#         def renew_watch!
-#           zk.stat(path, :watch => true)
-#           nil
-#         end
-      end
-    end   # Callbacks
-
-    # aliases for long-names of properties from mb-zookeeper version
-    module Stat
-      [ %w[created_zxid czxid],
-        %w[last_modified_zxid mzxid],
-        %w[created_time ctime],
-        %w[last_modified_time mtime],
-        %w[child_list_version cversion],
-        %w[acl_list_version aversion] ].each do |long, short|
-
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{long}
-            #{short}
-          end
-        RUBY
-      end
-
-      MEMBERS = [:version, :exists, :czxid, :mzxid, :ctime, :mtime, :cversion, :aversion, :ephemeralOwner, :dataLength, :numChildren, :pzxid]
-
-      def self.included(mod)
-        mod.class_eval do
-          unless method_defined?(:exists?)
-            alias :exists? :exists
-          end
-        end
-      end
-
-      def ==(other)
-        MEMBERS.all? { |m| self.__send__(m) == other.__send__(m) }
-      end
-    end
-  end     # Extensions
-end       # ZK
-
-# ZookeeperCallbacks::Callback.extend(ZK::Extensions::Callbacks::Callback)
-ZookeeperCallbacks::Callback.send(:include, ZK::Extensions::Callbacks::Callback)
-ZookeeperCallbacks::WatcherCallback.send(:include, ZK::Extensions::Callbacks::WatcherCallbackExt)
-ZookeeperStat::Stat.send(:include, ZK::Extensions::Stat)
-
-# Include the InterruptedSession module in key ZookeeperExceptions to allow
-# clients to catch a single error type when waiting on a node (for example)
-
-[:ConnectionClosed, :NotConnected, :SessionExpired, :SessionMoved, :ConnectionLoss].each do |class_name|
-  ZookeeperExceptions::ZookeeperException.const_get(class_name).tap do |klass|
-    klass.__send__(:include, ZK::Exceptions::InterruptedSession)
-  end
-end
-
-class ::Exception
-  unless method_defined?(:to_std_format)
-    def to_std_format
-      ary = ["#{self.class}: #{message}"]
-      ary.concat(backtrace || [])
-      ary.join("\n\t")
-    end
-  end
-end
-
-class ::Thread
-  def zk_mongoid_lock_registry
-    self[:_zk_mongoid_lock_registry]
-  end
-
-  def zk_mongoid_lock_registry=(obj)
-    self[:_zk_mongoid_lock_registry] = obj
-  end
-end
-

data/lib/z_k/version.rb

@@ -1,3 +0,0 @@
-module ZK
-  VERSION = "0.9.1"
-end

data/lib/z_k.rb

@@ -1,97 +0,0 @@
-require 'rubygems'
-
-require 'logger'
-require 'zookeeper'
-require 'forwardable'
-require 'thread'
-require 'monitor'
-require 'set'
-
-require 'z_k/logging'
-require 'z_k/exceptions'
-require 'z_k/threadpool'
-require 'z_k/event_handler_subscription'
-require 'z_k/event_handler'
-require 'z_k/message_queue'
-# require 'z_k/locker_base'
-require 'z_k/locker'
-require 'z_k/extensions'
-require 'z_k/election'
-require 'z_k/mongoid'
-require 'z_k/client'
-require 'z_k/pool'
-require 'z_k/find'
-
-module ZK
-  ZK_ROOT = File.expand_path('../..', __FILE__)
-
-  KILL_TOKEN = Object.new unless defined?(KILL_TOKEN) 
-
-  unless @logger
-    @logger = Logger.new($stderr).tap { |n| n.level = Logger::ERROR }
-  end
-
-  # The logger used by the ZK library. uses a Logger stderr with Logger::ERROR
-  # level. The only thing that should ever be logged are exceptions that are
-  # swallowed by background threads.
-  #
-  # You can change this logger by setting ZK#logger= to an object that
-  # implements the stdllb Logger API.
-  #
-  def self.logger
-    @logger
-  end
-
-  # Assign the Logger instance to be used by ZK
-  def self.logger=(logger)
-    @logger = logger
-  end
-
-  # Create a new ZK::Client instance. If no arguments are given, the default
-  # config of 'localhost:2181' will be used. Otherwise all args will be passed
-  # to ZK::Client#new
-  #
-  # if a block is given, it will be yielded the client *before* the connection
-  # is established, this is useful for registering connected-state handlers.
-  #
-  def self.new(*args, &block)
-    # XXX: might need to do some param parsing here
-   
-    opts = args.pop if args.last.kind_of?(Hash)
-    args = %w[localhost:2181] if args.empty?
-
-    # ignore opts for now
-    Client.new(*args, &block)
-  end
-
-  # Like new, yields a connection to the given block and closes it when the
-  # block returns
-  def self.open(*args)
-    cnx = new(*args)
-    yield cnx
-  ensure
-    cnx.close! if cnx
-  end
-
-  # creates a new ZK::Pool::Bounded with the default options.
-  def self.new_pool(host, opts={})
-    ZK::Pool::Bounded.new(host, opts)
-  end
-
-  # Eventually this will implement proper File.join-like behavior, but only
-  # using the '/' char for a separator. for right now, this simply delegates to
-  # File.join
-  #--
-  # like File.join but ignores $INPUT_RECORD_SEPARATOR (i.e. $/, which is
-  # platform dependent) and only uses the '/' character
-  def self.join(*paths)
-    File.join(*paths)
-  end
-
-  protected
-    def self.chomp_sep(str)
-      p = (p[0] == ?/ ) ? p[1..-1] : p
-      p = (p[-1] == ?/) ? p[0..-2] : p
-    end
-end
-

data/spec/z_k/client/drop_box_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-module ZK
-  module Client
-    describe 'ZK::Client::DropBox' do
-      let(:drop_box) { DropBox.new }
-
-      after do
-        DropBox.remove_current
-      end
-
-      it %[should start out with an undefined value] do
-        drop_box.value.should == DropBox::UNDEFINED
-      end
-
-      it %[should block the caller waiting for a response] do
-        @rv = nil
-
-        th1 = Thread.new do
-          Thread.current.abort_on_exception = true
-          @rv = drop_box.pop
-        end
-
-        wait_until(2) { th1.status == 'sleep' }
-
-        th1.status.should == 'sleep'
-
-        th2 = Thread.new do
-          drop_box.push :result
-        end
-
-        th2.join(2).should == th2
-        th1.join(2).should == th1
-
-        @rv.should == :result
-      end
-
-      describe :oh_noes! do
-        let(:error_class) { SpecialHappyFuntimeError }
-        let(:error_msg)   { 'this is a unique message' }
-
-        it %[should wake the caller by raising the exception class and message given] do
-          drop_box.should_not be_done # sanity check
-
-          th1 = Thread.new do
-            drop_box.pop
-          end
-
-          wait_until(2) { th1.status == 'sleep' }
-
-          th1.status.should == 'sleep'
-
-          drop_box.oh_noes!(error_class, error_msg).should_not be_nil
-
-          lambda { th1.join(2) }.should raise_error(error_class, error_msg)
-
-          drop_box.should be_done
-        end
-      end
-
-      describe :done? do
-        it %[should be done if the value is defined] do
-          drop_box.should_not be_done
-          drop_box.push :defined
-          drop_box.should be_done
-        end
-
-        it %[should not be done once cleared] do
-          drop_box.push :defined
-          drop_box.should be_done
-          drop_box.clear
-          drop_box.should_not be_done
-        end
-      end
-
-      describe :with_current do
-        it %[should clear the current thread's drop_box once the block exits] do
-          DropBox.with_current do |c|
-            c.should_not be_done
-            c.push 'yo_mama'
-            c.should be_done
-          end
-
-          DropBox.current.should_not be_done
-        end
-      end
-    end
-  end
-end
-

data/spec/z_k/client/multiplexed_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe 'ZK::Client::Multiplexed', :client => :multiplexed do
-  before do
-    @zk = ZK::Client::Multiplexed.new("localhost:#{ZK_TEST_PORT}").tap do |zk|
-      wait_until { zk.connected? }
-    end
-
-    @zk.rm_rf('/test')
-  end
-
-  after do
-    @zk.rm_rf('/test')
-    @zk.close!
-
-    wait_until(2) { @zk.closed? }
-  end
-
-  it_should_behave_like 'client'
-end

data/spec/z_k/client_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe ZK::Client::Threaded do
-  include_context 'threaded client connection'
-  it_should_behave_like 'client'
-end
-