asir 0.2.0

data/lib/asir/client.rb

@@ -0,0 +1,111 @@
+module ASIR
+  # !SLIDE
+  # Client support for any Module
+  #
+  # Extend Module with #client proxy support.
+  module Client
+    # !SLIDE
+    # Client Mixin
+    def self.included target
+      super
+      target.extend ModuleMethods if Module === target
+      target.send(:include, InstanceMethods) if Class === target
+    end
+
+    module CommonMethods
+      def client_options &blk
+        client._configure(&blk)
+      end
+    end
+
+    module ModuleMethods
+      include CommonMethods
+      # Proxies are cached for Module/Class methods because serialization will not include
+      # Transport.
+      def client
+        @_asir_client ||= ASIR::Client::Proxy.new(self)
+      end
+    end
+
+    module InstanceMethods
+      include CommonMethods
+      # Proxies are not cached in instances because receiver is to be serialized by
+      # its Transport's Coder.
+      def client
+        ASIR::Client::Proxy.new(self)
+      end
+    end
+
+    # !SLIDE
+    # Client Proxy
+    #
+    # Provide client interface proxy to a service.
+    class Proxy
+      attr_accessor :receiver
+
+      # Accept messages as a proxy for the receiver.
+      # Blocks are used represent a "continuation" for the Result.
+      def send selector, *arguments, &block
+        message = Message.new(@receiver, selector, arguments, block, self)
+        message = @before_send_message.call(message) if @before_send_message
+        @__configure.call(message) if @__configure
+        result = transport.send_message(message)
+        result
+      end
+      # Accept all other messages to be encoded and transported to a service.
+      alias :method_missing :send
+
+      # !SLIDE
+      # Client Transport
+      attr_accessor :transport
+
+      def transport
+        @transport ||= Transport::Local.new
+      end
+
+      # !SLIDE
+      # Proxy Configuration
+
+      # A Proc to call with the Message object before sending to transport#send_message(message).
+      # Must return a Message object.
+      attr_accessor :before_send_message
+
+      # If true, this Message is one-way, even if the Transport is bi-directional.
+      attr_accessor :_one_way
+
+      # A Proc to call with the Message object before sending to transport#send_message(message).
+      # See #_configure.
+      attr_accessor :__configure
+
+      # Returns a new Client Proxy with a block to be called with the Message.
+      # This block can configure additional options of the Message before
+      # it is sent to the Transport.
+      def _configure &blk
+        proxy = self.dup
+        proxy.__configure = blk
+        proxy
+      end
+      alias :_options :_configure
+
+      # !SLIDE
+      # Configuration Callbacks
+
+      def initialize rcvr
+        key = Module === (@receiver = rcvr) ? @receiver : @receiver.class
+        (@@config_callbacks[key] || 
+         @@config_callbacks[key.name] || 
+         @@config_callbacks[nil] ||
+         IDENTITY_LAMBDA).call(self)
+      end
+
+      @@config_callbacks ||= { }
+      def self.config_callbacks
+        @@config_callbacks
+      end
+
+      # !SLIDE END
+    end
+    # !SLIDE END
+  end
+  # !SLIDE END
+end

data/lib/asir/code_block.rb

@@ -0,0 +1,57 @@
+module ASIR
+  # !SLIDE
+  # Code Block
+  #
+  # Encode/decode Message#block.
+  module CodeBlock
+    # Most coders cannot serialize Procs.
+    # But we can attempt to serialize a String representing a Proc.
+    def encode_block!
+      obj = nil
+      if @block && ! ::String === @block_code
+        obj ||= self.dup
+        obj.block_code = CodeBlock.block_to_code(obj.block)
+        obj.block = nil 
+      end
+      obj
+    end
+
+    def decode_block!
+      if ::String === @block_code
+        @block ||= CodeBlock.code_to_block(@block_code)
+        @block_code = nil
+      end
+      self
+    end
+
+    # Returns a block_cache Hash.
+    # Flushed every 1000 accesses.
+    def self.block_cache
+      cache = Thread.current[:'ASIR::CodeBlock.block_cache'] ||= { }
+      count = Thread.current[:'ASIR::CodeBlock.block_cache_count'] ||= 0
+      count += 1
+      if count >= 1000
+        cache.clear
+        count = 0
+      end
+      Thread.current[:'ASIR::CodeBlock.block_cache_count'] = count
+      cache
+    end
+
+    # Uses ruby2ruby, if loaded.
+    def self.block_to_code block
+      (block_cache[block.object_id] ||=
+        [ block.respond_to?(:to_ruby) && block.to_ruby, block ]).
+        first
+    end
+
+    # Calls eval.
+    # May be unsafe.
+    def self.code_to_block code
+      (block_cache[code.dup.freeze] ||=
+        [ eval(@block_code), code ]).
+        first
+    end
+
+  end
+end

data/lib/asir/code_more.rb

@@ -0,0 +1,50 @@
+module ASIR
+  # !SLIDE
+  # Code More
+  #
+  # Help encode/decode and resolve receiver class.
+  module CodeMore
+    include ObjectResolving # resolve_object()
+    include CodeBlock # encode_block!, decode_block!
+
+    def encode_more!
+      obj = encode_block! # may self.dup
+      unless ::String === @receiver_class
+        obj ||= self.dup # dont dup twice.
+        obj.receiver = @receiver.name if ::Module === @receiver
+        obj.receiver_class = @receiver_class.name
+        if resp = obj.result and resp.message == self
+          resp.message = obj
+        end
+      end
+      obj || self
+    end
+
+    def decode_more!
+      decode_block!
+      if ::String === @receiver_class
+        @receiver_class = resolve_object(@receiver_class)
+        @receiver = resolve_object(@receiver) if ::Module === @receiver_class
+        unless @receiver_class === @receiver
+          raise Error, "receiver #{@receiver.class.name} is not a #{@receiver_class}" 
+        end
+      end
+      self
+    end
+
+    # Mixin for Result.
+    module Result
+      def encode_more!
+        @message = @message.encode_more! if @message
+        self
+      end
+
+      def decode_more!
+        @message = @message.decode_more! if @message
+        self
+      end
+    end
+  end
+  # !SLIDE END
+end
+

data/lib/asir/coder.rb

@@ -0,0 +1,26 @@
+module ASIR
+  # !SLIDE
+  # Coder
+  #
+  # Define encoding and decoding for Messages and Results along a Transport.
+  class Coder
+    include Log, Initialization
+
+    def encode obj
+      _encode obj
+    end
+
+    def decode obj
+      obj and _decode obj
+    end
+
+    # Coder subclasses:
+    def _subclass_responsibility *args
+      raise "subclass responsibility"
+    end
+    alias :_encode :_subclass_responsibility
+    alias :_decode :_subclass_responsibility
+  end
+  # !SLIDE END
+end
+

data/lib/asir/coder/base64.rb

@@ -0,0 +1,19 @@
+require 'asir'
+
+require 'base64'
+
+module ASIR
+  class Coder
+    class Base64 < self
+      def _encode obj
+        raise TypeError unless String === obj
+        ::Base64.encode64(obj)
+      end
+      def _decode obj
+        raise TypeError unless String === obj
+        ::Base64.decode64(obj)
+      end
+    end
+  end
+end
+

data/lib/asir/coder/chain.rb

@@ -0,0 +1,30 @@
+module ASIR
+  class Coder
+    # !SLIDE
+    # Chain Coder
+    # Chain multiple Coders as one.
+    #
+    # @@@ text
+    # message  --> | e1 | --> | e2 | --> | eN | -->
+    # result   <-- | d1 | <-- | d2 | <-- | dN | <--
+    # @@@
+    class Chain < self
+      attr_accessor :encoders
+
+      def _encode obj
+        encoders.each do | e |
+          obj = e.dup.encode(obj)
+        end
+        obj
+      end
+
+      def _decode obj
+        encoders.reverse_each do | e |
+          obj = e.dup.decode(obj)
+        end
+        obj
+      end
+    end
+  end
+end
+

data/lib/asir/coder/identity.rb

@@ -0,0 +1,23 @@
+require 'asir/coder'
+
+module ASIR
+  class Coder
+    # !SLIDE
+    # Identity Coder
+    # Perform no encode/decode.
+    class Identity < self
+      def _encode obj
+        obj
+      end
+
+      def _decode obj
+        obj
+      end
+
+      # Completely stateless.
+      def dup; self; end
+    end
+    # !SLIDE END
+  end
+end
+

data/lib/asir/coder/json.rb

@@ -0,0 +1,30 @@
+require 'asir'
+
+module ASIR
+  class Coder
+    # !SLIDE
+    # JSON Coder
+    #
+    # Note: Symbols are not handled.
+    # The actual JSON expression is wrapped with an Array.
+    class JSON < self
+      def _encode obj
+        [ obj ].to_json
+      end
+
+      def _decode obj
+        parser = ::JSON.parser.new(obj)
+        ary = parser.parse
+        ary.first
+      end
+    end
+    # !SLIDE END
+  end
+end
+
+if RUBY_PLATFORM =~ /java/
+require 'json'
+else
+require 'json/ext'
+end
+

data/lib/asir/coder/marshal.rb

@@ -0,0 +1,17 @@
+module ASIR
+  class Coder
+    # !SLIDE
+    # Marshal Coder
+    # Use Ruby Marshal for encode/decode.
+    class Marshal < self
+      def _encode obj
+        ::Marshal.dump(obj)
+      end
+
+      def _decode obj
+        ::Marshal.load(obj)
+      end
+    end # class
+    # !SLIDE END
+  end # class
+end # module

data/lib/asir/coder/null.rb

@@ -0,0 +1,23 @@
+require 'asir/coder'
+
+module ASIR
+  class Coder
+    # !SLIDE
+    # Null Coder
+    # Always encode/decode as nil.
+    class Null < self
+      def _encode obj
+        nil
+      end
+
+      def _decode obj
+        nil
+      end
+
+      # Completely stateless.
+      def dup; self; end
+    end
+    # !SLIDE END
+  end
+end
+

data/lib/asir/coder/proc.rb

@@ -0,0 +1,22 @@
+require 'asir'
+
+module ASIR
+  class Coder
+    # !SLIDE
+    # Proc Coder
+    # Generic Proc-based coder.
+    class Proc < self
+      # Procs that take one argument.
+      attr_accessor :encoder, :decoder
+
+      def _encode obj
+        @encoder.call(obj)
+      end
+      def _decode obj
+        @decoder.call(obj)
+      end
+    end
+    # !SLIDE END
+  end
+end
+

data/lib/asir/coder/sign.rb

@@ -0,0 +1,48 @@
+require 'digest/sha1'
+
+module ASIR
+  class Coder
+    # !SLIDE
+    # Sign Coder
+    #
+    # Sign payload during encode, check signature during decode.
+    #
+    # Signature is the digest of secret + payload.
+    #
+    # Encode payload as Hash containing the digest function name, signature and payload.
+    # Decode and validate Hash containing the digest function name, signature and payload.
+    #
+    class Sign < self
+      attr_accessor :secret, :function
+
+      def _encode obj
+        payload = obj.to_s
+        { :function  => function,
+          :signature => ::Digest.const_get(function).
+                          new.hexdigest(secret + payload),
+          :payload   => payload }
+      end
+
+      def _decode obj
+        raise SignatureError, "expected Hash, given #{obj.class}" unless Hash === obj
+        payload = obj[:payload]
+        raise SignatureError, "signature invalid" unless obj == _encode(payload)
+        payload
+      end
+
+      # !SLIDE
+      # Sign Coder Support
+
+      # Signature Error.
+      class SignatureError < Error; end
+
+      def initialize_before_opts
+        @function = :SHA1
+      end
+      # !SLIDE END
+    end 
+    # !SLIDE END
+  end # class
+end # class
+
+