asir 0.2.0

data/lib/asir/object_resolving.rb

@@ -0,0 +1,15 @@
+module ASIR
+  # !SLIDE
+  # Object Resolving
+  #
+  module ObjectResolving
+    class ResolveError < Error; end
+    def resolve_object name
+      name.to_s.split(MODULE_SEP).inject(Object){|m, n| m.const_get(n)}
+    rescue ::Exception => err
+      raise ResolveError, "cannot resolve #{name.inspect}: #{err.inspect}", err.backtrace
+    end
+  end
+  # !SLIDE END
+end
+

data/lib/asir/result.rb

@@ -0,0 +1,39 @@
+module ASIR
+  # !SLIDE
+  # Result
+  #
+  # Encapsulate the result returned to the Client.
+  class Result
+    include AdditionalData, Identity, CodeMore::Result
+    attr_accessor :message, :result, :exception
+    # Optional: Opaque data about the server that processed the Message.
+    attr_accessor :server
+
+    def initialize msg, res = nil, exc = nil
+      @message = msg; @result = res
+      @exception = exc && EncapsulatedException.new(exc)
+      @identifier = @message.identifier
+    end
+  end
+  # !SLIDE END
+
+  # !SLIDE
+  # Encapsulated Exception
+  #
+  # Encapsulates exceptions raised in the Service.
+  class EncapsulatedException
+    include ObjectResolving, AdditionalData
+    attr_accessor :exception_class, :exception_message, :exception_backtrace
+
+    def initialize exc
+      @exception_class     = exc.class.name
+      @exception_message   = exc.message
+      @exception_backtrace = exc.backtrace
+    end
+
+    def invoke!
+      raise resolve_object(@exception_class), @exception_message, @exception_backtrace
+    end
+  end
+  # !SLIDE END
+end

data/lib/asir/retry_behavior.rb

@@ -0,0 +1,54 @@
+module ASIR
+  # !SLIDE
+  # Generic retry behavior
+  module RetryBehavior
+    # Maximum trys.
+    attr_accessor :try_max
+    # Initial amount of seconds to sleep between each try.
+    attr_accessor :try_sleep
+    # Amount of seconds to increment sleep between each try.
+    attr_accessor :try_sleep_increment
+    # Maxinum amount of seconds to sleep between each try.
+    attr_accessor :try_sleep_max
+
+    # Yields:
+    #   :try, n_try
+    #   :rescue, exc
+    #   :retry, exc
+    #   :failed, nil
+    def with_retry
+      n_try = 0
+      sleep_secs = try_sleep
+      result = done = last_exception = nil
+      begin
+        n_try += 1
+        result = yield :try, n_try
+        done = true
+      rescue *Error::Unforwardable.unforwardable => exc
+        raise
+      rescue ::Exception => exc
+        last_exception = exc
+        yield :rescue, exc
+        if ! try_max || try_max > n_try
+          yield :retry, exc
+          if sleep_secs
+            sleep sleep_secs
+            sleep_secs += try_sleep_increment if try_sleep_increment
+            sleep_secs = try_sleep_max if try_sleep_max && sleep_secs > try_sleep_max
+          end
+          retry
+        end
+      end
+      unless done
+        unless yield :failed, last_exception
+          exc = last_exception
+          raise RetryError, "Retry failed: #{exc.inspect}", exc.backtrace
+        end
+      end
+      result
+    end
+    class RetryError < Error; end
+  end # module
+  # !SLIDE END
+end # module ASIR
+

data/lib/asir/transport.rb

@@ -0,0 +1,241 @@
+require 'time'
+require 'asir/message/delay'
+
+module ASIR
+  # !SLIDE
+  # Transport
+  #
+  # Client: Send the Message to the Service.
+  # Service: Receive the Message from the Client.
+  # Service: Invoke the Message.
+  # Service: Send the Result to the Client.
+  # Client: Receive the Result from the Service.
+  class Transport
+    include Log, Initialization, AdditionalData, Message::Delay
+
+    attr_accessor :encoder, :decoder, :one_way
+
+    # !SLIDE
+    # Transport#send_message
+    # * Encode Message.
+    # * Send encoded Message.
+    # * 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?
+      @before_send_message.call(self, message) if @before_send_message
+      relative_message_delay! message
+      message_payload = encoder.dup.encode(message)
+      opaque_result = _send_message(message, message_payload)
+      receive_result(message, opaque_result)
+    end
+
+    # !SLIDE
+    # Transport#receive_message
+    # Receive Message payload from stream.
+    def receive_message stream
+      @message_count ||= 0; @message_count += 1
+      additional_data = { }
+      if req_and_state = _receive_message(stream, additional_data)
+        message = req_and_state[0] = encoder.dup.decode(req_and_state.first)
+        message.additional_data!.update(additional_data) if message
+        if @after_receive_message
+          begin
+            @after_receive_message.call(self, message)
+          rescue ::Exception => exc
+            _log { [ :receive_message, :after_receive_message, :exception, exc ] }
+          end
+        end
+      end
+      req_and_state
+    end
+    # !SLIDE END
+
+    # !SLIDE
+    # Transport#send_result
+    # 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
+        result.message = nil # avoid sending back entire Message.
+        result_payload = decoder.dup.encode(result)
+        _send_result(message, result, result_payload, stream, message_state)
+      end
+    end
+    # !SLIDE END
+
+    # !SLIDE
+    # Transport#receive_result
+    # Receieve Result from stream:
+    # * Receive Result payload
+    # * Decode Result.
+    # * Extract Result result or exception.
+    def receive_result message, opaque_result
+      result_payload = _receive_result(message, opaque_result)
+      result = decoder.dup.decode(result_payload)
+      if result && ! message.one_way
+        if exc = result.exception
+          exc.invoke!
+        else
+          if ! @one_way && message.block
+            message.block.call(result)
+          end
+          result.result
+        end
+      end
+    end
+    # !SLIDE END
+
+    def initialize *args
+      @verbose = 0
+      super
+    end
+
+    # Incremented for each message sent or received.
+    attr_accessor :message_count
+
+    # A Proc to call within #receive_message, after #_receive_message.
+    # trans.after_receiver_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.
+    # 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, :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
+
+    attr_accessor :verbose
+
+    def _subclass_responsibility *args
+      raise Error::SubclassResponsibility "subclass responsibility"
+    end
+    alias :_send_message :_subclass_responsibility
+    alias :_receive_message :_subclass_responsibility
+    alias :_send_result :_subclass_responsibility
+    alias :_receive_result :_subclass_responsibility
+
+    # !SLIDE
+    # Serve a Message.
+    def serve_message! in_stream, out_stream
+      message = message_state = message_ok = result = result_ok = nil
+      exception = original_exception = unforwardable_exception = nil
+      message, message_state = receive_message(in_stream)
+      if message
+        message_ok = true
+        result = invoke_message!(message)
+        result_ok = true
+        self
+      else
+        nil
+      end
+    rescue ::Exception => exc
+      exception = original_exception = exc
+      _log [ :message_error, exc ]
+      @on_exception.call(self, exc, :message, message) if @on_exception
+    ensure
+      begin
+        if message_ok
+          if exception && ! result_ok
+            case exception
+            when *Error::Unforwardable.unforwardable
+              unforwardable_exception = exception = Error::Unforwardable.new(exception)
+            end
+            result = Result.new(message, nil, exception)
+          end
+          if out_stream
+            send_result(result, out_stream, message_state)
+          end
+        end
+      rescue ::Exception => exc
+        _log [ :result_error, exc ]
+        @on_exception.call(self, exc, :result, message, result) if @on_exception
+      end
+      raise original_exception if unforwardable_exception
+    end
+
+    # !SLIDE pause
+
+    # !SLIDE 
+    # Transport Server Support
+
+    def stop! force = false
+      @running = false
+      stop_server! if respond_to?(:stop_server!)
+      raise Error::Terminate if force
+      self
+    end
+
+    def with_server_signals!
+      old_trap = { }
+      [ "TERM", "HUP" ].each do | sig |
+        trap = proc do | *args |
+          stop!
+          @signal_exception = ::ASIR::Error::Terminate.new("#{self} by SIG#{sig} #{args.inspect} in #{__FILE__}:#{__LINE__}")
+        end
+        old_trap[sig] = Signal.trap(sig, trap)
+      end
+      yield
+      if exc = @signal_exception
+        @signal_exception = nil
+        raise exc
+      end
+    ensure
+      # $stderr.puts "old_trap = #{old_trap.inspect}"
+      old_trap.each do | sig, trap |
+        Signal.trap(sig, trap) rescue nil
+      end
+    end
+
+    # !SLIDE
+    # Transport Support
+    # ...
+
+    def encoder
+      @encoder ||=
+        Coder::Identity.new
+    end
+
+    def decoder
+      @decoder ||=
+        encoder
+    end
+
+    # 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
+    end
+
+    # !SLIDE END
+    # !SLIDE resume
+
+  end
+  # !SLIDE END
+end

data/lib/asir/transport/beanstalk.rb

@@ -0,0 +1,217 @@
+require 'asir/transport/tcp_socket'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # Beanstalk Transport
+    class Beanstalk < TcpSocket
+      LINE_TERMINATOR = "\r\n".freeze
+
+      attr_accessor :tube, :priority, :delay, :ttr
+
+      def initialize *args
+        @port ||= 11300
+        @tube ||= 'asir'
+        @priority ||= 0
+        @delay ||= 0
+        @ttr ||= 600
+        super
+      end
+
+      # !SLIDE
+      # Sends the encoded Message payload String.
+      def _send_message message, message_payload
+        stream.with_stream! do | s |
+          begin
+            match = 
+              _beanstalk(s, 
+                         "put #{message[:beanstalk_priority] || @priority} #{message[:beanstalk_delay] || @delay} #{message[:beanstalk_ttr] || @ttr} #{message_payload.size}\r\n",
+                         /\AINSERTED (\d+)\r\n\Z/,
+                         message_payload)
+            job_id = message[:beanstalk_job_id] = match[1].to_i
+            _log { "beanstalk_job_id = #{job_id.inspect}" } if @verbose >= 2
+          rescue ::Exception => exc
+            message[:beanstalk_error] = exc
+            close
+            raise exc
+          end
+        end
+      end
+
+      RESERVE = "reserve\r\n".freeze
+
+      # !SLIDE
+      # Receives the encoded Message payload String.
+      def _receive_message channel, additional_data
+        channel.with_stream! do | stream |
+          begin
+            match = 
+              _beanstalk(stream,
+                         RESERVE,
+                         /\ARESERVED (\d+) (\d+)\r\n\Z/)
+            additional_data[:beanstalk_job_id] = match[1].to_i
+            additional_data[:beanstalk_message_size] = 
+              size = match[2].to_i
+            message_payload = stream.read(size)
+            _read_line_and_expect! stream, /\A\r\n\Z/
+            # Pass the original stream used to #_send_result below.
+            [ message_payload, stream ]
+          rescue ::Exception => exc
+            _log { [ :_receive_message, :exception, exc ] }
+            additional_data[:beanstalk_error] = exc
+            channel.close
+          end
+        end
+      end
+
+      # !SLIDE
+      # Sends the encoded Result payload String.
+      def _send_result message, result, result_payload, channel, stream
+        #
+        # There is a possibility here the following could happen:
+        #
+        #   _receive_message
+        #     channel == #<Channel:1>   
+        #     channel.stream == #<TCPSocket:1234>
+        #   end
+        #   ...
+        #   ERROR OCCURES:
+        #      channel.stream.close
+        #      channel.stream = nil
+        #   ...
+        #   _send_result 
+        #     channel == #<Channel:1>
+        #     channel.stream == #<TCPSocket:5678> # NEW CONNECTION
+        #     stream.write "delete #{job_id}"
+        #   ...
+        #
+        # Therefore: _receiver_message passes the original message stream to us.
+        # We insure that the same stream is still the active one and use it.
+        channel.with_stream! do | maybe_other_stream |
+          _log [ :_send_result, "stream lost" ] if maybe_other_stream != stream
+          job_id = message[:beanstalk_job_id] or raise "no beanstalk_job_id"
+          _beanstalk(stream,
+                     "delete #{job_id}\r\n",
+                     /\ADELETED\r\n\Z/)
+        end
+      end
+
+      # !SLIDE
+      # Receives the encoded Result payload String.
+      def _receive_result message, opaque_result
+        nil
+      end
+
+      # !SLIDE
+      # Sets beanstalk_delay if message.delay was specified.
+      def relative_message_delay! message, now = nil
+        if delay = super
+          message[:beanstalk_delay] = delay.to_i
+        end
+        delay
+      end
+
+      # !SLIDE
+      # Beanstalk protocol support
+
+      # Send "something ...\r\n".
+      # Expect /\ASOMETHING (\d+)...\r\n".
+      def _beanstalk stream, message, expect, payload = nil
+        _log { [ :_beanstalk, :message, message ] } if @verbose >= 3
+        stream.write message
+        if payload
+          stream.write payload
+          stream.write LINE_TERMINATOR
+        end
+        stream.flush
+        if match = _read_line_and_expect!(stream, expect)
+          _log { [ :_beanstalk, :result, match[0] ] } if @verbose >= 3
+        end
+        match
+      end
+
+      def _after_connect! stream
+        if @tube
+          _beanstalk(stream,
+                     "use #{@tube}\r\n",
+                     /\AUSING #{@tube}\r\n\Z/)
+        end
+      end
+
+      # !SLIDE
+      # Beanstalk Server
+
+      def prepare_beanstalk_server!
+        _log { "prepare_beanstalk_server! #{uri}" } if @verbose >= 1
+        @server = connect!(:try_max => nil,
+                           :try_sleep => 1,
+                           :try_sleep_increment => 0.1,
+                           :try_sleep_max => 10) do | stream |
+          if @tube
+            _beanstalk(stream, 
+                       "watch #{@tube}\r\n",
+                       /\AWATCHING (\d+)\r\n\Z/)
+          end
+        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!
+      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
+      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
+      end
+
+    end
+    # !SLIDE END
+  end # class
+end # module
+