ap4r 0.3.6 → 0.3.7

data/History.txt

@@ -1,4 +1,6 @@
 == 0.3.x
+* Fixed: qdb connection via PostgresPR etc.
+         Based on a patch from cypher256 <kashihara at gmail.com>
 
 === 0.3.6 (February 6, 2008)
 * Added: configuration to set HTTP timeout.

data/Manifest.txt

@@ -11,7 +11,9 @@ config/queues_ar.cfg
 config/queues_disk.cfg
 config/queues_mysql.cfg
 config/queues_pgsql.cfg
+fresh_rakefile
 lib/ap4r.rb
+lib/ap4r/async_helper.rb
 lib/ap4r/carrier.rb
 lib/ap4r/db/migrate/001_reliable_msg_queue_and_topic.rb
 lib/ap4r/dispatcher.rb
@@ -39,6 +41,8 @@ lib/ap4r/util/queue_client.rb
 lib/ap4r/version.rb
 lib/ap4r/xxx_create_table_for_saf.rb
 lib/ap4r/xxx_create_table_for_saf_to_postgresql.rb
+lib/tasks/ap4r.rb
+lib/tasks/databases.rake
 rails_plugin/ap4r/init.rb
 rails_plugin/ap4r/lib/ap4r/queue_put_stub.rb
 rails_plugin/ap4r/lib/ap4r/service_handler.rb
@@ -49,6 +53,7 @@ script/irm
 script/mongrel_ap4r
 script/start
 script/stop
+spec/local/async_helper_queue_put_spec.rb
 spec/local/dispatcher_base_spec.rb
 spec/local/message_builder_spec.rb
 spec/local/send_message_handler_spec.rb

data/Rakefile

@@ -18,7 +18,7 @@ begin
       p.email = %q{shinohara.shunichi@future.co.jp, kato.kiwamu@future.co.jp}
 
       p.extra_deps << ['reliable-msg', '=1.1.0']
-      p.extra_deps << ['activesupport']
+#      p.extra_deps << ['activesupport']
       p.extra_deps << ['mongrel']
       p.extra_deps << ['rake']
       p.extra_deps << ['hoe']
@@ -151,26 +151,6 @@ task :stats => "release:copy_plugin" do
                      ).to_s
 end
 
-namespace :qdb do
-  desc "Make queue and topic tables through scripts in lib/ap4r/db/migrate."
-  task :migrate do
-
-    # Todo: configurable file name, 2007/10/01 kiwamu
-    ap4r_config_file = "config/queues_ar.cfg"
-    ap4r_config = YAML::load(ERB.new(IO.read(ap4r_config_file)).result)
-    database_config = ap4r_config["store"]
-    if "activerecord" == database_config["type"].downcase
-      database_config["adapter"] = database_config["adapter"].downcase
-    else
-      # Todo
-    end
-    ActiveRecord::Base.logger = Logger.new(STDOUT)
-    ActiveRecord::Base.establish_connection(database_config)
-
-    ActiveRecord::Migrator.migrate("lib/ap4r/db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
-  end
-end
-
 todos_dirs = %w(lib rails_plugin spec)
 
 desc "List TODO comments in #{todos_dirs.join(", ")} directories"

data/config/queues_pgsql.cfg

@@ -1,12 +1,13 @@
---- 
-store: 
+---
+store:
   type: postgresql
-  uri: # default is tcp://localhost:5432
+  host: localhost
+  port: 5432
   database: ap4r
   username: ap4r
   password: ap4r
-drb: 
-  host: 
+drb:
+  host:
   port: 6438
   acl: allow 127.0.0.1 allow ::1 allow 10.0.0.0/8
 dispatchers:
@@ -14,6 +15,6 @@ dispatchers:
     targets: queue.*
     threads: 1
 #carriers:
-#  - 
+#  -
 #    source_uri: druby://another.host.local:6438
 #    threads: 1

data/fresh_rakefile

@@ -0,0 +1,10 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'ap4r'
+require 'tasks/ap4r'
+

data/lib/ap4r/async_helper.rb

@@ -0,0 +1,375 @@
+# Author:: Shunichi Shinohara
+# Copyright:: Copyright (c) 2007 Future Architect Inc.
+# Licence:: MIT Licence
+
+require 'reliable-msg'
+require 'ap4r/stored_message'
+require 'ap4r/message_builder'
+
+module Ap4r
+
+  # This +AsyncHelper+ is included to +Ap4rClient+ and works the Rails plugin
+  # for asynchronous processing.
+  #
+  module AsyncHelper
+
+    module Base
+      Converters = {}
+
+      DRUBY_HOST = ENV['AP4R_DRUBY_HOST'] || 'localhost'
+      DRUBY_PORT = ENV['AP4R_DRUBY_PORT'] || '6438'
+      DRUBY_URI = "druby://#{DRUBY_HOST}:#{DRUBY_PORT}"
+
+      @@druby_uris = [DRUBY_URI]
+      @@druby_uri_options = { :rotate => false, :fail_over => false, :fail_reuse => false }
+      @@druby_uri_retry_count = 0
+      @@druby_uris_size = 1
+
+      @@default_dispatch_mode = :HTTP
+      @@default_rm_options = { :delivery => :once, :dispatch_mode => @@default_dispatch_mode }
+      @@default_queue_prefix = "queue."
+
+      mattr_accessor :default_dispatch_mode, :default_rm_options, :default_queue_prefix, :saf_delete_mode
+
+      def druby_uris(uris, options = {})
+        @@druby_uris = []
+        if uris.empty?
+          @@druby_uris << DRUBY_URI
+        else
+          @@druby_uris << uris
+          @@druby_uris.flatten!
+        end
+        @@druby_uri_options = @@druby_uri_options.merge(options)
+        @@druby_uris_size = @@druby_uris.size
+        @@druby_uri_retry_count = 0
+      end
+      module_function :druby_uris
+
+      # This method is aliased as ::Ap4r::Client#transaction
+      #
+      def transaction_with_saf(active_record_class = ::Ap4r::StoredMessage, *objects, &block)
+
+        Thread.current[:use_saf] = true
+        Thread.current[:stored_messages] = {}
+
+        # store
+        active_record_class ||= ::Ap4r::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.
+          #
+          # TODO: add delayed forward mode 2007/05/02 by shino
+          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. Application logic has already completed and messages are saved.
+          logger.warn("Failed to put a message into queue: #{err}")
+        end
+
+        begin
+          StoredMessage.transaction do
+            options = {:delete_mode => @@saf_delete_mode || :physical}
+            forwarded_messages.keys.each {|id|
+              ::Ap4r::StoredMessage.destroy_if_exists(id, options)
+            }
+          end
+        rescue Exception => err
+          # Don't raise any Exception. Application logic has already completed and messages are saved.
+          logger.warn("Failed to put a message into queue: #{err}")
+        end
+
+      ensure
+        Thread.current[:use_saf] = false
+        Thread.current[:stored_messages] = nil
+      end
+
+      # This method is aliased as ::Ap4r::Client#async_to
+      #
+      def async_dispatch(url_options = {}, async_params = {}, rm_options = {}, &block)
+
+        if logger.debug?
+          logger.debug("url_options: ")
+          logger.debug(url_options.inspect)
+          logger.debug("async_params: ")
+          logger.debug(async_params.inspect)
+          logger.debug("rm_options: ")
+          logger.debug(rm_options.inspect)
+        end
+
+        rm_options = @@default_rm_options.merge(rm_options || {})
+
+        # 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(url_options, async_params, rm_options, self)
+        # logger.debug("druby uri for queue-manager : #{@@druby_uris.first}")
+
+        queue_name = converter.queue_name
+        queue_message = converter.make_params
+        queue_headers = converter.make_rm_options
+
+        message_builder = ::Ap4r::MessageBuilder.new(queue_name, queue_message, queue_headers)
+        if block_given?
+          message_builder.instance_eval(&block)
+        end
+        queue_name = message_builder.queue_name
+        queue_headers = message_builder.message_headers
+        # TODO: proces flow of Converter and MessageBuilder should (probably) be reversed 2007/09/19 by shino
+        # This branching is ad-hoc fix
+        if queue_headers[:dispatch_mode] == :HTTP
+          queue_message = message_builder.format_message_body
+        else
+          queue_message = message_builder.message_body
+        end
+
+
+        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)
+        # TODO: can use a Queue instance repeatedly? 2007/05/02 by shino
+        begin
+          druby_uri = @@druby_uris.first
+          logger.debug "Trying to connect to #{druby_uri} (druby uri list : #{@@druby_uris.join(", ")})."
+
+          q = ReliableMsg::Queue.new(queue_name, :drb_uri => druby_uri)
+          q.put(queue_message, queue_headers)
+
+          logger.debug "#{druby_uri} was connected and message was enqueued successfully."
+          @@druby_uri_retry_count = 0
+          __rotate_druby_uri if @@druby_uri_options[:rotate]
+        rescue DRb::DRbConnError => err
+          raise err unless @@druby_uri_options[:fail_over]
+          logger.debug "#{druby_uri} was not connected."
+
+          unconnected_uri = @@druby_uris.shift
+          raise "No more active druby uri." if @@druby_uris.empty?
+
+          @@druby_uris << unconnected_uri if @@druby_uri_options[:fail_reuse]
+          @@druby_uri_retry_count += 1
+
+          if @@druby_uri_retry_count >= @@druby_uris_size
+            @@druby_uri_retry_count = 0
+            logger.debug "All registered druby uri was not connected."
+            raise err
+          end
+
+          __queue_put(queue_name, queue_message, queue_headers)
+        end
+      end
+
+      def __rotate_druby_uri()
+        druby_uri = @@druby_uris.shift
+        @@druby_uris << druby_uri
+      end
+
+    end
+
+    module Converters #: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::AsyncHelper::Base::Converters[mode_symbol] = self
+        end
+
+        def initialize(url_options, async_params, rm_options, url_for_handler)
+          @url_options = url_options
+          @async_params = async_params
+          @rm_options = rm_options
+          @url_for_handler = url_for_handler
+        end
+
+        # Returns a queue name to which a message will be queued.
+        # Should be implemented by subclasses.
+        def queue_name
+          raise 'must be implemented in subclasses'
+        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 in subclasses'
+        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 in subclasses'
+        end
+
+        private
+        # helper method for <tt>ActionController#url_for</tt>
+        def url_for(url_for_options, *parameter_for_method_reference)
+          return url_for_options if url_for_options.kind_of?(String)
+          @url_for_handler.url_for(url_for_options, *parameter_for_method_reference)
+        end
+
+      end
+
+      class ToRailsBase < Base
+        def initialize(url_options, async_params, rm_options, url_for_handler)
+          super
+
+          @url_options ||= {}
+          @url_options[:controller] ||= @url_for_handler.controller_path.gsub("/", ".")
+          @url_options[:url] ||= {:controller => url_options[:controller], :action => url_options[:action]}
+          @url_options[:url][:controller] ||= url_options[:controller] if url_options[:url].kind_of?(Hash)
+        end
+
+        def queue_name
+          queue_name = @rm_options[:queue]
+          return queue_name if queue_name
+
+          queue_prefix = ::Ap4r::AsyncHelper::Base.default_queue_prefix
+          queue_prefix = queue_prefix.chomp(".")
+          url = @url_options[:url]
+          if url.kind_of?(Hash)
+            @rm_options[:queue] ||=
+              [queue_prefix, url[:controller].to_s, url[:action].to_s].join(".")
+          else
+            @rm_options[:queue] ||=
+              "#{queue_prefix}.#{URI.parse(url).path.gsub("/", ".")}"
+          end
+          @rm_options[:queue]
+        end
+      end
+
+      class Http < ToRailsBase
+        dispatch_mode :HTTP
+
+        def make_params
+          @async_params
+        end
+
+        def make_rm_options
+          @rm_options[:target_url] ||= url_for(@url_options[:url])
+          @rm_options[:target_method] ||= 'POST'
+          #TODO: make option key to specify HTTP headers, 2006/10/16 shino
+          @rm_options
+        end
+      end
+
+      class WebService < ToRailsBase
+        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 = @url_options[:url][:action]
+          action_method_name.camelcase
+        end
+
+        def options_without_action
+          @url_options[:url].reject{ |k,v| k == :action }
+        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
+
+      class Druby < Base
+        OPTION_KEY = :receiver
+        dispatch_mode :druby
+
+        @@default_url = "druby://localhost:9999"
+        cattr_accessor :default_url
+
+        def initialize(url_options, async_params, rm_options, url_for_handler)
+          super
+          @url_options[:url] ||= @@default_url
+        end
+
+        def queue_name
+          queue_name = @rm_options[:queue]
+          return queue_name if queue_name
+
+          @rm_options[:queue] =
+            [AsyncHelper::Base.default_queue_prefix.chomp("."),
+             @url_options[OPTION_KEY].to_s || "druby",
+             @url_options[:message].to_s].join(".")
+          @rm_options[:queue]
+        end
+
+        def make_params
+          @async_params
+        end
+
+        def make_rm_options
+          @rm_options[:target_url] ||=
+            if @url_options[OPTION_KEY]
+              "#{@url_options[:url]}?#{@url_options[OPTION_KEY]}"
+            else
+              @url_options[:url]
+            end
+          @rm_options[:target_method] = @url_options[:message]
+          @rm_options
+        end
+      end
+
+    end
+  end
+end

data/lib/ap4r/dispatcher.rb

@@ -21,9 +21,10 @@ module Ap4r
   # - calls a <tt>Dispatchers::Base</tt>'s instance.
   class Dispatchers
 
+    attr_reader :config, :group
     @@sleep_inverval = 0.1
-
     @@logger = nil
+
     def self.logger
       @@logger
     end

data/lib/ap4r/message_store_ext.rb

@@ -497,7 +497,7 @@ if Object.const_defined? :PostgresPR
         maybe_result = original_query(q, &block)
         puts "PostgresPR: query called by #{q}" if $DEBUG
         puts "PostgresPR::Connenction#query returns #{maybe_result}(class: #{maybe_result.class})." if $DEBUG
-        return maybe_result.rows unless block && maybe_result.kind_of?(PostgresPR::Connection::Result)
+        return maybe_result unless block && maybe_result.kind_of?(PostgresPR::Connection::Result)
         begin
           puts "PostgresPR extention: about to yield result." if $DEBUG
           block.call(maybe_result.rows)

data/lib/ap4r/mongrel.rb

@@ -291,5 +291,88 @@ module Ap4r
 
     end
 
+    # This class is an experimental implementation of monitoring API by HTTP.
+    # It's possible to get the number of message in an arbitrary queue and
+    # the number of (alive/dead) thread of dispatchers.
+    #
+    #   === Rrequest example ===
+    #   GET /mointoring/queues/queue.test HTTP/1.1
+    #   GET /mointoring/queues/all HTTP/1.1
+    #   GET /mointoring/queues/dlq HTTP/1.1
+    #
+    #   GET /mointoring/dispatchers/alive_threads HTTP/1.1
+    #   GET /mointoring/dispatchers/dead_threads HTTP/1.1
+    #
+    class Ap4rMonitoringHandler < ::Mongrel::HttpHandler
+
+      def initialize(options)
+        @tick = Time.now
+
+        dlq = ReliableMsg::Queue.new "$dlq"
+        @qm = dlq.send :qm
+      end
+
+      def process(request, response)
+        if response.socket.closed?
+          return
+        end
+
+        target = request.params[::Mongrel::Const::PATH_INFO][1..-1]
+
+        if "GET".include? request.params[::Mongrel::Const::REQUEST_METHOD]
+          begin
+            # TODO: consider URL for each target, 2008/02/28 by kiwamu
+            result = case target
+                     when /^queues\/*(\S*)/
+                       case queue_name = $1
+                       when ""
+                         @qm.store.queues.keys.join(" ")
+                       when "dlq"
+                         @qm.store.queues["$dlq"].size
+                       when "all"
+                         @qm.store.queues.map{|k,v| v.size}.sum
+                       else
+                         @qm.store.queues[queue_name].size
+                       end
+                     when /^dispatchers\/*(\S*)/
+                       case $1
+                       when "alive_threads"
+                         @qm.dispatchers.group.list.size
+                       when "dead_threads"
+                         diff = @qm.dispatchers.config.map{|d| d["threads"]}.sum - @qm.dispatchers.group.list.size
+                         diff > 0 ? diff : 0
+                       else
+                         raise
+                       end
+                     else
+                       raise
+                     end
+
+            response.start(200) do |head, out|
+              head['Content-Type'] = 'text/plain'
+              out.write result
+            end
+          rescue
+            response.start(500) do |head, out|
+              head['Content-Type'] = 'text/plain'
+              out.write "Failed to monitor #{target}"
+            end
+          end
+        else
+          raise "HTTP method is not GET..."
+        end
+      end
+
+      # Does the internal reload for Rails.  It might work for most cases, but
+      # sometimes you get exceptions.  In that case just do a real restart.
+      def reload!
+        begin
+          #TODO not implemented 2007/04/09 by shino
+          raise "not yet implemented!"
+        end
+      end
+
+    end
+
   end
 end

data/lib/ap4r/mongrel_ap4r.rb

@@ -118,6 +118,7 @@ module Ap4r::Mongrel
           uri "/", :handler => ::Ap4r::Mongrel::Ap4rHandler.new(defaults)
           uri "/queues", :handler => ::Ap4r::Mongrel::Ap4rSendMessageHandler.new(defaults)
           uri "/subscribes", :handler => ::Ap4r::Mongrel::Ap4rSubscribeMessageHandler.new(defaults)
+          uri "/monitoring", :handler => ::Ap4r::Mongrel::Ap4rMonitoringHandler.new(defaults)
         end
         setup_signals(settings)
       end

data/lib/ap4r/script/workspace_generator.rb

@@ -9,11 +9,11 @@ module Ap4r
   module Script
     class WorkspaceGenerator < Base
       AP4R_Directories = %w(config log public script tmp)
-      
+
       def run argv, options
         OptionParser.new {|opt|
           opt.on('-m'){
-            # merge to rails project but not implemented yet... 
+            # merge to rails project but not implemented yet...
           }
 
           opt.parse!(argv)
@@ -38,6 +38,8 @@ module Ap4r
                      File.join(root_dir, recursive_copy_dir))
         }
 
+        copy_file(File.join(ap4r_base, "fresh_rakefile"), File.join(root_dir, "Rakefile"))
+
         logger.info{"\n[#{root_dir}] has successfully set up!\n"}
 
       end
@@ -58,6 +60,11 @@ module Ap4r
         }
       end
 
+      def copy_file(src, dest)
+        FileUtils.cp(src, dest)
+        logger.info{"copy file from #{File.expand_path(src)} to #{dest} ..."}
+      end
+
     end
   end
 end

data/lib/ap4r/version.rb

@@ -8,7 +8,7 @@ module Ap4r
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 3
-    TINY  = 6
+    TINY  = 7
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/tasks/ap4r.rb

@@ -0,0 +1,7 @@
+$VERBOSE = nil
+
+# Load AP4R rakefile extensions
+Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }
+
+# Load any custom rakefile extensions
+#Dir["#{AP4R_ROOT}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }

data/lib/tasks/databases.rake

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'erb'
+require 'find'
+require 'active_record'
+require File.join(File.dirname(__FILE__), '/../ap4r/version')
+
+namespace :qdb do
+  desc "Make queue and topic tables through scripts in lib/ap4r/db/migrate."
+  task :migrate do
+
+    # Todo: configurable file name, 2007/10/01 kiwamu
+    ap4r_config_file = "config/queues_ar.cfg"
+    ap4r_config = YAML::load(ERB.new(IO.read(ap4r_config_file)).result)
+    database_config = ap4r_config["store"]
+    if "activerecord" == database_config["type"].downcase
+      database_config["adapter"] = database_config["adapter"].downcase
+    else
+      # Todo
+    end
+    ActiveRecord::Base.logger = Logger.new(STDOUT)
+    ActiveRecord::Base.establish_connection(database_config)
+
+    ActiveRecord::Migrator.migrate("lib/ap4r/db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+  end
+end
+
+
+namespace :db do
+  desc "Create table for persistent message."
+  task :create do
+
+
+
+
+  end
+end
+

data/script/mongrel_ap4r

@@ -1,4 +1,6 @@
+puts "---"
 require 'rubygems'
+puts "==="
 require 'ap4r'
-
+puts "==="
 load 'ap4r/mongrel_ap4r.rb'

data/spec/local/async_helper_queue_put_spec.rb

@@ -0,0 +1,418 @@
+require File.join(File.dirname(__FILE__), "../spec_helper")
+
+require "reliable-msg"
+require "ap4r/async_helper"
+
+module Ap4r::AsyncHelper::Base
+  module_function :__queue_put
+end
+
+class Target
+  include Ap4r::AsyncHelper::Base
+  def initialize
+    @@logger = Logger.new(STDOUT)
+    @@logger.level = Logger::INFO
+  end
+
+  def queue_put
+    __queue_put("", { }, { })
+  end
+
+  require "active_support"
+  cattr_accessor :logger, :druby_uris, :druby_uri_retry_count
+end
+
+# mock
+class ReliableMsg::Queue
+  def initialize(queue_name, options = { })
+    @druby_uri = options[:drb_uri]
+  end
+
+  def put(queue_message, queue_headers)
+    case @@ap4r_servers_status[@druby_uri]
+    when :active   then "cd6f82d0-e9f1-012b-6ff8-0016cb9ad524" # uuid
+    when :inactive then raise ::DRb::DRbConnError
+    end
+  end
+
+  require "active_support"
+  cattr_accessor :ap4r_servers_status
+end
+
+
+describe Ap4r::AsyncHelper::Base, "no configuration and active server" do
+
+  before(:each) do
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :active
+    }
+    @target = Target.new
+  end
+
+  it "should have default druby uri" do
+    @target.druby_uris.size.should == 1
+    @target.druby_uris.first.should == "druby://localhost:6438"
+  end
+
+  it "should be not error" do
+    proc{ @target.queue_put }.should_not raise_error
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "no configuration and inactive server" do
+
+  before(:each) do
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :inactive
+    }
+    @target = Target.new
+  end
+
+  it "should be not error" do
+    proc{ @target.queue_put }.should raise_error(::DRb::DRbConnError)
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with default options and active server" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :active,
+      "druby://localhost:6439" => :active,
+      "druby://localhost:6440" => :active
+    }
+
+    @target = Target.new
+  end
+
+  it "should have configured URIs list druby uri" do
+    @target.druby_uris.size.should == @uris.size
+    @target.druby_uris.should == @uris
+  end
+
+  it "should be not error" do
+    proc{ @target.queue_put }.should_not raise_error
+    @target.druby_uris.first.should == @uris.first
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with default options and inactive server" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :inactive,
+      "druby://localhost:6439" => :active,
+      "druby://localhost:6440" => :active
+    }
+
+    @target = Target.new
+  end
+
+  it "should be error (should not fail over)" do
+    @target.druby_uris.first.should == @uris.first
+    proc{ @target.queue_put }.should raise_error(::DRb::DRbConnError)
+    @target.druby_uris.first.should == @uris.first
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with rotate option and active server" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris, :rotate => true, :fail_over => false, :fail_reuse => false)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :active,
+      "druby://localhost:6439" => :active,
+      "druby://localhost:6440" => :active
+    }
+
+    @target = Target.new
+  end
+
+  it "should rotate servers each connection" do
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[1]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[2]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should_not raise_error
+  end
+
+  it "should have the same URIs list after connections" do
+    2.times{ @target.queue_put }
+    @target.druby_uris.size.should == 3
+    (@target.druby_uris - @uris).should == []
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with rotate option and inactive 2nd server" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris, :rotate => true, :fail_over => false, :fail_reuse => false)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :active,
+      "druby://localhost:6439" => :inactive,
+      "druby://localhost:6440" => :active
+    }
+
+    @target = Target.new
+  end
+
+  it "should be error on the 2nd connection" do
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[1]
+    proc{ @target.queue_put }.should raise_error(::DRb::DRbConnError)
+
+    @target.druby_uris.first.should == @uris[1]
+  end
+
+  it "should be always error once error occured" do
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[1]
+    proc{ @target.queue_put }.should raise_error(::DRb::DRbConnError)
+
+    @target.druby_uris.first.should == @uris[1]
+    proc{ @target.queue_put }.should raise_error(::DRb::DRbConnError)
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with failover option and inactive 1st server" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris, :rotate => false, :fail_over => true, :fail_reuse => false)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :inactive,
+      "druby://localhost:6439" => :active,
+      "druby://localhost:6440" => :active
+    }
+
+    @target = Target.new
+  end
+
+  it "should fail over to 2nd server" do
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[1]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[1]
+    @target.druby_uris.size.should == 2
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with failover option and inactive 1st & 2nd servers" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris, :rotate => false, :fail_over => true, :fail_reuse => false)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :inactive,
+      "druby://localhost:6439" => :inactive,
+      "druby://localhost:6440" => :active
+    }
+
+    @target = Target.new
+  end
+
+  it "should fail over to 3rd server" do
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[2]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[2]
+    @target.druby_uris.size.should == 1
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with failover option and all inactive servers" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris, :rotate => false, :fail_over => true, :fail_reuse => false)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :inactive,
+      "druby://localhost:6439" => :inactive,
+      "druby://localhost:6440" => :inactive
+    }
+
+    @target = Target.new
+  end
+
+  it "should be error" do
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should raise_error(::RuntimeError, "No more active druby uri.")
+
+    @target.druby_uris.size.should == 0
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with fail_reuse option and inactive 1st server" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris, :rotate => false, :fail_over => true, :fail_reuse => true)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :inactive,
+      "druby://localhost:6439" => :active,
+      "druby://localhost:6440" => :active
+    }
+
+    @target = Target.new
+  end
+
+  it "should have the same URIs list after fail over" do
+    @target.druby_uri_retry_count.should == 0
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should_not raise_error
+    @target.druby_uri_retry_count.should == 0
+    @target.druby_uris.first.should == @uris[1]
+
+    @target.druby_uris.size.should == @uris.size
+    (@target.druby_uris - @uris).should == []
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with fail_reuse option and all inactive servers" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris, :rotate => false, :fail_over => true, :fail_reuse => true)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :inactive,
+      "druby://localhost:6439" => :inactive,
+      "druby://localhost:6440" => :inactive
+    }
+
+    @target = Target.new
+  end
+
+  it "should be error after tryed all druby uri" do
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should raise_error(::RuntimeError)
+
+    @target.druby_uris.first.should == @uris[0]
+    @target.druby_uris.size.should == @uris.size
+    (@target.druby_uris - @uris).should == []
+  end
+
+  it "should be not error after some node comes back" do
+    proc{ @target.queue_put }.should raise_error(::RuntimeError)
+
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :inactive,
+      "druby://localhost:6439" => :active,
+      "druby://localhost:6440" => :inactive
+    }
+
+    @target.druby_uris.first.should == @uris[0]
+    proc{ @target.queue_put }.should_not raise_error
+
+    @target.druby_uris.first.should == @uris[1]
+  end
+end
+
+
+describe Ap4r::AsyncHelper::Base, "multiple URIs with all options and inactive 2nd server" do
+
+  before(:each) do
+    # configuration
+    @uris = %w(6438 6439 6440).map {|port| "druby://localhost:#{port}"}
+    ::Ap4r::AsyncHelper::Base.druby_uris(@uris, :rotate => true, :fail_over => true, :fail_reuse => true)
+
+    # status
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :active,
+      "druby://localhost:6439" => :inactive,
+      "druby://localhost:6440" => :active
+    }
+
+    @target = Target.new
+  end
+
+  it "should be not error on the first connection" do
+    proc { @target.queue_put }.should_not raise_error
+  end
+
+  it "should fail over on the second connection" do
+    @target.druby_uris.first.should == @uris[0]
+    @target.queue_put # connected to 6438
+
+    @target.druby_uris.first.should == @uris[1]
+    @target.queue_put # connected to 6440 and rotate next uri
+
+    @target.druby_uris.first.should == @uris[0]
+  end
+
+  it "should reuse the uri which it was inactive after it comes back" do
+    2.times { @target.queue_put }
+    @target.druby_uris.first.should == @uris[0]
+
+    ReliableMsg::Queue.ap4r_servers_status = {
+      "druby://localhost:6438" => :active,
+      "druby://localhost:6439" => :active,
+      "druby://localhost:6440" => :active
+    }
+
+    @target.queue_put # connected to 6438
+    @target.queue_put # connected to 6439
+
+    @target.druby_uris.first.should == @uris[2]
+  end
+end

data/spec/local/message_builder_spec.rb

@@ -96,7 +96,7 @@ describe "When block style API is used, " do
     end
 
     it "should return the urlencoded body." do
-      @message_builder.format_message_body.should == "key1=value&key2=1"
+      @message_builder.format_message_body.split("&").sort.should == ["key2=1","key1=value"].sort
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ap4r
 version: !ruby/object:Gem::Version 
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors: 
 - Shunichi Shinohara
@@ -10,11 +10,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-06 00:00:00 +09:00
+date: 2009-03-19 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: reliable-msg
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -22,17 +23,9 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.1.0
     version: 
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 - !ruby/object:Gem::Dependency 
   name: mongrel
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -42,6 +35,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: rake
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -73,7 +67,9 @@ files:
 - config/queues_disk.cfg
 - config/queues_mysql.cfg
 - config/queues_pgsql.cfg
+- fresh_rakefile
 - lib/ap4r.rb
+- lib/ap4r/async_helper.rb
 - lib/ap4r/carrier.rb
 - lib/ap4r/db/migrate/001_reliable_msg_queue_and_topic.rb
 - lib/ap4r/dispatcher.rb
@@ -101,6 +97,8 @@ files:
 - lib/ap4r/version.rb
 - lib/ap4r/xxx_create_table_for_saf.rb
 - lib/ap4r/xxx_create_table_for_saf_to_postgresql.rb
+- lib/tasks/ap4r.rb
+- lib/tasks/databases.rake
 - rails_plugin/ap4r/init.rb
 - rails_plugin/ap4r/lib/ap4r/queue_put_stub.rb
 - rails_plugin/ap4r/lib/ap4r/service_handler.rb
@@ -111,6 +109,7 @@ files:
 - script/mongrel_ap4r
 - script/start
 - script/stop
+- spec/local/async_helper_queue_put_spec.rb
 - spec/local/dispatcher_base_spec.rb
 - spec/local/message_builder_spec.rb
 - spec/local/send_message_handler_spec.rb
@@ -139,11 +138,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ap4r
-rubygems_version: 1.0.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Asynchronous Processing for Ruby.
 test_files: 
+- spec/local/async_helper_queue_put_spec.rb
 - spec/local/dispatcher_base_spec.rb
 - spec/local/message_builder_spec.rb
 - spec/local/send_message_handler_spec.rb