asir 1.1.12 → 1.2.0

data/.gitignore

@@ -8,4 +8,5 @@ example/*.out
 coverage
 tmp.*
 cabar.yml
+.rbx
 

data/ChangeLog

@@ -1,5 +1,12 @@
-2012-12-28  Kurt A. Stephens  <ks.github@kurtstephens.com>
+2012-12-29  Kurt A. Stephens  <ks.github@kurtstephens.com>
+
+	* v1.2.0: New version: API changes.
+	* Message::State: internal object encapsulates state between #send_message, #receive_message, #send_result, #receive_result.
+	* Callbacks: most callbacks take a MessageResult object instead of Message and/or Result objects.
+	* UUID: Added new_uuid, process_uuid, counter_uuid, thread_uuid as mixin methods.
+	* Identity: Removed deprecated #client, #server attributes, use additional_data.
 
+2012-12-28  Kurt A. Stephens  <ks.github@kurtstephens.com>
 	* v1.1.12: New version.
 	* Rubinius: Rubinius -Xversion=18 and =19 support.
 	* XML: Really removed Coder::XML.

data/example/ex18.rb

@@ -9,8 +9,9 @@ begin
                                    :encoder => ASIR::Coder::Yaml.new(:yaml_options => { :ASCII_8BIT_ok => true }))
   tcp = ASIR::Transport::TcpSocket.new(:port => 31918,
                                        :encoder => ASIR::Coder::Marshal.new)
-  start_server_proc = lambda do | transport, message |
-    $stderr.puts "message = #{message.inspect}"
+  start_server_proc = lambda do | transport, message_result |
+    message = message_result.message
+    # $stderr.puts "message = #{message.inspect}"
     file.send_message(message)
     server_process do
       tcp.prepare_server!

data/example/ex26.rb

@@ -7,7 +7,7 @@ begin
   Email.asir.transport = t =
     ASIR::Transport::Thread.new
   spawned_thread = nil
-  t.after_thread_new = lambda do | transport, message, thread |
+  t.after_thread_new = lambda do | transport, message_result, thread |
     spawned_thread = thread
     $stderr.puts "\n  #{$$}: Spawned Thread #{thread.inspect}"
   end

data/example/example_helper.rb

@@ -48,7 +48,12 @@ def server_process &blk
     if ENV['ASIR_JRUBY_SPAWNED']
       $stderr.puts "  spawned server at #{__FILE__}:#{__LINE__}"
       puts "*** #{$$}: server process"; $stdout.flush
-      yield
+      begin
+        yield
+      rescue ::Exception => exc
+        $stderr.puts "*** #{$$}: service ERROR: #{exc.inspect}\n  #{exc.backtrace * "  \n"}"
+        raise exc
+      end
       Process.exit!(0)
       # dont do client, client is our parent process.
     else
@@ -64,7 +69,12 @@ def server_process &blk
     # $stderr.puts "  at #{__FILE__}:#{__LINE__}"
     $server_pid = Process.fork do
       puts "*** #{$$}: server process"; $stdout.flush
-      yield
+      begin
+        yield
+      rescue ::Exception => exc
+        $stderr.puts "*** #{$$}: service ERROR: #{exc.inspect}\n  #{exc.backtrace * "  \n"}"
+        raise exc
+      end
     end
   end
   sleep 1 # wait for server to be ready.

data/lib/asir.rb

@@ -242,6 +242,7 @@ require 'asir/code_block'
 require 'asir/code_more'
 require 'asir/message'
 require 'asir/result'
+require 'asir/message/state'
 require 'asir/client'
 require 'asir/coder'
 require 'asir/coder/null'

data/lib/asir/additional_data.rb

@@ -28,19 +28,19 @@ module ASIR
 
     module ModuleMethods
       # Provide a getter method that delegates to addtional_data[...].
-      def addr_getter *names
+      def addit_getter *names
         names.each do | name |
           name = name.to_sym
-          define_method(name) { | | addtional_data[name] }
+          define_method(name) { | | self[name] }
         end
       end
 
       # Provide getter and setter methods that delegate to addtional_data[...].
-      def addr_accessor *names
+      def addit_accessor *names
         addr_getter *names
         names.each do | name |
           name = name.to_sym
-          define_method(:"#{name}=") { | v | addtional_data[name] = v }
+          define_method(:"#{name}=") { | v | self[name] = v }
         end
       end
     end

data/lib/asir/client.rb

@@ -54,8 +54,7 @@ module ASIR
         message = Message.new(@receiver, selector, arguments, block, self)
         message = @before_send_message.call(message) if @before_send_message
         @__configure.call(message, self) if @__configure
-        result = transport.send_message(message)
-        result
+        transport.send_message(message) # => result
       end
       # Accept all other messages to be encoded and transported to a service.
       alias :method_missing :send

data/lib/asir/identity.rb

@@ -1,5 +1,4 @@
 require 'asir/uuid'
-require 'thread' # Mutex
 
 module ASIR
   # !SLIDE
@@ -8,29 +7,14 @@ module ASIR
   module Identity
     attr_accessor :identifier, :timestamp
 
-    # Optional: Opaque data about the Client that created the Message.
-    attr_accessor :client
-
-    # Optional: Opaque data about the Service that handled the Result.
-    attr_accessor :server
-
     # Creates a thread-safe unique identifier.
     def create_identifier!
-      @identifier ||= 
-        @@identifier_mutex.synchronize do
-          if @@uuid_pid != $$
-            @@uuid_pid = $$
-            @@uuid = nil
-          end
-          "#{@@counter += 1}-#{@@uuid ||= ::ASIR::UUID.generate}".freeze
-        end
+      @identifier ||= ::ASIR::UUID.counter_uuid
     end
-    @@counter ||= 0; @@uuid ||= nil; @@uuid_pid = nil; @@identifier_mutex ||= Mutex.new
 
     # Creates a timestamp.
     def create_timestamp!
-      @timestamp ||= 
-        ::Time.now.gmtime
+      @timestamp ||= ::Time.now.gmtime
     end
   end
 end

data/lib/asir/message/state.rb

@@ -0,0 +1,18 @@
+module ASIR
+  class Message
+  # !SLIDE
+  # Message::State
+  #
+  # Encapsulate the Message, Result and their payloads and other state.
+  # This is passed between Transport#send_request, #receive_request, #send_response, #receive_response.
+  class State
+    include Initialization
+    attr_accessor :message, :result
+    attr_accessor :message_payload, :result_payload
+    attr_accessor :message_opaque, :result_opaque
+    attr_accessor :in_stream, :out_stream
+    attr_accessor :additional_data
+  end
+  end
+end
+

data/lib/asir/transport.rb

@@ -1,6 +1,7 @@
 require 'time'
 require 'asir/thread_variable'
 require 'asir/message/delay'
+require 'asir/message/state'
 require 'asir/transport/conduit'
 
 module ASIR
@@ -23,46 +24,44 @@ module ASIR
     # * Send encoded Message.
     # * Receive decoded Result.
     def send_message message
-      @message_count ||= 0; @message_count += 1
+      @message_count ||= 0; @message_count += 1 # NOT THREAD-SAFE
       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.prepare.encode(message)
-      opaque_result = _send_message(message, message_payload)
-      receive_result(message, opaque_result)
+      state = Message::State.new(:message => message, :message_payload => encoder.prepare.encode(message))
+      @before_send_message.call(self, state) if @before_send_message
+      _send_message(state)
+      receive_result(state)
     end
 
     # !SLIDE
     # Transport#receive_message
     # Receive Message payload from stream.
-    def receive_message stream
-      # $stderr.puts "  #{$$} #{self} 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.prepare.decode(req_and_state.first)
-        message.additional_data!.update(additional_data) if message
-        if @after_receive_message
-          @after_receive_message.call(self, message)
+    def receive_message state
+      @message_count ||= 0; @message_count += 1 # NOT THREAD-SAFE
+      if received = _receive_message(state)
+        if message = state.message = encoder.prepare.decode(state.message_payload)
+          message.additional_data!.update(state.additional_data) if state.additional_data
+          @after_receive_message.call(self, state) if @after_receive_message
+          self
         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
+    def send_result state
+      result = state.result
+      message = state.message
       if @one_way && message.block
         message.block.call(result)
       else
-        # avoid sending back entire Message.
+        # Avoid sending back entire Message in Result.
         result.message = nil unless @coder_needs_result_message
-        result_payload = decoder.prepare.encode(result)
-        _send_result(message, result, result_payload, stream, message_state)
+        state.result_payload = decoder.prepare.encode(result)
+        _send_result(state)
       end
     end
     attr_accessor :coder_needs_result_message
@@ -75,19 +74,24 @@ module ASIR
     # * 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.prepare.decode(result_payload)
+    # * Invoke Exception or return Result value.
+    def receive_result state
+      value = nil
+      return value unless _receive_result(state)
+      result = state.result ||= decoder.prepare.decode(state.result_payload)
+      message = state.message
       if result && ! message.one_way
+        result.message = message
         if exc = result.exception
           invoker.invoke!(exc, self)
         else
           if ! @one_way && message.block
             message.block.call(result)
           end
-          result.result
+          value = result.result
         end
       end
+      value
     end
     # !SLIDE END
 
@@ -118,8 +122,8 @@ module ASIR
     # Proc to call with exception, if exception occurs within #serve_message!, but outside
     # Message#invoke!.
     #
-    # trans.on_exception.call(trans, exception, :message, Message_instance, nil)
-    # trans.on_exception.call(trans, exception, :result, Message_instance, Result_instance)
+    # trans.on_exception.call(trans, exception, :message, message_state)
+    # trans.on_exception.call(trans, exception, :result, message_state)
     attr_accessor :on_exception
 
     attr_accessor :needs_message_identifier, :needs_message_timestamp
@@ -139,15 +143,15 @@ module ASIR
     # !SLIDE
     # Serve a Message.
     def serve_message! in_stream, out_stream
-      message = message_state = message_ok = result = result_ok = nil
+      state = message_ok = result = result_ok = nil
       exception = original_exception = unforwardable_exception = nil
-      message, message_state = receive_message(in_stream)
-      if message
+      state = Message::State.new(:in_stream => in_stream, :out_stream => out_stream)
+      if receive_message(state)
         message_ok = true
-        result = invoke_message!(message)
+        invoke_message!(state)
         result_ok = true
         if @after_invoke_message
-          @after_invoke_message.call(self, message, result)
+          @after_invoke_message.call(self, state)
         end
         self
       else
@@ -156,7 +160,7 @@ module ASIR
     rescue ::Exception => exc
       exception = original_exception = exc
       _log [ :message_error, exc ]
-      @on_exception.call(self, exc, :message, message, nil) if @on_exception
+      @on_exception.call(self, exc, :message, state) if @on_exception
     ensure
       begin
         if message_ok
@@ -165,15 +169,15 @@ module ASIR
             when *Error::Unforwardable.unforwardable
               unforwardable_exception = exception = Error::Unforwardable.new(exception)
             end
-            result = Result.new(message, nil, exception)
+            state.result = Result.new(state.message, nil, exception)
           end
           if out_stream
-            send_result(result, out_stream, message_state)
+            send_result(state)
           end
         end
       rescue ::Exception => exc
-        _log [ :result_error, exc ]
-        @on_exception.call(self, exc, :result, message, result) if @on_exception
+        _log [ :result_error, exc, exc.backtrace ]
+        @on_exception.call(self, exc, :result, state) if @on_exception
       end
       raise original_exception if unforwardable_exception
     end
@@ -227,21 +231,25 @@ module ASIR
     end
 
     # Invokes the Message object, returns a Result object.
-    def invoke_message! message
-      result = nil
+    def invoke_message! state
       Transport.with_attr! :current, self do
-        with_attr! :message, message do
-          wait_for_delay! message
-          result = invoker.invoke!(message, self)
+        with_attr! :message_state, state do
+        with_attr! :message, state.message do
+          wait_for_delay! state.message
+          state.result = invoker.invoke!(state.message, self)
           # Hook for Exceptions.
-          if @on_result_exception && result.exception
-            @on_result_exception.call(self, result)
+          if @on_result_exception && state.result.exception
+            @on_result_exception.call(self, state)
           end
         end
       end
-      result
+      end
+      self
     end
-    # The current Message being handled.
+
+    # The current Message::State.
+    attr_accessor_thread :message_state
+    # The current Message being invoked.  DEPRECATED.
     attr_accessor_thread :message
 
     # The current active Transport.

data/lib/asir/transport/broadcast.rb

@@ -9,23 +9,22 @@ module ASIR
     class Broadcast < self
       include Composite
 
-      def _send_message message, message_payload
+      def _send_message state
         result = first_exception = nil
         transports.each do | transport |
           begin
-            result = transport.send_message(message)
+            result = transport.send_message(state.message)
           rescue ::Exception => exc
             first_exception ||= exc
-            _handle_send_message_exception! transport, message, exc
+            _handle_send_message_exception! transport, state, exc
             raise exc unless @continue_on_exception
           end
         end
         if first_exception && @reraise_first_exception
           raise first_exception
         end
-        result
+        state.result = Result.new(state.message, result)
       end
-
     end
     # !SLIDE END
   end

data/lib/asir/transport/buffer.rb

@@ -25,15 +25,15 @@ module ASIR
 
       # If paused, queue messages,
       # Otherwise delegate immediately to #transport.
-      def _send_message message, message_payload
+      def _send_message state
         return nil if @ignore
         if paused?
           @messages_mutex.synchronize do
-            @messages << message
+            @messages << state.message
           end
           nil
         else
-          @transport.send_message(message)
+          @transport.send_message(state.message)
         end
       end
 
@@ -97,7 +97,7 @@ module ASIR
       # Usually used in worker Thread.
       def process! non_block=false
         @running = true
-        while @running && message = shift(non_block)
+        while @running && (message = shift(non_block))
           @transport.send_message(message)
         end
         message

data/lib/asir/transport/composite.rb

@@ -4,7 +4,7 @@ module ASIR
     # !SLIDE
     # A Transport composed of other Transports.
     #
-    # Classes that mix this in should define #_send_message(message, message_payload).
+    # Classes that mix this in should define #_send_message.
     module Composite
       include Delegation
 

data/lib/asir/transport/conduit.rb

@@ -5,10 +5,11 @@ module Asir
     # Conduit service support.
     module Conduit
       attr_accessor :conduit_options, :conduit_pid
+
       def start_conduit! options = nil
-        opts = { :fork => true }
+        opts = @conduit_options ||= {}
+        opts.update(:fork => true)
         opts.update(options) if options
-        @conduit_options = opts
         _log { "start_conduit! #{self}" } if @verbose >= 1
         in_fork = opts[:fork]
         raise "already running #{@conduit_pid} #{@conduit_cmd}" if @conduit_pid
@@ -19,7 +20,7 @@ module Asir
             raise "Could not exec"
           end
           _log { "start_conduit! #{self} started pid=#{@conduit_pid.inspect}" } if @verbose >= 2
-          if pid_file = @conduit_options[:pid_file]
+          if pid_file = (@conduit_options || EMPTY_HASH)[:pid_file]
             File.open(pid_file, "w") { | fh | fh.puts @conduit_pid }
           end
         else
@@ -29,7 +30,7 @@ module Asir
       end
 
       def conduit_pid
-        if ! @conduit_pid and pid_file = @conduit_options[:pid_file]
+        if ! @conduit_pid and pid_file = (@conduit_options || EMPTY_HASH)[:pid_file]
           @conduit_pid = (File.read(pid_file).to_i rescue nil)
         end
         @conduit_pid
@@ -37,10 +38,11 @@ module Asir
 
       def stop_conduit! opts = nil
         if conduit_pid
-          pid_file = @conduit_options[:pid_file]
           _log { "stop_conduit! #{self} pid=#{@conduit_pid.inspect}" } if @verbose >= 1
           ::Process.kill( (opts && opts[:signal]) || 'TERM', @conduit_pid)
-          ::File.unlink(pid_file) rescue nil if pid_file
+          if pid_file = (@conduit_options || EMPTY_HASH)[:pid_file]
+            ::File.unlink(pid_file) rescue nil
+          end
           ::Process.waitpid @conduit_pid
         end
         self

data/lib/asir/transport/connection_oriented.rb

@@ -52,33 +52,35 @@ module ASIR
 
       # !SLIDE
       # Sends the encoded Message payload String.
-      def _send_message message, message_payload
+      def _send_message state
         stream.with_stream! do | io |
-          _write message_payload, io, message
+          state.in_stream = io
+          _write(state.message_payload, io, state)
         end
       end
 
       # !SLIDE
       # Receives the encoded Message payload String.
-      def _receive_message stream, additional_data
-        [ _read(stream, nil), nil ]
+      def _receive_message state
+        state.message_payload = _read(state.in_stream, state)
       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, message
+      def _send_result state
+        unless @one_way || state.message.one_way
+          # $stderr.write "\n  _send_result #{state.result_payload.inspect}\n\n"
+          _write(state.result_payload, state.out_stream, state)
+          true
         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, message
-          end
+      def _receive_result state
+        unless @one_way || state.message.one_way
+          state.result_payload = _read(state.in_stream, state)
+          true
         end
       end
 
@@ -115,6 +117,7 @@ module ASIR
       end
 
       def serve_connection!
+        _log { "serve_connection!: accepting connection" } if @verbose >= 2
         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

data/lib/asir/transport/database.rb

@@ -19,29 +19,27 @@ module ASIR
         self.needs_message_identifier = true
       end
 
-      def _send_message message, message_payload
+      def _send_message state
         if @before_message_save
-          @before_message_save.call(self, message, message_payload)
+          @before_message_save.call(self, state)
         end
-        message_payload.save!
+        state.message_payload.save!
         # message[:database_id] ||= message_payload.database_id
         if @after_message_save
-          @after_message_save.call(self, message, message_payload)
+          @after_message_save.call(self, state)
         end
-        nil # message_state
       end
 
-      def _send_result message, result, result_payload, stream, message_state
-        return if one_way? or message.one_way?
+      def _send_result state
+        return if one_way? or state.message.one_way?
         if @before_result_save
-          @before_result_save.call(self, message, result, result_payload)
+          @before_result_save.call(self, state)
         end
-        result_payload.save!
+        state.result_payload.save!
         result[:database_id] = result_payload.database_id
         if @after_result_save
-          @after_result_save.call(self, message, result, result_payload)
+          @after_result_save.call(self, state)
         end
-        nil
       end
     end
   end

data/lib/asir/transport/delegation.rb

@@ -14,14 +14,9 @@ module ASIR
       # 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
+      # Return the subTransports' result unmodified from #_send_message.
+      def _receive_result state
+        true
       end
 
       def needs_message_identifier? message
@@ -40,10 +35,10 @@ module ASIR
       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}: #{exc.backtrace.first}"
-        @on_send_message_exception.call(self, message, exc) if @on_send_message_exception
+      def _handle_send_message_exception! transport, state, exc
+        _log { [ :send_message, :transport_failed, exc, exc.backtrace ] }
+        (state.message[:transport_exceptions] ||= [ ]) << "#{exc.inspect}: #{exc.backtrace.first}"
+        @on_send_message_exception.call(self, state, exc) if @on_send_message_exception
         self
       end
     end

data/lib/asir/transport/demux.rb

@@ -23,8 +23,8 @@ module ASIR
         end
       end
 
-      def _send_message message, message_payload
-        transport.send_message(message)
+      def _send_message state
+        transport.send_message(state.message)
       end
     end
     # !SLIDE END

data/lib/asir/transport/fallback.rb

@@ -7,16 +7,16 @@ module ASIR
     class Fallback < self
       include Composite
 
-      def _send_message message, message_payload
+      def _send_message state
         result = sent = first_exception = nil
         transports.each do | transport |
           begin
-            result = transport.send_message(message)
+            result = transport.send_message(state.message)
             sent = true
             break
           rescue ::Exception => exc
             first_exception ||= exc
-            _handle_send_message_exception! transport, message, exc
+            _handle_send_message_exception! transport, state, exc
           end
         end
         unless sent
@@ -25,7 +25,7 @@ module ASIR
           end
           raise FallbackError, "fallback failed"
         end
-        result
+        state.result = Result.new(state.message, result)
       end
       class FallbackError < Error; end
     end

data/lib/asir/transport/file.rb

@@ -15,24 +15,24 @@ module ASIR
       def initialize opts = nil; @one_way = true; super; end
 
       # Writes a Message payload String.
-      def _send_message message, message_payload
-        _write message_payload, stream, message
+      def _send_message state
+        _write(state.message_payload, state.out_stream || stream, state)
       ensure
         close if file && ::File.pipe?(file)
       end
 
       # Returns a Message payload String.
-      def _receive_message stream, additional_data
-        [ _read(stream, nil), nil ]
+      def _receive_message state
+        state.message_payload = _read(state.in_stream || stream, state)
       end
 
       # one-way; no Result.
-      def _send_result message, result, result_payload, stream, message_state
+      def _send_result state
         nil
       end
 
       # one-way; no Result.
-      def _receive_result message, opaque_result
+      def _receive_result state
         nil
       end
 
@@ -63,7 +63,6 @@ module ASIR
       # Named Pipe Server
 
       def prepare_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
@@ -72,7 +71,6 @@ module ASIR
       alias :prepare_pipe_server! :prepare_server!
 
       def run_server!
-        # _log [ :run_pipe_server!, file ]
         with_server_signals! do
           @running = true
           while @running

data/lib/asir/transport/http.rb

@@ -30,18 +30,23 @@ module ASIR
 
       # Send the Message payload String using HTTP POST.
       # Returns the HTTPClient::Request response object.
-      def _send_message message, message_payload
+      def _send_message state
         client.with_stream! do | client |
-          client.post(uri, message_payload)
+          state.in_stream =
+            client.post(message_uri(state), state.message_payload)
         end
       end
 
+      # Subclasses can override.
+      def message_uri state
+        state.message[:uri] || uri
+      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
+      def _receive_result state
+        state.result_payload =
+          state.in_stream.content.to_s
       end
 
       CONTENT_TYPE = 'Content-Type'.freeze

data/lib/asir/transport/local.rb

@@ -6,14 +6,16 @@ module ASIR
     # 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)
+      # Capture Result object after invoking Message.
+      def _send_message state
+        invoke_message!(state)
+        self
       end
 
-      # Returns Result object from #send_message.
-      def _receive_result message, opaque_result
-        opaque_result
+      # Result object was captured in #_send_message.
+      def _receive_result state
+        state.result_payload = state.result
+        self
       end
     end
     # !SLIDE END

data/lib/asir/transport/null.rb

@@ -5,7 +5,7 @@ module ASIR
     #
     # Never send Message.
     class Null < self
-      def _send_message message, message_payload
+      def _send_message state
         nil
       end
     end

data/lib/asir/transport/payload_io.rb

@@ -14,7 +14,7 @@ module ASIR
       HEADER = "# asir_payload_size: "
       FOOTER = "\n# asir_payload_end"
 
-      def _write payload, stream, context
+      def _write payload, stream, state
         stream.write HEADER
         stream.puts payload.size
         stream.write payload
@@ -23,7 +23,7 @@ module ASIR
         stream
       end
 
-      def _read stream, context
+      def _read stream, state
         size = /\d+$/.match(stream.readline.chomp)[0].to_i # HEADER (size)
         payload = stream.read(size)
         stream.readline # FOOTER

data/lib/asir/transport/rack.rb

@@ -7,17 +7,16 @@ module ASIR
     # 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 ]
+      def _receive_message state
+        rack_request = state.in_stream
+        state.message_payload = rack_request.body.read
       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]
+      def _send_result state
+        rack_response = state.out_stream
         rack_response[CONTENT_TYPE] = APPLICATION_BINARY
-        rack_response.write result_payload
+        rack_response.write state.result_payload
       end
 
       # Constructs a Rackable App from this Transport.
@@ -41,8 +40,7 @@ module ASIR
       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
+        serve_message! rq, rs
         rs.finish # => [ status, header, rbody ]
       end
 

data/lib/asir/transport/retry.rb

@@ -13,19 +13,20 @@ module ASIR
       # Proc to call(transport, message) before retry.
       attr_accessor :before_retry
 
-      def _send_message message, message_payload
+      def _send_message state
         first_exception = nil
         with_retry do | action, data |
           case action
           when :try
-            transport.send_message(message)
+            result = transport.send_message(state.message)
+            state.result = Result.new(state.message, result)
           when :rescue #, exc
             first_exception ||= data
-            _handle_send_message_exception! transport, message, data
+            _handle_send_message_exception! transport, state, data
           when :retry #, exc
-            before_retry.call(self, message) if before_retry
+            before_retry.call(self, state) if before_retry
           when :failed
-            @on_failed_message.call(self, message) if @on_failed_message
+            @on_failed_message.call(self, state) if @on_failed_message
             if first_exception && @reraise_first_exception
               $! = first_exception
               raise

data/lib/asir/transport/subprocess.rb

@@ -11,18 +11,19 @@ module ASIR
         @one_way = true; super
       end
 
-      def _send_message message, message_payload
+      def _send_message state
         Process.fork do
-          send_result(super, nil, nil)
+          super
+          send_result(state)
         end
       end
 
       # one-way; no Result
-      def _receive_result message, opaque_result
+      def _receive_result state
       end
 
       # one-way; no Result
-      def _send_result message, result, result_payload, stream, message_state
+      def _send_result state
       end
     end
     # !SLIDE END

data/lib/asir/transport/tcp_socket.rb

@@ -9,14 +9,14 @@ module ASIR
       # !SLIDE
       # TCP Socket Client
       def _client_connect!
-        sock = TCPSocket.open(host, port)
+        sock = ::TCPSocket.open(host, port)
       end
 
       # !SLIDE
       # TCP Socket Server
       def _server!
-        @server = TCPServer.open(port)
-        @server.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, false)
+        @server = ::TCPServer.open(port)
+        @server.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, false)
       end
 
       def _server_accept_connection! server
@@ -24,8 +24,8 @@ module ASIR
         [ socket, socket ] # Use same socket for in_stream and out_stream
       end
 
-      def _server_close_connection! stream, out_stream
-        stream.close rescue nil
+      def _server_close_connection! in_stream, out_stream
+        in_stream.close rescue nil
       end
     end
     # !SLIDE END

data/lib/asir/transport/thread.rb

@@ -12,7 +12,7 @@ module ASIR
       # Defaults to ::Thread.
       attr_accessor :thread_class
 
-      # Callback: call(self, message, thr).
+      # Callback: call(self, MessageState, thr).
       attr_accessor :after_thread_new
 
       def initialize *args
@@ -20,20 +20,26 @@ module ASIR
         @one_way = true; super
       end
 
-      def _send_message message, message_payload
+      def _send_message state
         thr = thread_class.new do
-          send_result(super, nil, nil)
+          super
+          send_result(state)
         end
-        @after_thread_new.call(self, message, thr) if @after_thread_new
+        state.in_stream = thr
+        @after_thread_new.call(self, state, thr) if @after_thread_new
         thr
       end
 
       # one-way; no Result
-      def _receive_result message, opaque_result
+      def _receive_result state
       end
 
       # one-way; no Result
-      def _send_result message, result, result_payload, stream, message_state
+      def _send_result state
+      end
+
+      # one-may; no Result
+      def receive_result state
       end
     end
     # !SLIDE END

data/lib/asir/transport/webrick.rb

@@ -9,16 +9,18 @@ module ASIR
 
       # Server-side: WEBrick
 
-      # Receive the Message payload String from the HTTP Message object.
-      # Returns the original http_message as the message_state.
-      def _receive_message http_message, additional_data
-        [ http_message.body, http_message ]
+      # Receive the Message payload from the HTTP Message body.
+      def _receive_message state
+        http_message = state.in_stream
+        state.message_payload = http_message.body
+        state.message_opaque  = http_message
       end
 
-      # Send the Result payload String in the HTTP Response object as application/binary.
-      def _send_result message, result, result_payload, http_result, message_state
+      # Send the Result payload in the HTTP Response body as application/binary.
+      def _send_result state
+        http_result = state.out_stream
         http_result[CONTENT_TYPE] = APPLICATION_BINARY
-        http_result.body = result_payload
+        http_result.body = state.result_payload
       end
 
       def prepare_server! opts = { }

data/lib/asir/uuid.rb

@@ -1,3 +1,5 @@
+require 'thread'
+
 module ASIR
 # Provides an RFC4122-compliant random (version 4) UUID service.
 module UUID
@@ -13,19 +15,55 @@ module UUID
   PROC_SYS_FILE = "/proc/sys/kernel/random/uuid".freeze
   case
   when File.exist?(PROC_SYS_FILE)
-    def self.generate
+    def new_uuid
       File.read(PROC_SYS_FILE).chomp!
     end
   when (gem 'uuid' rescue nil)
     require 'uuid'
-    def self.generate
+    def new_uuid
       ::UUID.generate
     end
   else
-    def self.generate
+    def new_uuid
       raise "Unimplemented"
     end
   end
+  UUID_REGEX = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\Z/i
+
+  def process_uuid
+    @@process_uuid_mutex.synchronize do
+      if @@pid != $$
+        @@pid = $$
+        @@process_uuid = nil
+      end
+      @@process_uuid ||= new_uuid
+    end
+  end
+  @@pid = @@process_uuid = nil
+  @@process_uuid_mutex = Mutex.new
+
+  def counter_uuid
+    i = @@counter_mutex.synchronize do
+      @@counter += 1
+    end
+    "#{i}-#{process_uuid}"
+  end
+  @@counter ||= 0
+  @@counter_mutex = Mutex.new
+  COUNTER_UUID_REGEX = /\A[0-9]+-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\Z/i
+
+  # Returns a unique counter_uuid for a Thread.
+  # thr defaults to Thread.current.
+  def thread_uuid thr = nil
+    thr ||= Thread.current
+    thr[:'ASIR::UUID.thread_uuid'] || @@thread_uuid_mutex.synchronize do
+      thr[:'ASIR::UUID.thread_uuid'] = counter_uuid
+    end
+  end
+  @@thread_uuid_mutex = Mutex.new
+
+  extend self
+  alias :generate :new_uuid # DEPRECATED
 end
 end
 

data/lib/asir/version.rb

@@ -1,3 +1,3 @@
 module ASIR
-  VERSION = "1.1.12"
+  VERSION = "1.2.0"
 end

data/spec/transport_spec.rb

@@ -40,10 +40,10 @@ describe "ASIR::Transport" do
   end
 
   it 'should handle on_result_exception callbacks' do
-    _transport, _result = nil, nil
-    p = lambda do | transport, result |
+    _transport, _message_result = nil, nil
+    p = lambda do | transport, message_result |
       _transport = transport
-      _result = result
+      _message_result = message_result
     end
     transport.on_result_exception = p
 
@@ -71,12 +71,17 @@ describe "ASIR::Transport" do
 
     _transport.should == object.transport
 
+    _result = _message_result.result
     _result.class.should == ASIR::Result
     _result.object_id.should == result.object_id
 
     _result.message.class.should == ASIR::Message
     _result.message.object_id.should == result.message.object_id
     _result.exception.should == exc
+
+    _message = _message_result.message
+    _message.object_id.should == _message_result.message.object_id
+
   end
 end
 

data/spec/uuid_spec.rb

@@ -0,0 +1,76 @@
+require 'asir/uuid'
+
+describe "ASIR::UUID" do
+  attr_accessor :u
+  before { @u = ASIR::UUID }
+
+  it 'should return a UUID from #new_uuid.' do
+    x = u.new_uuid
+    x.should =~ ASIR::UUID::UUID_REGEX
+  end
+
+  it 'should return unique result from #new_uuid.' do
+    a = [ ]
+    10.times do
+      x = u.new_uuid
+      x.should =~ ASIR::UUID::UUID_REGEX
+      a << u.new_uuid
+    end
+    a.uniq.size.should == 10
+  end
+
+  it 'should single unique result per process from #process_uuid.' do
+    a = [ ]
+    10.times do
+      x = u.process_uuid
+      x.should =~ ASIR::UUID::UUID_REGEX
+      a << u.process_uuid
+      a << u.generate
+    end
+    a.uniq.size.should == 11
+  end
+
+  it 'should single unique result per process from #counter_uuid.' do
+    a = [ ]
+    10.times do
+      x = u.counter_uuid
+      x.should =~ ASIR::UUID::COUNTER_UUID_REGEX
+      a << x
+      a << u.process_uuid
+      a << u.generate
+    end
+    a.uniq.size.should == 21
+  end
+
+  it 'should single unique result per Thread from #thread_uuid.' do
+    a = [ ]
+    10.times do
+      x = u.thread_uuid
+      x.should =~ ASIR::UUID::COUNTER_UUID_REGEX
+      a << x
+      a << u.generate
+      a << u.process_uuid
+    end
+    a.uniq.size.should == 12
+
+    a = [ ]
+    b = [ ]
+    t1 = Thread.current
+    t2 = Thread.new do
+      10.times do
+        b << u.thread_uuid(t1)
+        b << u.thread_uuid(t2)
+      end
+    end
+    10.times do
+      a << u.thread_uuid(t1)
+      a << u.thread_uuid(t2)
+    end
+
+    t2.join
+    c = a + b
+    c.uniq.size.should == 2
+  end
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asir
 version: !ruby/object:Gem::Version
-  version: 1.1.12
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -221,6 +221,7 @@ files:
 - lib/asir/main.rb
 - lib/asir/message.rb
 - lib/asir/message/delay.rb
+- lib/asir/message/state.rb
 - lib/asir/object_resolving.rb
 - lib/asir/poll_throttle.rb
 - lib/asir/result.rb
@@ -264,6 +265,7 @@ files:
 - spec/thread_pool_spec.rb
 - spec/thread_variable_spec.rb
 - spec/transport_spec.rb
+- spec/uuid_spec.rb
 - spec/yaml_spec.rb
 - stylesheets/slides.css
 homepage: http://github.com/kstephens/abstracting_services_in_ruby
@@ -303,4 +305,5 @@ test_files:
 - spec/thread_pool_spec.rb
 - spec/thread_variable_spec.rb
 - spec/transport_spec.rb
+- spec/uuid_spec.rb
 - spec/yaml_spec.rb