rabbit-wq 1.9.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2567a7603af0d8e5b325f79a954b886d23f8a57a
-  data.tar.gz: a2a959493098b42965c5c60bcd3c710cfdc9452f
+  metadata.gz: e8146dc0247a3db1e510b8c6205e8ede3892667a
+  data.tar.gz: f141d450c09d9b0a925ce0f398f45aadfd1430f5
 SHA512:
-  metadata.gz: 7269f386abf1bb948ae772927ae2bd1965c258f86d8788395988122a5989f47740bfc4521aeae9d0f983a35599b8dae5b889eaf3f199e3d24e6f3e44dbfca64b
-  data.tar.gz: 7028c4112949da07e0971a7e69e776080b69d5a082cd2bbfeb839f82f683bbf235269c8ee1906ccb3f18a467373676c407221dd90295352aa8385259acbfca22
+  metadata.gz: 7f62f6087f74838fb3b4b3f02a63c1e36663a714f192731203dafabc6f86c506d488fd43f14c270f1893094da87462aed35202592c07ca63d46708d3b80fde6d
+  data.tar.gz: 76bdc1c54aba7299d5b7ba993b5fe5782bd508e8e7450a915f226c3c91938a20974596b55ec5d3a0ce4390426b89161985c7318644964e1b1f0c7056b0efbad6

data/bin/rabbit-wq

@@ -1,3 +1,3 @@
 #!/usr/bin/env ruby
-require 'rabbit_wq/cli'
-RabbitWQ::Cli.new( ARGV ).run
+require 'rabbit_wq'
+RabbitWQ::Cli.start

data/lib/rabbit_wq/cli.rb

@@ -1,129 +1,14 @@
-require 'rubygems'
-require 'rabbit_wq'
-require 'trollop'
-require 'yell'
+require 'servitude'
 
 module RabbitWQ
-  class Cli
+  class Cli < ::Servitude::Cli::Service
 
-    attr_reader :cmd,
-                :options
+    no_commands do
 
-    SUB_COMMANDS = %w(
-      restart
-      start
-      status
-      stop
-    )
-
-    DEFAULT_CONFIG_PATH = "/etc/#{APP_ID}/#{APP_ID}.conf"
-    DEFAULT_LOG_PATH    = "/var/log/#{APP_ID}/#{APP_ID}.log"
-    DEFAULT_PID_PATH    = "/var/run/#{APP_ID}/#{APP_ID}.pid"
-
-    def initialize( args )
-      Trollop::options do
-        version VERSION_COPYRIGHT
-        banner <<-EOS
-#{APP_NAME} #{VERSION_COPYRIGHT}
-
-Usage:
-  #{APP_ID} [command] [options]
-
-  commands:
-#{SUB_COMMANDS.map { |sub_cmd| "    #{sub_cmd}" }.join( "\n" )}
-
-  (For help with a command: #{APP_ID} [command] -h)
-
-options:
-      EOS
-        stop_on SUB_COMMANDS
-      end
-
-      # Get the sub-command and its options
-      #
-      @cmd = ARGV.shift || ''
-      @options = case( cmd )
-        when "restart"
-          Trollop::options do
-            opt :config, "The path for the config file", :type => String, :short => '-c', :default => DEFAULT_CONFIG_PATH
-            opt :log_level, "The log level", :type => String, :default => 'info'
-            opt :log, "The path for the log file", :type => String, :short => '-l', :default => DEFAULT_LOG_PATH
-            opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
-            opt :threads, "The number of threads", :type => Integer, :short => '-t'
-          end
-        when "start"
-          Trollop::options do
-            opt :config, "The path for the config file", :type => String, :short => '-c', :default => DEFAULT_CONFIG_PATH
-            opt :interactive, "Execute the server in interactive mode", :short => '-i'
-            opt :log_level, "The log level", :type => String, :default => 'info'
-            opt :log, "The path for the log file", :type => String, :short => '-l', :default => DEFAULT_LOG_PATH
-            opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
-            opt :threads, "The number of threads", :type => Integer, :short => '-t'
-          end
-        when "status"
-          Trollop::options do
-            opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
-            opt :quiet, "Do not prompt to remove an old PID file", :type => :boolean, :default => false, :short => '-q'
-          end
-        when "stop"
-          Trollop::options do
-            opt :pid, "The path for the PID file", :type => String, :default => DEFAULT_PID_PATH
-            opt :quiet, "Do not prompt to remove an old PID file", :type => :boolean, :default => false, :short => '-q'
-          end
-        else
-          Trollop::die "unknown command #{cmd.inspect}"
-        end
-
-      if cmd == 'start'
-        unless options[:interactive]
-          Trollop::die( :config, "is required when running as daemon" ) unless options[:config]
-          Trollop::die( :log, "is required when running as daemon" ) unless options[:log]
-          Trollop::die( :pid, "is required when running as daemon" ) unless options[:pid]
-        end
-      end
-
-      if %w(restart status stop).include?( cmd )
-        Trollop::die( :pid, "is required" ) unless options[:pid]
-      end
-    end
-
-    def run
-      send( cmd )
-    end
-
-  protected
-
-    def start
-      if options[:interactive]
-        start_interactive
-      else
-        start_daemon
+      def configuration_class
+        RabbitWQ::Configuration
       end
-    end
-
-    def start_interactive
-      server = RabbitWQ::Server.new( options.merge( log: nil ))
-      server.start
-    end
-
-    def start_daemon
-      server = RabbitWQ::ServerDaemon.new( options )
-      server.start
-    end
-
-    def stop
-      server = RabbitWQ::ServerDaemon.new( options )
-      server.stop
-    end
-
-    def restart
-      stop
-      start_daemon
-    end
 
-    def status
-      result = RabbitWQ::ServerDaemon.new( options ).status
-      at_exit { exit result }
     end
 
   end

data/lib/rabbit_wq/configuration.rb

@@ -1,83 +1,28 @@
-require 'oj'
+require 'servitude'
 
 module RabbitWQ
-  class Configuration
-
-    def self.attributes
-      %w(
-        delayed_exchange_prefix
-        delayed_queue_prefix
-        environment_file_path
-        env
-        error_queue
-        threads
-        time_zone
-        work_exchange
-        work_exchange_type
-        work_log_level
-        work_log_path
-        work_publish_queue
-        work_subscribe_queue
-      )
-    end
-
-    attr_accessor( *attributes )
-
-    def self.from_file( file_path )
-      options = Oj.load( File.read( file_path ))
-      RabbitWQ.configuration = Configuration.new
-
-      attributes.each do |c|
-        if options[c]
-          RabbitWQ.configuration.send( :"#{c}=", options[c] )
-        end
-      end
-    end
-
-    def delayed_exchange_prefix
-      @delayed_exchange_prefix || 'work-delay'
-    end
-
-    def delayed_queue_prefix
-      @delayed_queue_prefix || 'work-delay'
-    end
-
-    def env
-      @env || 'production'
-    end
-
-    def error_queue
-      @error_queue || 'work-error'
-    end
-
-    def time_zone
-      @time_zone || 'UTC'
-    end
-
-    def work_exchange
-      @work_exchange || 'work'
-    end
-
-    def work_exchange_type
-      @work_exchange_type || 'fanout'
-    end
-
-    def work_log_level
-      @work_log_level || 'info'
-    end
-
-    def work_log_path
-      @work_log_path || '/var/log/rabbit-wq/rabbit-wq-work.log'
-    end
-
-    def work_publish_queue
-      @work_publish_queue || 'work'
-    end
-
-    def work_subscribe_queue
-      @work_subscribe_queue || 'work'
+  class Configuration < Servitude::Configuration
+
+    def self.defaults
+      {
+        delayed_exchange_prefix: 'work-delay',
+        delayed_queue_prefix: 'work-delay',
+        env: 'production',
+        error_queue: 'work-error',
+        log: "/var/log/rabbit-wq/#{RabbitWQ.process_name}.log",
+        log_level: 'info',
+        pid: "/var/run/rabbit-wq/#{RabbitWQ.process_name}.pid",
+        supervision_retry_timeout_in_seconds: 1,
+        threads: 1,
+        time_zone: 'UTC',
+        work_exchange: 'work',
+        work_exchange_type: 'fanout',
+        work_log_level: 'info',
+        work_log_path: '/var/log/rabbit-wq/rabbit-wq-work.log',
+        work_publish_queue: 'work',
+        work_subscribe_queue: 'work'
+      }
     end
 
   end
-
 end

data/lib/rabbit_wq/invalid_work_error.rb

@@ -0,0 +1,5 @@
+module RabbitWQ
+  class InvalidWorkError < StandardError
+
+  end
+end

data/lib/rabbit_wq/message_handler.rb

@@ -1,25 +1,27 @@
 require 'celluloid/autostart'
+require 'servitude'
 require 'yaml'
 
 module RabbitWQ
   class MessageHandler
 
     include Celluloid
-    include Logging
     include Queues
+    include Servitude::Logging
+    include WorkLogging
 
     REQUEUE = true
 
     def call( options )
-      Time.zone = RabbitWQ.configuration.time_zone
+      Time.zone = Servitude.configuration.time_zone
 
       channel       = options[:channel]
       delivery_info = options[:delivery_info]
       metadata      = options[:metadata]
       payload       = options[:payload]
 
-      worker = YAML::load( payload )
-      info ANSI.yellow { "WORKER [#{worker.object_id}] " + worker.inspect }
+      worker = deserialize_worker( payload )
+      info Rainbow( "WORKER [#{worker.object_id}] " + worker.inspect ).yellow
       handle_work( worker, payload )
       try_on_success_callback( worker )
       channel.ack delivery_info.delivery_tag
@@ -29,6 +31,18 @@ module RabbitWQ
 
   protected
 
+    def deserialize_worker( payload )
+      YAML::load( payload ).tap do |worker|
+        unless worker.is_a?( RabbitWQ::Worker )
+          raise ArgumentError, "Worker of type #{worker.class.name} is not a valid worker (not a descendent of #{RabbitWQ::Worker.name})"
+        end
+      end
+    rescue => e
+      raise RabbitWQ::InvalidWorkError,
+            "#{e.message} -- #{e.class.name}",
+            e.backtrace
+    end
+
     def handle_work( worker, payload )
       unless worker.enabled?
         if worker.error_on_disabled?
@@ -106,7 +120,7 @@ module RabbitWQ
     end
 
     def requeue( channel, delivery_info, e=nil )
-      info ANSI.yellow { 'REQUEUE ' + e.message }
+      info Rainbow( 'REQUEUE ' + e.message ).yellow
       channel.reject delivery_info.delivery_tag, REQUEUE
     end
 

data/lib/rabbit_wq/server.rb

@@ -1,37 +1,42 @@
 require 'bunny'
-require 'celluloid/autostart'
 
 module RabbitWQ
   class Server
 
-    include Logging
+    include Servitude::Server
+    include Servitude::ServerThreaded
     include Queues
-    include ServerLogging
 
-    attr_reader :options,
-                :work_consumer,
+    after_initialize :initialize_work_logger
+    after_initialize :load_environment
+
+    attr_reader :work_consumer,
                 :work_exchange
 
-    def initialize( options )
-      @options = options
+    finalize do
+      info 'Shutting down ...'
 
-      configure_server
+      work_consumer.cancel
+      mq.close
     end
 
-    def start
-      log_startup
-      run
+  protected
 
-      trap( INT ) { finalize; exit }
-      sleep
+    def handler_class
+      RabbitWQ::MessageHandler
     end
 
-  protected
+    def run
+      @work_consumer = work_subscribe_queue.subscribe( manual_ack: true ) do |delivery_info, metadata, payload|
+        with_supervision( delivery_info: delivery_info ) do
+          debug( "#{Rainbow( "LISTENER RECEIVED " ).magenta} #{payload}" )
 
-    def finalize
-      info "SHUTTING DOWN"
-      work_consumer.cancel
-      mq.close
+          call_handler_respecting_thread_count( payload: payload,
+                                                delivery_info: delivery_info,
+                                                metadata: metadata,
+                                                channel: channel )
+        end
+      end
     end
 
     def work_exchange
@@ -45,56 +50,38 @@ module RabbitWQ
                                         bind( work_exchange )
     end
 
-    def pool
-      @pool ||= MessageHandler.pool( size: threads )
+    def error_queue
+      channel.queue( config.error_queue, durable: true )
     end
 
-    def run
-      if threads == 1
-        Celluloid::Actor[:message_handler] = MessageHandler.new
-      end
-
-      @work_consumer = work_subscribe_queue.subscribe( manual_ack: true ) do |delivery_info, metadata, payload|
-        info "LISTENER RECEIVED #{payload}"
-
-        if threads > 1
-          pool.async.call( payload: payload,
-                           delivery_info: delivery_info,
-                           metadata: metadata,
-                           channel: channel )
-        else
-          message_handler.call( payload: payload,
-                                delivery_info: delivery_info,
-                                metadata: metadata,
-                                channel: channel )
-        end
-      end
-    end
-
-    def message_handler
-      Celluloid::Actor[:message_handler]
+    def warn_for_supevision_error
+      warn( Rainbow( "RETRYING due to waiting on supervisor to restart actor ..." ).cyan )
     end
 
-    def threads
-      config.threads
+    def warn_for_dead_actor_error
+      warn( Rainbow( "RETRYING due to Celluloid::DeadActorError ..." ).blue )
     end
 
-    def config
-      RabbitWQ.configuration
+    def log_error( e )
+      parts = [Rainbow( [e.class.name, e.message].join( ': ' ) ).red, format_backtrace( e.backtrace )]
+      error( parts.join( "\n" ))
     end
 
-    def configure_server
-      load_configuration
-      initialize_loggers
-      load_environment
-      resolve_threads
+    def handle_error( options, e )
+      delivery_info = options[:delivery_info]
+      log_error( e )
+      #error_queue.publish( payload, headers: { exception_message: e.message,
+                                               #exception_class: e.class.name,
+                                               #exception_backtrace: e.backtrace } )
+      debug( Rainbow( "NACK" ).red + " #{e.message}" )
+      channel.nack( delivery_info.delivery_tag )
+    rescue => ex
+      error( Rainbow( "ERROR while handling error | #{ex.class.name} | #{ex.message} | #{ex.backtrace.inspect}" ).red )
     end
 
-    def load_configuration
-      if File.exists?( options[:config] )
-        options[:config_loaded] = true
-        Configuration.from_file( options[:config] )
-      end
+    def initialize_work_logger
+      RabbitWQ.work_logger = WorkLogger.new( config.work_log_level,
+                                             config.work_log_path )
     end
 
     def load_environment
@@ -107,18 +94,8 @@ module RabbitWQ
       require environment_file_path
     end
 
-    def resolve_threads
-      if options[:threads]
-        RabbitWQ.configuration.threads = options[:threads]
-      end
-
-      return if RabbitWQ.configuration.threads
-
-      RabbitWQ.configuration.threads = 1
-    end
-
     def environment_file_path
-      RabbitWQ.configuration.environment_file_path
+      config.environment_file_path
     end
 
   end

data/lib/rabbit_wq/version.rb

@@ -1,3 +1,3 @@
 module RabbitWQ
-  VERSION = "1.9.0"
+  VERSION = "2.0.0"
 end

data/lib/rabbit_wq/work.rb

@@ -5,6 +5,10 @@ module RabbitWQ
 
     YAML_MIMETYPE = 'application/yaml'
 
+    def self.config
+      Servitude.configuration ||= RabbitWQ::Configuration.load
+    end
+
     def self.enqueue( worker, options={} )
       payload = worker.to_yaml
       enqueue_payload( payload, options )
@@ -82,9 +86,5 @@ module RabbitWQ
       end
     end
 
-    def self.config
-      RabbitWQ.configuration
-    end
-
   end
 end

data/lib/rabbit_wq/work_logger.rb

@@ -32,7 +32,7 @@ module RabbitWQ
         end
 
         if worker
-          logger.send( level, "[" + ANSI.cyan { "#{worker.class.name}:#{worker.object_id}" } + "] #{message}" )
+          logger.send( level, "[" + Rainbow( "#{worker.class.name}:#{worker.object_id}" ).cyan + "] #{message}" )
         else
           logger.send( level, message )
         end

data/lib/rabbit_wq/{logging.rb → work_logging.rb}

@@ -1,7 +1,7 @@
 require 'yell'
 
 module RabbitWQ
-  module Logging
+  module WorkLogging
 
     %w(
       debug
@@ -11,13 +11,6 @@ module RabbitWQ
       warn
     ).each do |level|
 
-      define_method level do |*messages|
-        return unless RabbitWQ.logger
-        messages.each do |message|
-          RabbitWQ.logger.send level, message
-        end
-      end
-
       define_method "worker_#{level}" do |worker, *messages|
         return unless RabbitWQ.work_logger
         messages.each do |message|

data/lib/rabbit_wq.rb

@@ -1,41 +1,46 @@
-require 'ansi'
+require 'rainbow'
+require 'servitude'
 require 'rabbit_wq/version'
 
 module RabbitWQ
 
-  APP_ID                = 'rabbit-wq'
-  APP_NAME              = 'Rabbit Work Queue'
-  INT                   = 'INT'
-  VERSION_COPYRIGHT     = "v#{VERSION} \u00A9#{Time.now.year}"
-
-  autoload :Command,        'rabbit_wq/command'
-  autoload :Configuration,  'rabbit_wq/configuration'
-  autoload :FinalError,     'rabbit_wq/final_error'
-  autoload :Logging,        'rabbit_wq/logging'
-  autoload :Queues,         'rabbit_wq/queues'
-  autoload :MessageHandler, 'rabbit_wq/message_handler'
-  autoload :Server,         'rabbit_wq/server'
-  autoload :ServerDaemon,   'rabbit_wq/server_daemon'
-  autoload :ServerLogging,  'rabbit_wq/server_logging'
-  autoload :Work,           'rabbit_wq/work'
-  autoload :Worker,         'rabbit_wq/worker'
-  autoload :WorkLogger,     'rabbit_wq/work_logger'
-
-  def self.configuration
-    @configuration ||= Configuration.new
+  include Servitude::Base
+
+  autoload :Command,          'rabbit_wq/command'
+  autoload :Cli,              'rabbit_wq/cli'
+  autoload :Configuration,    'rabbit_wq/configuration'
+  autoload :FinalError,       'rabbit_wq/final_error'
+  autoload :InvalidWorkError, 'rabbit_wq/invalid_work_error'
+  autoload :Queues,           'rabbit_wq/queues'
+  autoload :MessageHandler,   'rabbit_wq/message_handler'
+  autoload :Server,           'rabbit_wq/server'
+  autoload :Work,             'rabbit_wq/work'
+  autoload :Worker,           'rabbit_wq/worker'
+  autoload :WorkLogger,       'rabbit_wq/work_logger'
+  autoload :WorkLogging,      'rabbit_wq/work_logging'
+
+  def self.perform_boot
+    author = 'C. Jason Harrelson'
+
+    years = 2013
+    years = "#{years}–#{::Time.now.year}" if years < ::Time.now.year
+
+    boot host_namespace:      self,
+         app_name:            'Rabbit WQ',
+         author:              author,
+         attribution:         "v#{VERSION} Copyright © #{years} #{author}",
+         default_config_path: "/etc/rabbit-wq/#{process_name}.conf",
+         use_config:          true
   end
 
-  def self.configuration=( configuration )
-    @configuration = configuration
-  end
-
-  def self.configure
-    yield( configuration ) if block_given?
+  def self.process_name
+    'rabbit-wq'
   end
 
   class << self
-    attr_accessor :logger,
-                  :work_logger
+    attr_accessor :work_logger
   end
 
+  perform_boot
+
 end

data/rabbit-wq.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "bunny", "~> 1"
   spec.add_dependency "celluloid", "~> 0"
   spec.add_dependency "oj", "~> 2"
-  spec.add_dependency "trollop", "~> 2"
+  spec.add_dependency "servitude", ">= 1.2", "< 2"
   spec.add_dependency "yell", "~> 1"
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rabbit-wq
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 2.0.0
 platform: ruby
 authors:
 - C. Jason Harrelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-09 00:00:00.000000000 Z
+date: 2015-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,17 +81,23 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
-  name: trollop
+  name: servitude
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
       - !ruby/object:Gem::Version
         version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
@@ -124,22 +130,20 @@ files:
 - README.md
 - Rakefile
 - bin/rabbit-wq
-- lib/ansi.rb
 - lib/rabbit-wq.rb
 - lib/rabbit_wq.rb
 - lib/rabbit_wq/cli.rb
 - lib/rabbit_wq/command.rb
 - lib/rabbit_wq/configuration.rb
 - lib/rabbit_wq/final_error.rb
-- lib/rabbit_wq/logging.rb
+- lib/rabbit_wq/invalid_work_error.rb
 - lib/rabbit_wq/message_handler.rb
 - lib/rabbit_wq/queues.rb
 - lib/rabbit_wq/server.rb
-- lib/rabbit_wq/server_daemon.rb
-- lib/rabbit_wq/server_logging.rb
 - lib/rabbit_wq/version.rb
 - lib/rabbit_wq/work.rb
 - lib/rabbit_wq/work_logger.rb
+- lib/rabbit_wq/work_logging.rb
 - lib/rabbit_wq/worker.rb
 - rabbit-wq.gemspec
 homepage: ''

data/lib/ansi.rb

@@ -1,36 +0,0 @@
-class ANSI
-
-  def self.resolve_text( color, &block )
-    text = nil
-    if block_given?
-      text = block.call + reset
-    end
-    "\e[#{chart[color.to_sym]}m#{text}"
-  end
-
-  def self.reset
-    "\e[0m"
-  end
-
-  def self.chart
-    {
-      black: 30,
-      red: 31,
-      green: 32,
-      yellow: 33,
-      blue: 34,
-      magenta: 35,
-      cyan: 36,
-      white: 37
-    }
-  end
-
-  chart.keys.each do |color|
-
-    define_singleton_method color do |&block|
-      resolve_text color, &block
-    end
-
-  end
-
-end

data/lib/rabbit_wq/server_daemon.rb

@@ -1,149 +0,0 @@
-require 'rubygems'
-require 'fileutils'
-require 'timeout'
-
-module RabbitWQ
-  class ServerDaemon
-
-    attr_reader :name,
-                :options,
-                :pid,
-                :pid_path,
-                :script,
-                :timeout
-
-    def initialize( options )
-      @options  = options
-      @name     = options[:name] || APP_NAME
-      @pid_path = options[:pid] || '.'
-      @pid      = get_pid
-      @timeout  = options[:timeout] || 10
-    end
-
-    def start
-      abort "Process already running!" if process_exists?
-
-      pid = fork do
-        exit if fork
-        Process.setsid
-        exit if fork
-        store_pid( Process.pid )
-        File.umask 0000
-        redirect_output!
-        run
-      end
-
-      Process.waitpid( pid )
-    end
-
-    def run
-      Server.new( options ).start
-    end
-
-    def stop
-      kill_process
-      FileUtils.rm pid_path
-    end
-
-    def status
-      $stdout.print "#{APP_NAME} "
-      if process_exists?
-        $stdout.puts "process running with PID: #{pid}"
-        true
-      else
-        $stdout.puts "process does not exist"
-        false
-      end
-    end
-
-   protected
-
-    #def create_pid( pid )
-    def store_pid( pid )
-      File.open( pid_path, 'w' ) do |f|
-        f.puts pid
-      end
-    rescue => e
-      $stderr.puts "Unable to open #{pid_path} for writing:\n\t(#{e.class}) #{e.message}"
-      exit!
-    end
-
-    def get_pid
-      return nil unless File.exists?( pid_path )
-      pid = nil
-      File.open( @pid_path, 'r' ) do |f|
-        pid = f.readline.to_s.gsub( /[^0-9]/, '' )
-      end
-      pid.to_i
-    rescue Errno::ENOENT
-      nil
-    end
-
-    def remove_pidfile
-      File.unlink( pid_path )
-    rescue => e
-      $stderr.puts "Unable to unlink #{pid_path}:\n\t(#{e.class}) #{e.message}"
-      exit
-    end
-
-    def kill_process
-      unless process_exists?
-        $stdout.write "#{APP_NAME} process is not running"
-        return
-      end
-
-      $stdout.write "Attempting to stop #{APP_NAME} process #{pid}..."
-      Process.kill INT, pid
-      iteration_num = 0
-      while process_exists? && iteration_num < 10
-        sleep 1
-        $stdout.write "."
-        iteration_num += 1
-      end
-      if process_exists?
-        $stderr.puts "\nFailed to stop #{APP_NAME} process #{pid}"
-      else
-        $stdout.puts "\nSuccessfuly stopped #{APP_NAME} process #{pid}"
-      end
-    rescue Errno::EPERM
-      $stderr.puts "No permission to query #{pid}!";
-    end
-
-    def process_exists?
-      return false unless pid
-      Process.kill( 0, pid )
-      true
-    rescue Errno::ESRCH, TypeError # "PID is NOT running or is zombied
-      false
-    rescue Errno::EPERM
-      $stderr.puts "No permission to query #{pid}!";
-      false
-    end
-
-    def redirect_output!
-      if log_path = options[:log]
-        #puts "redirecting to log"
-        # if the log directory doesn't exist, create it
-        FileUtils.mkdir_p( File.dirname( log_path ), :mode => 0755 )
-        # touch the log file to create it
-        FileUtils.touch( log_path )
-        # Set permissions on the log file
-        File.chmod( 0644, log_path )
-        # Reopen $stdout (NOT +STDOUT+) to start writing to the log file
-        $stdout.reopen( log_path, 'a' )
-        # Redirect $stderr to $stdout
-        $stderr.reopen $stdout
-        $stdout.sync = true
-      else
-        #puts "redirecting to /dev/null"
-        # We're not bothering to sync if we're dumping to /dev/null
-        # because /dev/null doesn't care about buffered output
-        $stdin.reopen '/dev/null'
-        $stdout.reopen '/dev/null', 'a'
-        $stderr.reopen $stdout
-      end
-      log_path = options[:log] ? options[:log] : '/dev/null'
-    end
-
-  end
-end

data/lib/rabbit_wq/server_logging.rb

@@ -1,52 +0,0 @@
-require 'yell'
-
-# Provides logging services for the base server.
-#
-module RabbitWQ
-  module ServerLogging
-
-  protected
-
-    def initialize_loggers
-      RabbitWQ.logger = Yell.new do |l|
-        l.level = log_level
-        l.adapter $stdout, :level => [:debug, :info, :warn]
-        l.adapter $stderr, :level => [:error, :fatal]
-      end
-
-      RabbitWQ.work_logger = WorkLogger.new( RabbitWQ.configuration.work_log_level,
-                                             RabbitWQ.configuration.work_log_path )
-      #Celluloid.logger = Yell.new do |l|
-        #l.level = :info
-        #l.adapter :file, File.join( File.dirname( options[:log] ), "#{APP_ID}-celluloid.log" )
-      #end
-    end
-
-    def log_startup
-      start_banner( options ).each do |line|
-        RabbitWQ.logger.info line
-      end
-    end
-
-    def start_banner( options )
-      [
-        "",
-        "***",
-        "* #{APP_NAME} started",
-        "*",
-        "* #{VERSION_COPYRIGHT}",
-        "*",
-        "* Configuration:",
-        (options[:config_loaded] ? "*   file: #{options[:config]}" : nil),
-        RabbitWQ::Configuration.attributes.map { |a| "*   #{a}: #{RabbitWQ.configuration.send( a )}" },
-        "*",
-        "***",
-      ].flatten.reject( &:nil? )
-    end
-
-    def log_level
-      options.fetch( :log_level, :info ).to_sym
-    end
-
-  end
-end