zack 0.3.2 → 0.3.3

data/History.txt

@@ -1,3 +1,15 @@
+= 0.3.3 / 29Nov2011
+  + Updates to the cod rewrite, this eliminates the dependency on 
+    beanstalk-client.
+    
+  + Works and is designed only for beanstalk now. This allows usage of some
+    advanced queuing features. 
+
+  + Breaking change: Default server is now 'localhost:11300', not a server on
+    the LAN we might not even own.
+
+  + Breaking change: Exception block now has two arguments. 
+
 = 0.3.2 / 31Aug2011
 
   . gemspec fix

data/README

@@ -40,7 +40,7 @@ above.
 
 DEPENDENCIES
 
-Depends on beanstalkd (beanstalkd 1.4.4 or better).
+Depends on beanstalkd server (beanstalkd 1.4.4 or better).
 
 COMPATIBILITY
 

data/Rakefile

@@ -4,7 +4,7 @@ require 'rubygems/package_task'
 
 require 'rspec'
 require 'rspec/core/rake_task'
-Rspec::Core::RakeTask.new
+RSpec::Core::RakeTask.new
 task :default => :spec
 
 # This task actually builds the gem. 

data/example/client.rb

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

data/example/server.rb

@@ -12,5 +12,4 @@ end
 
 Zack::Server.new(
   'sample', 
-  :simple => ChunkyBaconAnnouncer, 
-).run
+  :simple => ChunkyBaconAnnouncer).run

data/lib/zack.rb

@@ -8,10 +8,7 @@ module Zack
   class ServiceTimeout < StandardError; end
 end
 
-require 'zack/transparent_proxy'
 require 'zack/unique_name'
 
-require 'zack/target'
-
 require 'zack/server'
 require 'zack/client'

data/lib/zack/client.rb

@@ -12,21 +12,19 @@ module Zack
     # :server :: beanstalkd server location url
     # :only :: ignores all messages not in this hash
     # :with_answer :: these messages wait for an answer from the service
+    # :timeout :: How long to wait for an answer
     #
     def initialize(tube_name, opts={})
-      server = opts[:server] || 'beanstalk:11300'
       # Only respond to these messages
       @only        = opts[:only] || proc { true }
       # These have answers (wait for the server to answer)
       @with_answer = opts[:with_answer] || []
+      @timeout     = opts[:timeout]
+      
+      @tube_name  = tube_name
+      @server     = opts[:server] || 'localhost:11300'
 
-      @outgoing = Cod.beanstalk(server, tube_name)
-      unless @with_answer.empty?
-        @incoming = Cod.beanstalk(server, 
-          UniqueName.new(tube_name))
-      end
-    
-      @service = Cod::Client.new(@outgoing, @incoming, 1)
+      connect
     end
   
     def respond_to?(msg)
@@ -37,6 +35,59 @@ module Zack
       @with_answer.include?(sym.to_sym)
     end
 
-    include 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)
+        with_timeout do
+          return service.call([sym, args])
+        end
+      else
+        service.notify [sym, args]
+        return nil
+      end
+    rescue Timeout::Error => ex
+      raise Zack::ServiceTimeout, "The service took too long to answer (>#{@timeout || 1}s)."
+    end
+    
+    def close
+      @service.close
+    end
+  private 
+    def with_timeout
+      if @timeout
+        begin
+          timeout(@timeout) do
+            yield
+          end
+        rescue Timeout::Error 
+          # The timeout might have occurred at any place at all. This means
+          # that the connection is probably in an invalid state at this point. 
+          reconnect
+          raise Zack::ServiceTimeout, 
+            "The server took longer than #{@timeout} seconds to respond."
+        end
+      else
+        yield
+      end
+    end
+    
+    def reconnect
+      @service.close
+      connect
+    end
+    def connect
+      @outgoing = Cod.beanstalk(@tube_name, @server)
+
+      unless @with_answer.empty?
+        @incoming = Cod.beanstalk(
+          UniqueName.new(@tube_name), 
+          @server)
+      end
+    
+      @service = @outgoing.client(@incoming)
+    end
   end
 end

data/lib/zack/server.rb

@@ -2,22 +2,108 @@
 module Zack
   # Server side for RPC calls. 
   #
-  class Server < Target
+  class Server
     attr_reader :service
-  
+    attr_reader :factory
+    attr_reader :server
+    
+    # Initializes a zack server. To specify which class should be the target
+    # of the RPC call, you must either give the :factory or the :simple
+    # argument. 
+    #
+    # :simple expects a class. This class will be constructed each time a
+    # request is made. Then the method will be called on the class. 
+    #
+    # :factory expects a callable (a block or something that has #call) and is
+    # passed the control object for the request (see Cod for an explanation of
+    # this). You can chose to ignore the control and just use the block to
+    # produce an object that is linked to the rest of your program. Or you can
+    # link to the rest of the program and the control at the same time. 
+    #
+    # Note that in any case, one object instance _per call_ is created. This
+    # is to discourage creating stateful servers. If you still want to do
+    # that, well you will just have to code around the limitation, now won't
+    # you. 
+    #
     def initialize(tube_name, opts={})
-      super
-        
-      channel = Cod.beanstalk(server, tube_name)
-      @service = Cod::Service.new(channel)
-    end
-  
+      @server = opts[:server]
+
+      if opts.has_key? :factory
+        @factory = opts[:factory]
+      elsif opts.has_key? :simple
+        klass = opts[:simple]
+        @factory = lambda { |ctl| klass.new }
+      else
+        raise ArgumentError, "Either :factory or :simple argument must be given." 
+      end
+ 
+      channel = Cod.beanstalk(tube_name, server)
+      @service = channel.service
+    end 
+   
     # Handles exactly one request. 
     #
-    def handle_request
-      service.one { |(sym, args)|  
-        process_request(sym, args)
+    def handle_request(exception_handler=nil)
+      service.one { |(sym, args), control|
+        exception_handling(exception_handler, control) do
+          # p [sym, args]
+          process_request(control, sym, args)
+        end
       }
     end
+    
+    # Processes exactly one request, but doesn't define how the request gets
+    # here. 
+    #
+    def process_request(control, sym, args)
+      instance = factory.call(control)
+
+      instance.send(sym, *args)
+    end
+
+    # Runs the server and keeps running until the world ends (or the process,
+    # whichever comes first). If you pass a non-nil messages argument, the
+    # server will process that many messages and then quit. (Maybe you will
+    # want to respawn the server from time to time?)
+    #
+    # Any exception that is raised inside the RPC code will be passed to the
+    # exception_handler block: 
+    # 
+    #   server.run do |exception, control|
+    #     # control is the service control object from cod. You can exercise
+    #     # fine grained message control using this. 
+    #     log.fatal exception
+    #   end
+    #
+    # If you don't reraise exceptions from the exception handler block, they
+    # will be caught and the server will stay running. 
+    #
+    def run(messages=nil, &exception_handler)
+      loop do
+        handle_request(exception_handler)
+
+        if messages
+          messages -= 1
+          break if messages <= 0
+        end
+      end
+    end
+
+  private
+    # Defines how the server handles exception. 
+    #
+    def exception_handling(exception_handler, control)
+      begin
+        yield
+      rescue => exception
+        # If we have an exception handler, it gets handed all the exceptions. 
+        # No exceptions stop the operation. 
+        if exception_handler
+          exception_handler.call(exception, control)
+        else
+          raise
+        end
+      end
+    end
   end
 end

data/spec/acceptance/exception_handling_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe "Exception handling" do
+  # Clear old messages (test isolation)
+  before(:each) { 
+    conn = Beanstalk::Connection.new(BEANSTALK_CONNECTION, 'exceptions')
+    while conn.peek_ready
+      conn.reserve.delete
+    end
+    conn.close
+  }
+  
+  SimpleService = Struct.new(:control, :retry_log) do
+    # Used for the exception block specs
+    def do_something
+      fail
+    end
+
+    # Used for the handler specs
+    def retry_message
+      retries = (retry_log[control.msg_id] += 1)
+      if retries < 2
+        control.retry
+      end
+    end
+  end
+  
+  let!(:retry_log) { Hash.new(0) }
+  
+  let(:client) { Zack::Client.new('exceptions', 
+    server: BEANSTALK_CONNECTION) }
+  let(:server) { Zack::Server.new('exceptions', 
+    server: BEANSTALK_CONNECTION, 
+    factory: proc { |c| SimpleService.new(c, retry_log) }) }
+  
+  describe 'block given to #run' do
+    it "can retry the message" do
+      client.do_something
+      
+      retried = false
+      server.run(2) do |exception, control|
+        retried ? control.delete : control.retry
+        retried = true
+      end
+            
+      retried.should == true
+    end
+    it "can use msg_id to retry n times" do
+      client.do_something
+      client.do_something
+      
+      retry_per_msg = Hash.new(0)
+      
+      server.run(4) do |exception, control|
+        retries = (retry_per_msg[control.msg_id] += 1)
+        retries < 2 ? control.retry : control.delete
+      end
+            
+      retry_per_msg.should have(2).messages
+      retry_per_msg.each do |msg_id, retries|
+        msg_id.should >0
+        retries.should == 2
+      end
+    end 
+  end
+  describe 'using the control parameter to the factory' do
+    it "can retry the message from within the handler" do
+      client.retry_message
+      server.run(2)
+      
+      retry_log.should have(1).message
+      
+      msg_id, retries = retry_log.first
+      msg_id.should > 0
+      retries.should == 2
+    end 
+  end
+end

data/spec/{integration → acceptance}/regression_spec.rb

@@ -32,7 +32,8 @@ describe "Regression: " do
       'regression', 
       :timeout => timeout,
       :server => BEANSTALK_CONNECTION, 
-      :with_answer => with_answer)
+      :with_answer => with_answer).tap { |client| 
+        self.class.after(:each) { client.close } }
   end
 
   def print_stats
@@ -50,7 +51,7 @@ describe "Regression: " do
     connection.close
   end
     
-  describe "asynchronous long running message, followed by a short running reader message (bug)" do
+  describe "long running message, followed by a short running one (bug)" do
     class Regression1Server
       def reader; 42; end
       def long_running; sleep 0.1 end
@@ -98,11 +99,11 @@ describe "Regression: " do
     end
     
     it "should timeout a blocking call" do
-      lambda {
-        lambda {
+      expect {
+        expect {
           client.crash_and_burn
-        }.should_not take_long
-      }.should raise_error(Zack::ServiceTimeout)
+        }.not_to take_long
+      }.to raise_error(Zack::ServiceTimeout)
     end
   end
   describe "server that takes a long time, timeout in client stops the operation" do
@@ -119,7 +120,7 @@ describe "Regression: " do
     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
+    context "message ordering" do
       before(:each) {
         begin
           client.long_running(1.1, 10)
@@ -127,7 +128,7 @@ describe "Regression: " do
         end
       }
       
-      it "should correctly handle subsequent messages" do
+      it "should be preserved" do
         client.long_running(0, 42).should == 42
       end
     end

data/spec/{integration → acceptance}/server_runner_spec.rb

@@ -10,6 +10,17 @@ describe "Server#run" do
     end
   end
   
+  # Isolates the specs by clearing the 'server_run' tube before use.
+  before(:each) { 
+    conn = Beanstalk::Connection.new(BEANSTALK_CONNECTION, 'server_run')
+    
+    while conn.peek_ready
+      conn.reserve.delete
+    end
+    
+    conn.close
+  }
+  
   let(:server) { Zack::Server.new(
     'server_run', 
     :simple => RunServerRun,

data/spec/lib/zack/server_spec.rb

@@ -10,6 +10,7 @@ describe Zack::Server do
   end
   context "instance" do
     let(:implementation) { flexmock(:implementation) }
+    let(:control)        { flexmock(:control) }
 
     # Replacing the Cod::Service with a mock
     let(:service) { flexmock(:service) }
@@ -18,7 +19,7 @@ describe Zack::Server do
     context "with a factory" do
       # A small factory that always returns instance.
       class ImplFactory < Struct.new(:instance)
-        def call
+        def call(control)
           instance
         end
       end
@@ -37,7 +38,7 @@ describe Zack::Server do
 
           it "should call the right message on implementation" do
             service.should_receive(:one).
-              and_yield([:foobar, [123, '123', :a123]])
+              yields([:foobar, [123, '123', :a123]], control)
             
             implementation.
               should_receive(:foobar).
@@ -64,7 +65,7 @@ describe Zack::Server do
 
           it "should call the right message on implementation" do
             service.should_receive(:one).
-              and_yield([:foobar, [123, '123', :a123]])
+              yields([:foobar, [123, '123', :a123]], control)
             
             implementation.
               should_receive(:foobar).

data/spec/spec_helper.rb

@@ -1,4 +1,6 @@
 
+require 'beanstalk-client'
+
 require 'zack'
 
 RSpec.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zack
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
   prerelease: 
 platform: ruby
 authors:
@@ -10,42 +10,41 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-31 00:00:00.000000000 +02:00
-default_executable: 
+date: 2011-11-29 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cod
-  requirement: &2165838080 !ruby/object:Gem::Requirement
+  requirement: &70152213379200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.4'
   type: :runtime
   prerelease: false
-  version_requirements: *2165838080
+  version_requirements: *70152213379200
 - !ruby/object:Gem::Dependency
-  name: beanstalk-client
-  requirement: &2165837600 !ruby/object:Gem::Requirement
+  name: uuid
+  requirement: &70152213378720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.3'
   type: :runtime
   prerelease: false
-  version_requirements: *2165837600
+  version_requirements: *70152213378720
 - !ruby/object:Gem::Dependency
-  name: uuid
-  requirement: &2165837140 !ruby/object:Gem::Requirement
+  name: beanstalk-client
+  requirement: &70152213378240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.3'
-  type: :runtime
+        version: '1.0'
+  type: :development
   prerelease: false
-  version_requirements: *2165837140
+  version_requirements: *70152213378240
 description: 
 email:
 - kaspar.schiess@absurd.li
@@ -61,19 +60,16 @@ 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/acceptance/exception_handling_spec.rb
+- spec/acceptance/regression_spec.rb
+- spec/acceptance/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: []
 post_install_message: 
@@ -88,6 +84,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2009193566488392526
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -96,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Ruby RPC calls via Cod

data/example/pubsub.rb

@@ -1,35 +0,0 @@
-
-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/lib/zack/target.rb

@@ -1,68 +0,0 @@
-
-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

@@ -1,22 +0,0 @@
-
-# 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