asir 0.2.0

data/lib/asir/transport/broadcast.rb

@@ -0,0 +1,34 @@
+require 'asir/transport/composite'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # Broadcast Transport
+    #
+    # Broadcast to multiple Transports.
+    class Broadcast < self
+      include Composite
+
+      def _send_message message, message_payload
+        result = first_exception = nil
+        transports.each do | transport |
+          begin
+            result = transport.send_message(message)
+          rescue ::Exception => exc
+            first_exception ||= exc
+            _handle_send_message_exception! transport, message, exc
+            raise unless @continue_on_exception
+          end
+        end
+        if first_exception && @reraise_first_exception
+          $! = first_exception
+          raise
+        end
+        result
+      end
+
+    end
+    # !SLIDE END
+  end
+end
+

data/lib/asir/transport/buffer.rb

@@ -0,0 +1,115 @@
+require 'asir/transport'
+require 'thread'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # Buffer Transport
+    #
+    # Buffers Messages until #flush!
+    # Assumes One-way Messages.
+    class Buffer < self
+      include Delegation
+
+      # Transport to send_message.
+      attr_accessor :transport
+
+      def initialize *args
+        super
+        @messages = Queue.new
+        @messages_mutex = Mutex.new
+        @paused = 0
+        @paused_mutex = Mutex.new
+      end
+
+      # If paused, queue messages,
+      # Otherwise delegate immediately to #transport.
+      def _send_message message, message_payload
+        return nil if @ignore
+        if paused?
+          @messages_mutex.synchronize do
+            @messages << message
+          end
+          nil
+        else
+          @transport.send_message(message)
+        end
+      end
+
+      # Returns true if currently paused.
+      # Messages are queued until #resume!.
+      def paused?
+        @paused > 0
+      end
+
+      # Pauses all messages until resume!.
+      # May be called multiple times.
+      def pause!
+        @paused_mutex.synchronize do
+          @paused += 1
+        end
+        self
+      end
+
+      # Will automatically call #flush! when not #paused?.
+      def resume!
+        should_flush = @paused_mutex.synchronize do
+          @paused -= 1 if @paused > 0
+          @paused == 0
+        end
+        flush! if should_flush
+        self
+      end
+
+      def size
+        @messages_mutex.synchronize do
+          @messages.size
+        end
+      end
+
+      # Will flush pending Messages even if ! #paused?.
+      def flush!
+        clear!.each do | message |
+          @transport.send_message(message)
+        end
+        self
+      end
+
+      # Clear all pending Messages without sending them.
+      # Returns Array of Messages that would have been sent.
+      def clear!
+        messages = [ ]
+        @messages_mutex.synchronize do
+          @messages.size.times do
+            messages << @messages.shift(true)
+          end
+        end
+        messages
+      end
+
+      # Take Message from head of Queue.
+      def shift non_block=false
+        @messages.shift(non_block)
+      end
+
+      # Processes queue.
+      # Usually used in worker Thread.
+      def process! non_block=false
+        @running = true
+        while @running && message = shift(non_block)
+          @transport.send_message(message)
+        end
+        message
+      end
+
+      # Stop processing queue.
+      def stop!
+        @messages_mutex.synchronize do
+          @ignore = true; @running = false
+        end
+        self
+      end
+    end
+    # !SLIDE END
+  end
+end

data/lib/asir/transport/composite.rb

@@ -0,0 +1,19 @@
+require 'asir/transport/delegation'
+module ASIR
+  class Transport
+    # !SLIDE
+    # A Transport composed of other Transports.
+    #
+    # Classes that mix this in should define #_send_message(message, message_payload).
+    module Composite
+      include Delegation
+
+      # Enumerable of Transport objects.
+      attr_accessor :transports
+      # If true, continue with other Transports when Transport#send_message raises an Exception.
+      attr_accessor :continue_on_exception
+    end
+    # !SLIDE END
+  end
+end
+

data/lib/asir/transport/connection_oriented.rb

@@ -0,0 +1,180 @@
+require 'asir/transport/stream'
+require 'asir/transport/payload_io'
+require 'uri'
+
+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
+
+      # !SLIDE
+      # Returns a connected Channel.
+      def stream
+        @stream ||=
+          connect!
+      end
+
+      # Yields Channel after _connect!.
+      def connect!(opts = nil, &blk)
+        base_opts = {
+          :on_connect => lambda { | channel |
+            connection = _connect!
+            blk.call(connection) if blk
+            connection
+          }
+        }
+        base_opts.update(opts) if opts
+        Channel.new(base_opts)
+      end
+
+      # 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
+      rescue ::Exception => err
+        raise Error, "Cannot connect to #{self.class} #{uri}: #{err.inspect}", err.backtrace
+      end
+
+      # Subclasses can override.
+      def _after_connect! stream
+        self
+      end
+
+      # Subclasses can override.
+      def _before_close! stream
+        self
+      end
+
+      # !SLIDE
+      # Sends the encoded Message payload String.
+      def _send_message message, message_payload
+        stream.with_stream! do | io |
+          _write message_payload, io
+        end
+      end
+
+      # !SLIDE
+      # Receives the encoded Message payload String.
+      def _receive_message stream, additional_data
+        [ _read(stream), nil ]
+      end
+
+      # !SLIDE
+      # Sends the encoded Result payload String.
+      def _send_result message, result, result_payload, stream, message_state
+        unless @one_way || message.one_way
+          _write result_payload, stream
+        end
+      end
+
+      # !SLIDE
+      # Receives the encoded Result payload String.
+      def _receive_result message, opaque_result
+        unless @one_way || message.one_way
+          stream.with_stream! do | io |
+            _read io
+          end
+        end
+      end
+
+      # !SLIDE
+      # Server
+
+      def prepare_server!
+        _log { "prepare_server! #{uri}" } if @verbose >= 1
+        _server!
+      rescue ::Exception => err
+        _log [ "prepare_server! #{uri}", :exception, err ]
+        raise Error, "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
+          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
+          end
+        end
+        self
+      ensure
+        _server_close!
+      end
+
+      def _server!
+        raise Error::SubclassResponsibility, "_server!"
+      end
+
+      def _server_close!
+        if @server
+          @server.close rescue nil
+        end
+        @server = nil
+        self
+      end
+
+      # Accept a client connection.
+      def _server_accept_connection! server
+        raise Error::SubclassResponsibility, "_server_accept_connection!"
+      end
+
+      # Close a client connection.
+      def _server_close_connection! stream
+        raise Error::SubclassResponsibility, "_server_close_connection!"
+      end
+    end
+    # !SLIDE END
+  end # class
+end # module
+

data/lib/asir/transport/delay.rb

@@ -0,0 +1,38 @@
+module ASIR
+  class Message
+    # !SLIDE
+    # Message Delay Support
+    #
+    module Delay
+      # Returns the number of seconds from now, that the message should be delayed.
+      # If message.delay is Numeric, sets message.delay to the Time to delay til.
+      # If message.delay is Time, returns (now - message.delay).to_f
+      # Returns Float if message.delay was set, or nil.
+      # Returns 0 if delay has already expired.
+      def relative_message_delay! message, now = nil
+        case delay = message.delay
+        when nil
+        when Numeric
+          now ||= Time.now
+          delay = delay.to_f
+          message.delay = (now + delay).utc
+        when Time
+          now ||= Time.now
+          delay = (delay - now).to_f
+          delay = 0 if delay < 0
+        else
+          raise TypeError, "Expected message.delay to be Numeric or Time, given #{delay.class}"
+        end
+        delay
+      end
+
+      def wait_for_delay! message
+        while (delay = relative_message_delay!(message)) && delay > 0 
+          sleep delay
+        end
+        self
+      end
+
+    end
+  end
+end

data/lib/asir/transport/delegation.rb

@@ -0,0 +1,53 @@
+module ASIR
+  class Transport
+    # !SLIDE
+    # A Transport that delgated to one or more other Transports.
+    #
+    # Classes that include this must define #_send_message(message, message_payload).
+    module Delegation
+      # If true, reraise the first Exception that occurred during Transport#send_message.
+      attr_accessor :reraise_first_exception
+
+      # Proc to call(transport, message, exc) when a delegated #send_message fails.
+      attr_accessor :on_send_message_exception
+
+      # Proc to call(transport, message) when #send_message fails with no recourse.
+      attr_accessor :on_failed_message
+
+      # Return the subTransports#send_message result unmodified from #_send_message.
+      def _receive_result message, opaque_result
+        opaque_result
+      end
+
+      # Return the subTransports#send_message result unmodified from #_send_message.
+      def receive_result message, opaque_result
+        opaque_result
+      end
+
+      def needs_message_identifier?
+        @needs_message_identifier ||
+          transports.any? { | t | t.needs_message_identifier? }
+      end
+
+      def needs_message_timestamp?
+        @needs_message_timestamp ||
+          transports.any? { | t | t.needs_message_timestamp? }
+      end
+
+      # Subclasses with multiple transport should override this method.
+      def transports
+        @transports ||= [ transport ]
+      end
+
+      # Called from within _send_message rescue.
+      def _handle_send_message_exception! transport, message, exc
+        _log { [ :send_message, :transport_failed, exc ] }
+        (message[:transport_exceptions] ||= [ ]) << "#{exc.inspect}"
+        @on_send_message_exception.call(self, message, exc) if @on_send_message_exception
+        self
+      end
+    end
+    # !SLIDE END
+  end
+end
+

data/lib/asir/transport/fallback.rb

@@ -0,0 +1,36 @@
+require 'asir/transport/composite'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # Fallback Transport
+    class Fallback < self
+      include Composite
+
+      def _send_message message, message_payload
+        result = sent = first_exception = nil
+        transports.each do | transport |
+          begin
+            result = transport.send_message(message)
+            sent = true
+            break
+          rescue ::Exception => exc
+            first_exception ||= exc
+            _handle_send_message_exception! transport, message, exc
+          end
+        end
+        unless sent
+          if first_exception && @reraise_first_exception
+            $! = first_exception
+            raise
+          end
+          raise FallbackError, "fallback failed"
+        end
+        result
+      end
+      class FallbackError < Error; end
+    end
+    # !SLIDE END
+  end
+end
+