ap4r 0.1.0

data/CHANGELOG

@@ -0,0 +1,6 @@
+CHANGELOG
+
+== 0.1.0
+
+* Initial release.
+

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006  ???
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,52 @@
+We are pleased to announce the FIRST release of AP4R.
+ 
+    http://rubyforge.org/projects/ap4r/
+    
+ 
+== DESCRIPTION
+ 
+AP4R, Asynchronous Processing for Ruby, is the implementation of 
+reliable asynchous message processing. 
+ 
+
+Using asynchronous processing, we can cut down turn-around-time 
+of web applications by queuing, or can utilize more machine power 
+by load-balancing.
+ 
+AP4R provides message queuing, and message dispatching.
+Also AP4R nicely ties with your Ruby on Rails applications.
+ 
+
+== INSTALLATION
+ 
+sudo gem install ap4r
+ 
+
+== FEATURES
+ 
+* Business logics can be implemented as simple Web apps, or ruby code,
+  whether it's called asynchronously or synchronously.
+ 
+* Asynchronous messaging are reliable
+  by PersistRDBMS (now MySQL only) or file persistence.
+ 
+* Load balancing over multiple AP4R processes on single/multiple servers 
+ is supported.
+ 
+* Asynchronous processing is via various protocols, such as XML-RPC, SOAP,
+  HTTP PUT, and more. (now implemented just as XML-RPC) 
+ 
+
+== CHANGES
+ 
+This is the first release!
+ 
+
+== ACKNOWLEDGEMENT
+ 
+K.K. and S.S. are on the payroll of Future System Consulting Corp. Japan.
+ 
+
+--
+Kato, Kiwamu          kato.kiwamu@future.co.jp
+Shinohara, Shunichi   shinohara.shunichi@future.co.jp

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+Gem::Specification.new do |s|
+  s.name = %q{orca}
+  s.version = "0.1.0"
+  s.date = %q{2006-05-18}
+  s.summary = %q{Messageing library with Rails for asynchronous process.}
+  s.email = %q{kato.kiwamu@future.co.jp}
+  s.homepage = %q{http://orca2.rtfa.local/orca/}
+  s.rubyforge_project = %q{}
+  s.description = %q{Messageing library with Rails for asynchronous proces.}
+  s.autorequire = %q{orca}
+  s.has_rdoc = true
+  s.authors = ["Shino,Kato"]
+  s.files = Dir.glob("{script,lib,logs,utils}/**/*") << "CHANGELOG" << "log4r.yaml" << "MIT-LICENSE" << "queues.cfg" << "queues1.cfg" << "queues2.cfg" << "Rakefile" << "README"
+  s.requirements = ["none"]
+end
+
+

data/bin/irm.cmd

@@ -0,0 +1,2 @@
+@ECHO OFF
+irb -Ilib/ -r utils/irm

data/bin/loop.cmd

@@ -0,0 +1,3 @@
+@ECHO OFF
+
+ruby %~dp0loop.rb manager start -c queues%1.cfg

data/bin/loop.rb

@@ -0,0 +1,8 @@
+load_path = "-Ilib/"
+
+loop{
+  puts; puts '=== queue manager starting ==='
+  system "ruby #{load_path} script/queues.rb #{ARGV.join(' ')}"
+  puts; puts '=== queue manager stopped ==='
+}
+

data/bin/queues.cmd

@@ -0,0 +1,2 @@
+@ECHO OFF
+ruby script\queues.rb %*

data/bin/queues.rb

@@ -0,0 +1,3 @@
+require 'ap4r'
+
+ReliableMsg::CLI.new.run

data/bin/stop.cmd

@@ -0,0 +1 @@
+./queues manager stop

data/configs/log4r.yaml

@@ -0,0 +1,61 @@
+purpose    : Test
+description: This is the YAML doc
+  this yaml has many many unnecessary setting
+  for testing/explanation only.
+  edit properly for normal use.
+
+---
+
+log4r_config:
+  # define all pre config ...
+  pre_config:
+    global:
+      level: DEBUG
+    root  :
+      level: DEBUG
+    parameters:
+      - name   : x
+        value  : aaa
+      - name   : y
+        value  : bbb
+
+  # define all loggers ...
+  loggers:
+    - name      : qm_logger
+      level     : DEBUG
+      additive  : 'false'
+      trace     : 'false'      
+      outputters:
+        - stderr
+        - logfile 
+
+    - name      :  yourlogger  #not used yet...
+      level     : INFO
+      outputters: 
+        - stderr
+        - logfile 
+
+  # define all outputters (incl. formatters)      
+  outputters:
+    - type     : StderrOutputter
+      name     : stderr 
+      level    : DEBUG
+      only_at  :
+        - INFO
+        - WARN
+        - FATAL
+      formatter:
+        date_pattern: '%y%m%d %H:%M:%S'
+        pattern     : '%d %l: %m '
+        type        : PatternFormatter
+
+    - type        : DateFileOutputter
+      name        : logfile
+      level       : DEBUG
+      date_pattern: '%Y%m%d'
+      trunc       : 'false'
+      dirname     : "#{HOME}/logs"
+      formatter   :
+        date_pattern: '%y%m%d %H:%M:%S'
+        pattern     : '%d %l: %m'
+        type        : PatternFormatter

data/configs/queues.cfg

@@ -0,0 +1,20 @@
+--- 
+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
+

data/configs/queues_disk.cfg

@@ -0,0 +1,15 @@
+--- 
+store: 
+  username: orca
+  type: mysql
+  host: localhost
+  database: ap4r
+  password: ap4r
+drb: 
+  host: 
+  port: 6438
+  acl: allow 127.0.0.1 allow 10.0.0.0/8
+dispatchers:
+  -
+    queue: queue.orders.*
+    threads: 1

data/configs/queues_mysql.cfg

@@ -0,0 +1,15 @@
+--- 
+store: 
+  username: orca
+  type: mysql
+  host: localhost
+  database: ap4r
+  password: ap4r
+drb: 
+  host: 
+  port: 6438
+  acl: allow 127.0.0.1 allow 10.0.0.0/8
+dispatchers:
+  -
+    queue: queue.orders.*
+    threads: 1

data/lib/ap4r.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+version = "> 0"
+if ARGV.size > 0 && ARGV[0][0]==95 && ARGV[0][-1]==95
+  if Gem::Version.correct?(ARGV[0][1..-2])
+    version = ARGV[0][1..-2] 
+    ARGV.shift
+  end
+end
+
+require_gem 'reliable-msg', version
+
+hack = true
+debug_hack = true
+
+if hack
+  require "ap4r/queue_manager_ext"
+end
+
+if debug_hack
+  require "ap4r/queue_manager_ext_debug"
+end
+

data/lib/ap4r/message_store_ext.rb

@@ -0,0 +1,29 @@
+module ReliableMsg
+  module MessageStore
+    class Base
+
+      def stale_queue targets
+        queue_names = targets.split(/[\s;]/).
+          select{|queue| !queue.empty? }.
+          map{|queue| queue.strip! || queue }
+
+        queue_and_created = @queues.select{|queue, messages|
+          messages && (messages.size > 0) &&
+          queue_names.any?{|mq|
+            if mq[-1] == '*'[0]
+              queue[0..(mq.size-2)] == mq[0..-2]
+            else
+              queue == mq
+            end
+          }
+        }.map{|queue, messages| 
+          [queue, messages[0][:created]]
+        }.min {|q1, q2|
+          q1[1] <=> q2[1]
+        }
+        queue_and_created ? queue_and_created[0] : nil
+      end
+
+    end
+  end
+end

data/lib/ap4r/multi_queue.rb

@@ -0,0 +1,21 @@
+module ReliableMsg
+  class MultiQueue < Client
+    def initialize multi_queue, options = nil
+      @multi_queue = multi_queue
+      @options = options
+    end
+
+    def get selector = nil, &block
+      queue_name = repeated {|qm|
+        qm.stale_queue @multi_queue
+      }
+      return nil unless queue_name
+      queue = Queue.new queue_name, @options
+      queue.get selector, &block
+    end
+
+    def name
+      @multi_queue
+    end
+  end
+end

data/lib/ap4r/queue_manager_ext.rb

@@ -0,0 +1,175 @@
+require 'ap4r/message_store_ext'
+require 'ap4r/multi_queue'
+require 'ap4r/retention_history'
+
+require 'soap/wsdlDriver'
+require 'xmlrpc/client'
+require 'active_support'
+
+require 'yaml'
+require 'thread'
+require 'pp'
+
+module ReliableMsg
+  module LifecycleListener
+    
+  end
+
+  class QueueManager
+    def stale_queue multi_queue
+      @store.stale_queue multi_queue
+    end
+
+    alias :start_original :start
+    alias :stop_original :stop
+    alias :initialize_original :initialize
+
+    def initialize options = nil
+      initialize_original options
+      @global_lock ||= Mutex.new
+      @lifecycle_listeners = []
+      RetentionHistory.new(self, @logger, @config)
+    end
+
+    def add_lifecycle_listener listener, iv_name, attr_mode = 'reader'
+      @lifecycle_listeners << listener
+      instance_variable_set "@#{iv_name}".to_sym, listener
+      self.class.class_eval("attr_#{attr_mode} :#{iv_name}")
+    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 }
+      end
+    end
+
+    def stop
+      @global_lock.synchronize do
+        return unless @@active == self
+        @lifecycle_listeners.each {|l| l.stop }
+        stop_carriers
+        stop_dispatchers
+        stop_original
+      end
+    end
+
+    def start_dispatchers
+      return unless @config.disps
+      @logger.info{ "about to start dispatchers with config #{@config.disps.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
+                  # 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})"
+          }
+        }
+        @dispatch_targets.concat(conf["targets"]).concat(';')
+        @logger.info{ "dispatch queues : #{@dispatch_targets}" }
+      }
+      @logger.info "queue manager has forked dispatchers"
+    end
+
+    def stop_dispatchers
+      return unless @disps
+      @disps.list.each {|d| d[:dying] = true}
+      @disps.list.each {|d| d.join }
+    end
+ 
+    def start_carriers
+      conf = @config.carriers
+      return unless conf
+
+      @logger.info{ "ready to start carrires with config #{conf.to_yaml}" }
+      @carriers = ThreadGroup.new
+      conf.each { |remote|
+        remote["threads"].times { |index|
+          Thread.fork(@carriers, remote, index, @logger){|group, remote, index, logger|
+            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
+                #TODO cache DRbObject if necessary
+                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}" }
+
+                  #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
+                  #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 carrier (index #{index}) for the queue manager #{remote['uri']}"
+          }
+        }
+      }
+      @logger.info "queue manager has forked carriers"
+    end
+
+    def stop_carriers
+      @logger.info "stop_carriers #{@carriers}"
+      return unless @carriers
+      @carriers.list.each {|d| d[:dying] = true}
+      @carriers.list.each {|d| d.join }
+    end
+
+  end
+end

data/lib/ap4r/queue_manager_ext_debug.rb

@@ -0,0 +1,48 @@
+require 'drb/drb'
+
+module ReliableMsg
+  class QueueManager
+    attr_reader :store, :transactions, :mutex, :config
+
+    def eval_to_inspect code, inspect_mode = :inspect
+      # TODO: too sloppy implementation
+      result = Thread.new(code, inspect_mode){ |c, mode|
+        $SAFE = 4
+        result = self.instance_eval(c)
+      }.value
+      case inspect_mode
+      when :inspect
+        result.inspect
+      when :yaml
+        result.to_yaml
+      when :json
+        result.to_json
+      when :xml
+        result.to_xml
+      else
+        result.inspect
+      end
+    end
+    alias e2i eval_to_inspect
+
+  end
+  
+  module MessageStore
+    class Base
+      include DRbUndumped
+      attr_reader :mutex, :queues, :topics, :cache
+
+      alias activate_original activate
+
+      def activate
+        activate_original
+        @mutex.extend DRbUndumped
+#        @queues.extend DRbUndumped
+#        @topics.extend DRbUndumped
+#        @cache.extend DRbUndumped
+      end
+
+    end
+  end
+end
+

data/lib/ap4r/retention_history.rb

@@ -0,0 +1,57 @@
+require 'active_support'
+
+module ReliableMsg
+  class RetentionHistory
+    include DRbUndumped
+
+    LOOP_INTERVAL = 3.seconds
+    SHELF_LIFE = 1.hour
+#    SHELF_LIFE = 10.seconds
+    attr_reader :data
+
+    def initialize(qm, logger, config)
+      @data = {}
+      @qm = qm
+      @logger = logger
+      @config = config
+      @qm.add_lifecycle_listener(self, 'retention')
+    end
+
+    def start
+      @collector = Thread.start do
+        loop do
+          begin
+            sleep LOOP_INTERVAL
+            collect
+            sweep
+          rescue Exception => ex
+            @logger.warn("message retention history (collect) #{ex.inspect}")
+            @logger.warn(ex.backtrace.join("\n\t"))
+          end
+        end
+      end
+    end
+
+    def stop
+      @collector.terminate
+    end
+
+    private
+    def collect
+      @qm.store.queues.each {|name, messages|
+        new_data(name, messages.size)
+      }
+    end
+
+    def new_data(queue_name, count)
+      (@data[queue_name.to_sym] ||= []) << [Time.now, count]
+    end
+
+    def sweep
+      limit = Time.now - SHELF_LIFE
+      @data.each do |q, time_count|
+        time_count.delete_if {|t,c| t < limit }
+      end
+    end
+  end
+end

data/lib/ap4r/start_with_log4r.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'log4r'
+require 'log4r/yamlconfigurator'
+# we use various outputters, so require them, otherwise config chokes
+require 'log4r/outputter/datefileoutputter'
+require 'log4r/outputter/emailoutputter'
+include Log4r
+
+cfg = YamlConfigurator
+cfg['HOME'] = '.'
+
+cfg.load_yaml_file('log4r.yaml')
+
+log4r_logger = Log4r::Logger.get 'mylogger'
+#log4r_logger.outputters = Log4r::Outputter.stdout
+
+
+require 'ap4r'
+manager = ReliableMsg::QueueManager.new( {:config => 'queues.cfg',
+                                           :logger => log4r_logger })
+manager.start
+
+begin
+  while manager.alive?
+    sleep 3
+  end
+rescue Interrupt
+  manager.stop
+end
+

data/lib/ap4r/utils/irm.rb

@@ -0,0 +1,109 @@
+# interactive reliable message
+#   version 0.1.1
+#   written by shino
+
+require 'reliable-msg-hack'
+
+require 'pathname'
+require 'uri'
+
+$KCODE = 'u'
+
+$config = 'queues.cfg'
+$drb_host = 'localhost'
+$drb_port = 6438
+
+module Kernel
+  DEFAULT_QUEUE_PREFIX = 'queue.test.'
+  DEFAULT_QUEUE_SUFFIX = 'default'
+  DEFAULT_MULTI_QUEUE = DEFAULT_QUEUE_PREFIX + '*'
+
+  def irm_queue_manager config = $config
+    raise "NOT exist : #{config}" unless Pathname.new(config).exist?
+    DRb::DRbObject.new_with_uri irm_drb_uri
+  end
+
+  def irm_queue_manager_stop config = $config
+    manager = irm_queue_manager config
+    begin
+      manager.stop
+    rescue DRb::DRbConnError => error
+      error.message
+    end
+  end
+
+
+  def irm_list_queues
+    qm.store.queues.keys
+  end
+  
+  def irm_list_messages suffix = DEFAULT_QUEUE_SUFFIX,
+    prefix = DEFAULT_QUEUE_PREFIX
+    qm.store.queues[prefix.to_s + suffix.to_s]
+  end
+
+
+  def irm_make_queue suffix = DEFAULT_QUEUE_SUFFIX,
+    prefix = DEFAULT_QUEUE_PREFIX
+    ReliableMsg::Queue.new prefix.to_s + suffix.to_s, :drb_uri => irm_drb_uri
+  end
+
+  def irm_queue_get suffix = DEFAULT_QUEUE_SUFFIX, selector = nil,
+    prefix = DEFAULT_QUEUE_PREFIX, &block
+    q = irm_make_queue suffix, prefix
+    q.get selector, &block
+  end
+
+  def irm_queue_put suffix = DEFAULT_QUEUE_SUFFIX,
+    message = nil, prefix = DEFAULT_QUEUE_PREFIX,
+    headers = nil
+    unless message
+      t = Time.now
+      message = sprintf("test message %s,%s",
+                        t.strftime("%Y/%m/%d %H:%M:%S"), t.usec)
+    end
+    q = irm_make_queue suffix, prefix
+    q.put message, headers
+  end
+
+  def irm_make_multi_queue multi_queue = DEFAULT_MULTI_QUEUE
+    ReliableMsg::MultiQueue.new multi_queue.to_s
+  end
+
+  def irm_multi_queue_get selector = nil,
+    multi_queue = DEFAULT_MULTI_QUEUE, &block
+    mq = irm_make_multi_queue multi_queue, :drb_uri => irm_drb_uri
+    mq.get selector, &block
+  end
+
+  def irm_set_config arg
+    if arg.is_a? Integer
+      $config = "queues#{arg.to_s}.cfg"
+    else
+      $config = arg.to_s
+    end
+    config = ReliableMsg::Config.new($config)
+    config.load_no_create
+    $drb_port = config.drb['port']
+  end
+
+  def irm_drb_uri
+    "druby://#{$drb_host}:#{$drb_port}"
+  end
+
+  alias qm irm_queue_manager
+  alias qm_stop irm_queue_manager_stop
+
+  alias lsq irm_list_queues
+  alias lsm irm_list_messages
+
+  alias mkq irm_make_queue
+  alias qg irm_queue_get
+  alias qp irm_queue_put
+  alias mkmq irm_make_multi_queue
+  alias mqg irm_multi_queue_get
+
+  alias cfg irm_set_config
+  alias uri irm_drb_uri
+end
+

data/lib/ap4r/utils/loc.rb

@@ -0,0 +1,8 @@
+require 'active_support'
+require 'code_statistics'
+
+CodeStatistics.new(
+  ["Core Source", "lib"],
+  ["Utilities", "utils"],
+  ["Scripts", "script"]
+).to_s

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: ap4r
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-09-01 00:00:00 +09:00
+summary: Asynchronous Processing for Ruby.
+require_paths: 
+- lib
+email: kato.kiwamu@future.co.jp, shinohara.shunichi@future.co.jp
+homepage: http://rubyforge.org/projects/ap4r/
+rubyforge_project: ap4r
+description: Asynchronous Processing for Ruby.
+autorequire: ap4r.rb
+default_executable: 
+- ap4r
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Shunichi Shinohara, Kiwamu Kato
+files: 
+- bin/ap4r
+- bin/irm.cmd
+- bin/loop.cmd
+- bin/loop.rb
+- bin/queues.cmd
+- bin/queues.rb
+- bin/stop.cmd
+- configs/log4r.yaml
+- configs/queues.cfg
+- configs/queues_disk.cfg
+- configs/queues_mysql.cfg
+- lib/ap4r
+- lib/ap4r.rb
+- lib/ap4r/message_store_ext.rb
+- lib/ap4r/multi_queue.rb
+- lib/ap4r/queue_manager_ext.rb
+- lib/ap4r/queue_manager_ext_debug.rb
+- lib/ap4r/retention_history.rb
+- lib/ap4r/start_with_log4r.rb
+- lib/ap4r/utils
+- lib/ap4r/utils/irm.rb
+- lib/ap4r/utils/loc.rb
+- CHANGELOG
+- MIT-LICENSE
+- Rakefile
+- README
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- ap4r
+extensions: []
+
+requirements: 
+- none
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: reliable-msg
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+    version: