asir 0.2.0

data/example/ex14.rb

@@ -0,0 +1,30 @@
+# !SLIDE :capture_code_output true
+# Synchronous HTTP service on instance methods.
+
+require 'example_helper'
+require 'asir/transport/webrick'
+require 'asir/coder/base64'
+begin
+  MyClass.client.transport = t =
+    ASIR::Transport::Webrick.new(:uri => "http://localhost:30914/")
+  t.encoder =
+    ASIR::Coder::Chain.new(:encoders =>
+                           [ ASIR::Coder::Marshal.new,
+                             ASIR::Coder::Base64.new, ])
+  server_process do
+    t.prepare_server!
+    t.run_server!
+  end; sleep 2
+  pr MyClass.new("abc123").client.size
+  sleep 2
+rescue Object => err
+  $stderr.puts "#{err.inspect}\n#{err.backtrace * "\n"}"
+ensure
+  t.close; sleep 3; server_kill; sleep 2
+end
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : server process
+# EXPECT: : pr: 6
+

data/example/ex15.rb

@@ -0,0 +1,13 @@
+# !SLIDE :capture_code_output true
+# Local Process with delay option.
+
+require 'example_helper'
+
+pr DelayedService.client.
+  _configure{|req| req.delay = 5}.
+  do_it(Time.now)
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: DelayedService.do_it => :ok
+# EXPECT: : pr: :ok

data/example/ex16.rb

@@ -0,0 +1,33 @@
+# !SLIDE :capture_code_output true
+# Asynchronous beanstalkd service with delay option
+
+require 'example_helper'
+require 'asir/transport/beanstalk'
+begin
+  DelayedService.client.transport = t =
+    ASIR::Transport::Beanstalk.new(:address => '127.0.0.1', :port => 30916)
+  t.encoder =
+    ASIR::Coder::Marshal.new
+  t.start_beanstalkd!; sleep 1
+  server_process do
+    t.prepare_beanstalk_server!
+    t.run_beanstalk_server!
+  end; sleep 1
+  pr DelayedService.client.
+    _configure{|req| req.delay = 5}.
+    do_it(Time.now)
+  sleep 10
+rescue Object => err
+  $stderr.puts "#{err.inspect}\n#{err.backtrace * "\n"}"
+ensure
+  t.close; sleep 1
+  server_kill; sleep 1
+  t.stop_beanstalkd!
+end
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : server process
+# EXPECT: DelayedService.do_it => :ok
+# EXPECT: : pr: nil
+

data/example/ex17.rb

@@ -0,0 +1,41 @@
+# !SLIDE :capture_code_output true
+# Buffered asynchronous beanstalkd service with delay option
+
+require 'example_helper'
+require 'asir/transport/beanstalk'
+require 'asir/transport/buffer'
+begin
+  t =
+    ASIR::Transport::Beanstalk.new(:address => '127.0.0.1', :port => 30917)
+  t.encoder =
+    ASIR::Coder::Marshal.new
+  t.start_beanstalkd!; sleep 1
+  DelayedService.client.transport =
+    t0 = ASIR::Transport::Buffer.new(:transport => t)
+  t0.pause!
+  server_process do
+    t.prepare_beanstalk_server!
+    t.run_beanstalk_server!
+  end; sleep 1
+  pr [ :paused, t0.paused?, :at, Time.now.iso8601(2) ]
+  pr DelayedService.client.
+    _configure{|req| req.delay = 5}.
+    do_it(Time.now)
+  sleep 2
+  pr [ :resuming, :size, t0.size, :at, Time.now.iso8601(2) ]
+  t0.resume!
+  pr [ :paused, t0.paused?, :size, t0.size, :at, Time.now.iso8601(2) ]
+  sleep 10
+rescue Object => err
+  $stderr.puts "#{err.inspect}\n#{err.backtrace * "\n"}"
+ensure
+  t.close; sleep 1; server_kill; sleep 1
+  t.stop_beanstalkd!
+end
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : server process
+# EXPECT: DelayedService.do_it => :ok
+# EXPECT: : pr: nil
+

data/example/ex18.rb

@@ -0,0 +1,62 @@
+# !SLIDE :capture_code_output true
+# Socket service with retry.
+
+require 'example_helper'
+require 'asir/transport/retry'
+begin
+  File.unlink(service_log = "#{__FILE__}.service.log") rescue nil
+  file = ASIR::Transport::File.new(:file => service_log,
+                                   :encoder => ASIR::Coder::Yaml.new)
+  tcp = ASIR::Transport::TcpSocket.new(:port => 31918,
+                                       :encoder => ASIR::Coder::Marshal.new)
+  start_server_proc = lambda do | transport, message |
+    $stderr.puts "message = #{message.inspect}"
+    file.send_message(message)
+    server_process do
+      tcp.prepare_server!
+      tcp.run_server!
+    end; sleep 2
+  end
+  Email.client.transport = t =
+    ASIR::Transport::Retry.new(:transport => tcp,
+                               :try_sleep => 1,
+                               :try_sleep_increment => 2,
+                               :try_max => 3,
+                               :before_retry => start_server_proc
+                               )
+  pr Email.client.send_email(:pdf_invoice,
+                             :to => "user@email.com", :customer => 123)
+  sleep 1
+  pr Email.client.send_email(:pdf_invoice,
+                             :to => "user2@email.com", :customer => 456)
+  sleep 1
+rescue ::Exception => err
+  $stderr.puts "ERROR: #{err.inspect}\n  #{err.backtrace * "\n  "}"
+  raise
+ensure
+  file.close rescue nil;
+  tcp.close rescue nil; sleep 1
+  server_kill
+  puts "\x1a\n#{service_log.inspect} contents:"
+  puts File.read(service_log)
+end
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : server process
+# EXPECT/: : Email.send_mail :pdf_invoice .*:to=>"user@email.com"
+# EXPECT/: : Email.send_mail :pdf_invoice .*:to=>"user2@email.com"
+# EXPECT: : pr: :ok
+# EXPECT: service.log" contents:
+# EXPECT: --- !ruby/object:ASIR::Message
+# EXPECT:   :transport_exceptions:
+# EXPECT: ASIR::Error: Cannot connect to ASIR::Transport::TcpSocket tcp://127.0.0.1:
+# EXPECT: arguments:
+# EXPECT: - :pdf_invoice
+# EXPECT/:  :to: user@email.com
+# EXPECT/:  :customer: 123
+# EXPECT!/:  :to: user2@email.com
+# EXPECT!/:  :customer: 456
+# EXPECT: receiver: Email
+# EXPECT: receiver_class: Module
+# EXPECT: selector: :send_email

data/example/ex19.rb

@@ -0,0 +1,32 @@
+# !SLIDE :capture_code_output true
+# Socket service with unsafe Exception.
+
+require 'example_helper'
+begin
+  tcp = ASIR::Transport::TcpSocket.new(:port => 31919,
+                                       :encoder => ASIR::Coder::Marshal.new)
+  server_process do
+    tcp.prepare_server!
+    tcp.run_server!
+  end; sleep 2
+  UnsafeService.client.transport = t = tcp
+  pr UnsafeService.client.do_it("exit 999; :ok")
+  sleep 1
+rescue ::ASIR::Error::Unforwardable => err
+  $stderr.puts "### #{$$}: Unforwardable ERROR: #{err.inspect}}"
+rescue ::Exception => err
+  $stderr.puts "### #{$$}: ERROR: #{err.inspect}\n  #{err.backtrace * "\n  "}"
+  raise
+ensure
+  file.close rescue nil;
+  tcp.close rescue nil; sleep 1
+  server_kill
+#  puts "\x1a\n#{service_log.inspect} contents:"
+#  puts File.read(service_log)
+end
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : server process
+# EXPECT!: : pr: :ok
+# EXPECT: Unforwardable ERROR: #<ASIR::Error::Unforwardable: SystemExit

data/example/ex20.rb

@@ -0,0 +1,28 @@
+# !SLIDE :capture_code_output true
+# One-way ZMQ service.
+
+require 'example_helper'
+require 'asir/transport/zmq'
+begin
+  zmq = ASIR::Transport::Zmq.new(:port => 31920,
+                                 :encoder => ASIR::Coder::Marshal.new,
+                                 :one_way => true)
+  server_process do
+    zmq.prepare_server!
+    zmq.run_server!
+  end; sleep 1
+  UnsafeService.client.transport = t = zmq
+  pr UnsafeService.client.do_it(":ok")
+rescue ::Exception => err
+  $stderr.puts "### #{$$}: ERROR: #{err.inspect}\n  #{err.backtrace * "\n  "}"
+  raise
+ensure
+  zmq.close rescue nil; sleep 1; server_kill
+end
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : server process
+# EXPECT: UnsafeService.do_it => :ok
+# EXPECT: : pr: nil
+# EXPECT!: ERROR

data/example/ex21.rb

@@ -0,0 +1,28 @@
+# !SLIDE :capture_code_output true
+# Bi-directional ZMQ service.
+
+require 'example_helper'
+require 'asir/transport/zmq'
+begin
+  zmq = ASIR::Transport::Zmq.new(:port => 31920,
+                                 :encoder => ASIR::Coder::Marshal.new,
+                                 :one_way => false)
+  server_process do
+    zmq.prepare_server!
+    zmq.run_server!
+  end; sleep 1
+  UnsafeService.client.transport = t = zmq
+  pr UnsafeService.client.do_it(":ok")
+rescue ::Exception => err
+  $stderr.puts "### #{$$}: ERROR: #{err.inspect}\n  #{err.backtrace * "\n  "}"
+  raise
+ensure
+  zmq.close rescue nil; sleep 1; server_kill
+end
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : server process
+# EXPECT: UnsafeService.do_it => :ok
+# EXPECT: : pr: :ok
+# EXPECT!: ERROR

data/example/ex22.rb

@@ -0,0 +1,15 @@
+# !SLIDE :capture_code_output true
+# In-core, in-process service, with continuation block.
+
+require 'example_helper'
+pr(Email.client.send_email(:pdf_invoice,
+                           :to => "user@email.com",
+                           :customer => @customer,
+                           &proc { | res | pr [ :in_block, res.result ] })
+)
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : Email.send_mail :pdf_invoice
+# EXPECT: : pr: :ok
+# EXPECT: : pr: [:in_block, :ok]

data/example/ex23.rb

@@ -0,0 +1,20 @@
+#
+# !SLIDE :capture_code_output true
+# Subprocess service with continuation
+
+require 'example_helper'
+begin
+  Email.client.transport = t =
+    ASIR::Transport::Subprocess.new(:one_way => true)
+  pr(Email.client.send_email(:pdf_invoice,
+                             :to => "user@email.com",
+                             :customer => @customer) { | resp |
+     pr [ :in_block, resp.result ] })
+end
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : Email.send_mail :pdf_invoice
+# EXPECT: : pr: nil
+# EXPECT: : pr: [:in_block, :ok]
+

data/example/ex24.rb

@@ -0,0 +1,35 @@
+# !SLIDE :capture_code_output true
+# Synchronous HTTP service on Rack under WEBrick
+
+gem 'rack'
+require 'example_helper'
+require 'asir/transport/rack'
+require 'asir/coder/base64'
+begin
+  Email.client.transport = t =
+    ASIR::Transport::Rack.new(:uri => "http://localhost:31924/")
+  t.encoder =
+    ASIR::Coder::Chain.new(:encoders =>
+                           [ASIR::Coder::Marshal.new,
+                            ASIR::Coder::Base64.new, ])
+  server_process do
+    t.prepare_server!
+    t.run_server!
+  end; sleep 2
+  pr Email.client.send_email(:pdf_invoice,
+                             :to => "user@email.com",
+                             :customer => @customer)
+  sleep 2
+rescue Object => err
+  $stderr.puts "#{err.inspect}\n#{err.backtrace * "\n"}"
+ensure
+  t.close rescue nil; sleep 3
+  server_kill; sleep 2
+end
+
+# !SLIDE END
+# EXPECT: : client process
+# EXPECT: : server process
+# EXPECT: : Email.send_mail :pdf_invoice
+# EXPECT: : pr: :ok
+

data/example/example_helper.rb

@@ -0,0 +1,51 @@
+# Sample client support
+#
+
+$: << File.expand_path("../../lib", __FILE__)
+require 'asir'
+require 'asir/transport/file'
+require 'asir/transport/local'
+require 'asir/transport/subprocess'
+require 'asir/transport/tcp_socket'
+require 'asir/transport/fallback'
+require 'asir/transport/broadcast'
+require 'asir/coder/marshal'
+require 'asir/coder/yaml'
+require 'asir/coder/sign'
+require 'asir/coder/chain'
+ASIR::Log.enabled = true unless ENV['ASIR_EXAMPLE_SILENT']
+require 'sample_service'
+require 'delayed_service'
+require 'unsafe_service'
+
+require 'pp'
+require File.expand_path('../../spec/debug_helper', __FILE__)
+
+@customer = 123
+
+class ::Object
+
+def pr result
+  $stdout.puts "*** #{$$}: pr: #{PP.pp(result, '')}"
+end
+
+def server_process &blk
+  $server_pid = Process.fork do
+    puts "*** #{$$}: server process"; $stdout.flush
+    yield
+  end
+  sleep 1 # wait for server to be ready.
+end
+
+def server_kill
+  if $server_pid
+    Process.kill 9, $server_pid
+    Process.waitpid($server_pid)
+  end
+  $server_pid = nil
+end
+
+end
+
+puts "*** #{$$}: client process"; $stdout.flush
+

data/example/sample_service.rb

@@ -0,0 +1,162 @@
+=begin
+# !SLIDE
+# Stuff Gets Complicated
+#
+# Systems become:
+# * bigger ->
+# * complex ->
+# * slower ->
+# * distributed ->
+# * hard to test
+#
+# !SLIDE END
+
+# !SLIDE
+# Sample Service
+#
+module Email
+  def send_email template_name, options
+    $stderr.puts "*** #{$$}: Email.send_mail #{template_name.inspect} #{options.inspect}"
+    :ok
+  end
+  def do_raise msg
+    raise msg
+  end
+  extend self
+end
+# !SLIDE END
+
+# !SLIDE
+# Back when things were simple...
+#
+class CustomersController < ApplicationController
+  def send_invoice
+    @customer = Customer.find(params[:id])
+    Email.send_email(:pdf_invoice,
+                     :to => @customer.email,
+                     :customer => @customer)
+  end
+end
+# !SLIDE END
+
+# !SLIDE
+# Trying to improve user's experience...
+#
+class CustomersController < ApplicationController
+  def send_invoice
+    @customer = Customer.find(params[:id])
+    Process.fork do
+      Email.send_email(:pdf_invoice,
+                       :to = @customer.email,
+                       :customer => @customer)
+    end
+  end
+end
+# !SLIDE END
+
+# !SLIDE
+# Use other machines to poll a work table...
+#
+class CustomersController < ApplicationController
+  def send_invoice
+    @customer = Customer.find(params[:id])
+    EmailWork.create(:template_name => :pdf_invoice,
+                     :options => {
+                       :to => @customer.email,
+                       :customer => @customer,
+                     })
+  end
+end
+# !SLIDE END
+
+# !SLIDE
+# Use queue infrastructure
+#
+class CustomersController < ApplicationController
+  def send_invoice
+    @customer = Customer.find(params[:id])
+    queue_service.put(:queue => :Email,
+                      :action => :send_email,
+                      :template_name => :pdf_invoice,
+                      :options => {
+                        :to => @customer.email,
+                        :customer => @customer,
+                      })
+  end
+end
+# !SLIDE END
+
+# !SLIDE
+# Example Message
+#
+Email.client.send_email(:pdf_invoice,
+                        :to => "user@email.com",
+                        :customer => @customer)
+# ->
+message = Message.new(...)
+message.receiver_class == ::Module
+message.receiver == ::Email
+message.selector == :send_email
+message.arguments == [ :pdf_invoice,
+                       { :to => "user@email.com",
+                         :customer => ... } ]
+# !SLIDE END
+
+# !SLIDE
+# Using a Client Proxy
+#
+Email.send_email(:pdf_invoice,
+                 :to => "user@email.com",
+                 :customer => @customer)
+# ->
+Email.client.
+      send_email(:pdf_invoice,
+                 :to => "user@email.com",
+                 :customer => @customer)
+# !SLIDE END
+
+# !SLIDE
+# Example Exception
+#
+Email.do_raise("DOH!")
+#
+# ->
+result.exception = ee = EncapsulatedException.new(...)
+ee.exception_class = "::RuntimeError"
+ee.exception_message = "DOH!"
+ee.exception_backtrace = [ ... ]
+# !SLIDE END
+=end
+
+# !SLIDE
+# Sample Service with Client Support
+#
+
+require 'asir'
+# Added .client support.
+module Email
+  include ASIR::Client # Email.client
+  def send_email template_name, options
+    $stderr.puts "*** #{$$}: Email.send_mail #{template_name.inspect} #{options.inspect}"
+    :ok
+  end
+  def do_raise msg
+    raise msg
+  end
+  extend self
+end
+# !SLIDE END
+
+# !SLIDE
+# Sample Object Instance Client
+#
+class MyClass
+  include ASIR::Client
+  def initialize x
+    @x = x
+  end
+  def method_missing sel, *args
+    @x.send(sel, *args)
+  end
+end
+# !SLIDE END