ap4r 0.1.1 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,10 @@
+== 0.2.x
+
+=== 0.2.0 (October 17th, 2006)
+
+* Added: Protocols to invoke asynchronous logics
+* Added: At-lease-once QoS
+
 == 0.1.x
 
 === 0.1.1 (October 5th, 2006)

data/README

@@ -11,7 +11,8 @@ http://rubyforge.org/projects/ap4r/
 1. Business logics can be implemented as simple Web applications, or ruby code, whether it's called asynchronously or synchronously.
 1. Asynchronous messaging is reliable by RDBMS persistence (now MySQL only) or file persistence, under the favor of reliable-msg.
 1. Load balancing over multiple AP4R processes on single/multiple servers is supported.
-1. Asynchronous logics are called via various protocols, such as XML-RPC, SOAP, HTTP PUT, and more. (now implemented just as XML-RPC) 
+1. Asynchronous logics are called via various protocols, such as XML-RPC, SOAP, HTTP PUT, and more.
+1. Using store and forward function, at-least-omce QoS level is provided.
 
 == Typical process flow
 
@@ -124,12 +125,12 @@ Since the asynchronous logic sleeps ten seconds and appends to the file, wait br
 * Make sample application available
   * If you have an SVN client,
 
-     $ svn co svn://rubyforge.org/var/ap4r/tags/ap4r-0.1.0/sample [some directory]
+     $ 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.zip 
+        filename: HelloWorld.tar.gz
 
     1. and extract to an appropricate directory(ex. HelloWorld ).
        There are app/, components/,... directories under HelloWorld. 
@@ -152,6 +153,7 @@ Since the asynchronous logic sleeps ten seconds and appends to the file, wait br
 * 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,
@@ -164,9 +166,7 @@ Since the asynchronous logic sleeps ten seconds and appends to the file, wait br
 
 == Future Plan
 
-* add protocols to invoke asynchronous logics
 * only-once QoS
-* at-lease-once QoS
 * DLQ recovery
 * flow volume control, load balancing
 * 7x24 support (e.g. rolling database tables)

data/Rakefile

@@ -96,10 +96,20 @@ Rake::RDocTask.new { |rdoc|
 
 # AP4R release ----------------------------------------------------------------
 
-desc "Make gem and sample tgz"
-task :release => [ :make_release_dir, :make_sample_tgz, :copy_to_release_dir ]
+desc "Make gem"
+task :gem_release => [ :make_release_dir, :copy_to_ap4r_from_sample, :gem]
 
-task :make_sample_tgz => [ :make_temp_dir, :copy_sample, :make_tgz ]
+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')
+end
+
+desc "Make sample tgz"
+task :sample_release => [ :make_release_dir, :make_sample_tgz, :copy_to_release_dir ]
+
+task :make_sample_tgz => [ :make_temp_dir, :copy_sample, :execute_migration, :make_tgz ]
 
 task :make_release_dir do
   make_dir RELEASE_DIR
@@ -126,6 +136,12 @@ task :copy_sample do
   }
 end
 
+task :execute_migration do
+  Dir.chdir('temp/')
+  `rake db:migrate`
+  Dir.chdir('../')
+end
+
 task :make_tgz do
   Dir.chdir('temp/')
   `tar czvf HelloWorld.tar.gz HelloWorld/`

data/lib/ap4r/queue_manager_ext.rb

@@ -8,12 +8,16 @@ require 'ap4r/retention_history'
 
 require 'soap/wsdlDriver'
 require 'xmlrpc/client'
-require 'active_support'
+require 'uri'
+require 'net/http'
 
+require 'active_support'
 require 'yaml'
 require 'thread'
 require 'pp'
 
+require 'uuid'
+
 module ReliableMsg
   module LifecycleListener #:nodoc:
     
@@ -32,8 +36,8 @@ module ReliableMsg
 
     # Hooks original initialize method to add lifecyle listeners.
     #--
-    # TODO: Make dispatchers and carriers lifecyle listeners
-    # and separate them from QueueManager.
+    # TODO: Make dispatchers and carriers lifecyle listeners, 2006/09/01 shino
+    # TODO: and separate them from QueueManager, 2006/09/01 shino
     def initialize options = nil #:notnew:
       initialize_original options
       @global_lock ||= Mutex.new
@@ -48,13 +52,18 @@ module ReliableMsg
     end
 
     def start
-      @global_lock.synchronize do
-        return if @@active == self
-        @dispatch_targets = ''
-        start_original
-        start_dispatchers
-        start_carriers
-        @lifecycle_listeners.each {|l| l.start }
+      begin
+        @global_lock.synchronize do
+          return if @@active == self
+          @dispatch_targets = ''
+          start_original
+          start_dispatchers
+          start_carriers
+          @lifecycle_listeners.each {|l| l.start }
+        end
+      rescue Exception => err
+        @logger.warn{"Error in starting queue-manager #{err}"}
+        @logger.warn{err.backtrace.join("\n")}
       end
     end
 
@@ -69,49 +78,110 @@ module ReliableMsg
     end
 
     def start_dispatchers
-      return unless @config.dispatchers
-      @logger.info{ "about to start dispatchers with config #{@config.dispatchers.to_yaml}" }
-      @disps = ThreadGroup.new
-      @config.dispatchers.each{ |conf|
-        conf["threads"].to_i.times { |index|
-          Thread.fork(@disps, conf["targets"], index, @logger){|group, targets, index, logger|
-            group.add Thread.current
-            mq = MultiQueue.new targets
-            logger.info{ "start dispatcher: targets= #{mq} (index #{index})" }
-            until Thread.current[:dying]
-              sleep 0.1
-#              logger.debug{ "try dispatch #{mq} #{mq.name}" }
-              begin
-                mq.get{|m|
-                  logger.debug{"dispatcher get message\n#{m.to_yaml}"} if m
-                  # TODO: divede into comcrete classes by protocols.
-
-                  # version 1 SOAP
-#                  driver = SOAP::WSDLDriverFactory.new(m[:target_url]).create_rpc_driver
-#                  logger.debug(driver)
-#                  response = driver.send(m[:target_action], m.object)
-                  # version 2 XML-RPC
-                  endpoint = m[:target_url]
-                  client = XMLRPC::Client.new2(endpoint)
-                  success, response = client.call2(m[:target_action], m.object)
-                  logger.debug{"dispatcher get response\n#{response.to_yaml}"}
-                  raise response unless success
-                }
-              rescue Exception => err
-                logger.warn("dispatch err #{err.inspect}")
-                logger.warn(err.backtrace.join("\n"))
-              end
-            end
-            logger.info "end dispatcher #{mq} (index #{index})"
+      begin
+        return unless @config.dispatchers
+        @logger.info{ "about to start dispatchers with config #{@config.dispatchers.to_yaml}" }
+        @disps = ThreadGroup.new
+        @config.dispatchers.each{ |conf|
+          conf["threads"].to_i.times { |index|
+            Thread.fork(@disps, conf["targets"], index){|group, targets, index|
+              dispatch_loop(group, targets, index)
+            }
           }
+          @dispatch_targets.concat(conf["targets"]).concat(';')
+          @logger.info{ "dispatch targets are : #{@dispatch_targets}" }
         }
-        @dispatch_targets.concat(conf["targets"]).concat(';')
-        @logger.info{ "dispatch queues : #{@dispatch_targets}" }
-      }
-      @logger.info "queue manager has forked dispatchers"
+        @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
+
+    def dispatch_loop(group, targets, index)
+      group.add Thread.current
+      mq = MultiQueue.new targets
+      @logger.info{ "start dispatcher: targets= #{mq} (index #{index})" }
+      until Thread.current[:dying]
+        sleep 0.1
+        # @logger.debug{ "try dispatch #{mq} #{mq.name}" }
+        # TODO: needs timeout?, 2006/10/16 shino
+        begin
+          mq.get{|m|
+            @logger.debug{"dispatcher get message\n#{m.to_yaml}"} if m
+            response = 
+            case m.headers[:dispatch_mode]
+            when :HTTP
+              dispatch_via_http(m)
+            when :XMLRPC
+              dispatch_via_xmlrpc(m)
+            when :SOAP
+              dispatch_via_soap(m)
+            else
+              raise "undefined dispatch mode #{m.headers[:mode]}"
+            end
+            @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
+
+    # Dispatch via a HTTP protocol
+    # Current implementation uses POST method, irrespectively options[:target_method]
+    #
+    # Determination of "success" is two fold
+    # * status code should be 200, other codes (including 201-2xx) are treated as error
+    # * when status code is 200, body should include a string "true"
+    def dispatch_via_http(message)
+      #TODO: Add some request headers e.g. User-Agent and Accept, 2006/10/12 shino
+      #TODO: Now support POST only, 2006/10/12 shino
+      response = Net::HTTP.post_form(URI.parse(message[:target_url]),
+                                     message.object)
+      @logger.debug{"response status [#{response.code} #{response.message}]"}
+
+      #TODO: make the difinition of success variable, 2006/10/13 shino
+      unless response.kind_of?(Net::HTTPOK)
+        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
+ 
+      unless response.body =~ /true/
+        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
+
+      response
+    end
+
+    def dispatch_via_xmlrpc(message)
+      endpoint = message[:target_url]
+      client = XMLRPC::Client.new2(endpoint)
+      success, response = client.call2(message[:target_action], message.object)
+      raise response unless success
+      response
+    end
+
+    def dispatch_via_soap(message)
+      @logger.debug{message[:target_url]}
+      driver = SOAP::WSDLDriverFactory.new(message[:target_url]).create_rpc_driver
+      @logger.debug{driver}
+      driver.send(message[:target_action], message.object)
     end
 
     def stop_dispatchers
+      @logger.info{"stop_dispatchers #{@disps}"}
       return unless @disps
       @disps.list.each {|d| d[:dying] = true}
       @disps.list.each {|d| d.join }
@@ -125,32 +195,34 @@ module ReliableMsg
       @carriers = ThreadGroup.new
       conf.each { |remote|
         remote["threads"].times { |index|
-          Thread.fork(@carriers, remote, index, @logger){|group, remote, index, logger|
+          Thread.fork(@carriers, remote, index){|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']}" }
+            @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
-                #TODO cache DRbObject if necessary
+                #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}" }
+                @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)" }
+                    @logger.debug{ "carrier strikes at the air (T_T)" }
                     next
                   end
-                  #logger.debug{ "carrier gets a message\n#{m.to_yaml}" }
+                  # @logger.debug{ "carrier gets a message\n#{m.to_yaml}" }
 
-                  # TODO: decide the better one, and delete another.
+                  # 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
+                  # 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
@@ -160,29 +232,29 @@ module ReliableMsg
                   begin
                     tx = Thread.current[ReliableMsg::Client::THREAD_CURRENT_TX]
                     Thread.current[ReliableMsg::Client::THREAD_CURRENT_TX] = nil
-                    #logger.debug{ "before tx: #{tx}" }
+                    # @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]}" }
+                    # @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"
+                @logger.warn "error in remote-get/local-put #{ex}\n#{ex.backtrace.join("\n\t")}\n"
               end
             end
-            logger.info "ends carrier (index #{index}) for the queue manager #{remote['uri']}"
+            @logger.info{"ends a carrier (index #{index}) for the queue manager #{remote['uri']}"}
           }
         }
       }
-      @logger.info "queue manager has forked carriers"
+      @logger.info{"queue manager has forked all carriers"}
     end
 
     def stop_carriers
-      @logger.info "stop_carriers #{@carriers}"
+      @logger.info{"stop_carriers #{@carriers}"}
       return unless @carriers
-      @carriers.list.each {|d| d[:dying] = true}
-      @carriers.list.each {|d| d.join }
+      @carriers.list.each{|d| d[:dying] = true}
+      @carriers.list.each{|d| d.join }
     end
 
   end

data/lib/ap4r/store_and_forward.rb

@@ -0,0 +1,126 @@
+# Author:: Kiwamu Kato
+# Copyright:: Copyright (c) 2006 Future System Consulting Corp.
+# Licence:: MIT Licence
+
+begin require 'rubygems'; rescue LoadError; end
+
+require 'reliable-msg'
+require 'ap4r/stored_message'
+
+module AP4R
+
+  # This +StoreAndForward+ provides at-least-once QoS level which 
+  # guarantees not to lose any message.
+  #
+  # Example:
+  #   
+  #   include StoreAndFoward
+  #
+  #   name = "queue.test.sample"
+  #   message = "hogehoge"
+  #   options = {}
+  #
+  #   sm = StoreMessages.store(name, message, options)
+  #   forward_by_queue_info(sm.id, {:queue_name => name, 
+  #    :queue_message => message, :queue_headers => options})
+  #
+  module StoreAndForward
+      
+    DRUBY_URI = "druby://#{ENV['AP4R_DRUBY_HOST']||'localhost'}:#{ENV['AP4R_DRUBY_PORT'] || \
+'6438'}"
+
+    # This method needs information about stored message, such as 
+    # putting queue's name, message, options, as aruments.
+    # And those values stucked queue_info hash and following keys are necessary.
+    # * :queue_name
+    # * :queue_message
+    # * :queue_headers
+    #
+    # As :queue_headers, some options are supported.
+    # See the reliable-msg docuememt for more details.
+    #
+    # And this method's options is now :delete_mode only. 
+    # See the StoreMessage rdoc for more details.
+    #
+    def __ap4r_forward_by_queue_info(stored_message_id, queue_info, options)
+      __ap4r_queue_put(queue_info[:queue_name], queue_info[:queue_message], queue_info[:queue_headers])
+      StoredMessage.destroy_if_exists(stored_message_id, options)
+    end
+    alias :forward_by_queue_info :__ap4r_forward_by_queue_info
+
+
+    # This method does't need information about stored message.
+    # All that is required is stored_message_id.
+    # Find target record by stored_message_id, make queue information, such as
+    # queue name, message, options, for putting into queue.
+    # Now under implementation.
+    #
+    # And this method's options is now :delete_mode only. 
+    # See the StoreMessage rdoc for more details.
+    #
+    def __ap4r_forward_by_stored_message_id(stored_message_id, options)
+      # TODO: Find record and make queue info , 2006/10/13 kato-k
+      queue_name = nil
+      queue_message = nil
+      queue_headers = nil
+      __ap4r_forward_by_queue_info(queue_name, queue_message, queue_headers)
+    end
+    alias :forward_by_stored_message_id :__ap4r_forward_by_stored_message_id 
+
+    
+    # Put a message into queue.
+    # As queue_headers, some options are supported.
+    # See the reliable-msg docuememt for more details.
+    def __ap4r_queue_put(queue_name, queue_message, queue_headers)
+      q = ReliableMsg::Queue.new(queue_name, :drb_uri => @@drb_uri || DRUBY_URI)
+      q.put(queue_message, queue_headers)
+    end
+    alias :queue_put :__ap4r_queue_put
+
+  end
+end
+
+#--
+# For test
+if __FILE__ == $0
+
+  class TestSaf
+
+    include ::AP4R::StoreAndForward
+
+    def connect
+      unless ActiveRecord::Base.connected?
+        #TODO: Get parameters from config, 2006/10/12 kato-k
+        ActiveRecord::Base.establish_connection(
+                                                :adapter => 'sqlite3',
+                                                :database => '../../samples/HelloWorld/db/hello_world_development.db'
+                                                )
+      end
+    end
+
+    def async_dispatch_with_saf(queue_name, queue_message, rm_options = {})
+
+      connect()
+      stored_message_id = ::AP4R::StoredMessage.store(queue_name, queue_message, rm_options)
+      forward_by_queue_info(
+             stored_message_id, 
+             {
+               :queue_name => queue_name, 
+               :queue_message => queue_message, 
+               :queue_headers => rm_options
+             }, 
+             options = {} )   
+    end
+  end
+
+  queue_message = "Hello World !"
+  queue_name = "queue.test.sample"
+  rm_options = {
+    :drb_uri=>"druby://localhost:6437",
+    :priority => 0,
+    :delivery => :repeated
+  }
+
+  TestSaf.new.async_dispatch_with_saf(queue_name, queue_message, rm_options)
+
+end

data/lib/ap4r/stored_message.rb

@@ -0,0 +1,95 @@
+# Author:: Kiwamu Kato
+# Copyright:: Copyright (c) 2006 Future System Consulting Corp.
+# Licence:: MIT Licence
+
+begin 
+  require 'active_record'
+  require 'uuid'
+rescue LoadError
+  require 'rubygems'
+  require_gem 'activerecord'
+  require_gem 'uuid'
+end
+
+module AP4R
+
+  # This class is the model class for SAF(store and foward).
+  # The migration file is located at following path,
+  #   ap4r/lib/ap4r/xxx_create_table_for_saf.rb
+  # Don't forget to create table, before use SAF.
+  class StoredMessage < ActiveRecord::Base
+
+    STATUS_STORED = 0
+    STATUS_FORWARDED = 1
+    STATUS_FAILED = -1
+
+    PHYSICAL = :physical
+    LOGICAL = :logical
+
+    #--
+    # TODO: modify directory structure and be reloadable, 2006/10/17 kato-k
+    #++
+    # Temporarily, exclude this class from auto-reload targets of rails.  
+    def self.reloadable?
+      false
+    end
+
+    # Insert queue information, such as queue name and message,  for next logic.
+    #
+    # duplication_check_id is generated from UUID and should be unique
+    # in all records of StoreMessages. 
+    # So, using this id, it's possible to protect to execute same asynchronous 
+    # processing by same message.
+    # But by default, record of StoreMessages is removed after putting a message 
+    # into queue completed.
+    #
+    def self.store(queue_name, queue_message, rm_options = {})
+      sm = StoredMessage.new do |s|
+        s.duplication_check_id = UUID.new
+        s.queue = queue_name
+        s.status = STATUS_STORED
+        s.object = Marshal::dump(queue_message)
+        s.headers = Marshal::dump(rm_options)
+      end
+
+      begin
+        sm.save!
+      rescue Exception => error
+        raise error
+      end  
+      sm
+    end
+
+    # Destroy a record by id.
+    # Some options are supported.
+    # * :delete_mode (:physical or :logical)
+    # Default delete mmode is physical.
+    # If you need logical delete, for example you neeed checking message
+    # duplication etc, Set the instance variable appropriately. 
+    def self.destroy_if_exists(id, options)
+      result = nil
+      begin
+        result = StoredMessage.find(id) 
+      rescue ActiveRecord::RecordNotFound
+        # There are chances that othere thread or process already forwarded. 
+        return nil
+      end
+      result.destroy_or_update(options)
+    end
+
+    def destroy_or_update(options = {:delete_mode => PHYSICAL})
+      case options[:delete_mode]
+      when PHYSICAL
+        # TODO: Confirm to raise error, 2006/10/17 kato-k 
+        self.destroy
+      when LOGICAL
+        self.status = STATUS_FORWARDED
+        self.save!
+      else
+        raise "unknown delete mode: #{options[:delete_mode]}"
+      end
+      self
+    end
+
+  end
+end

data/lib/ap4r/version.rb

@@ -7,8 +7,8 @@ module AP4R
   # its string expression.
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
-    TINY  = 1
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/rails_plugin/ap4r/init.rb

@@ -3,8 +3,8 @@
 # Licence:: MIT Licence
 
 require_dependency 'async_controller'
+require_dependency 'ap4r/stored_message'
 
 class ActionController::Base
-  include AP4R::AsyncController
+  include AP4R::AsyncController::Base
 end
-

data/rails_plugin/ap4r/lib/async_controller.rb

@@ -3,6 +3,7 @@
 # Licence:: MIT Licence
 
 require 'reliable-msg'
+#require 'ap4r/stored_message'
 
 module AP4R
   # This +asyncController+ is the Rails plugin for asynchronous processing.
@@ -11,54 +12,272 @@ module AP4R
   #
   # Examples: The part of calling next asynchronous logics in a controller in the HelloWorld Sample.
   #
-  #     req = WorldRequest.new
-  #     req.world_id = 1
-  #     req.message = "World"
-  #
-  #     req_hash = {}
-  #     req.each_pair{|k,v| req_hash[k.to_sym]=v}
+  #     req = WorldRequest.new([:world_id => 1, :message => "World"})
+  #     async_dispatch(req,
+  #                     {:controller => 'async_world', :action => 'execute',
+  #                     :mode => :XMLRPC })
   #
   #     render :action => 'response'
   #
-  #     async_dispatch(req_hash,
-  #                     :controller => 'async_world', :action => 'execute',
-  #                     :mode => :XMLRPC)
-  #
   module AsyncController
-    #DEFAULT_DISPATCH_MODE = :SOAP
-    DEFAULT_DISPATCH_MODE = :XMLRPC
-
-    # Queue a message for next asynchronous logic. Some options are supported.
-    # * :controller (name of next logic)
-    # * :action (name of next logic)
-    # * :mode (protocol)
-    def async_dispatch(object, options = {})
-      target_url = url_for(:controller => options[:controller],
-                           :action => nil)
-      options[:mode] = options[:mode] || dispatch_mode
-      options[:target_url] = target_url_name(target_url, options[:mode])
-      target_action = action_api_name(options.delete(:action), options[:mode])
-      options[:target_action] = target_action
-
-      queue_name = "queue.".concat(options[:controller].to_s).
-        concat('.').concat(target_action)
-
-      q = ReliableMsg::Queue.new(queue_name)
-      mid = q.put(object, options)
-      mid
-    end
-    
-    private
-    def dispatch_mode
-      DEFAULT_DISPATCH_MODE
-    end
+      
+    module Base
+      Converters = {}
+      DRUBY_URI = "druby://#{ENV['AP4R_DRUBY_HOST']||'localhost'}:#{ENV['AP4R_DRUBY_PORT'] || '6438'}"
+
+      @@default_dispatch_mode = :XMLRPC
+      @@default_rm_options = { :delivery => :once }
+      @@default_queue_prefix = "queue."
+
+      mattr_accessor :default_dispatch_mode, :default_rm_options, :default_queue_prefix
+
+      # Provide at-least-once QoS level.
+      # Execute application logic and store the message for next logic to the application
+      # database. This is a store processing. After commit to the database, 
+      # put the message into queue and update or delte a management table.
+      # This is a forward processing.
+      # SAF(store and forward) processing like this guarantees that any message 
+      # is never lost and keeps reasonable performance.   
+      # 
+      # Examples: Just call async_dispath method in this block.
+      #
+      #     transaction_with saf do
+      #       req = WorldRequest.new([:world_id => 1, :message => "World"})
+      #       async_dispatch(req,
+      #                       {:controller => 'async_world', :action => 'execute',
+      #                       :mode => :XMLRPC })
+      #
+      #       render :action => 'response'
+      #     end
+      #
+      def transaction_with_saf(active_record_class = StoredMessage, *objects, &block)
+
+        Thread.current[:use_saf] = true
+        Thread.current[:stored_messages] = {}
+
+        # store
+        active_record_class ||= StoredMessage
+        active_record_class.transaction(*objects, &block)
+
+        # forward
+        forwarded_messages = {}
+        begin
+
+          # TODO: reconsider forwarding strategy, 2006/10/13 kato-k
+          # Once some error occured, such as disconnect reliable-msg or server crush,
+          # which is smart to keep to put a message or stop to do it?
+          # In the case of being many async messages, the former strategy is not so good.
+          Thread.current[:stored_messages].each {|k,v|
+            __queue_put(v[:queue_name], v[:queue_message], v[:queue_headers])
+            forwarded_messages[k] = v
+          }
+        rescue Exception => err
+          # Don't raise any Exception. Response to user already completed. 
+          # nop
+          logger.warn("Failed to put a message into queue: #{err}")
+        end
+      
+        begin
+          StoredMessage.transaction do
+            options = {:delete_mode => @delete_mode || :physical}
+            forwarded_messages.keys.each {|id|
+              ::AP4R::StoredMessage.destroy_if_exists(id, options)
+            }
+          end
+        rescue Exception => err
+          # Don't raise any Exception. Response to user already completed. 
+          # nop
+          logger.warn("Failed to put a message into queue: #{err}")
+        end
+        
+      ensure     
+        Thread.current[:use_saf] = false
+        Thread.current[:stored_messages] = nil
+      end
+
+      # Queue a message for next asynchronous logic. Some options are supported.
+      #
+      # Use options to specify target url, etc.
+      # Accurate meanings are defined by a individual converter class.
+      # * :controller (name of next logic)
+      # * :action (name of next logic)
+      #
+      # Use rm_options to pass parameter in queue-put.
+      # Listings below are AP4R extended options.
+      # See the reliable-msg docuememt for more details.
+      # * :target_url (URL of target, prevail over :controller)
+      # * :target_action (action of target, prevail over :action)
+      # * :target_method (HTTP method, e.g. "GET", "POST", etc.)
+      # * :dispatch_mode (protocol in dispatching)
+      # * :queue_name (prevail over :controller and :action)
+      #
+      # Object of argumemts (async_params, options and rm_options) will not be modified.
+      # Implementors (of this class and converters) should not modify them.
+      #
+      def async_dispatch(async_params = nil, options = {}, rm_options = nil)
+        if logger.debug?
+          logger.debug("async_params: ")
+          logger.debug(async_params.inspect)
+          logger.debug("options: ")
+          logger.debug(options.inspect)
+          logger.debug("rm_options")
+          logger.debug(rm_options.inspect)
+        end
+
+        # TODO: clone it, 2006/10/16 shino
+        options ||= {}
+        rm_options = @@default_rm_options.merge(rm_options || {})
+        # TODO: put into :dispatch_mode to @@default_rm_options
+        rm_options[:dispatch_mode] ||= @@default_dispatch_mode
+
+        # Only async_params is not cloned. options and rm_options are cloned before now.
+        # This is a current contract between this class and converter classes.
+        converter = Converters[rm_options[:dispatch_mode]].new(self, async_params, options, rm_options)
+        logger.debug{"druby uri for queue-manager : #{DRUBY_URI}"}
+
+        queue_name = __get_queue_name(options, rm_options)
+        queue_message = converter.make_params
+        queue_headers = converter.make_rm_options
+
+        if Thread.current[:use_saf]
+          stored_message = ::AP4R::StoredMessage.store(queue_name, queue_message, queue_headers)
+
+          Thread.current[:stored_messages].store(
+                                                 stored_message.id, 
+                                                 {
+                                                   :queue_message => queue_message, 
+                                                   :queue_name => queue_name,
+                                                   :queue_headers => queue_headers 
+                                                 } )
+          return stored_message.id
+        end 
+
+        __queue_put(queue_name, queue_message, queue_headers)
+      end
+
+      private
+      def __queue_put(queue_name, queue_message, queue_headers)
+        q = ReliableMsg::Queue.new(queue_name, :drb_uri => DRUBY_URI)
+        q.put(queue_message, queue_headers)
+      end
+
+      def __get_queue_name(options, rm_options)
+        rm_options[:queue_name] ||
+          @@default_queue_prefix.concat(options[:controller].to_s).concat('.').concat(options[:action].to_s)
+      end
 
-    def target_url_name(target_url, mode)
-      target_url + "/api"
     end
 
-    def action_api_name(action_method_name, mode)
-      action_method_name.capitalize
+    #--
+    # TODO: pluralize it, 2006/10/16 shino
+    module Converter #:nodoc:
+
+      # A base class for converter classes.
+      # Responsibilities of subclasses are as folows
+      # * by +make_params+, convert async_params to appropriate object
+      # * by +make_rm_options+, make appropriate +Hash+ passed by <tt>ReliableMsg::Queue#put</tt>
+      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::AsyncController::Base::Converters[mode_symbol] = self
+        end
+
+        def initialize(controller, async_params, options, rm_options)
+          @controller = controller
+          @async_params = async_params
+          @options = options
+          @rm_options = rm_options
+        end
+
+        # helper method for <tt>ActionController#url_for</tt>
+        def url_for(url_for_options, *parameter_for_method_reference)
+          @controller.url_for(url_for_options, *parameter_for_method_reference)
+        end
+
+        # Returns a object which passed to <tt>ReliableMsg::Queue.put(message, headers)</tt>'s
+        # first argument +message+.
+        # Should be implemented by subclasses.
+        def make_params
+          raise 'must be implemented'
+        end
+
+        # Returns a object which passed to <tt>ReliableMsg::Queue.put(message, headers)</tt>'s
+        # second argument +headers+.
+        # Should be implemented by subclasses.
+        def make_rm_options
+          raise 'must be implemented'
+        end
+      end
+
+      class Http < Base
+        dispatch_mode :HTTP
+
+        def make_params
+          @async_params
+        end
+
+        def make_rm_options
+          @rm_options[:target_url] ||= url_for(@options)
+          @rm_options[:target_method] ||= 'POST'
+          #TODO: make option key to specify HTTP headers, 2006/10/16 shino
+          @rm_options
+        end
+      end
+
+      class WebService < Base
+        def make_params
+          message_obj = {}
+          @async_params.each_pair{|k,v| message_obj[k.to_sym]=v}
+          message_obj
+        end
+
+        def make_rm_options
+          @rm_options[:target_url] ||= target_url_name
+          @rm_options[:target_action] ||= action_api_name
+          @rm_options
+        end
+        
+        def action_api_name
+          action_method_name = @options[:action]
+          action_method_name.camelcase
+        end
+
+        def options_without_action
+          new_opts = @options.dup
+          new_opts[:action] = nil
+          new_opts
+        end
+          
+      end
+
+      class XmlRpc < WebService
+        dispatch_mode :XMLRPC
+
+        def target_url_name
+          url_for(options_without_action) + rails_api_url_suffix
+        end
+        
+        private
+        def rails_api_url_suffix
+          '/api'
+        end
+      end
+
+      class SOAP < WebService
+        dispatch_mode :SOAP
+
+        def target_url_name
+          url_for(options_without_action) + rails_wsdl_url_suffix
+        end
+
+        private
+        def rails_wsdl_url_suffix
+          '/service.wsdl'
+        end
+      end
+
     end
   end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ap4r
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2006-10-05 00:00:00 +09:00
+  version: 0.2.0
+date: 2006-10-17 00:00:00 +09:00
 summary: Asynchronous Processing for Ruby.
 require_paths: 
 - lib
@@ -29,48 +29,50 @@ authors:
 - Shunichi Shinohara
 - Kiwamu Kato
 files: 
-- bin
 - CHANGELOG
-- config
-- lib
-- MIT-LICENSE
-- rails_plugin
 - Rakefile
+- bin
 - README
+- lib
+- MIT-LICENSE
+- config
 - script
+- rails_plugin
 - bin/ap4r_setup
-- config/ap4r_settings.rb
-- config/log4r.yaml
-- config/queues.cfg
 - config/queues_disk.cfg
 - config/queues_mysql.cfg
+- config/log4r.yaml
+- config/ap4r_settings.rb
+- config/queues.cfg
 - rails_plugin/ap4r
 - rails_plugin/ap4r/init.rb
 - rails_plugin/ap4r/lib
 - rails_plugin/ap4r/lib/async_controller.rb
 - script/irm
-- script/loop.cmd
+- script/stop
 - script/loop.rb
 - script/start
-- script/stop
-- lib/ap4r
+- script/loop.cmd
 - lib/ap4r.rb
-- lib/ap4r/message_store_ext.rb
-- lib/ap4r/multi_queue.rb
+- lib/ap4r
 - lib/ap4r/queue_manager_ext.rb
 - lib/ap4r/queue_manager_ext_debug.rb
+- lib/ap4r/stored_message.rb
+- lib/ap4r/store_and_forward.rb
 - lib/ap4r/retention_history.rb
-- lib/ap4r/script
-- lib/ap4r/start_with_log4r.rb
 - lib/ap4r/util
+- lib/ap4r/start_with_log4r.rb
+- lib/ap4r/multi_queue.rb
+- lib/ap4r/message_store_ext.rb
+- lib/ap4r/script
 - lib/ap4r/version.rb
+- lib/ap4r/util/loc.rb
+- lib/ap4r/util/queue_client.rb
+- lib/ap4r/util/irm.rb
 - lib/ap4r/script/base.rb
+- lib/ap4r/script/workspace_generator.rb
 - lib/ap4r/script/queue_manager_control.rb
 - lib/ap4r/script/setup.rb
-- lib/ap4r/script/workspace_generator.rb
-- lib/ap4r/util/irm.rb
-- lib/ap4r/util/loc.rb
-- lib/ap4r/util/queue_client.rb
 test_files: []
 
 rdoc_options: