zk 0.6.4

data/spec/message_queue_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe ZK::MessageQueue do
+
+  before(:each) do
+    @zk = ZK.new("localhost:#{ZK_TEST_PORT}", :watcher => :default)
+    @zk2 = ZK.new("localhost:#{ZK_TEST_PORT}", :watcher => :default)
+    wait_until{ @zk.connected? && @zk2.connected? }
+    @queue_name = "_specQueue"
+    @consume_queue = @zk.queue(@queue_name)
+    @publish_queue = @zk2.queue(@queue_name)
+  end
+
+  after(:each) do
+    @consume_queue.destroy!
+    @zk.close!
+    @zk2.close!
+    wait_until{ !@zk.connected? && !@zk2.connected? }
+  end
+
+  it "should be able to receive a published message" do
+    message_received = false
+    @consume_queue.subscribe do |title, data|
+      data.should == 'mydata'
+      message_received = true
+    end
+    @publish_queue.publish("mydata")
+    wait_until {message_received }
+    message_received.should be_true
+  end
+
+  it "should be able to receive a custom message title" do
+    message_title = false
+    @consume_queue.subscribe do |title, data|
+      title.should == 'title'
+      message_title = true
+    end
+    @publish_queue.publish("data", "title")
+    wait_until { message_title }
+    message_title.should be_true
+  end
+
+  it "should work even after processing a message from before" do
+    @publish_queue.publish("data1", "title")
+    message_times = 0
+    @consume_queue.subscribe do |title, data|
+      title.should == "title"
+      message_times += 1
+    end
+
+    @publish_queue.publish("data2", "title")
+    wait_until { message_times == 2 }
+    message_times.should == 2
+  end
+end

data/spec/mongoid_spec.rb

@@ -0,0 +1,330 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+require 'tracer'
+
+describe ZK::Mongoid::Locking do
+  before do
+    ZK::Mongoid::Locking.zk_lock_pool = ZK.new_pool('localhost:2181', :min_clients => 1, :max_clients => 5)
+
+    @doc        = BogusMongoid.new
+    @other_doc  = BogusMongoid.new
+  end
+
+  after do
+    th = Thread.new do
+      ZK::Mongoid::Locking.zk_lock_pool.close_all!
+    end
+
+    unless th.join(5) == th
+      logger.warn { "Forcing pool closed!" }
+      ZK::Mongoid::Locking.zk_lock_pool.force_close!
+      th.join(5).should == th
+    end
+
+    ZK::Mongoid::Locking.zk_lock_pool = nil
+  end
+
+  describe :with_shared_lock do
+    it %[should grab a shared lock] do
+      @lock_state = nil
+
+      th = Thread.new do
+        @doc.with_shared_lock do
+          @lock_state = @doc.locked_for_share?
+        end
+      end
+
+      th.join_until { !@lock_state.nil? }
+      @lock_state.should_not be_nil
+      @lock_state.should be_true
+    end
+
+    it %[should allow another thread to enter the shared lock] do
+      @counter = 0
+      @queue = Queue.new
+
+      begin
+        @th1 = Thread.new do
+          @doc.with_shared_lock do
+            @counter += 1
+            @queue.pop
+          end
+        end
+
+        @th1.join_until { @counter > 0 }
+        @counter.should > 0
+
+        @th1.join_until { @queue.num_waiting > 0 }
+        @queue.num_waiting.should > 0
+
+        @th2 = Thread.new do
+          @other_doc.with_shared_lock do
+            @counter += 1
+          end
+        end
+
+        @th2.join_until { @counter == 2 }
+        @counter.should == 2
+
+        @th2.join(2).should == @th2
+      ensure
+        @queue << :unlock
+
+        unless @th1.join(2)
+          $stderr.puts "UH OH! @th1 IS HUNG!!"
+        end
+      end
+    end
+
+    it %[should block an exclusive lock from entering] do
+      begin
+        q1 = Queue.new
+        q2 = Queue.new
+
+        @got_exclusive_lock = nil
+
+        @th1 = Thread.new do
+          @doc.with_shared_lock do
+            q1 << :have_shared_lock
+            q2.pop
+            logger.debug { "@th1 releasing shared lock" }
+          end
+        end
+
+        @th2 = Thread.new do
+          q1.pop
+          logger.debug { "@th1 has the shared lock" }
+
+          @other_doc.lock_for_update do
+            logger.debug { "@th2 got an exclusive lock" }
+            @got_exclusive_lock = true
+          end
+        end
+
+        @th1.join_until { q2.num_waiting >= 1 }
+        q2.num_waiting.should >= 1
+
+        @th2.join_until { q1.size == 0 }
+        q1.size.should be_zero
+
+        @got_exclusive_lock.should_not be_true
+
+        q2.enq(:release)
+
+        @th1.join_until { q2.size == 0 }
+        q2.size.should be_zero
+
+        @th2.join_until(5) { @got_exclusive_lock }
+        @got_exclusive_lock.should be_true
+
+      rescue Exception => e
+        $stderr.puts e.to_std_format
+        raise e
+      ensure 
+        q2 << :release
+
+        unless @th1.join(2)
+          $stderr.puts "UH OH! @th1 IS HUNG!!"
+        end
+
+        unless @th2.join(2) 
+          $stderr.puts "UH OH! @th2 IS HUNG!!"
+        end
+      end
+    end
+  end
+
+  describe :lock_for_update do
+    it %[should be locked_for_update? inside the block] do
+      @lock_state = nil
+
+      th = Thread.new do
+        @doc.lock_for_update do
+          @lock_state = @doc.locked_for_update?
+        end
+      end
+
+      th.join_until { !@lock_state.nil? }
+      @lock_state.should_not be_nil
+      @lock_state.should be_true
+    end
+
+    it %[should allow the same thread to re-enter the lock] do
+      @counter = 0
+
+      th = Thread.new do
+        @doc.lock_for_update do
+          @counter += 1
+          logger.debug { "we are locked for update, trying to lock again" }
+
+          @doc.lock_for_update do
+            logger.debug { "locked again" }
+            @counter += 1
+          end
+        end
+      end
+
+      th.join_until { @counter >= 2 }
+      @counter.should == 2
+    end
+
+    it %[should block another thread from entering the lock] do
+      @counter = 0
+      queue = Queue.new
+      @other_doc_got_lock = false
+
+      th1 = Thread.new do
+        @doc.lock_for_update do
+          @counter += 1
+          queue.pop
+        end
+      end
+
+      th1.join_until { @counter == 1 }
+      @counter.should == 1
+
+      th1.zk_mongoid_lock_registry[:exclusive].should include(@doc.zk_lock_name)
+
+      th2 = Thread.new do
+        @other_doc.lock_for_update do
+          @other_doc_got_lock = true
+          @counter += 1
+        end
+      end
+
+      th2.join(0.1)
+
+      # this is not a deterministic check of whether or not th2 ran and did not
+      # get the lock but probably close enough
+      
+      @counter.should == 1
+      @other_doc_got_lock.should == false
+      th2.zk_mongoid_lock_registry[:exclusive].should_not include(@other_doc.zk_lock_name)
+
+      queue << :release_lock
+      th1.join(5).should == th1
+
+      th2.join_until { @counter == 2 }
+      @counter.should == 2
+      @other_doc_got_lock.should be_true
+    end
+
+    describe :with_name do
+      before do
+        @queue = Queue.new
+      end
+
+      after do
+        if @queue.num_waiting > 0
+          @queue << :bogus
+          @th1.join(5).should == @th1
+        end
+      end
+
+      it %[should block another thread using the same name] do
+        @counter = 0
+        @queue = Queue.new
+        @other_doc_got_lock = false
+        @name = 'peanuts'
+
+        @th1 = Thread.new do
+          @doc.lock_for_update(@name) do
+            @counter += 1
+            @queue.pop
+          end
+        end
+
+        @th1.join_until { @counter == 1 }
+        @counter.should == 1
+
+        @th1.zk_mongoid_lock_registry[:exclusive].should include(@doc.zk_lock_name(@name))
+
+        @th2 = Thread.new do
+          @other_doc.lock_for_update(@name) do
+            @other_doc_got_lock = true
+            @counter += 1
+          end
+        end
+
+        @th2.join(0.1)
+
+        # this is not a deterministic check of whether or not @th2 ran and did not
+        # get the lock but probably close enough
+        
+        @counter.should == 1
+        @other_doc_got_lock.should == false
+
+        @queue << :release_lock
+        @th1.join(5).should == @th1
+
+        @th2.join_until { @counter == 2 }
+        @counter.should == 2
+        @other_doc_got_lock.should be_true
+      end
+
+      it %[should not affect another thread using a different name] do
+        @counter = 0
+        @queue = Queue.new
+        @other_doc_got_lock = false
+        @name = 'peanuts'
+
+        @th1 = Thread.new do
+          @doc.lock_for_update(@name) do
+            @counter += 1
+            @queue.pop
+          end
+        end
+
+        @th1.join_until { @counter == 1 }
+        @counter.should == 1
+
+        @th1.zk_mongoid_lock_registry[:exclusive].should include(@doc.zk_lock_name(@name))
+
+        @th2 = Thread.new do
+          @other_doc.lock_for_update do
+            @other_doc_got_lock = true
+            @counter += 1
+          end
+        end
+
+        @th2.join_until { @other_doc_got_lock }
+        @other_doc_got_lock.should be_true
+        
+        @counter.should == 2
+
+        @queue << :release_lock
+        @th1.join(2).should == @th1
+      end
+    end
+  end
+
+  describe :assert_locked_for_update! do
+    it %[should raise MustBeExclusivelyLockedException if the current thread does not hold the lock] do
+      lambda { @doc.assert_locked_for_update! }.should raise_error(ZK::Exceptions::MustBeExclusivelyLockedException)
+    end
+
+    it %[should not raise an exception if the current thread holds the lock] do
+      lambda do
+        @doc.lock_for_update do
+          @doc.assert_locked_for_update!
+        end
+      end.should_not raise_error
+    end
+  end
+
+  describe :assert_locked_for_share! do
+    it %[should raise MustBeShareLockedException if the current thread does not hold a shared lock] do
+      lambda { @doc.assert_locked_for_share! }.should raise_error(ZK::Exceptions::MustBeShareLockedException)
+    end
+
+    it %[should not raise an exception if the current thread holds a shared lock] do
+      lambda do
+        @doc.with_shared_lock do
+          @doc.assert_locked_for_share!
+        end
+      end.should_not raise_error
+    end
+  end
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,96 @@
+require 'rubygems'
+require 'bundler/setup'
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'zk'
+require 'benchmark'
+
+ZK_TEST_PORT = 2181
+
+LOG_FILE = File.open(File.join(ZK::ZK_ROOT, 'test.log'), 'a').tap { |f| f.sync = true }
+
+ZK.logger = Logger.new(LOG_FILE).tap { |log| log.level = Logger::DEBUG }
+#Zookeeper.logger = ZK.logger
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}
+
+$stderr.sync = true
+
+# COMMENT THESE LINES FOR REMOTE DEBUGGING
+require 'ruby-debug'
+require 'flexmock'
+
+RSpec.configure do |config|
+  config.mock_with :flexmock
+  config.include(FlexMock::ArgumentTypes)
+
+#   config.before(:all) do
+#     unless $did_debug
+#       $did_debug = true
+#       $stderr.puts "debugger started? is #{Debugger.started?.inspect}"
+
+#       Debugger.wait_connection = true
+#       $stderr.puts "run 'rdebug -c -p #{Debugger::PORT}'"
+#       Debugger.start_remote
+
+#       config.debug = true
+#     end
+#   end
+end
+
+def logger
+  ZK.logger
+end
+
+# method to wait until block passed returns true or timeout (default is 2 seconds) is reached 
+def wait_until(timeout=2)
+  time_to_stop = Time.now + timeout
+
+  until yield 
+    break if Time.now > time_to_stop
+    Thread.pass
+  end
+end
+
+def wait_while(timeout=2)
+  time_to_stop = Time.now + timeout
+
+  while yield 
+    break if Time.now > time_to_stop
+    Thread.pass
+  end
+end
+
+
+class ::Thread
+  # join with thread until given block is true, the thread joins successfully, 
+  # or timeout seconds have passed
+  #
+  def join_until(timeout=2)
+    time_to_stop = Time.now + timeout
+
+    until yield
+      break if Time.now > time_to_stop
+      break if join(0.1)
+    end
+  end
+  
+  def join_while(timeout=2)
+    time_to_stop = Time.now + timeout
+
+    while yield
+      break if Time.now > time_to_stop
+      break if join(0.1)
+    end
+  end
+end
+
+def report_realtime(what)
+  t = Benchmark.realtime { yield }
+  $stderr.puts "#{what}: %0.3f" % [t.to_f]
+end
+
+

data/spec/support/bogus_mongoid.rb

@@ -0,0 +1,11 @@
+class BogusMongoid
+  include ZK::Mongoid::Locking
+  include ZK::Logging
+
+  attr_reader :id
+
+  def initialize(opts={})
+    @id = opts[:id] || 42
+  end
+end
+

data/spec/support/queuey_thread.rb

@@ -0,0 +1,11 @@
+class QueueyThread < ::Thread
+  attr_reader :input, :output
+
+  def initialize(*args, &block)
+    @output = Queue.new
+    @input = Queue.new
+
+    super(*args, &block)
+  end
+end
+

data/spec/test_file.txt

@@ -0,0 +1,4 @@
+a
+b
+c
+d

data/spec/threadpool_spec.rb

@@ -0,0 +1,71 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe ZK::Threadpool do
+
+  before do
+    @threadpool = ZK::Threadpool.new
+  end
+
+  after do
+    @threadpool.shutdown
+  end
+
+  describe :new do
+    it %[should be running] do
+      @threadpool.should be_running
+    end
+
+    it %[should use the default size] do
+      @threadpool.size.should == ZK::Threadpool.default_size
+    end
+  end
+
+
+  describe :defer do
+    it %[should run the given block on a thread in the threadpool] do
+      @th = nil
+
+      @threadpool.defer { @th = Thread.current }
+
+      wait_until(2) { @th }
+
+      @th.should_not == Thread.current
+    end
+
+    it %[should barf if the argument is not callable] do
+      bad_obj = mock(:not_callable)
+      bad_obj.should_not respond_to(:call)
+
+      lambda { @threadpool.defer(bad_obj) }.should raise_error(ArgumentError)
+    end
+
+    it %[should barf if the threadpool is not running] do
+      @threadpool.shutdown
+      lambda { @threadpool.defer { "hai!" } }.should raise_error(ZK::Exceptions::ThreadpoolIsNotRunningException)
+    end
+  end
+
+  describe :shutdown do
+    it %[should set running to false] do
+      @threadpool.shutdown
+      @threadpool.should_not be_running
+    end
+  end
+
+  describe :start! do
+    it %[should be able to start a threadpool that had previously been shutdown (reuse)] do
+      @threadpool.shutdown
+      @threadpool.start!
+
+      @threadpool.should be_running
+
+      @rval = nil
+
+      @threadpool.defer { @rval = true }
+      wait_until(2) { @rval }
+      @rval.should be_true
+    end
+  end
+
+end
+

data/spec/watch_spec.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe ZK do
+  describe do
+    before do
+      @cnx_str = "localhost:#{ZK_TEST_PORT}"
+      @zk = ZK.new(@cnx_str)
+
+      @path = "/_testWatch"
+      wait_until { @zk.connected? }
+    end
+
+    after do
+      if @zk.connected?
+        @zk.close! 
+        wait_until { !@zk.connected? }
+      end
+
+      ZK.open(@cnx_str) { |zk| zk.rm_rf(@path) }
+    end
+
+    it "should call back to path registers" do
+      locker = Mutex.new
+      callback_called = false
+
+      @zk.watcher.register(@path) do |event|
+        locker.synchronize do
+          callback_called = true
+        end
+        event.path.should == @path
+      end
+
+      @zk.exists?(@path, :watch => true)
+      @zk.create(@path, "", :mode => :ephemeral)
+
+      wait_until(5) { locker.synchronize { callback_called } }
+      callback_called.should be_true
+    end
+
+    it %[should only deliver an event once to each watcher registered for exists?] do
+      events = []
+
+      sub = @zk.watcher.register(@path) do |ev|
+        logger.debug "got event #{ev}"
+        events << ev
+      end
+
+      2.times do
+        @zk.exists?(@path, :watch => true).should_not be_true
+      end
+
+      @zk.create(@path, '', :mode => :ephemeral)
+
+      wait_until { events.length >= 2 }
+      events.length.should == 1
+    end
+
+    it %[should only deliver an event once to each watcher registered for get] do
+      events = []
+
+      @zk.create(@path, 'one', :mode => :ephemeral)
+
+      sub = @zk.watcher.register(@path) do |ev|
+        logger.debug "got event #{ev}"
+        events << ev
+      end
+
+      2.times do
+        data, stat = @zk.get(@path, :watch => true)
+        data.should == 'one'
+      end
+
+      @zk.set(@path, 'two')
+
+      wait_until { events.length >= 2 }
+      events.length.should == 1
+    end
+
+
+    it %[should only deliver an event once to each watcher registered for children] do
+      events = []
+
+      @zk.create(@path, '')
+
+      sub = @zk.watcher.register(@path) do |ev|
+        logger.debug "got event #{ev}"
+        events << ev
+      end
+
+      2.times do
+        children = @zk.children(@path, :watch => true)
+        children.should be_empty
+      end
+
+      @zk.create("#{@path}/pfx", '', :mode => :ephemeral_sequential)
+
+      wait_until { events.length >= 2 }
+      events.length.should == 1
+    end
+  end
+
+  describe 'state watcher' do
+    before do
+      @event = nil
+      @cnx_str = "localhost:#{ZK_TEST_PORT}"
+
+      @zk = ZK.new(@cnx_str) do |zk|
+        @cnx_reg = zk.on_connected { |event| @event = event }
+      end
+    end
+
+    it %[should fire the registered callback] do
+      wait_while { @event.nil? }
+      @event.should_not be_nil
+    end
+  end
+end
+