ap4r 0.3.1 → 0.3.2

data/CHANGELOG

@@ -1,22 +1,32 @@
 == 0.3.x
 
+=== 0.3.2 (June 7th, 2007)
+* Fixed: util/loc.rb doesn't work.
+* Changed: Argument order of async_dispatch has changed, backward INCOMPATIBLE.
+* Added: Dynamic configuration with ERb.
+* Added: Script to run AP4R on Mongrel.
+* Changed: How to plugin and main API names have changed. 
+* Added: Support of several Content-type on asynchronous call. 
+* Added: Block style for async_to.
+* Added: Url rewrite filter. 
+
 === 0.3.1 (April 24th, 2007)
 
-* Changed: @delete_mode of AsyncController to @@saf_delete_mode with accessor
-* Changed: default value of dispatch_mode, from :XMLRPC to :HTTP
-* Added: Bootstrap script to let ap4r run on mongrel, experimental yet
+* Changed: @delete_mode of AsyncController to @@saf_delete_mode with accessor.
+* Changed: default value of dispatch_mode, from :XMLRPC to :HTTP.
+* Added: Bootstrap script to let ap4r run on mongrel, experimental yet.
 
 === 0.3.0 (April 6th, 2007)
 
-* Changed: name space from "AP4R" to "Ap4r"
-* Added: support the latest version for Rails(1.8.6) and RubyGems(0.9.2) and Rails(1.2.3) 
+* Changed: name space from "AP4R" to "Ap4r".
+* Added: support the latest version for Ruby(1.8.6) and RubyGems(0.9.2) and Rails(1.2.3) .
 
 == 0.2.x
 
 === 0.2.0 (October 17th, 2006)
 
-* Added: Protocols to invoke asynchronous logics
-* Added: At-lease-once QoS
+* Added: Protocols to invoke asynchronous logics.
+* Added: At-lease-once QoS.
 
 == 0.1.x
 

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2006  Future System Consulting Corp.
+Copyright (c) 2007  Future Architect Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README

@@ -4,7 +4,9 @@ AP4R, Asynchronous Processing for Ruby, is the implementation of reliable asynch
 Using asynchronous processing, we can cut down turn-around-time of web applications by queuing, or can utilize more machine power by load-balancing.
 Also AP4R nicely ties with your Ruby on Rails applications. See Hello World sample application from rubyforge.
 
-http://rubyforge.org/projects/ap4r/
+For more information, please step in AP4R homepage!
+
+http://ap4r.rubyforge.org/wiki/wiki.pl
 
 == Features
 
@@ -30,149 +32,6 @@ Use RubyGems command.
 
   $ sudo gem install ap4r --include-dependencies
 
-
-== Working directory
-
-Create your working directory (ex. my_work) wherever you want.
-
-  $ ap4r_setup my_work
-  $ cd my_work
-
-Its structure is as follows.
-
-  my_work
-   +-- config
-   +-- log
-   +-- script
-   +-- tmp
-
-== Message Persistence
-
-AP4R uses reliable-msg for message persistence. It enables disk or RDBMS persistence. See references for details of reliable-msg. Install MySQL if you choose MySQL persistence. We recommend to install MySQL/Ruby library to connect to MySQL. For convinience, Ruby/MySQL bundled in the ActiveRecord gem can be used.
-Create a table in your database. (If you use topics via reliable-msg, create another slightly different table.)
-
-  CREATE TABLE `reliable_msg_queues` (
-    `id` varchar(255) NOT NULL default '',
-    `queue` varchar(255) NOT NULL default '',
-    `headers` text NOT NULL,
-    `object` blob NOT NULL,
-    PRIMARY KEY  (`id`)
-  ) ENGINE=InnoDB DEFAULT CHARSET=binary;
-
-== Configuration file
-
-A command ap4r_setup have created a template configuration file (my_work/config/queues.cfg).
-
-  --- 
-  store: 
-    type: mysql
-    host: localhost
-    database: test
-    username: test
-    password: 
-  drb: 
-    host: 
-    port: 6438
-    acl: allow 127.0.0.1
-  dispatchers:
-    -
-      targets: queue.*
-      threads: 1
-  #carriers:
-  #  - 
-  #    source_uri: druby://another.host.local:6438
-  #    threads: 1
-
-queues.cfg has four parts.
-
-* persistent role (store: )
-  * Set database or file information. 
-
-* message listener (drb:)
-  * Set IP, and port number which are used by clients.
-  * acl = access control list, exmaple below.
-
-    allow 127.0.0.1 allow 10.0.0.0/8 deny 192.168.0.1
-
-* asynchronous process invokers (dispatchers:)
-  * Dispatchers handle messages in queues specified by targets,
-  * with as many threads as specified by threads.
-  * Each thread waits (is blocked) until the invocation returns. 
-
-* message routing (carriers:) # EXPERIMENTAL
-  * Carriers get messages from an AP4R server specified by source_uri,
-  * with as many threads as specified by threads,
-  * and put messages to a local AP4R server. 
-
-== Monitoring
-
-Future plan: connections with monitoring tools such as Cacti and ZABBIX.
-
-* Cacti
-  * http://www.cacti.net/ 
-* ZABBIX
-  * http://www.zabbix.org/ 
-
-== Sample - HelloWorld -
-
-There is an asynchronous application sample with file persistence, where a synchronous logic outputs "Hello" to a file, and an asynchronous logic appends "World".
-Once the synchronous logic has done, a client (a web browser) displays response, and there is only "Hello" in a file.
-Since the asynchronous logic sleeps ten seconds and appends to the file, wait briefly and you can see whole "HelloWorld" in the file
-
-* Install Ruby, Rails and AP4R and configure AP4R in reference above sections
-  * No need for MySQL. 
-
-* Make sample application available
-  * If you have an SVN client,
-
-     $ svn co svn://rubyforge.org/var/ap4r/tags/ap4r-0.2.0/sample [some directory]
-
-  * Unless
-    1. download the sample from RubyForge      
-        http://rubyforge.org/projects/ap4r/
-        filename: HelloWorld.tar.gz
-
-    1. and extract to an appropricate directory(ex. HelloWorld ).
-       There are app/, components/,... directories under HelloWorld. 
-
-* Start WEBRick.
-  * In a command line
-
-     $ cd HelloWorld
-     $ ruby script\server
-
-  * If you see Welcome screen at http://localhost:3000, it's ok. 
-
-* Start AP4R.
-  * In another command line,
-  * start AP4R with specifying the configuraion file.
-
-     $ cd my_work
-     $ ruby script/start -c config/queues_disk.cfg
-
-* Execute a synchronous logic.
-  * http://localhost:3000/sync_hello/execute
-  * A file HelloWorld.txt is creted under HelloWorld/ which contains a word "Hello". 
-  * execute_via_soap, execute_via_http and execute_with_saf actions are also available.
-
-* Confirm the execution of an asynchronous logic.
-  * Wait ten seconds,
-  * and look into the file HelloWorld.txt again, there must be "HelloWorld". 
-
-* Think of application to your real application
-  * This mechanism can work in general applications.
-    * An order acceptance logic instead of printing "Hello".
-    * Asynchronous logic of auto shipping order or accounting instead of appending "World". 
-
-== Future Plan
-
-* only-once QoS
-* DLQ recovery
-* flow volume control, load balancing
-* 7x24 support (e.g. rolling database tables)
-* monitoring (e.g. thread status, web frontend)
-* Coordination with Ruby on Rails, such as development/testing lifesycle support. 
-
 == References
 
 * Ruby Homepage
@@ -187,7 +46,7 @@ Since the asynchronous logic sleeps ten seconds and appends to the file, wait br
 == Licence
 
 This licence is licensed under the MIT license.
-Copyright(c) 2006 Future System Consulting Corp.
+Copyright(c) 2007 Future Architect Inc.
 
 == Authors
 

data/Rakefile

@@ -1,5 +1,5 @@
 # Author:: Kiwamu Kato
-# Copyright:: Copyright (c) 2006 Future System Consulting Corp.
+# Copyright:: Copyright (c) 2007 Future Architect Inc.
 # Licence:: MIT Licence
 
 require 'rake'
@@ -59,6 +59,9 @@ spec = Gem::Specification.new do |s|
   EOF
 
   s.add_dependency(%q<reliable-msg>, ["= 1.1.0"])
+	s.add_dependency(%q<rake>)
+	s.add_dependency(%q<activesupport>)
+	s.add_dependency(%q<mongrel>)
 
   s.has_rdoc = true
   s.extra_rdoc_files = ["README", "CHANGELOG", 'rails_plugin']
@@ -94,6 +97,32 @@ Rake::RDocTask.new { |rdoc|
   rdoc.rdoc_files.include('rails_plugin/**/*.rb')
 }
 
+# Spec tasks ----------------------------------------------------------------
+require 'spec/rake/spectask'
+
+namespace :spec do
+  %w(local).each do |flavor|
+    desc "Run #{flavor} examples"
+    Spec::Rake::SpecTask.new(flavor) do |t|
+      t.spec_files = FileList["spec/#{flavor}/**/*.rb"]
+    end
+
+    namespace :coverage do
+      desc "Run #{flavor} examples with RCov"
+      Spec::Rake::SpecTask.new(flavor) do |t|
+        t.spec_files = FileList["spec/#{flavor}/**/*.rb"]
+        t.rcov = true
+        excludes = %w(^spec\/)
+        if ENV['GEM_HOME']
+          excludes << Regexp.escape(ENV['GEM_HOME'])
+        end
+        t.rcov_opts = ["--exclude" , excludes.join(","),
+                      "--text-summary"]
+      end
+    end
+  end
+end
+
 # AP4R release ----------------------------------------------------------------
 
 desc "Make gem"
@@ -103,7 +132,9 @@ task :copy_to_ap4r_from_sample do
   FileUtils.cp(HELLO_WORLD_DIR + '/db/migrate/001_create_table_for_saf.rb', './lib/ap4r/xxx_create_table_for_saf.rb')
 
   FileUtils.cp(HELLO_WORLD_DIR + '/vendor/plugins/ap4r/init.rb', './rails_plugin/ap4r/init.rb')
-  FileUtils.cp(HELLO_WORLD_DIR + '/vendor/plugins/ap4r/lib/async_controller.rb', './rails_plugin/ap4r/lib/async_controller.rb')
+  FileUtils.cp(HELLO_WORLD_DIR + '/vendor/plugins/ap4r/lib/async_helper.rb', './rails_plugin/ap4r/lib/async_helper.rb')
+  FileUtils.cp(HELLO_WORLD_DIR + '/vendor/plugins/ap4r/lib/ap4r_client.rb', './rails_plugin/ap4r/lib/ap4r_client.rb')
+  FileUtils.cp(HELLO_WORLD_DIR + '/vendor/plugins/ap4r/lib/message_builder.rb', './rails_plugin/ap4r/lib/message_builder.rb')
 end
 
 desc "Make sample tgz"
@@ -137,9 +168,9 @@ task :copy_sample do
 end
 
 task :execute_migration do
-  Dir.chdir('temp/')
+  Dir.chdir('temp/HelloWorld')
   `rake db:migrate`
-  Dir.chdir('../')
+  Dir.chdir('../../')
 end
 
 task :make_tgz do
@@ -157,3 +188,18 @@ task :copy_to_release_dir do
   }
 end
 
+# AP4R misc tools ----------------------------------------------------------------
+
+desc "display code statistics"
+task :stats do
+  require 'rubygems'
+  require 'active_support'
+  require 'code_statistics'
+  CodeStatistics::TEST_TYPES.concat(["Local specs"])
+  CodeStatistics.new(
+                     ["Core Sources", "lib"],
+                     ["Rails plugin", "rails_plugin"],
+                     ["Scripts", "script"],
+                     ["Local specs", "spec/local"]
+                     ).to_s
+end

data/lib/ap4r.rb

@@ -1,5 +1,5 @@
 # Author:: Shunichi Shinohara
-# Copyright:: Copyright (c) 2006 Future System Consulting Corp.
+# Copyright:: Copyright (c) 2007 Future Architect Inc.
 # Licence:: MIT Licence
 
 require 'rubygems'

data/lib/ap4r/carrier.rb

@@ -0,0 +1,107 @@
+# Author:: Shunichi Shinohara
+# Copyright:: Copyright (c) 2007 Future Architect Inc.
+# Licence:: MIT Licence
+
+require 'yaml'
+require 'thread'
+require 'pp'
+require 'active_support'
+
+require 'reliable-msg'
+
+module Ap4r
+
+  # This class aims to balance loads of several reliable-msg servers.
+  # Only P2P channells (queues) are considered so far.
+  # Now reliable-msg can not be accessed from remote (means "not localhost").
+  # Alpha status now.
+  #--
+  # TODO: refactoring with dispatcher.rb, around thread group, etc. 2007/05/09 by shino
+  class Carriers
+
+    def initialize(queue_manager, config, logger, dispatchers)
+      @qm = queue_manager
+      @config = config
+      @logger = logger
+      @group = ThreadGroup.new
+      @dispatchers = dispatchers
+    end
+
+    def start
+      return unless @config
+      @logger.info{ "ready to start carrires with config #{@config.to_yaml}" }
+      @config.each { |remote|
+        remote["threads"].times { |index|
+          Thread.fork(@group, remote, index){|group, remote, index|
+            carrier_loop(group, remote, index)
+          }
+        }
+      }
+      @logger.info{"queue manager has forked all carriers"}
+    end
+
+    def stop
+      @logger.info{"stop_carriers #{@group}"}
+      return unless @group
+      @group.list.each{|d| d[:dying] = true}
+      @group.list.each{|d| d.join }
+    end
+
+    private
+    def carrier_loop(group, remote, index)
+      # TODO: refactor structure, 2006/10/06 shino
+      group.add Thread.current
+      @logger.info{ "starting a carrier (index #{index}) for the queue manager #{remote['source_uri']}" }
+      uri = remote['source_uri']
+      until Thread.current[:dying]
+        begin
+          sleep 0.1
+          # TODO check :dying flag here and break, 2006/09/01 shino
+          # TODO cache DRbObject if necessary, 2006/09/01 shino
+          remote_qm = DRb::DRbObject.new_with_uri(uri)
+          queue_name = remote_qm.stale_queue dispatch_targets
+          next unless queue_name
+
+          @logger.debug{ "stale queue name : #{queue_name}" }
+          q = ReliableMsg::Queue.new queue_name, :drb_uri => uri
+          q.get { |m|
+            unless m
+              @logger.debug{ "carrier strikes at the air (T_T)" }
+              next
+            end
+            # @logger.debug{ "carrier gets a message\n#{m.to_yaml}" }
+
+            # TODO: decide the better one, and delete another, 2006/09/01 shino
+            # TODO: or switchable implementation in versions, 2006/10/16 shino
+
+            # version 1: use thread fork so queue manager use a different tx
+            # TODO probably should have a thread as an instance variable or in a thread local, 2006/09/01 shino
+            # Thread.fork(m) {|m|
+            #   local_queue = ReliableMsg::Queue.new queue_name
+            #   local_queue.put m.object
+            # }.join
+            
+            #version 2: store tx and set nil, and resotre tx after putting a message
+            begin
+              tx = Thread.current[ReliableMsg::Client::THREAD_CURRENT_TX]
+              Thread.current[ReliableMsg::Client::THREAD_CURRENT_TX] = nil
+              # @logger.debug{ "before tx: #{tx}" }
+              ReliableMsg::Queue.new(queue_name).put(m.object)
+            ensure
+              Thread.current[ReliableMsg::Client::THREAD_CURRENT_TX] = tx
+              # @logger.debug{ "after tx: #{Thread.current[ReliableMsg::Client::THREAD_CURRENT_TX]}" }
+            end
+          }
+        rescue Exception => ex
+          @logger.warn "error in remote-get/local-put #{ex}\n#{ex.backtrace.join("\n\t")}\n"
+        end
+      end
+      @logger.info{"ends a carrier (index #{index}) for the queue manager #{remote['uri']}"}
+    end
+
+    def dispatch_targets
+      @dispatchers.targets
+    end
+
+  end
+end

data/lib/ap4r/dispatcher.rb

@@ -0,0 +1,326 @@
+# Author:: Shunichi Shinohara
+# Copyright:: Copyright (c) 2007 Future Architect Inc.
+# Licence:: MIT Licence
+
+require 'yaml'
+require 'thread'
+require 'pp'
+require 'active_support'
+
+require 'uri'
+require 'net/http'
+require 'xmlrpc/client'
+require 'soap/wsdlDriver'
+
+module Ap4r
+
+  # Represents a group of dispatchers.
+  # Responsibilities are follows:
+  # - polls target queues,
+  # - gets messages from queues, and
+  # - calls a <tt>Dispatchers::Base</tt>'s instance.
+  class Dispatchers
+
+    @@sleep_inverval = 0.1
+
+    @@logger = nil
+    def self.logger
+      @@logger
+    end
+
+    # storage for <tt>Dispatchers::Base</tt>'s subclasses.
+    @@subclasses = {}
+
+    # Stores +klass+ for a dispatch mode +mode+
+    # Each +klass+ is used to create instances to handle dispatching messages.
+    def self.register_dispatcher_class(mode, klass)
+      @@subclasses[mode] = klass
+    end
+
+    # Sum of each dispatcher's target queues.
+    def targets
+      @dispatch_targets
+    end
+
+    def initialize(queue_manager, config, logger_obj)
+      @qm = queue_manager
+      @config = config  # (typically) dispatcher section of queues.cfg
+      @@logger ||= logger_obj
+      raise "no configuration specified" unless @config
+      @group = ThreadGroup.new
+      # TODO: needs refinement 2007/05/30 by shino
+      @dispatch_targets = ""
+    end
+
+    # Starts every dispatcher.
+    # If an exception is detected, this method raise it through with logging.
+    # 
+    def start
+      begin
+        logger.info{ "about to start dispatchers with config\n#{@config.to_yaml}" }
+        @config.each{ |conf|
+          conf["threads"].to_i.times { |index|
+            Thread.fork(@group, conf, index){|group, conf, index|
+              dispatching_loop(group, conf, index)
+            }
+          }
+          @dispatch_targets.concat(conf["targets"]).concat(';')
+          logger.debug{ "dispatch targets are : #{@dispatch_targets}" }
+        }
+        logger.info "queue manager has forked dispatchers"
+      rescue Exception => err
+        logger.warn{"Error in starting dipatchers #{err}"}
+        logger.warn{err.backtrace.join("\n")}
+        raise err
+      end
+    end
+
+    # Stops every dispatcher.
+    # Current implementation makes just dying flags up.
+    # Some threads don't stop quickly in some cases such as blocking at socket read.
+    #--
+    # TODO: needs forced mode? 2007/05/09 by shino
+    def stop
+      logger.info{"stop_dispatchers #{@group}"}
+      return unless @group
+      @group.list.each {|d| d[:dying] = true}
+      @group.list.each {|d| d.join }
+      @dispatch_targets = ""
+    end
+
+    private
+
+    # Creates and returns an appropriate instace.
+    # If no class for +dispatch_mode+, raises an exception.
+    def get_dispather_instance(dispatch_mode, message, conf_per_targets)
+      klass = @@subclasses[dispatch_mode]
+      raise "undefined dispatch mode #{m.headers[:mode]}" unless klass
+      klass.new(message, conf_per_targets)
+    end
+
+    # Defines the general structure for each dispatcher thread 
+    # from begging to end.
+    def dispatching_loop(group, conf, index)
+      group.add(Thread.current)
+      mq = ::ReliableMsg::MultiQueue.new(conf["targets"])
+      logger.info{ "start dispatcher: targets= #{mq}, index= #{index})" }
+      until Thread.current[:dying]
+        # TODO: change sleep interval depending on last result? 2007/05/09 by shino
+        sleep @@sleep_inverval
+        # logger.debug{ "try dispatch #{mq} #{mq.name}" }
+        # TODO: needs timeout?, 2006/10/16 shino
+        begin
+          mq.get{|m|
+            unless m
+              logger.debug{"message is nul"} 
+              break
+            end
+            logger.debug{"dispatcher get message\n#{m.to_yaml}"}
+            response = get_dispather_instance(m.headers[:dispatch_mode], m, conf).call
+            logger.debug{"dispatcher get response\n#{response.to_yaml}"}
+          }
+        rescue Exception => err
+          logger.warn("dispatch err #{err.inspect}")
+          logger.warn(err.backtrace.join("\n"))
+        end
+      end
+      logger.info{"end dispatcher #{mq} (index #{index})"}
+    end
+
+    def logger
+      @@logger
+    end
+
+
+    # A base class for dispathcer classes associated with each <tt>dispatch_mode</tt>.
+    # Responsibilities of subclasses are to implement following methods, only +invoke+
+    # is mandatory and others are optional (no operations by default).
+    # * +modify_message+ to preprocess a message, e.g. rewirte URL or discard message.
+    # * +invoke+ to execute main logic, e.g. HTTP POST call. *mandatory*
+    # * +validate_response+ to judge whether +invoke+ finished successfully.
+    # * +response+ to return the result of +invoke+ process.
+    class Base
+
+      # Difine a constant +DISPATCH_MODE+ to value 'mode_symbol' and
+      # add self to a Converters list.
+      def self.dispatch_mode(mode_symbol)
+        self.const_set(:DISPATCH_MODE, mode_symbol)
+        ::Ap4r::Dispatchers.register_dispatcher_class(mode_symbol, self)
+      end
+
+      # Takes 
+      # * +message+: from a queue
+      # * +conf+: configuration from dispatchers section
+      #--
+      # TODO: Subclass should have +conf+ instead of instance? 2007/06/06 by shino
+      def initialize(message, conf)
+        @message = message
+        @conf = conf
+      end
+
+      # Entry facade for each message processing.
+      # Modifies, invokes (maybe remote), validates, and responds.
+      def call
+        # TODO: rename to more appropriate one 2007/05/10 by shino
+        self.modify_message
+        logger.debug{"Ap4r::Dispatcher after modification\n#{@message.to_yaml}"}
+        self.invoke
+        self.validate_response
+        self.response
+      end
+
+      # Modifies message.
+      # Now only URL modification is implemented.
+      def modify_message
+        modification_rules = @conf["modify_rules"]
+        return unless modification_rules
+        modify_url(modification_rules)
+      end
+
+      # Main logic of message processing.
+      # Maybe calls remote, e.g. HTTP request.
+      def invoke
+        # TODO: rename to more appropriate one 2007/05/10 by shino
+        raise 'must be implemented in subclasses'
+      end
+
+      def validate_response
+        # nop
+      end
+
+      # Returns response.
+      # The return value is also the return value of +call+ method.
+      # By default impl, the instance variable <tt>@response</tt> is used.
+      def response
+        @response
+      end
+
+      private
+      def logger
+        ::Ap4r::Dispatchers.logger
+      end
+
+      # Modifies <tt>:target_url</tt> according to a rule.
+      # TODO: +proc+ in configuration is eval'ed every time. 2007/06/06 by shino
+      def modify_url(modification_rules)
+        proc_for_url = modification_rules["url"]
+        return unless proc_for_url
+
+        url = URI.parse(@message.headers[:target_url])
+        eval(proc_for_url).call(url)
+        @message.headers[:target_url] = url.to_s
+      end
+    end
+
+    # Dispatches via a raw HTTP protocol.
+    # Current implementation uses only a POST method, irrespective of
+    # <tt>options[:target_method]</tt>.
+    #
+    # Determination of "success" is two fold:
+    # * status code should be exactly 200, other codes (including 201-2xx) are 
+    #   treated as error, and
+    # * body should include a string "true"
+    #
+    class Http < Base
+      dispatch_mode :HTTP
+
+      def invoke
+        # TODO: should be added some request headers 2006/10/12 shino
+        #       e.g. X-Ap4r-Version, Accept(need it?)
+        # TODO: Now supports POST only, 2006/10/12 shino
+        @response = nil
+        uri = URI.parse(@message[:target_url])
+        headers = make_header
+        
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          @response, = http.post(uri.path, @message.object, headers)
+        end
+      end
+      
+      def make_header
+        headers = { }
+        @message.headers.map do |k,v|
+          s = StringScanner.new(k.to_s)
+          s.scan(/\Ahttp_header_/)
+          headers[s.post_match] = v if s.post_match
+        end
+        headers
+      end
+      
+      def validate_response
+        logger.debug{"response status [#{@response.code} #{@response.message}]"}
+        validate_response_status(Net::HTTPOK)
+        validate_response_body(/true/)
+      end
+
+      # Checks whether the response status is a kind of +status_kind+.
+      # +status_kind+ should be one of <tt>Net::HTTPRespose</tt>'s subclasses.
+      def validate_response_status(status_kind)
+        #TODO: make the difinition of success variable, 2006/10/13 shino
+        unless @response.kind_of?(status_kind)
+          error_message = "HTTP Response FAILURE, " +
+            "status [#{@response.code} #{@response.message}]"
+          logger.error(error_message)
+          logger.info{@response.to_yaml}
+          #TODO: must create AP4R specific Exception class, 2006/10/12 shino
+          raise StandardError.new(error_message)
+        end
+      end
+
+      # Checks whether the response body includes +pattern+.
+      # +pattern+ should be a regular expression.
+      def validate_response_body(pattern)
+        unless @response.body =~ pattern
+          error_message = "HTTP Response FAILURE, status" +
+            " [#{@response.code} #{@response.message}], body [#{@response.body}]"
+          #TODO: Refactor error logging, 2006/10/13 shino
+          logger.error(error_message)
+          logger.info{@response.to_yaml}
+          #TODO: must create AP4R specific Exception class, 2006/10/12 shino
+          raise StandardError.new(error_message)
+        end
+      end
+
+    end
+
+    # Dispatches via XML-RPC protocol.
+    # Uses +XMLRPC+ library.
+    #
+    # The call result is judged as
+    # * "failure" if the first element of <tt>XMLRPC::Client#call2</tt> result
+    #   is false, and
+    # * "success" otherwise.
+    #
+    class XmlRpc < Base
+      dispatch_mode :XMLRPC
+
+      def invoke
+        endpoint = @message[:target_url]
+        client = XMLRPC::Client.new2(endpoint)
+        @success, @response = client.call2(@message[:target_action], @message.object)
+      end
+
+      def validate_response
+        raise @response unless @success
+      end
+    end
+
+    # Dispatches via SOAP protocol.
+    # Uses +SOAP+ library.
+    #
+    # The call result is judged as
+    # * "success" if <tt>SOAP::WSDLDrive#send</tt> finishes without an exception, and
+    # * "failuar" otherwise.
+    #
+    class SOAP < Base
+      dispatch_mode :SOAP
+
+      def invoke
+        # TODO: nice to cache drivers probably 2007/05/09 by shino
+        driver = ::SOAP::WSDLDriverFactory.new(@message[:target_url]).create_rpc_driver
+        driver.send(@message[:target_action], @message.object)
+      end
+    end
+
+  end
+end