zack 0.3.1 → 0.3.2

data/History.txt

@@ -1,3 +1,7 @@
+= 0.3.2 / 31Aug2011
+
+  . gemspec fix
+
 = 0.3.1 / 31Aug2011
 
   . small refactorings

data/example/client.rb

@@ -0,0 +1,7 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'zack'
+
+client = Zack::Client.new('sample', :with_answer => [:get_time])
+
+client.announce
+puts client.get_time

data/example/pubsub.rb

@@ -0,0 +1,35 @@
+
+class Handler
+  def foo
+    puts "Foo was called."
+  end
+  def bar
+    Process.pid
+  end
+  def shutdown
+    exit 0
+  end
+end
+
+source = Zack::Notifier.new(
+  'football', 
+  server: 'localhost:11300', 
+  with_answer: [:bar])
+  
+%w(foo bar).each do |filter|
+  fork do
+    handler = Zack::Listener.new(
+      'football', 
+      simple: Handler,
+      server: 'localhost:11300')
+      
+    handler.run
+  end
+end
+
+source.foo
+p source.bar
+
+source.shutdown
+
+Process.waitall

data/example/server.rb

@@ -0,0 +1,16 @@
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'zack'
+
+class ChunkyBaconAnnouncer
+  def announce
+    puts 'chunky bacon'
+  end
+  def get_time
+    "I wouldn't give you the time"
+  end
+end
+
+Zack::Server.new(
+  'sample', 
+  :simple => ChunkyBaconAnnouncer, 
+).run

data/lib/zack/target.rb

@@ -0,0 +1,68 @@
+
+module Zack
+  # Abstract base class for everything that is an RPC target. This implements
+  # some common mechanisms like a run loop, exception handling and argument
+  # handling. 
+  #
+  class Target
+    attr_reader :factory
+    attr_reader :server
+    
+    # Initializes #factory and #server.
+    #
+    def initialize(tube_name, opts={})
+      @server = opts[:server] || 'beanstalk:11300'
+
+      if opts.has_key? :factory
+        @factory = opts[:factory]
+      elsif opts.has_key? :simple
+        klass = opts[:simple]
+        @factory = lambda { klass.new }
+      else
+        raise ArgumentError, "Either :factory or :simple argument must be given." 
+      end
+    end
+
+    # Processes exactly one request, but doesn't define how the request gets
+    # here. 
+    #
+    def process_request(sym, args)
+      instance = factory.call
+      
+      instance.send(sym, *args)
+    end
+    
+    # Handles one request. This is specific to implementors. 
+    #
+    def handle_request
+      raise NotImplementedError, 
+        "Abstract base class doesn't implement #handle_request."
+    end
+
+    # Runs the server and keeps running until the world ends (or the process, 
+    # whichever comes first).
+    #
+    def run(&block)
+      loop do
+        exception_handling(block) do
+          handle_request
+        end
+      end
+    end
+
+  private
+    # Defines how the server handles exception. 
+    #
+    def exception_handling(exception_handler)
+      if exception_handler
+        begin
+          yield
+        rescue => exception
+          exception_handler.call(exception)
+        end
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/zack/transparent_proxy.rb

@@ -0,0 +1,22 @@
+
+# A method missing implementation that will use respond_to? to see wether a 
+# message should be answered. If yes, it delegates the message to service, 
+# which is supposed to return one of Cods RPC client primitives. Depending on
+# the value of has_answer?(symbol), either #call or #notify is used. 
+#
+module Zack::TransparentProxy
+  def method_missing(sym, *args, &block)
+    super unless respond_to?(sym)
+
+    raise ArgumentError, "Can't call methods remotely with a block" if block
+
+    if has_answer?(sym)
+      return service.call([sym, args])
+    else
+      service.notify [sym, args]
+      return nil
+    end
+  rescue Cod::Channel::TimeoutError
+    raise Zack::ServiceTimeout, "No response from server in the allowed time."
+  end
+end

data/lib/zack/unique_name.rb

@@ -0,0 +1,35 @@
+require 'uuid'
+
+# A UUID based unique name based on base_name. 
+#
+class Zack::UniqueName
+  def initialize(base_name)
+    @name = unique_tube_name(base_name)
+  end
+  
+  attr_reader :name
+  
+  alias to_s name
+
+private
+  # Pretend that UUIDs don't collide for now.
+  #
+  def unique_tube_name(name)
+    "name.#{uuid}"
+  end
+  def uuid
+    uuid_generator.generate
+  end
+  def uuid_generator
+    generator=Thread.current[:zack_uuid_generator]
+    return generator if generator
+  
+    # assert: generator is nil
+  
+    # Pretend we've just forked, because that might be the case. 
+    UUID.generator.next_sequence
+  
+    Thread.current[:zack_uuid_generator]=generator=UUID.new
+  end
+  
+end

data/spec/integration/regression_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+require 'timeout'
+
+describe "Regression: " do
+  def self.fork_server(server_class)
+    # Fork a server in the background
+    before(:each) { 
+      # Clear old messages
+      conn = Beanstalk::Connection.new(BEANSTALK_CONNECTION, 'regression')
+      while conn.peek_ready
+        conn.reserve.delete
+      end
+      
+      # Start a new server
+      @pid = fork do
+        $stderr.reopen('/dev/null')
+        Zack::Server.new(
+          'regression', 
+          :server => BEANSTALK_CONNECTION, 
+          :simple => server_class
+        ).run
+      end
+    }
+    after(:each) { 
+      Process.kill('KILL', @pid) 
+      Process.waitpid(@pid)
+    }
+  end
+  def get_client(timeout, *with_answer)
+    Zack::Client.new(
+      'regression', 
+      :timeout => timeout,
+      :server => BEANSTALK_CONNECTION, 
+      :with_answer => with_answer)
+  end
+
+  def print_stats
+    connection = Beanstalk::Connection.new(BEANSTALK_CONNECTION)
+
+    puts "Stats: "
+    pp connection.stats
+
+    puts "Tubes: "
+    connection.list_tubes.each do |tube|
+      p tube
+      pp connection.stats_tube(tube)
+    end
+    
+    connection.close
+  end
+    
+  describe "asynchronous long running message, followed by a short running reader message (bug)" do
+    class Regression1Server
+      def reader; 42; end
+      def long_running; sleep 0.1 end
+    end
+    fork_server Regression1Server
+
+    let(:client) { get_client(10, :reader) }
+
+    # Wait for the server to launch
+    before(:each) { 
+      sleep 0.01    # This is the same bug that we expose below...
+      # wait till the server works
+      client.reader.should == 42
+    }
+  
+    it "should correctly call the reader" do
+      # Because the code used to watch ALL tubes, not just the relevant ones, 
+      # we got our own request back from the service tube when waiting for an
+      # answer on the answer tube. 
+      client.long_running
+      client.reader.should == 42
+    end 
+  end
+  describe "server crash during a message that has an answer" do
+    class CrashingServer
+      def crash_and_burn
+        fail
+      end
+    end
+    
+    fork_server CrashingServer
+    let(:client) { get_client(1, :crash_and_burn) }
+    
+    RSpec::Matchers.define :take_long do 
+      match(&lambda do |block|
+        begin 
+          Timeout::timeout(2) do
+            block.call
+          end
+        rescue Timeout::Error
+          return true
+        end
+        false
+      end)
+    end
+    
+    it "should timeout a blocking call" do
+      lambda {
+        lambda {
+          client.crash_and_burn
+        }.should_not take_long
+      }.should raise_error(Zack::ServiceTimeout)
+    end
+  end
+  describe "server that takes a long time, timeout in client stops the operation" do
+    class LongRunningServer
+      def long_running(time, answer)
+        sleep time
+        return answer
+      end
+    end
+    
+    fork_server LongRunningServer
+    let(:client) { get_client(1, :long_running) }
+    
+    it "should pass a sanity check" do
+      client.long_running(0, 42).should == 42
+    end 
+    context "when the first call takes longer than the client timeout" do
+      before(:each) {
+        begin
+          client.long_running(1.1, 10)
+        rescue Zack::ServiceTimeout
+        end
+      }
+      
+      it "should correctly handle subsequent messages" do
+        client.long_running(0, 42).should == 42
+      end
+    end
+  end
+end

data/spec/integration/server_runner_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Server#run" do
+  class RunServerRun
+    def crash
+      raise "Some Exception"
+    end
+    def message
+      # ...
+    end
+  end
+  
+  let(:server) { Zack::Server.new(
+    'server_run', 
+    :simple => RunServerRun,
+    :server => BEANSTALK_CONNECTION) 
+  }
+  let(:client) { Zack::Client.new(
+    'server_run', :server => BEANSTALK_CONNECTION) 
+  }
+
+  it "should loop forever" do
+    flexmock(server).should_receive(:loop).and_yield
+    
+    # Post a message for the server to handle
+    client.message
+    
+    # Run just once
+    server.run
+  end
+    
+  context "when given a block" do
+    it "should yield exceptions" do
+      flexmock(server).should_receive(:loop).and_yield
+      client.crash    # this will raise an exception as soon as we run
+      
+      called = false
+      server.run { |exception|
+        called = true
+        exception.should be_a(RuntimeError)
+        exception.message.should == "Some Exception"
+      }
+      
+      called.should == true
+    end
+  end
+end

data/spec/lib/zack/client_spec.rb

@@ -0,0 +1,45 @@
+
+require 'spec_helper'
+
+describe Zack::Client do
+  let(:beanstalk) { Beanstalk::Connection.new(BEANSTALK_CONNECTION, 'zack_client_test') }
+  before(:each) do
+    while beanstalk.peek_ready
+      beanstalk.reserve.delete
+    end
+  end
+  
+  context "when not waiting for answers" do
+    let(:client) { Zack::Client.new(
+      'zack_client_test', 
+      :server => BEANSTALK_CONNECTION, 
+      :only   => { :foo => true, :foobar => true }, 
+      :with_answer => [:bar]) }
+
+    # Replace Cod with a mock
+    let(:service) { flexmock(:service) }
+    before(:each) { flexmock(client).should_receive(:service).and_return(service) }
+    
+    describe "return value for asynchronous calls" do
+      it "should be nil" do
+        service.should_receive(:notify)
+        
+        client.foo.should be_nil
+      end 
+    end
+    describe "calling rpc method with a block" do
+      it "should raise ArgumentError" do
+        lambda {
+          client.foo { something }
+        }.should raise_error(ArgumentError)
+      end 
+    end
+    context "when calling #foobar(123, '123', :a123)" do
+      it "should queue the message [:foobar, [123, '123', :a123]]" do
+        service.should_receive(:notify).with([:foobar, [123, '123', :a123]]).once
+        
+        client.foobar(123, '123', :a123)
+      end 
+    end
+  end
+end

data/spec/lib/zack/server_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Zack::Server do
+  context "when constructing without :factory / :simple" do
+    it "should raise ArgumentError" do
+      lambda {
+        Zack::Server.new('foobar')
+      }.should raise_error(ArgumentError)
+    end
+  end
+  context "instance" do
+    let(:implementation) { flexmock(:implementation) }
+
+    # Replacing the Cod::Service with a mock
+    let(:service) { flexmock(:service) }
+    before(:each) { flexmock(server, :service => service) }
+
+    context "with a factory" do
+      # A small factory that always returns instance.
+      class ImplFactory < Struct.new(:instance)
+        def call
+          instance
+        end
+      end
+
+      let(:server) {
+        Zack::Server.new(
+          'zack_server_test', 
+          :factory => ImplFactory.new(implementation), 
+          :server => BEANSTALK_CONNECTION
+        )
+      }
+      
+      describe "<- #handle_request" do
+        context "when receiving [:foobar, [123, '123', :a123]]" do
+          after(:each) { server.handle_request }
+
+          it "should call the right message on implementation" do
+            service.should_receive(:one).
+              and_yield([:foobar, [123, '123', :a123]])
+            
+            implementation.
+              should_receive(:foobar).
+              with(123, '123', :a123).
+              once
+          end 
+        end
+      end
+    end
+    context "with a simple class" do
+      let(:implementation_klass) { flexmock(:new => implementation) }
+      
+      let(:server) {
+        Zack::Server.new(
+          'zack_server_test', 
+          :simple => implementation_klass,
+          :server => BEANSTALK_CONNECTION
+        )
+      }
+
+      describe "<- #handle_request" do
+        context "when receiving [1, :foobar, [123, '123', :a123]]" do
+          after(:each) { server.handle_request }
+
+          it "should call the right message on implementation" do
+            service.should_receive(:one).
+              and_yield([:foobar, [123, '123', :a123]])
+            
+            implementation.
+              should_receive(:foobar).
+              with(123, '123', :a123).
+              once
+          end 
+        end
+      end
+    end    
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+
+require 'zack'
+
+RSpec.configure do |config|
+  config.mock_with :flexmock
+end
+
+BEANSTALK_CONNECTION = 'localhost:11300'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zack
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -15,7 +15,7 @@ default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cod
-  requirement: &2166707740 !ruby/object:Gem::Requirement
+  requirement: &2165838080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -23,10 +23,10 @@ dependencies:
         version: '0.3'
   type: :runtime
   prerelease: false
-  version_requirements: *2166707740
+  version_requirements: *2165838080
 - !ruby/object:Gem::Dependency
   name: beanstalk-client
-  requirement: &2166707260 !ruby/object:Gem::Requirement
+  requirement: &2165837600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -34,10 +34,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2166707260
+  version_requirements: *2165837600
 - !ruby/object:Gem::Dependency
   name: uuid
-  requirement: &2166706800 !ruby/object:Gem::Requirement
+  requirement: &2165837140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -45,7 +45,7 @@ dependencies:
         version: '2.3'
   type: :runtime
   prerelease: false
-  version_requirements: *2166706800
+  version_requirements: *2165837140
 description: 
 email:
 - kaspar.schiess@absurd.li
@@ -61,7 +61,18 @@ files:
 - README
 - lib/zack/client.rb
 - lib/zack/server.rb
+- lib/zack/target.rb
+- lib/zack/transparent_proxy.rb
+- lib/zack/unique_name.rb
 - lib/zack.rb
+- spec/integration/regression_spec.rb
+- spec/integration/server_runner_spec.rb
+- spec/lib/zack/client_spec.rb
+- spec/lib/zack/server_spec.rb
+- spec/spec_helper.rb
+- example/client.rb
+- example/pubsub.rb
+- example/server.rb
 has_rdoc: true
 homepage: http://github.com/kschiess/zack
 licenses: []