asir 0.2.0 → 1.0.1

data/lib/asir/transport.rb

@@ -1,5 +1,7 @@
 require 'time'
+require 'asir/thread_variable'
 require 'asir/message/delay'
+require 'asir/transport/conduit'
 
 module ASIR
   # !SLIDE
@@ -11,7 +13,7 @@ module ASIR
   # Service: Send the Result to the Client.
   # Client: Receive the Result from the Service.
   class Transport
-    include Log, Initialization, AdditionalData, Message::Delay
+    include Log, Initialization, AdditionalData, Message::Delay, ThreadVariable, Conduit
 
     attr_accessor :encoder, :decoder, :one_way
 
@@ -22,8 +24,8 @@ module ASIR
     # * Receive decoded Result.
     def send_message message
       @message_count ||= 0; @message_count += 1
-      message.create_timestamp! if needs_message_timestamp?
-      message.create_identifier! if needs_message_identifier?
+      message.create_timestamp! if needs_message_timestamp? message
+      message.create_identifier! if needs_message_identifier? message
       @before_send_message.call(self, message) if @before_send_message
       relative_message_delay! message
       message_payload = encoder.dup.encode(message)
@@ -57,13 +59,6 @@ module ASIR
     # Send Result to stream.
     def send_result result, stream, message_state
       message = result.message
-      if @on_result_exception && result.exception
-        begin
-          @on_result_exception.call(self, result)
-        rescue ::Exception => exc
-          _log { [ :send_result, :result, result, :on_result_exception, exc ] }
-        end
-      end
       if @one_way && message.block
         message.block.call(result)
       else
@@ -85,7 +80,7 @@ module ASIR
       result = decoder.dup.decode(result_payload)
       if result && ! message.one_way
         if exc = result.exception
-          exc.invoke!
+          invoker.invoke!(exc, self)
         else
           if ! @one_way && message.block
             message.block.call(result)
@@ -105,27 +100,27 @@ module ASIR
     attr_accessor :message_count
 
     # A Proc to call within #receive_message, after #_receive_message.
-    # trans.after_receiver_message(trans, message)
+    # trans.after_receive_message(trans, message)
     attr_accessor :after_receive_message
 
     # A Proc to call within #send_message, before #_send_message.
     # trans.before_send_message(trans, message)
     attr_accessor :before_send_message
 
-    # Proc to call after #_send_result if result.exception.
+    # Proc to call with #invoke_message! if result.exception.
     # trans.on_result_exception.call(trans, result)
     attr_accessor :on_result_exception
 
     # Proc to call with exception, if exception occurs within #serve_message!, but outside
     # Message#invoke!.
     #
-    # trans.on_exception.call(trans, exception, :message, Message_instance)
+    # trans.on_exception.call(trans, exception, :message, Message_instance, nil)
     # trans.on_exception.call(trans, exception, :result, Message_instance, Result_instance)
     attr_accessor :on_exception
 
     attr_accessor :needs_message_identifier, :needs_message_timestamp
-    alias :needs_message_identifier? :needs_message_identifier
-    alias :needs_message_timestamp? :needs_message_timestamp
+    def needs_message_identifier? m; @needs_message_identifier; end
+    def needs_message_timestamp?  m; @needs_message_timestamp; end
 
     attr_accessor :verbose
 
@@ -154,7 +149,7 @@ module ASIR
     rescue ::Exception => exc
       exception = original_exception = exc
       _log [ :message_error, exc ]
-      @on_exception.call(self, exc, :message, message) if @on_exception
+      @on_exception.call(self, exc, :message, message, nil) if @on_exception
     ensure
       begin
         if message_ok
@@ -180,6 +175,7 @@ module ASIR
 
     # !SLIDE 
     # Transport Server Support
+    attr_accessor :running
 
     def stop! force = false
       @running = false
@@ -225,12 +221,29 @@ module ASIR
 
     # Invokes the Message object, returns a Result object.
     def invoke_message! message
-      _processing_message = @processing_message
-      @processing_message = true
-      wait_for_delay! message
-      message.invoke!
-    ensure
-      @processing_message = _processing_message
+      result = nil
+      Transport.with_attr! :current, self do
+        with_attr! :message, message do
+          wait_for_delay! message
+          result = invoker.invoke!(message, self)
+          # Hook for Exceptions.
+          if @on_result_exception && result.exception
+            @on_result_exception.call(self, result)
+          end
+        end
+      end
+      result
+    end
+    # The current Message being handled.
+    attr_accessor_thread :message
+
+    # The current active Transport.
+    cattr_accessor_thread :current
+
+    # The Invoker responsible for invoking the Message.
+    attr_accessor :invoker
+    def invoker
+      @invoker ||= Invoker.new
     end
 
     # !SLIDE END

data/lib/asir/transport/beanstalk.rb

@@ -140,9 +140,8 @@ module ASIR
 
       # !SLIDE
       # Beanstalk Server
-
-      def prepare_beanstalk_server!
-        _log { "prepare_beanstalk_server! #{uri}" } if @verbose >= 1
+      def _server!
+        _log { "_server! #{uri}" } if @verbose >= 1
         @server = connect!(:try_max => nil,
                            :try_sleep => 1,
                            :try_sleep_increment => 0.1,
@@ -155,61 +154,28 @@ module ASIR
         end
         self
       end
-      alias :prepare_server! :prepare_beanstalk_server!
-
-      def run_beanstalk_server!
-        _log :run_beanstalk_server! if @verbose >= 1
-        with_server_signals! do
-          @running = true
-          while @running
-            prepare_beanstalk_server! unless @server
-            # Same socket for both in and out stream.
-            serve_stream! @server, @server
-          end
-        end
-        self
-      ensure
-        _server_close!
-      end
-      alias :run_server! :run_beanstalk_server!
- 
-      def serve_stream! in_stream, out_stream
-        while @running
-          begin
-            serve_stream_message! in_stream, out_stream
-          rescue ::Exception => exc
-            _log [ :serve_stream_error, exc ]
-            @running = false
-          end
-        end
-        self
-      ensure
-        _server_close!
+
+      def _server_accept_connection! server
+        prepare_server! unless @server
+        [ @server, @server ]
       end
 
-      def start_beanstalkd!
-        _log { "run_beanstalkd! #{uri}" } if @verbose >= 1
-        raise "already running #{@beanstalkd_pid}" if @beanstalkd_pid
-        addr = @address ? "-l #{@address} " : ""
-        cmd = "beanstalkd #{addr}-p #{port}"
-        @beanstalkd_pid = Process.fork do 
-          _log { "Start beanstalkd: #{cmd} ..." } if @verbose >= 1
-          exec(cmd)
-          raise "exec #{cmd.inspect} failed"
-        end
-        _log { "Start beanstalkd: #{cmd} pid=#{@beanstalkd_pid.inspect}" } if @verbose >= 2
-        self
+      def _server_close_connection! in_stream, out_stream
+        # NOTHING
       end
 
-      def stop_beanstalkd!
-        _log { "stop_beanstalkd! #{uri} pid=#{@beanstalkd_pid.inspect}" } if @verbose >= 1
-        Process.kill 'TERM', @beanstalkd_pid
-        Process.waitpid @beanstalkd_pid
-        self
-      ensure
-        @beanstalkd_pid = nil
+      def stream_eof? stream
+        # Note: stream.eof? on a beanstalkd connection,
+        # will cause blocking read *forever* because
+        # beanstalk connections are long lived.
+        false
       end
 
+      def _start_conduit!
+        addr = address ? "-l #{address} " : ""
+        cmd = "beanstalkd #{addr}-p #{port}"
+        exec(cmd)
+      end
     end
     # !SLIDE END
   end # class

data/lib/asir/transport/conduit.rb

@@ -0,0 +1,42 @@
+require 'asir/transport'
+
+module Asir
+  class Transport
+    # Conduit service support.
+    module Conduit
+      def start_conduit! options = nil
+        opts = { :fork => true }
+        opts.update(options) if options
+        _log { "start_conduit! #{self}" } if @verbose >= 1
+        in_fork = opts[:fork]
+        raise "already running #{@conduit_pid} #{@conduit_cmd}" if @conduit_pid
+        if in_fork
+          @conduit_pid = ::Process.fork do
+          _log { "start_conduit! #{self} starting pid=#{$$.inspect}" } if @verbose >= 2
+            _start_conduit!
+            raise "Could not exec"
+          end
+          _log { "start_conduit! #{self} started pid=#{@conduit_pid.inspect}" } if @verbose >= 2
+        else
+          _start_conduit!
+        end
+        self
+      end
+
+      def stop_conduit!
+        if @conduit_pid
+          ::Process.kill 'TERM', @conduit_pid
+          ::Process.waitpid @conduit_pid
+          # File.unlink @redis_conf
+        end
+        self
+      ensure
+        @conduit_pid = nil
+      end
+
+      def _start_conduit!
+        raise Error::SubclassResponsibility
+      end
+    end
+  end
+end

data/lib/asir/transport/connection_oriented.rb

@@ -1,51 +1,13 @@
 require 'asir/transport/stream'
 require 'asir/transport/payload_io'
-require 'uri'
+require 'asir/uri_config'
 
 module ASIR
   class Transport
     # !SLIDE
     # Connection-Oriented Transport
     class ConnectionOriented < Stream
-      include PayloadIO
-
-      attr_accessor :uri, :scheme, :port, :address
-      alias :protocol :scheme
-      alias :protocol= :scheme=
-
-      def uri
-        @uri ||= "#{scheme}://#{address}:#{port}"
-      end
-
-      def scheme
-        @scheme ||=
-          case
-          when @uri
-            URI.parse(@uri).scheme
-          else
-            'tcp'.freeze
-          end
-      end
-
-      def address
-        @address ||=
-          case
-          when @uri
-            URI.parse(@uri).host
-          else
-            '127.0.0.1'.freeze
-          end
-      end
-
-      def port
-        @port ||=
-          case
-          when @uri
-            URI.parse(@uri).port
-          else
-            raise Error, "#{self.class}: port not set."
-          end
-      end
+      include PayloadIO, UriConfig
 
       # !SLIDE
       # Returns a connected Channel.
@@ -70,12 +32,12 @@ module ASIR
       # Returns raw client stream.
       def _connect!
         _log { "_connect! #{uri}" } if @verbose >= 1
-        sock = _client_connect!
-        _log { "_connect! socket=#{sock}" } if @verbose >= 1
-        _after_connect! sock
-        sock
+        stream = _client_connect!
+        _log { "_connect! stream=#{stream}" } if @verbose >= 1
+        _after_connect! stream
+        stream
       rescue ::Exception => err
-        raise Error, "Cannot connect to #{self.class} #{uri}: #{err.inspect}", err.backtrace
+        raise err.class, "Cannot connect to #{self.class} #{uri}: #{err.inspect}", err.backtrace
       end
 
       # Subclasses can override.
@@ -128,30 +90,43 @@ module ASIR
         _server!
       rescue ::Exception => err
         _log [ "prepare_server! #{uri}", :exception, err ]
-        raise Error, "Cannot prepare server on #{self.class} #{uri}: #{err.inspect}", err.backtrace
+        raise err.class, "Cannot prepare server on #{self.class} #{uri}: #{err.inspect}", err.backtrace
       end
 
       def run_server!
         _log { "run_server! #{uri}" } if @verbose >= 1
         with_server_signals! do
           @running = true
+          server_on_start!
           while @running
-            stream = _server_accept_connection! @server
-            _log { "run_server!: connected" } if @verbose >= 1
-            begin
-              # Same socket for both in and out stream.
-              serve_stream! stream, stream
-            ensure
-              _server_close_connection!(stream)
-            end
-            _log { "run_server!: disconnected" } if @verbose >= 1
+            serve_connection!
           end
         end
         self
       ensure
+        server_on_stop!
         _server_close!
       end
 
+      def server_on_start!
+      end
+
+      def server_on_stop!
+      end
+
+      def serve_connection!
+        in_stream, out_stream = _server_accept_connection! @server
+        _log { "serve_connection!: connected #{in_stream} #{out_stream}" } if @verbose >= 1
+        _server_serve_stream! in_stream, out_stream
+      rescue Error::Terminate => err
+        @running = false
+        _log [ :serve_connection_terminate, err ]
+      ensure
+        _server_close_connection!(in_stream, out_stream)
+        _log { "serve_connection!: disconnected" } if @verbose >= 1
+      end
+      alias :_server_serve_stream! :_serve_stream!
+
       def _server!
         raise Error::SubclassResponsibility, "_server!"
       end
@@ -165,12 +140,13 @@ module ASIR
       end
 
       # Accept a client connection.
+      # Returns [ in_stream, out_stream ].
       def _server_accept_connection! server
         raise Error::SubclassResponsibility, "_server_accept_connection!"
       end
 
       # Close a client connection.
-      def _server_close_connection! stream
+      def _server_close_connection! in_stream, out_stream
         raise Error::SubclassResponsibility, "_server_close_connection!"
       end
     end

data/lib/asir/transport/delegation.rb

@@ -24,17 +24,17 @@ module ASIR
         opaque_result
       end
 
-      def needs_message_identifier?
+      def needs_message_identifier? message
         @needs_message_identifier ||
-          transports.any? { | t | t.needs_message_identifier? }
+          transports.any? { | t | t.needs_message_identifier?(message) }
       end
 
-      def needs_message_timestamp?
+      def needs_message_timestamp? message
         @needs_message_timestamp ||
-          transports.any? { | t | t.needs_message_timestamp? }
+          transports.any? { | t | t.needs_message_timestamp?(message) }
       end
 
-      # Subclasses with multiple transport should override this method.
+      # Subclasses with multiple transports should override this method.
       def transports
         @transports ||= [ transport ]
       end

data/lib/asir/transport/demux.rb

@@ -0,0 +1,33 @@
+require 'asir/transport/delegation'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # Select a Transport based on a Proc.
+    class Demux < self
+      include Delegation
+
+      # Proc returning actual transport to use.
+      # transport_proc.call(transport, message)
+      attr_accessor :transport_proc
+
+      # Only active during #send_message.
+      attr_accessor_thread :transport
+
+      # Support for Delegation mixin.
+      def transports; [ transport ]; end
+
+      def send_message message
+        with_attr! :transport, transport_proc.call(self, message) do
+          super
+        end
+      end
+
+      def _send_message message, message_payload
+        transport.send_message(message)
+      end
+    end
+    # !SLIDE END
+  end
+end
+