asir 0.2.0

data/lib/asir/transport/file.rb

@@ -0,0 +1,88 @@
+require 'asir/transport/stream'
+require 'asir/transport/payload_io'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # File Transport
+    #
+    # Send Message one-way to a file.
+    # Can be used as a log or named pipe service.
+    class File < Stream
+      include PayloadIO # _write, _read
+      attr_accessor :file, :mode, :perms, :stream
+
+      def initialize opts = nil; @one_way = true; super; end
+
+      # Writes a Message payload String.
+      def _send_message message, message_payload
+        _write message_payload, stream
+      ensure
+        close if ::File.pipe?(file)
+      end
+
+      # Returns a Message payload String.
+      def _receive_message stream, additional_data
+        [ _read(stream), nil ]
+      end
+
+      # one-way; no Result.
+      def _send_result message, result, result_payload, stream, message_state
+        nil
+      end
+
+      # one-way; no Result.
+      def _receive_result message, opaque_result
+        nil
+      end
+
+      # !SLIDE
+      # File Transport Support
+
+      def stream
+        @stream ||=
+          begin
+            stream = ::File.open(file, mode || "w+")
+            ::File.chmod(perms, file) rescue nil if @perms
+            after_connect!(stream) if respond_to?(:after_connect!)
+            stream
+          end
+      end
+
+      # !SLIDE
+      # Process (receive) messages from a file.
+
+      def serve_file!
+        ::File.open(file, "r") do | stream |
+          @running = true
+          serve_stream! stream, nil # One-way: no result stream.
+        end
+      end
+
+      # !SLIDE
+      # Named Pipe Server
+
+      def prepare_pipe_server!
+        # _log [ :prepare_pipe_server!, file ]
+        unless ::File.exist? file
+          system(cmd = "mkfifo #{file.inspect}") or raise "cannot run #{cmd.inspect}"
+          ::File.chmod(perms, file) rescue nil if perms
+        end
+      end
+
+      def run_pipe_server!
+        # _log [ :run_pipe_server!, file ]
+        with_server_signals! do
+          @running = true
+          while @running
+            serve_file!
+          end
+        end
+      end
+
+      # !SLIDE END
+    end
+    # !SLIDE END
+  end
+end
+

data/lib/asir/transport/http.rb

@@ -0,0 +1,54 @@
+require 'asir'
+
+require 'rubygems'
+gem 'httpclient'
+require 'httpclient'
+require 'uri'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # HTTP Transport
+    #
+    # Using HTTPClient.
+    class HTTP < self
+      attr_accessor :uri, :server, :debug
+
+      # Client-side: HTTPClient
+
+      def client
+        @client ||=
+          Channel.new(:on_connect =>
+            lambda { | channel | ::HTTPClient.new })
+      end
+
+      def close
+        @client.close if @client
+      ensure
+        @client = nil unless Channel === @client
+      end
+
+      # Send the Message payload String using HTTP POST.
+      # Returns the HTTPClient::Request response object.
+      def _send_message message, message_payload
+        client.with_stream! do | client |
+          client.post(uri, message_payload)
+        end
+      end
+
+      # Recieve the Result payload String from the opaque
+      # HTTPClient::Request response object returned from #_send_message.
+      def _receive_result message, http_result_message
+        # $stderr.puts " ### http_result_message.content.encoding = #{http_result_message.content.encoding.inspect}" rescue nil
+        # $stderr.puts " ### http_result_message.content = #{http_result_message.content.inspect}" rescue nil
+        http_result_message.content.to_s
+      end
+
+      CONTENT_TYPE = 'Content-Type'.freeze
+      APPLICATION_BINARY = 'application/binary'.freeze
+
+    end
+    # !SLIDE END
+  end # class
+end # module
+

data/lib/asir/transport/local.rb

@@ -0,0 +1,21 @@
+module ASIR
+  class Transport
+    # !SLIDE
+    # Local Transport
+    #
+    # Send Message to same process.
+    # Requires Identity Coder.
+    class Local < self
+      # Returns Result object after invoking Message.
+      def _send_message message, message_payload
+        invoke_message!(message)
+      end
+
+      # Returns Result object from #send_message.
+      def _receive_result message, opaque_result
+        opaque_result
+      end
+    end
+    # !SLIDE END
+  end
+end

data/lib/asir/transport/null.rb

@@ -0,0 +1,14 @@
+module ASIR
+  class Transport
+    # !SLIDE 
+    # Null Transport
+    #
+    # Never send Message.
+    class Null < self
+      def _send_message message, message_payload
+        nil
+      end
+    end
+    # !SLIDE END
+  end
+end

data/lib/asir/transport/payload_io.rb

@@ -0,0 +1,52 @@
+module ASIR
+  class Transport
+    # !SLIDE
+    # Payload IO for Transport
+    #
+    # Framing
+    # * Line containing the number of bytes in the payload.
+    # * The payload bytes.
+    # * Blank line.
+    module PayloadIO
+      class UnexpectedResponse < Error; end
+
+      NEWLINE = "\n"
+
+      def _write payload, stream
+        stream.puts payload.size
+        stream.write payload
+        stream.write NEWLINE
+        stream.flush
+        stream
+      end
+
+      def _read stream
+        size = stream.readline.chomp.to_i
+        payload = stream.read(size)
+        stream.readline
+        payload
+      end
+
+      def _read_line_and_expect! stream, regexp
+        line = stream.readline
+        unless match = regexp.match(line)
+          _log { "_read_line_and_expect! #{stream} #{regexp.inspect} !~ #{line.inspect}" }
+          raise UnexpectedResponse, "expected #{regexp.inspect}, received #{line.inspect}"
+        end
+        match
+      end
+
+      # !SLIDE pause
+      def close
+        if @stream
+          _before_close! stream if respond_to?(:_before_close!)
+          @stream.close
+        end
+      ensure
+        @stream = nil unless Channel === @stream
+      end
+
+      # !SLIDE resume
+    end
+  end
+end

data/lib/asir/transport/rack.rb

@@ -0,0 +1,73 @@
+require 'asir/transport/http'
+require 'rack'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # Rack Transport
+    class Rack < HTTP
+      # Receive the Message payload String from the Rack::Request object.
+      # Returns the [ Rack::Request, Rack::Response ] as the message_state.
+      def _receive_message rack_req_res, additional_data
+        body = rack_req_res.first.body.read
+        [ body, rack_req_res ]
+      end
+
+      # Send the Result payload String in the Rack::Response object as application/binary.
+      def _send_result message, result, result_payload, rack_rq_rs, message_state
+        rack_response = rack_rq_rs[1]
+        rack_response[CONTENT_TYPE] = APPLICATION_BINARY
+        rack_response.write result_payload
+      end
+
+      # Constructs a Rackable App from this Transport.
+      def rack_app &blk
+        App.new(self, &blk)
+      end
+
+      # Rack Transport Application.
+      class App
+        def initialize transport = nil, &blk
+          @app = transport
+          instance_eval &blk if blk
+        end
+
+        def call env
+          @app.call(env)
+        end
+      end
+
+      # Rack application handler.
+      def call(env)
+        rq = ::Rack::Request.new(env)
+        rs = ::Rack::Response.new
+        rack_rq_rs = [ rq, rs ]
+        serve_message! rack_rq_rs, rack_rq_rs
+        rs.finish # => [ status, header, rbody ]
+      end
+
+      ###############################
+      # Dummy server.
+
+      def prepare_server! opts = { }
+        self
+      end
+
+      # WEBrick under Rack.
+      def run_server!
+        #require 'rack/handler'
+        u = URI.parse(uri); port = u.port # <= REFACTOR
+        ::Rack::Handler::WEBrick.run \
+          ::Rack::ShowExceptions.new(::Rack::Lint.new(self.rack_app)),
+          :Port => port
+        self
+      end
+
+      def stop_server!
+        # NOT IMPLEMENTED
+        self
+      end
+    end
+    # !SLIDE END
+  end
+end

data/lib/asir/transport/retry.rb

@@ -0,0 +1,41 @@
+require 'asir/transport/delegation'
+require 'asir/retry_behavior'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # Retry Transport
+    class Retry < self
+      include Delegation, RetryBehavior
+
+      # The transport to delegate to.
+      attr_accessor :transport
+      # Proc to call(transport, message) before retry.
+      attr_accessor :before_retry
+
+      def _send_message message, message_payload
+        first_exception = nil
+        with_retry do | action, data |
+          case action
+          when :try
+            transport.send_message(message)
+          when :rescue #, exc
+            first_exception ||= data
+            _handle_send_message_exception! transport, message, data
+          when :retry #, exc
+            before_retry.call(self, message) if before_retry
+          when :failed
+            @on_failed_message.call(self, message) if @on_failed_message
+            if first_exception && @reraise_first_exception
+              $! = first_exception
+              raise
+            end
+            nil # fallback to raise RetryError
+          end
+        end
+      end
+    end
+    # !SLIDE END
+  end
+end
+

data/lib/asir/transport/stream.rb

@@ -0,0 +1,35 @@
+module ASIR
+  class Transport
+    # !SLIDE
+    # Stream Transport
+    #
+    # Base class handles Messages on a stream.
+    # Stream Transports require a Coder that encodes to and from String payloads.
+    class Stream < self
+
+      # !SLIDE
+      # Serve all Messages from a stream.
+      def serve_stream! in_stream, out_stream
+        with_server_signals! do
+          while @running && ! in_stream.eof?
+            begin
+              serve_stream_message! in_stream, out_stream
+            rescue Error::Terminate => err
+              @running = false
+              _log [ :serve_stream_terminate, err ]
+            rescue ::Exception => err
+              _log [ :serve_stream_error, err ]
+            end
+          end
+        end
+      end
+
+      # !SLIDE
+      # Serve a Message from a stream.
+      def serve_stream_message! in_stream, out_stream
+        serve_message! in_stream, out_stream
+      end
+    end
+    # !SLIDE END
+  end
+end

data/lib/asir/transport/subprocess.rb

@@ -0,0 +1,30 @@
+require 'asir/transport/local'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # Subprocess Transport
+    #
+    # Send one-way Message to a forked subprocess.
+    class Subprocess < Local
+      def initialize *args
+        @one_way = true; super
+      end
+
+      def _send_message message, message_payload
+        Process.fork do
+          send_result(super, nil, nil)
+        end
+      end
+
+      # one-way; no Result
+      def _receive_result message, opaque_result
+      end
+
+      # one-way; no Result
+      def _send_result message, result, result_payload, stream, message_state
+      end
+    end
+    # !SLIDE END
+  end
+end

data/lib/asir/transport/tcp_socket.rb

@@ -0,0 +1,34 @@
+require 'asir/transport/connection_oriented'
+require 'socket'
+
+module ASIR
+  class Transport
+    # !SLIDE
+    # TCP Socket Transport
+    class TcpSocket < ConnectionOriented
+      # !SLIDE
+      # TCP Socket Client
+      def _client_connect!
+        sock = TCPSocket.open(address, port)
+      end
+
+      # !SLIDE
+      # TCP Socket Server
+      def _server!
+        @server = TCPServer.open(port)
+        @server.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, false)
+      end
+
+      def _server_accept_connection! server
+        server.accept
+      end
+
+      def _server_close_connection! stream
+        stream.close rescue nil
+      end
+    end
+    # !SLIDE END
+  end # class
+end # module
+
+