asir 0.2.0

data/hack_night/solution/prob-7.rb

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

data/lab/phony_proc.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+require 'pp'
+
+class PhonyProc
+  def initialize hash
+    @data = hash
+  end
+  def to_proc
+    self
+  end
+  def call lang, *args, &blk
+    @data[lang].call(*args, &blk)
+  end
+end
+
+def with_block something, &block
+  pp block
+  block.call(:ruby, something)
+end
+
+with_block(123, &PhonyProc.new(:ruby => proc { | x | x * 2 },
+                               :js => 'function (x) { return x * 2; }'))
+
+=begin
+
+ > ruby lab/phony_proc.rb 
+lab/phony_proc.rb:21: PhonyProc#to_proc should return Proc (TypeError)
+
+wah-wah.. :(
+
+=end

data/lib/asir.rb

@@ -0,0 +1,253 @@
+# !SLIDE
+# Abstracting Services in Ruby
+#
+# * Kurt Stephens
+# * Enova Financial
+# * 2012/04/02
+# * 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
+#
+# !SLIDE END
+
+# !SLIDE
+# Issues
+#
+# * Problem Domain, Solution Domain
+# * Service Middleware Semantics
+# * Testing, Debugging, Diagnostics
+# * Productivity
+#
+# !SLIDE END
+
+# !SLIDE
+# Problem Domain, Solution Domain
+#
+# * Client knows too much about infrastructure.
+# * Evaluating and switching infrastructures.
+#
+# !SLIDE END
+
+# !SLIDE
+# Service Middleware Semantics
+#
+# * Directionality: One-way, Two-way
+# * Synchronicity: Synchronous, Asynchronous, Delayed, Buffered
+# * Distribution: Local Thread, Local Process, Distributed
+# * Transport: File, IPC, Pipe, Network
+# * Robustness: Retry, Replay, Fallback
+# * Encoding: XML, JSON, YAML, Base64, Compression
+#
+# !SLIDE END
+
+# !SLIDE
+# Testing, Debugging, Diagnostics
+#
+# * Configuration for testing and QA is more complex.
+# * Measuring test coverage of remote services.
+# * Debugging the root cause of remote service errors.
+# * Diagnostic hooks.
+#
+# !SLIDE END
+
+# !SLIDE
+# Objectives
+#
+# * Simplify service/client definitions and interfaces.
+# * Anticipate new encoding, delivery and security requirements.
+# * Separate encoding and transport concerns.
+# * Composition over Configuration.
+# * Elide deployment decisions.
+# * Integrate diagnostics and logging.
+# * Simplify testing.
+#
+# !SLIDE END
+
+# !SLIDE
+# Foundations of Objects
+#
+# * Message
+# * State
+# * Behavior
+
+# !SLIDE
+# Messaging
+#
+# * "Call a Method", "Call a Function" are all the same, in *all* languages.
+# ** Decomposed into lookup() and apply().
+# * "Send Message", not "Call a Method".
+# * Messaging abstracts:
+# ** Object use from its implementation.
+# ** Transfer of control (method, function invocation, RPC, etc).
+
+# !SLIDE
+# REST
+#
+# "Roy Fielding - Architectural Styles and the Design of Network-based Software Architectures":http://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm
+#
+# * Imperative Action .vs. Behavorial Resource
+# * REST Connector .vs. REST Component
+# * "Generality of connectors leads to middleware..."
+# * "Modifiability is about the ease with which a change can be made to an application architecture... broken down into evolvability, extensibility, customizability, configurability, and reusability..."
+#
+# !SLIDE END
+
+# !SLIDE
+# Design
+#
+# * Nouns -> Objects -> Classes
+# * Verbs -> Responsibilities -> Methods
+#
+# h3. Book: "Designing Object-Oriented Software"
+#  * Wirfs-Brock, Wilkerson, Wiener
+#
+# !SLIDE END
+
+# !SLIDE
+# Design: Nouns
+#
+# * Service -> Object
+# * Client -> Just a Ruby message sender.
+# * 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)
+#
+# !SLIDE END
+
+# !SLIDE
+# Design: Verbs
+#
+# * Intercept Message -> Proxy
+# * Invoke Message    -> Message
+# * Return Result, Invoke Exception  -> Result
+# * Send Message, Recieve Message -> Transport
+# * Encode Object, Decode Object -> Coder
+#
+# !SLIDE END
+
+# !SLIDE
+# Simple
+#
+# !IMAGE BEGIN PIC width:800 height:300
+#
+# box "Client" "(CustomersController" "#send_invoice)" wid 4.0 ht 2.5; arrow;
+# ellipse "Send" "Message" "(Ruby message)" wid 4.0 ht 2.5; arrow;
+# box "Service" "(Email.send_email)" wid 4.0 ht 2.5;
+#
+# !IMAGE END
+#
+# !SLIDE END
+
+# !SLIDE
+# Client-Side Message
+#
+# !IMAGE BEGIN PIC width:800 height:300
+# box "Client" wid 2.5 ht 2.5; arrow;
+# ellipse "Proxy" wid 2.5 ht 2.5; arrow;
+# ellipse "Create" "Message" wid 2.5 ht 2.5; arrow;
+# ellipse "Encode" "Message" wid 2.5 ht 2.5; arrow;
+# ellipse "Send" "Message" wid 2.5 ht 2.5;
+# line; down; arrow;
+# !IMAGE END
+#
+# !SLIDE END
+
+# !SLIDE
+# Server-Side
+#
+# !IMAGE BEGIN PIC width:800 height:300
+# down; line; right; arrow;
+# ellipse "Receive" "Message" wid 2.5 ht 2.5; arrow;
+# ellipse "Decode" "Message" wid 2.5 ht 2.5; arrow;
+# ellipse "Message" wid 2.5 ht 2.5;
+# line; down; arrow;
+# IR: ellipse "Invoke" "Message" wid 2.5 ht 2.5;
+# right; move; move;
+# Service: box "Service" wid 2.5 ht 2.5 with .w at IR.e + (movewid, 0);
+# arrow <-> from IR.e to Service.w;
+# move to IR.s; down; line;
+# left; arrow;
+# ellipse "Create" "Result" wid 2.5 ht 2.5; arrow;
+# ellipse "Encode" "Result" wid 2.5 ht 2.5; arrow;
+# ellipse "Send" "Result" wid 2.5 ht 2.5;
+# line; down; arrow
+# !IMAGE END
+#
+# !SLIDE END
+
+# !SLIDE
+# Client-Side Result
+#
+# !IMAGE BEGIN PIC width:800 height:300
+# down; line; left; arrow;
+# ellipse "Receive" "Result" wid 2.5 ht 2.5; arrow;
+# ellipse "Decode" "Result" wid 2.5 ht 2.5; arrow;
+# ellipse "Result" wid 2.5 ht 2.5; arrow;
+# ellipse "Proxy" wid 2.5 ht 2.5; arrow;
+# box "Client" wid 2.5 ht 2.5;
+# !IMAGE END
+#
+# !SLIDE END
+
+# !SLIDE
+# Implementation
+#
+# * Primary Base classes: Transport, Coder.
+# * Primary API: Proxy via Client mixin.
+# * Handful of mixins.
+#
+# !SLIDE END
+
+# !SLIDE
+# Modules and Classes
+module ASIR
+  # Reusable constants to avoid unnecessary garbage.
+  EMPTY_ARRAY = [ ].freeze; EMPTY_HASH =  { }.freeze; EMPTY_STRING = ''.freeze
+  MODULE_SEP = '::'.freeze; IDENTITY_LAMBDA = lambda { | x | x }
+end
+# !SLIDE END
+Asir = ASIR
+
+require "asir/version"
+require 'asir/error'
+require 'asir/log'
+require 'asir/initialization'
+require 'asir/additional_data'
+require 'asir/object_resolving'
+require 'asir/identity'
+require 'asir/code_block'
+require 'asir/code_more'
+require 'asir/message'
+require 'asir/result'
+require 'asir/client'
+require 'asir/coder'
+require 'asir/coder/null'
+require 'asir/coder/identity'
+require 'asir/transport'
+require 'asir/channel'
+require 'asir/transport/local'
+
+# !SLIDE
+# Synopsis
+#
+# * Services are easy to abstract away.
+# * Separation of transport, encoding.
+#
+# !SLIDE END
+
+# !SLIDE
+# Slide Tools
+#
+# * Riterate -- "":http://github.com/kstephens/riterate
+# * Scarlet -- "":http://github.com/kstephens/scarlet
+#
+# !SLIDE END
+
+# !SLIDE
+# Appendix
+#
+#
+# !SLIDE END
+

data/lib/asir/additional_data.rb

@@ -0,0 +1,25 @@
+module ASIR
+  # !SLIDE
+  # Addtional Data
+  #
+  # Support additional data attached to any object.
+  module AdditionalData
+    def additional_data
+      @additional_data || EMPTY_HASH
+    end
+    def additional_data!
+      @additional_data ||= { }
+    end
+    def additional_data= x
+      @additional_data = x
+    end
+    def [] key
+      @additional_data && @additional_data[key]
+    end
+    def []= key, value
+      (@additional_data ||= { })[key] = value
+    end
+  end
+  # !SLIDE END
+end
+

data/lib/asir/channel.rb

@@ -0,0 +1,130 @@
+require 'asir'
+require 'asir/retry_behavior'
+
+module ASIR
+  # Generic I/O Channel abstraction.
+  # Handles stream per Thread and forked child processes.
+  class Channel
+    include Initialization, RetryBehavior
+
+    attr_accessor :on_connect, :on_close, :on_retry, :on_error
+    
+    ON_ERROR = lambda do | channel, exc, action, stream |
+      channel.close rescue nil if stream
+      raise exc
+    end
+    ON_CLOSE = lambda do | channel, stream |
+      stream.close
+    end
+    ON_RETRY = lambda do | channel, exc, action |
+    end
+
+    def initialize opts = nil
+      @on_close = ON_CLOSE
+      @on_error = ON_ERROR
+      # @on_retry = ON_RETRY
+      self.try_max = 10
+      self.try_sleep = 0.1
+      self.try_sleep_increment = 0.1
+      self.try_sleep_max = 10
+      super
+    end
+
+    # Returns IO stream for current Thread.
+    # Automatically calls #connect! if stream is created.
+    def stream
+      _streams[self] ||= 
+        connect!
+    end
+    
+    # Invokes @on_connect.call(self).
+    # On Exception, invokes @on_error.call(self, exc, :connect, nil).
+    def connect!
+      n_try = nil
+      with_retry do | action, data |
+        case action
+        when :try
+          n_try = data
+          @on_connect.call(self)
+        when :retry #, exc
+          exc = data
+          $stderr.puts "RETRY: #{n_try}: ERROR : #{data.inspect}"
+          @on_retry.call(self, exc, :connect) if @on_retry
+        when :failed
+          exc = data
+          $stderr.puts "FAILED: #{n_try}: ERROR : #{data.inspect}"
+          handle_error!(exc, :connect, nil)
+        end
+      end
+    end
+    
+    # Invokes @on_close.call(self, stream).
+    # On Exception, invokes @on_error.call(self, exc, :close, stream).
+    def close
+      if stream = _stream
+        self.stream = nil
+        @on_close.call(self, stream) if @on_close
+      end
+    rescue ::Exception => exc
+      handle_error!(exc, :close, stream)
+    end
+    
+    # Yield #stream to block.
+    # On Exception, invokes @on_error.call(self, exc, :with_stream, stream).
+    def with_stream!
+      x = stream
+      begin
+        yield x
+      rescue ::Exception => exc
+        handle_error!(exc, :with_stream, x)
+      end
+    end
+    
+    # Delegate to actual stream.
+    def method_missing sel, *args, &blk
+      with_stream! do | obj |
+        obj.__send__(sel, *args, &blk)
+      end
+    end
+
+    # Dispatches exception and arguments if @on_error is defined.
+    # Otherwise, reraise exception.
+    def handle_error! exc, action, stream
+      if @on_error
+        @on_error.call(self, exc, action, stream)
+      else
+        raise exc
+      end
+    end
+    
+    # Returns a Thread-specific mapping, unique to this process id. 
+    # 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?
+        @owning_process = $$
+        streams.clear
+      end
+      streams
+    end
+    
+    # Returns the stream for this Channel, or nil.
+    def _stream
+      _streams[self]
+    end
+    
+    # Sets the stream for this Channel, or nil.
+    def stream= x
+      if x == nil
+        _streams.delete(self)
+      else
+        _streams[self] = x
+      end
+    end
+    
+  end # class Channel
+end # module
+
+