asir 0.2.0 → 1.0.1

data/hack_night/exercise/prob-6.rb

@@ -81,9 +81,9 @@ begin
 
   # system("curl http://localhost:#{port}/")
 
-  MathService.client.transport = t
+  MathService.asir.transport = t
 
-  MathService.client.sum([1, 2, 3])
+  MathService.asir.sum([1, 2, 3])
 
 rescue Exception => err
   $stderr.puts "ERROR: #{err.inspect}\n#{err.backtrace * "\n"}"

data/hack_night/exercise/prob-7.rb

@@ -21,8 +21,8 @@ begin
   end
   sleep 1 # wait for server to start
 
-  MathService.client.transport = t
-  MathService.client.sum([1, 2, 3])
+  MathService.asir.transport = t
+  MathService.asir.sum([1, 2, 3])
 
 rescue Exception => err
   $stderr.puts "ERROR: #{err.inspect}\n#{err.backtrace * "\n"}"

data/hack_night/solution/prob-2.rb

@@ -10,6 +10,6 @@ MathService.send(:include, ASIR::Client)
 # Driver:
 
 begin
-  MathService.client.transport._log_enabled = true
-  puts MathService.client.sum([1, 2, 3])
+  MathService.asir.transport._log_enabled = true
+  puts MathService.asir.sum([1, 2, 3])
 end

data/hack_night/solution/prob-3.rb

@@ -11,7 +11,7 @@ MathService.send(:include, ASIR::Client)
 # Driver:
 
 begin
-  MathService.client.transport = ASIR::Transport::Subprocess.new
-  MathService.client.transport._log_enabled = true
-  puts MathService.client.sum([1, 2, 3])
+  MathService.asir.transport = ASIR::Transport::Subprocess.new
+  MathService.asir.transport._log_enabled = true
+  puts MathService.asir.sum([1, 2, 3])
 end

data/hack_night/solution/prob-6.rb

@@ -1,7 +1,8 @@
 # Write a ASIR::Transport::HTTP class that uses HTTP::Client for transport send_result and receive_result.
+# And WEBrick to handle requests.
 
 $: << File.expand_path("../../../lib", __FILE__)
-require 'asir/transport/http'
+require 'asir/transport/webrick'
 require 'asir/coder/marshal'
 
 require 'math_service'
@@ -9,19 +10,19 @@ MathService.send(:include, ASIR::Client)
 
 port = 3001
 begin
-  t = ASIR::Transport::HTTP.new(:uri => "http://localhost:#{port}/")
+  t = ASIR::Transport::Webrick.new(:uri => "http://localhost:#{port}/")
   t._log_enabled = true
   c = t.encoder = ASIR::Coder::Marshal.new
   c._log_enabled = true
 
   server_pid = Process.fork do
-    t.setup_webrick_server!
-    t.start_webrick_server!
+    t.prepare_server!
+    t.run_server!
   end
   sleep 1 # wait for server to start
 
-  MathService.client.transport = t
-  MathService.client.sum([1, 2, 3])
+  MathService.asir.transport = t
+  MathService.asir.sum([1, 2, 3])
 
 rescue Exception => err
   $stderr.puts "ERROR: #{err.inspect}\n#{err.backtrace * "\n"}"

data/hack_night/solution/prob-7.rb

@@ -1,7 +1,7 @@
 # Use the Marshal and Base64 coders in prob-4.rb
 
 $: << File.expand_path("../../../lib", __FILE__)
-require 'asir/transport/http'
+require 'asir/transport/webrick'
 require 'asir/coder/marshal'
 require 'asir/coder/base64'
 require 'asir/coder/chain'
@@ -11,7 +11,7 @@ MathService.send(:include, ASIR::Client)
 
 port = 3001
 begin
-  t = ASIR::Transport::HTTP.new(:uri => "http://localhost:#{port}/")
+  t = ASIR::Transport::Webrick.new(:uri => "http://localhost:#{port}/")
   t._log_enabled = true
   c = t.encoder = ASIR::Coder::Chain.new(:encoders =>
                                          [ 
@@ -21,13 +21,13 @@ begin
   c._log_enabled = true
 
   server_pid = Process.fork do
-    t.setup_webrick_server!
-    t.start_webrick_server!
+    t.prepare_server!
+    t.run_server!
   end
   sleep 1 # wait for server to start
 
-  MathService.client.transport = t
-  MathService.client.sum([1, 2, 3])
+  MathService.asir.transport = t
+  MathService.asir.sum([1, 2, 3])
 rescue Exception => err
   $stderr.puts "ERROR: #{err.inspect}\n#{err.backtrace * "\n"}"
 ensure

data/lib/asir.rb

@@ -3,7 +3,7 @@
 #
 # * Kurt Stephens
 # * Enova Financial
-# * 2012/04/02
+# * 2012/07/18
 # * Slides -- "":http://kurtstephens.com/pub/ruby/abstracting_services_in_ruby/asir.slides/
 # * Code -- "":http://kurtstephens.com/pub/ruby/abstracting_services_in_ruby/
 # * Git -- "":http://github.com/kstephens/abstracting_services_in_ruby
@@ -34,7 +34,7 @@
 # * Directionality: One-way, Two-way
 # * Synchronicity: Synchronous, Asynchronous, Delayed, Buffered
 # * Distribution: Local Thread, Local Process, Distributed
-# * Transport: File, IPC, Pipe, Network
+# * Transport: File, IPC, Pipe, Network, Beanstalk, ZMQ, Resque
 # * Robustness: Retry, Replay, Fallback
 # * Encoding: XML, JSON, YAML, Base64, Compression
 #
@@ -73,11 +73,11 @@
 # !SLIDE
 # Messaging
 #
-# * "Call a Method", "Call a Function" are all the same, in *all* languages.
+# * "Send a Message", "Call a Function" are all the same, in *all* languages.
 # ** Decomposed into lookup() and apply().
-# * "Send Message", not "Call a Method".
+# * "Send a Message", not "Call a Method".
 # * Messaging abstracts:
-# ** Object use from its implementation.
+# ** Behavior from Implementation.
 # ** Transfer of control (method, function invocation, RPC, etc).
 
 # !SLIDE
@@ -111,8 +111,8 @@
 # * Proxy
 # * Message -> Just a Ruby message.
 # * Result, Exception (two-way) -> Return value or else.
-# * Transport -> (file, pipe, http, queue, ActiveResource)
-# * Encoder, Decoder -> Coder (Marshal, XML, JSON, ActiveResource)
+# * Transport -> (file, pipe, http, queue, socket, ZMQ).
+# * Encoder, Decoder -> Coder (Marshal, XML, JSON, zlib).
 #
 # !SLIDE END
 
@@ -127,6 +127,25 @@
 #
 # !SLIDE END
 
+# !SLIDE
+# Abstraction Leads to Rich Features
+#
+# * One-way and two-way requests as Module or instance methods.
+# * Message support:
+# ** Delayed Messages.
+# * Transports:
+# ** Null, Local, File, Named Pipe, TCP.
+# ** HTTP under WEBrick or as Rack application.
+# ** Beanstalkd, ZeroMQ, Resque.
+# ** Buffered, Broadcast, Fallback, Demux transports.
+# ** Time-decaying retry logic.
+# * Encodings:
+# ** Marshal, XML, JSON, YAML, Base64, ZLib.
+# ** Chained encodings.
+# ** Signed payloads.
+#
+# !SLIDE END
+
 # !SLIDE
 # Simple
 #
@@ -211,11 +230,13 @@ end
 Asir = ASIR
 
 require "asir/version"
+require 'asir/config'
 require 'asir/error'
 require 'asir/log'
 require 'asir/initialization'
 require 'asir/additional_data'
 require 'asir/object_resolving'
+require 'asir/thread_variable'
 require 'asir/identity'
 require 'asir/code_block'
 require 'asir/code_more'
@@ -226,6 +247,7 @@ require 'asir/coder'
 require 'asir/coder/null'
 require 'asir/coder/identity'
 require 'asir/transport'
+require 'asir/invoker'
 require 'asir/channel'
 require 'asir/transport/local'
 

data/lib/asir/additional_data.rb

@@ -19,6 +19,31 @@ module ASIR
     def []= key, value
       (@additional_data ||= { })[key] = value
     end
+
+    def self.included target
+      super
+      target.extend(ModuleMethods)
+    end
+
+    module ModuleMethods
+      # Provide a getter method that delegates to addtional_data[...].
+      def addr_getter *names
+        names.each do | name |
+          name = name.to_sym
+          define_method(name) { | | addtional_data[name] }
+        end
+      end
+
+      # Provide getter and setter methods that delegate to addtional_data[...].
+      def addr_accessor *names
+        addr_getter *names
+        names.each do | name |
+          name = name.to_sym
+          define_method(:"#{name}=") { | v | addtional_data[name] = v }
+        end
+      end
+    end
+
   end
   # !SLIDE END
 end

data/lib/asir/channel.rb

@@ -10,11 +10,11 @@ module ASIR
     attr_accessor :on_connect, :on_close, :on_retry, :on_error
     
     ON_ERROR = lambda do | channel, exc, action, stream |
-      channel.close rescue nil if stream
+      channel.close rescue nil
       raise exc
     end
     ON_CLOSE = lambda do | channel, stream |
-      stream.close
+      stream.close rescue nil if stream
     end
     ON_RETRY = lambda do | channel, exc, action |
     end
@@ -101,9 +101,8 @@ module ASIR
     # Maps from Channel objects to actual stream.
     def _streams
       streams = Thread.current[:'ASIR::Channel._streams'] ||= { }
-      if ! @owning_process ||
-          @owning_process != $$ || # child process?
-          @owning_process > $$ # PIDs wrapped around?
+      if  @owning_process != $$ || # child process?
+          @owning_process > $$     # PIDs wrapped around?
         @owning_process = $$
         streams.clear
       end

data/lib/asir/client.rb

@@ -13,27 +13,32 @@ module ASIR
     end
 
     module CommonMethods
-      def client_options &blk
-        client._configure(&blk)
+      def asir_options &blk
+        asir._configure(&blk)
       end
+      alias_method :"#{ASIR::Config.client_method}_options", :asir_options if ASIR::Config.client_method
     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)
+      def asir
+        @_asir ||= ASIR::Client::Proxy.new(self, self)
       end
+      alias_method ASIR::Config.client_method, :asir if ASIR::Config.client_method
     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)
+      def asir
+        proxy = self.class.asir.dup
+        proxy.receiver = self
+        proxy
       end
+      alias_method ASIR::Config.client_method, :asir if ASIR::Config.client_method
     end
 
     # !SLIDE
@@ -41,14 +46,14 @@ module ASIR
     #
     # Provide client interface proxy to a service.
     class Proxy
-      attr_accessor :receiver
+      attr_accessor :receiver, :receiver_class
 
       # 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
+        @__configure.call(message, self) if @__configure
         result = transport.send_message(message)
         result
       end
@@ -80,8 +85,12 @@ module ASIR
       # 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.
+      #
+      # Call sequence:
+      #
+      #   proxy.__configure.call(message, proxy).
       def _configure &blk
-        proxy = self.dup
+        proxy = @receiver == @receiver_class ? self.dup : self
         proxy.__configure = blk
         proxy
       end
@@ -90,12 +99,19 @@ module ASIR
       # !SLIDE
       # Configuration Callbacks
 
-      def initialize rcvr
-        key = Module === (@receiver = rcvr) ? @receiver : @receiver.class
-        (@@config_callbacks[key] || 
-         @@config_callbacks[key.name] || 
+      def initialize rcvr, rcvr_class
+        @receiver = rcvr
+        @receiver_class = rcvr_class
+        _configure!
+      end
+
+      def _configure!
+        key = @receiver_class
+        (@@config_callbacks[key] ||
+         @@config_callbacks[key.name] ||
          @@config_callbacks[nil] ||
          IDENTITY_LAMBDA).call(self)
+        self
       end
 
       @@config_callbacks ||= { }

data/lib/asir/config.rb

@@ -0,0 +1,8 @@
+module ASIR
+  # Low-level ASIR configuration
+  module Config
+    @@client_method = nil
+    def self.client_method; @@client_method; end
+    def self.client_method= x; @@client_method = x; end
+  end
+end

data/lib/asir/description.rb

@@ -0,0 +1,34 @@
+module ASIR
+  module Description
+    def describe obj, indent = "", more = nil
+      case obj
+      when nil, ASIR::Coder::Identity
+        s = ""; more = nil
+      when ASIR::Transport
+        s = "#{describe(obj.encoder, indent, "->\n")}#{indent}#{obj.class.name}"
+        opts = [ :file, :uri ].
+          select { | x | obj.respond_to?(x) && obj.send(x) != nil }.
+          map { | x | "#{x}: #{obj.send(x).inspect}" } * ","
+        s << "(" << opts << ")" unless opts.empty?
+        case
+        when obj.respond_to?(:transports)
+          s << "->[\n"
+          s << obj.transports.map { | x | describe(x, indent + "  ") } * ",\n"
+          s << "]"
+        when obj.respond_to?(:transport)
+          s << "->\n" << describe(obj.transport, indent + "  ")
+        end
+      when ASIR::Coder::Chain
+        s = "#{indent}Chain(\n"
+        s << obj.encoders.map { | x | describe(x, indent + "  ") } * "->\n"
+        s << ")"
+      else
+        s = "#{indent}#{obj.class.name}"
+      end
+      s << more if more
+      s
+    end
+
+    extend self
+  end
+end

data/lib/asir/environment.rb

@@ -0,0 +1,96 @@
+require 'asir'
+
+module ASIR; class Environment
+  attr_accessor :phase
+  attr_accessor :verb, :adjective, :object, :identifier
+  attr_accessor :config_rb, :config
+  attr_accessor :log_dir, :log_file, :pid_dir
+  attr_accessor :verbose
+
+  def initialize
+    @verbose = 0
+    @exit_code = 0
+  end
+
+  def log_dir
+    @log_dir ||= find_writable_directory :log_dir,
+    ENV['ASIR_LOG_DIR'],
+    '/var/log/asir',
+    '~/asir/log',
+    '/tmp'
+  end
+
+  def pid_dir
+    @pid_dir ||= find_writable_directory :pid_dir,
+      ENV['ASIR_PID_DIR'],
+      '/var/run/asir',
+      '~/asir/run',
+      '/tmp'
+  end
+
+  def find_writable_directory kind, *list
+    list.
+      reject { | p | ! p }.
+      map { | p |  File.expand_path(p) }.
+      find { | p | File.writable?(p) } or
+      raise "Cannot find writable directory for #{kind}"
+  end
+
+  def pid_file
+    @pid_file ||=
+      "#{pid_dir}/#{asir_basename}.pid"
+  end
+
+  def log_file
+    @log_file ||=
+      "#{log_dir}/#{asir_basename}.log"
+  end
+
+  def asir_basename
+    "asir-#{adjective}-#{object}-#{identifier}"
+  end
+
+  def config_rb
+    @config_rb ||=
+      File.expand_path(ENV['ASIR_CONFIG_RB'] || 'config/asir_config.rb')
+  end
+
+  def config! phase, opts = { }
+    ((@config ||= { })[phase] ||= [
+      begin
+        opts[:phase] = phase
+        save = { }
+        opts.each do | k, v |
+          save[k] = send(k)
+          send(:"#{k}=", v)
+        end
+        $stderr.puts "#{self.class} calling #{config_rb} asir.phase=#{phase.inspect} ..." if @verbose >= 1
+        value = config_lambda.call(self)
+        $stderr.puts "#{self.class} calling #{config_rb} asir.phase=#{phase.inspect} DONE" if @verbose >= 1
+        value
+      ensure
+        save.each do | k , v |
+          send(:"#{k}=", v)
+        end
+      end
+      ]).first
+  end
+
+  def config_lambda
+    @config_lambda ||=
+      (
+        file = config_rb
+        $stderr.puts "#{self.class} loading #{file} ..." if @verbose >= 1
+        expr = File.read(file)
+        expr = "begin; lambda do | asir |; #{expr}\n end; end"
+        cfg = Object.new.send(:eval, expr, binding, file, 1)
+        # cfg = load file
+        # $stderr.puts "#{self.class} loading #{file} DONE" if @verbose >= 1
+        raise "#{file} did not return a Proc, returned a #{cfg.class}" unless Proc === cfg
+        cfg
+      )
+  end
+
+end; end
+
+