amqp-daemon-kit 0.1.8.1

data/lib/daemon_kit/dk_amqp.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+require 'mq'
+
+module DaemonKit
+  # Thin wrapper around the amqp gem, specifically designed to ease
+  # configuration of a AMQP consumer daemon and provide some added
+  # simplicity
+  class AMQP
+
+    @@instance = nil
+
+    class << self
+
+      def instance
+        @instance ||= new
+      end
+
+      private :new
+
+      def run(&block)
+        instance.run(&block)
+      end
+    end
+
+    def initialize( config = {} )
+      @config = DaemonKit::Config.load('amqp').to_h( true )
+    end
+
+    def run(&block)
+      # Ensure graceful shutdown of the connection to the broker
+      DaemonKit.trap('INT') { ::AMQP.stop { ::EM.stop } }
+      DaemonKit.trap('TERM') { ::AMQP.stop { ::EM.stop } }
+
+      # Start our event loop and AMQP client
+      DaemonKit.logger.debug("AMQP.start(#{@config.inspect})")
+      ::AMQP.start(@config, &block)
+    end
+  end
+end

data/lib/daemon_kit/em.rb

@@ -0,0 +1,43 @@
+module DaemonKit
+
+  # EventMachine forms a critical part of the daemon-kit toolset, and
+  # especially of daemon process developers.
+  #
+  # This class abstracts away the difficulties of managing multiple
+  # libraries that all utilize the event reactor.
+  class EM
+
+    class << self
+
+      # Start a reactor, just like classical EM.run. If the block is
+      # provided, the method will block and call the provided block
+      # argument inside the running reactor. If the block argument is
+      # not provided the reactor will be started in a separate thread
+      # and the program will continue to run after the method. All the
+      # signal traps are configured to shutdown the reactor when the
+      # daemon exists.
+      def run(&block)
+        if ::EM.reactor_running?
+          DaemonKit.logger.warn "EventMachine reactor already running"
+          block.call if block_given?
+
+        else
+          if block_given?
+            ::EM.run { block.call }
+          else
+            Thread.main[:_dk_reactor] = Thread.new { EM.run {} }
+            DaemonKit.trap( 'INT' ) { DaemonKit::EM.stop  }
+            DaemonKit.trap( 'TERM' ) { DaemonKit::EM.stop }
+          end
+        end
+      end
+
+      # Stop the reactor
+      def stop
+        ::EM.stop_event_loop if ::EM.reactor_running?
+        Thread.main[:_dk_reactor].join
+      end
+    end
+
+  end
+end

data/lib/daemon_kit/error_handlers/base.rb

@@ -0,0 +1,32 @@
+module DaemonKit
+  module ErrorHandlers
+    # Error handlers in DaemonKit are used by the #Safety class. Any
+    # error handler has to support the interface provided by this
+    # class. It's also required that safety handlers implement a
+    # singleton approach (handled by default by #Base).
+    class Base
+
+      class << self
+
+        @instance = nil
+
+        def instance
+          @instance ||= new
+        end
+        private :new
+
+        # When we're inherited, immediately register the handler with
+        # the safety net
+        def inherited( child ) #:nodoc:
+          Safety.register_error_handler( child )
+        end
+      end
+
+      # Error handlers should overwrite this method and implement
+      # their own reporting method.
+      def handle_exception( exception )
+        raise NoMethodError, "Error handler doesn't support #handle_exception"
+      end
+    end
+  end
+end

data/lib/daemon_kit/error_handlers/hoptoad.rb

@@ -0,0 +1,180 @@
+require 'net/http'
+
+module DaemonKit
+  module ErrorHandlers
+    # Error reporting via Hoptoad.
+    class Hoptoad < Base
+
+      # Front end to parsing the backtrace for each notice
+      # (Graciously borrowed from http://github.com/thoughtbot/hoptoad_notifier)
+      class Backtrace
+
+        # Handles backtrace parsing line by line
+        # (Graciously borrowed from http://github.com/thoughtbot/hoptoad_notifier)
+        class Line
+
+          INPUT_FORMAT = %r{^([^:]+):(\d+)(?::in `([^']+)')?$}.freeze
+
+          # The file portion of the line (such as app/models/user.rb)
+          attr_reader :file
+
+          # The line number portion of the line
+          attr_reader :number
+
+          # The method of the line (such as index)
+          attr_reader :method
+
+          # Parses a single line of a given backtrace
+          # @param [String] unparsed_line The raw line from +caller+ or some backtrace
+          # @return [Line] The parsed backtrace line
+          def self.parse(unparsed_line)
+            _, file, number, method = unparsed_line.match(INPUT_FORMAT).to_a
+            new(file, number, method)
+          end
+
+          def initialize(file, number, method)
+            self.file   = file
+            self.number = number
+            self.method = method
+          end
+
+          # Reconstructs the line in a readable fashion
+          def to_s
+            "#{file}:#{number}:in `#{method}'"
+          end
+
+          def ==(other)
+            to_s == other.to_s
+          end
+
+          def inspect
+            "<Line:#{to_s}>"
+          end
+
+          def to_xml
+            data = [ method, file, number ].map { |s| URI.escape( s || 'unknown', %q{"'<>&} ) }
+            %q{<line method="%s" file="%s" number="%s" />} % data
+          end
+
+          private
+
+          attr_writer :file, :number, :method
+        end
+
+        # holder for an Array of Backtrace::Line instances
+        attr_reader :lines
+
+        def self.parse(ruby_backtrace, opts = {})
+          ruby_lines = split_multiline_backtrace(ruby_backtrace)
+
+          filters = opts[:filters] || []
+          filtered_lines = ruby_lines.to_a.map do |line|
+            filters.inject(line) do |line, proc|
+              proc.call(line)
+            end
+          end.compact
+
+          lines = filtered_lines.collect do |unparsed_line|
+            Line.parse(unparsed_line)
+          end
+
+          instance = new(lines)
+        end
+
+        def initialize(lines)
+          self.lines = lines
+        end
+
+        def inspect
+          "<Backtrace: " + lines.collect { |line| line.inspect }.join(", ") + ">"
+        end
+
+        def ==(other)
+          if other.respond_to?(:lines)
+            lines == other.lines
+          else
+            false
+          end
+        end
+
+        private
+
+        attr_writer :lines
+
+        def self.split_multiline_backtrace(backtrace)
+          if backtrace.to_a.size == 1
+            backtrace.to_a.first.split(/\n\s*/)
+          else
+            backtrace
+          end
+        end
+      end
+
+      # Your hoptoad API key
+      @api_key = nil
+      attr_accessor :api_key
+
+      def handle_exception( exception )
+        headers = {
+          'Content-type' => 'text/xml',
+          'Accept' => 'text/xml, application/xml'
+        }
+
+        http = Net::HTTP.new( url.host, url.port )
+        data = format_exception( exception )
+        DaemonKit.logger.debug("Sending to Hoptoad: #{data}")
+
+        response = begin
+                     http.post( url.path, data, headers )
+                   rescue TimeoutError => e
+                     DaemonKit.logger.error("Timeout while contacting the Hoptoad server.")
+                     nil
+                   end
+        case response
+        when Net::HTTPSuccess then
+          DaemonKit.logger.info "Hoptoad Success: #{response.class}"
+        else
+          DaemonKit.logger.error "Hoptoad Failure: #{response.class}\n#{response.body if response.respond_to? :body}"
+        end
+      end
+
+      def url
+        URI.parse("http://hoptoadapp.com/notifier_api/v2/notices")
+      end
+
+      def format_exception( exception )
+        lines = Backtrace.parse( exception.backtrace )
+        exception_message= exception.message
+        exception_message.gsub!("\"","&quot;")
+        exception_message.gsub!("'","&apos;")
+        exception_message.gsub!("&","&amp;")
+        exception_message.gsub!("<","&lt;")
+        exception_message.gsub!(">","&gt;")
+
+        <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<notice version="2.0">
+  <api-key>#{self.api_key}</api-key>
+  <notifier>
+    <name>daemon-kit</name>
+    <version>#{DaemonKit::VERSION}</version>
+    <url>http://github.com/kennethkalmer/daemon-kit</url>
+  </notifier>
+  <error>
+    <class>#{exception.class.name}</class>
+    <message>#{exception_message}</message>
+    <backtrace>
+      #{Backtrace.parse( exception.backtrace ).lines.inject('') { |string,line| string << line.to_xml }}
+    </backtrace>
+  </error>
+  <server-environment>
+    <project-root>#{DaemonKit.root}</project-root>
+    <environment-name>#{DaemonKit.env}</environment-name>
+  </server-environment>
+</notice>
+        EOF
+      end
+    end
+
+  end
+end

data/lib/daemon_kit/exceptions.rb

@@ -0,0 +1,15 @@
+module DaemonKit
+  # The core of daemon-kit exceptions
+  class Exception < ::StandardError
+  end
+
+  # Raised when no class is registered to process a ruote workitem
+  class MissingParticipant < Exception; end
+
+  # Raised when the daemon itself cannot be found.
+  class DaemonNotFound < Exception
+    def initialize( file )
+      super "No daemon found at the path '#{file}'"
+    end
+  end
+end

data/lib/daemon_kit/generators.rb

@@ -0,0 +1,67 @@
+# TODO: Don't always depend on bundled thor
+$:.unshift File.dirname(__FILE__) + '/vendor/thor-0.13.6/lib'
+
+require 'daemon_kit/generators/base'
+
+module DaemonKit
+  module Generators
+    autoload :AppGenerator,         'generators/daemon_kit/app/app_generator'
+    autoload :CucumberGenerator,    'generators/daemon_kit/cucumber/cucumber_generator'
+    autoload :AmqpGenerator,        'generators/daemon_kit/amqp/amqp_generator'
+    autoload :CronGenerator,        'generators/daemon_kit/cron/cron_generator'
+    autoload :CapistranoGenerator,  'generators/daemon_kit/capistrano/capistrano_generator'
+    autoload :NaniteAgentGenerator, 'generators/daemon_kit/nanite_agent/nanite_agent_generator'
+    autoload :SpecGenerator,        'generators/daemon_kit/rspec/rspec_generator'
+    autoload :TestUnitGenerator,    'generators/daemon_kit/test_unit/test_unit_generator'
+    autoload :RuoteGenerator,       'generators/daemon_kit/ruote/ruote_generator'
+    autoload :XmppGenerator,        'generators/daemon_kit/xmpp/xmpp_generator'
+
+    class << self
+
+      def configure!
+      end
+
+      def invoke( namespace, args = ARGV, config = {} )
+        klass_name = constants.detect do |sym|
+          klass = const_get( sym )
+          klass.respond_to?( :namespace ) && klass.namespace == namespace
+        end
+
+        if klass_name.nil?
+          raise Error, "Could not find generator #{namespace}."
+        end
+
+        klass = const_get( klass_name )
+
+        args << '--help' if args.empty? && klass.arguments.any? { |a| a.required? }
+        klass.start( args, config )
+      end
+
+      def help
+        namespaces = constants.inject([]) do |list, sym|
+          unless sym == :Base || sym == :AppGenerator
+            klass = const_get( sym )
+            list << klass.namespace if klass.respond_to?( :namespace )
+          end
+
+          list
+        end
+
+        puts "Usage:"
+        puts "  script/generate GENERATOR [args] [options]"
+        puts
+        puts "General options:"
+        puts "  -h, [--help]     # Print generators options and usage"
+        puts "  -p, [--pretend]  # Run but do not make any changes"
+        puts "  -f, [--force]    # Overwrite files that already exist"
+        puts "  -s, [--skip]     # Skip files that already exist"
+        puts "  -q, [--quiet]    # Supress status output"
+        puts
+        puts "Available generators:"
+
+        namespaces.each { |ns| puts "  " + ns }
+        puts
+      end
+    end
+  end
+end

data/lib/daemon_kit/generators/base.rb

@@ -0,0 +1,60 @@
+require 'thor/group'
+
+module DaemonKit
+  module Generators
+    class Error < Thor::Error
+    end
+
+    class Base < Thor::Group
+      include Thor::Actions
+
+      add_runtime_options!
+
+      # Tries to get the description from a USAGE file one folder above the source
+      # root otherwise uses a default description.
+      def self.desc(description=nil)
+        return super if description
+        usage = File.expand_path(File.join(source_root, "..", "USAGE"))
+
+        @desc ||= if File.exist?(usage)
+          File.read(usage)
+        else
+          "Description:\n    Create #{base_name.humanize.downcase} files for #{generator_name} generator."
+        end
+      end
+
+      protected
+
+      def app_name
+        @app_name = File.basename( destination_root )
+      end
+
+      # Small macro to add ruby as an option to the generator with proper
+      # default value plus an instance helper method called shebang.
+      #
+      def self.add_shebang_option!
+        class_option :ruby, :type => :string, :aliases => "-r", :default => Thor::Util.ruby_command,
+                            :desc => "Path to the Ruby binary of your choice", :banner => "PATH"
+
+        no_tasks {
+          define_method :shebang do
+            @shebang ||= begin
+              command = if options[:ruby] == Thor::Util.ruby_command
+                "/usr/bin/env #{File.basename(Thor::Util.ruby_command)}"
+              else
+                options[:ruby]
+              end
+              "#!#{command}"
+            end
+          end
+        }
+      end
+
+      def self.namespace(name = nil)
+        return super if name
+        @namespace ||= super.sub(/_generator$/, '').sub(/:generators:/, ':').sub(/^daemon_kit:/, '')
+      end
+
+    end
+  end
+end

data/lib/daemon_kit/initializer.rb

@@ -0,0 +1,449 @@
+require 'pathname'
+
+DAEMON_ENV = (ENV['DAEMON_ENV'] || 'development').dup unless defined?(DAEMON_ENV)
+
+# Absolute paths to the daemon_kit libraries added to $:
+require File.dirname(__FILE__) + '/core_ext'
+$LOAD_PATH.unshift( File.expand_path('../', __FILE__).to_absolute_path ) unless
+  $LOAD_PATH.include?( File.expand_path('../', __FILE__).to_absolute_path )
+
+require 'daemon_kit'
+
+module DaemonKit
+
+  class << self
+
+    def configuration
+      @configuration
+    end
+
+    def configuration=( configuration )
+      @configuration = configuration
+    end
+
+    def arguments
+      @arguments
+    end
+
+    def arguments=( args )
+      @arguments = args
+    end
+
+    def trap( *args, &block )
+      self.configuration.trap( *args, &block )
+    end
+
+    def at_shutdown( &block )
+      self.configuration.at_shutdown( &block )
+    end
+
+  end
+
+
+  # This class does all the nightmare work of setting up a working
+  # environment for your daemon.
+  class Initializer
+
+    attr_reader :configuration
+
+    def self.run
+      configuration = DaemonKit.configuration || Configuration.new
+
+      yield configuration if block_given?
+      initializer = new configuration
+      initializer.before_daemonize
+      initializer
+    end
+
+    def self.continue!
+      initializer = new DaemonKit.configuration
+      initializer.after_daemonize
+    end
+
+    def self.shutdown( clean = false, do_exit = false )
+      return unless $daemon_kit_shutdown_hooks_ran.nil?
+      $daemon_kit_shutdown_hooks_ran = true
+
+      DaemonKit.logger.info "Running shutdown hooks"
+
+      DaemonKit.configuration.shutdown_hooks.each do |hook|
+        begin
+          hook.call
+        rescue => e
+          DaemonKit.logger.exception( e )
+        end
+      end
+
+      log_exceptions if DaemonKit.configuration.backtraces && !clean
+
+      DaemonKit.logger.warn "Shutting down #{DaemonKit.configuration.daemon_name}"
+
+      exit if do_exit
+    end
+
+    def initialize( configuration )
+      @configuration = configuration
+    end
+
+    def before_daemonize
+      DaemonKit.configuration = @configuration
+
+      set_load_path
+      load_gems
+      load_patches
+      load_environment
+      load_predaemonize_configs
+    end
+
+    def after_daemonize
+      set_umask
+
+      initialize_logger
+      initialize_signal_traps
+
+      include_core_lib
+      load_postdaemonize_configs
+      configure_backtraces
+
+      set_process_name
+
+      DaemonKit.logger.info( "DaemonKit (#{DaemonKit::VERSION}) booted, now running #{DaemonKit.configuration.daemon_name}" )
+
+      if DaemonKit.configuration.user || DaemonKit.configuration.group
+        euid = Process.euid
+        egid = Process.egid
+        uid = Process.uid
+        gid = Process.gid
+        DaemonKit.logger.info( "DaemonKit dropped privileges to: #{euid} (EUID), #{egid} (EGID), #{uid} (UID), #{gid} (GID)"  )
+      end
+    end
+
+    def set_load_path
+      configuration.load_paths.each do |d|
+        $:.unshift( "#{DAEMON_ROOT}/#{d}" ) if File.directory?( "#{DAEMON_ROOT}/#{d}" )
+      end
+    end
+
+    def load_gems
+
+    end
+
+    def load_patches
+
+    end
+
+    def load_environment
+      # Needs to be global to prevent loading the files twice
+      return if $_daemon_environment_loaded
+      $_daemon_environment_loaded = true
+
+      config = configuration
+
+      eval(IO.read(configuration.environment_path), binding, configuration.environment_path)
+
+      eval(IO.read(configuration.daemon_initializer), binding, configuration.daemon_initializer) if File.exist?( configuration.daemon_initializer )
+    end
+
+    def load_predaemonize_configs
+      Dir[ File.join( DAEMON_ROOT, 'config', 'pre-daemonize', '*.rb' ) ].each do |f|
+        next if File.basename( f ) == File.basename( configuration.daemon_initializer )
+
+        require f
+      end
+    end
+
+    def load_postdaemonize_configs
+      Dir[ File.join( DAEMON_ROOT, 'config', 'post-daemonize', '*.rb' ) ].each do |f|
+        require f
+      end
+    end
+
+    def set_umask
+      File.umask configuration.umask
+    end
+
+    def initialize_logger
+      return if DaemonKit.logger
+
+      unless logger = configuration.logger
+        logger = AbstractLogger.new( configuration.log_path )
+        logger.level = configuration.log_level
+        logger.copy_to_stdout = configuration.log_stdout
+      end
+
+      DaemonKit.logger = logger
+
+      DaemonKit.logger.info "DaemonKit (#{DaemonKit::VERSION}) booting in #{DAEMON_ENV} mode"
+
+      configuration.trap("USR1") {
+        DaemonKit.logger.level = DaemonKit.logger.debug? ? :info : :debug
+        DaemonKit.logger.info "Log level changed to #{DaemonKit.logger.debug? ? 'DEBUG' : 'INFO' }"
+      }
+      configuration.trap("USR2") {
+        DaemonKit.logger.level = :debug
+        DaemonKit.logger.info "Log level changed to DEBUG"
+      }
+      configuration.trap("HUP") {
+        DaemonKit::Application.reopen_logs
+      }
+    end
+
+    def initialize_signal_traps
+      # Only exit the process if we're not in the 'test' environment
+      term_proc = Proc.new { DaemonKit::Initializer.shutdown( true, DAEMON_ENV != 'test' ) }
+      configuration.trap( 'INT', term_proc )
+      configuration.trap( 'TERM', term_proc )
+      at_exit { DaemonKit::Initializer.shutdown }
+    end
+
+    def include_core_lib
+      if File.exists?( core_lib = File.join( DAEMON_ROOT, 'lib', configuration.daemon_name + '.rb' ) )
+        require core_lib
+      end
+    end
+
+    def configure_backtraces
+      Thread.abort_on_exception = configuration.backtraces
+    end
+
+    def set_process_name
+      $0 = configuration.daemon_name
+    end
+
+    def self.log_exceptions
+      trace_file = File.join( DaemonKit.root, 'log', "backtrace-#{Time.now.strftime('%Y%m%d%H%M%S')}-#{Process.pid}.log" )
+      trace_log = Logger.new( trace_file )
+
+      # Find the last exception
+      e = nil
+      ObjectSpace.each_object {|o|
+        if ::Exception === o
+          e = o
+        end
+      }
+
+      trace_log.info "*** Below you'll find the most recent exception thrown, this will likely (but not certainly) be the exception that made #{DaemonKit.configuration.daemon_name} exit abnormally ***"
+      trace_log.error e
+
+      trace_log.info "*** Below you'll find all the exception objects in memory, some of them may have been thrown in your application, others may just be in memory because they are standard exceptions ***"
+      ObjectSpace.each_object {|o|
+        if ::Exception === o
+          trace_log.error o
+        end
+      }
+
+      trace_log.close
+    end
+  end
+
+  # Holds our various configuration values
+  class Configuration
+
+    include Configurable
+
+    # Root to the daemon
+    attr_reader :root_path
+
+    # List of load paths
+    attr_accessor :load_paths
+
+    # Custom logger instance to use
+    attr_accessor :logger
+
+    # The log level to use, defaults to DEBUG
+    attr_reader :log_level
+
+    # Path to the log file, defaults to 'log/<environment>.log'
+    configurable :log_path
+
+    # Duplicate log data to stdout
+    attr_accessor :log_stdout
+
+    # Path to the pid file, defaults to 'log/<daemon_name>.pid'
+    attr_accessor :pid_file
+
+    # The application name
+    configurable :daemon_name, :locked => true
+
+    # Use the force kill patch? Give the number of seconds
+    configurable :force_kill_wait
+
+    # Should be log backtraces
+    configurable :backtraces, false
+
+    # Configurable umask
+    configurable :umask, 0022
+
+    # Configurable user
+    configurable :user, :locked => true
+
+    # Confgiruable group
+    configurable :group, :locked => true
+
+    # Collection of signal traps
+    attr_reader :signal_traps
+
+    # Our safety net (#Safety) instance
+    attr_accessor :safety_net
+
+    # :nodoc: Shutdown hooks
+    attr_reader :shutdown_hooks
+
+    def initialize
+      parse_arguments!
+
+      set_root_path!
+      set_daemon_defaults!
+
+      self.load_paths = default_load_paths
+      self.log_level  ||= default_log_level
+      self.log_path   ||= default_log_path
+
+      self.force_kill_wait = false
+
+      self.safety_net = DaemonKit::Safety.instance
+
+      @signal_traps = {}
+      @shutdown_hooks = []
+    end
+
+    def environment
+      ::DAEMON_ENV
+    end
+
+    # The path to the current environment's file (<tt>development.rb</tt>, etc.). By
+    # default the file is at <tt>config/environments/#{environment}.rb</tt>.
+    def environment_path
+      "#{root_path}/config/environments/#{environment}.rb"
+    end
+
+    def daemon_initializer
+      "#{root_path}/config/initializers/#{self.daemon_name}.rb"
+    end
+
+    # Add a trap for the specified signal, can be code block or a proc
+    def trap( signal, proc = nil, &block )
+      return if proc.nil? && !block_given?
+
+      # One step towards running on windows, not enough though
+      unless Signal.list.include?( signal )
+        DaemonKit.logger.warn( "Trapping #{signal} signals not supported on this platform" )
+        return
+      end
+
+      unless @signal_traps.has_key?( signal )
+        set_trap( signal )
+      end
+
+      @signal_traps[signal].unshift( proc || block )
+    end
+
+    # Add a block or proc to be called during shutdown
+    def at_shutdown( proc = nil, &block )
+      return if proc.nil? && !block_given?
+
+      @shutdown_hooks << ( proc || block )
+    end
+
+    def pid_file
+      @pid_file ||= "#{File.dirname(self.log_path)}/#{self.daemon_name}.pid"
+    end
+
+    # Set the log level
+    def log_level=( level )
+      @log_level = level
+      DaemonKit.logger.level = @log_level if DaemonKit.logger
+    end
+
+    protected
+
+    def run_traps( signal )
+      DaemonKit.logger.info "Running signal traps for #{signal}"
+      self.signal_traps[ signal ].each { |trap| trap.call }
+    end
+
+    private
+
+    def set_trap( signal )
+      DaemonKit.logger.info "Setting up trap for #{signal}"
+      @signal_traps[ signal ] = []
+      Signal.trap( signal, Proc.new { self.run_traps( signal ) } )
+    end
+
+    def parse_arguments!
+      return unless own_args?
+
+      configs = Arguments.configuration( ARGV ).first
+      @unused_arguments = {}
+
+      configs.each do |c|
+        k,v = c.split('=')
+
+        if v.nil?
+          error( "#{k} has no value" )
+          next
+        end
+
+        begin
+          if self.respond_to?( k )
+            self.send( "#{k}=", v ) # pid_file = /var/run/foo.pid
+          else
+            @unused_arguments[ k ] = v
+          end
+        rescue => e
+          error( "Couldn't set `#{k}' to `#{v}': #{e.message}" )
+        end
+      end
+    end
+
+    # DANGEROUS: Change the value of DAEMON_ENV
+    def environment=( env )
+      ::DAEMON_ENV.replace( env )
+    end
+
+    def set_root_path!
+      raise "DAEMON_ROOT is not set" unless defined?(::DAEMON_ROOT)
+      raise "DAEMON_ROOT is not a directory" unless File.directory?(::DAEMON_ROOT)
+
+      @root_path = ::DAEMON_ROOT.to_absolute_path
+
+      Object.const_set(:RELATIVE_DAEMON_ROOT, ::DAEMON_ROOT.dup) unless defined?(::RELATIVE_DAEMON_ROOT)
+      ::DAEMON_ROOT.replace @root_path
+    end
+
+    def set_daemon_defaults!
+      self.log_stdout = false
+    end
+
+    def default_load_paths
+      [ 'lib' ]
+    end
+
+    def default_log_path
+      File.join(root_path, 'log', "#{environment}.log")
+    end
+
+    def default_log_level
+      environment == 'production' ? :info : :debug
+    end
+
+    def error( msg )
+      msg = "[E] Configuration: #{msg}"
+
+      if DaemonKit.logger
+        DaemonKit.logger.error( msg )
+      else
+        STDERR.puts msg
+      end
+    end
+
+    # If we are executed with any of these commands, don't allow
+    # arguments to be parsed cause they will interfere with the
+    # script encapsulating DaemonKit, like capistrano
+    def own_args?
+      !%w( rake cap spec cucumber ).include?( File.basename( $0 ) )
+    end
+  end
+
+
+end