daemon-kit 0.1.7 → 0.1.7.4

data/daemon_generators/deploy_capistrano/templates/USAGE

@@ -0,0 +1,10 @@
+
+Capistrano deployment configuration generator completed
+
+Usage:
+  Review the configuration files in config/deploy.rb and
+  config/deploy/*.rb
+
+  Once you're happy with the configurations, you can review
+  a list of available capistrano commands by running `cap -T'
+

data/daemon_generators/deploy_capistrano/templates/config/deploy.rb

@@ -34,7 +34,9 @@ set :config_files, %w{}
 set :shared_children, %w{log tmp}
 
 # Record our dependencies
-depend :remote, :gem, "daemon-kit", ">=0.0.0"
+unless File.directory?( "#{DaemonKit.root}/vendor/daemon_kit" )
+  depend :remote, :gem, "daemon-kit", ">=#{DaemonKit::VERSION}"
+end
 
 # Hook into capistrano's events
 before "deploy:update_code", "deploy:check"

data/lib/daemon_kit.rb

@@ -1,17 +1,45 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
+# TODO: Strip this out eventually so we can run without rubygems
 require 'rubygems'
 
+require File.dirname(__FILE__) + '/daemon_kit/core_ext'
+
+$:.unshift( File.dirname(__FILE__).to_absolute_path ) unless
+  $:.include?( File.dirname(__FILE__).to_absolute_path )
+
 module DaemonKit
-  VERSION = '0.1.7'
+  VERSION = '0.1.7.4'
 
   autoload :Initializer, 'daemon_kit/initializer'
   autoload :Application, 'daemon_kit/application'
+  autoload :Arguments,   'daemon_kit/arguments'
   autoload :Config,      'daemon_kit/config'
+  autoload :Safety,      'daemon_kit/safety'
+  autoload :PidFile,     'daemon_kit/pid_file'
+
   autoload :Cron,        'daemon_kit/cron'
   autoload :Jabber,      'daemon_kit/jabber'
   autoload :AMQP,        'daemon_kit/amqp'
   autoload :Nanite,      'daemon_kit/nanite'
-  autoload :Safety,      'daemon_kit/safety'
+
+  class << self
+    def logger
+      @logger
+    end
+
+    def logger=( logger )
+      @logger = logger
+    end
+
+    def root
+      DAEMON_ROOT
+    end
+
+    def env
+      DAEMON_ENV
+    end
+
+    def framework_root
+      @framework_root ||= File.join( File.dirname(__FILE__), '..' ).to_absolute_path
+    end
+  end
 end

data/lib/daemon_kit/amqp.rb

@@ -30,7 +30,8 @@ module DaemonKit
       DaemonKit.trap('INT') { ::AMQP.stop { ::EM.stop } }
       DaemonKit.trap('TERM') { ::AMQP.stop { ::EM.stop } }
 
-      # Start our event loop
+      # Start our event loop and AMQP client
+      DaemonKit.logger.debug("AMQP.start(#{@config.inspect})")
       ::AMQP.start(@config, &block)
     end
   end

data/lib/daemon_kit/application.rb

@@ -1,4 +1,4 @@
-require 'daemons'
+require 'timeout'
 
 module DaemonKit
 
@@ -7,29 +7,154 @@ module DaemonKit
 
     class << self
 
-      # Run the file as a daemon
-      def run( file )
+      # Run the specified file as a daemon process.
+      def exec( file )
         raise DaemonNotFound.new( file ) unless File.exist?( file )
 
-        app_name = DaemonKit.configuration.daemon_name || File.basename( file )
-        options = { :backtrace => true, :log_output => true, :app_name => app_name }
+        DaemonKit.configuration.daemon_name ||= File.basename( file )
+
+        command, configs, args = Arguments.parse( ARGV )
+
+        case command
+        when :run
+          parse_arguments( args )
+          run( file )
+        when :start
+          parse_arguments( args )
+          start( file )
+        when :stop
+          stop
+        end
+      end
+
+      # Run the daemon in the foreground without daemonizing
+      def run( file )
+        self.chroot
+        self.clean_fd
+        self.redirect_io( true )
+
+        require file
+      end
+
+      # Run our file properly
+      def start( file )
+        self.daemonize
+        self.chroot
+        self.clean_fd
+        self.redirect_io
+
+        require file
+      end
+
+      def stop
+        @pid_file = PidFile.new( DaemonKit.configuration.pid_file )
+
+        unless @pid_file.running?
+          @pid_file.cleanup
+          puts "Nothing to stop"
+          exit
+        end
+
+        target_pid = @pid_file.pid
+
+        puts "Sending TERM to #{target_pid}"
+        Process.kill( 'TERM', target_pid )
+
+        if seconds = DaemonKit.configuration.force_kill_wait
+          begin
+            Timeout::timeout( seconds ) do
+              loop do
+                puts "Waiting #{seconds} seconds for #{target_pid} before sending KILL"
+
+                break unless @pid_file.running?
 
-        options[:dir_mode]        = DaemonKit.configuration.dir_mode
-        options[:dir]             = DaemonKit.configuration.dir
-        options[:multiple]        = DaemonKit.configuration.multiple
-        options[:force_kill_wait] = DaemonKit.configuration.force_kill_wait if DaemonKit.configuration.force_kill_wait
+                seconds -= 1
+                sleep 1
+              end
+            end
+          rescue Timeout::Error
+            Process.kill( 'KILL', target_pid )
+          end
+        end
 
-        Daemons.run( file, options )
+        @pid_file.cleanup
       end
 
       # Call this from inside a daemonized process to complete the
       # initialization process
       def running!
-        DaemonKit::Initializer.continue!
+        Initializer.continue!
 
         yield DaemonKit.configuration if block_given?
       end
 
+      # Exit the daemon
+      # TODO: Make configurable callback chain
+      # TODO: Hook into at_exit()
+      def exit!( code = 0 )
+      end
+
+      protected
+
+      def parse_arguments( args )
+        DaemonKit.arguments = Arguments.new
+        DaemonKit.arguments.parse( args )
+      end
+
+      # Daemonize the process
+      def daemonize
+        @pid_file = PidFile.new( DaemonKit.configuration.pid_file )
+        @pid_file.ensure_stopped!
+
+        if RUBY_VERSION < "1.9"
+          exit if fork
+          Process.setsid
+          exit if fork
+        else
+          Process.daemon( true, true )
+        end
+
+        @pid_file.write!
+
+        # TODO: Convert into shutdown hook
+        at_exit { @pid_file.cleanup }
+      end
+
+      # Release the old working directory and insure a sensible umask
+      # TODO: Make chroot directory configurable
+      def chroot
+        Dir.chdir '/'
+        File.umask 0000
+      end
+
+      # Make sure all file descriptors are closed (with the exception
+      # of STDIN, STDOUT & STDERR)
+      def clean_fd
+        ObjectSpace.each_object(IO) do |io|
+          unless [STDIN, STDOUT, STDERR].include?(io)
+            begin
+              unless io.closed?
+                io.close
+              end
+            rescue ::Exception
+            end
+          end
+        end
+      end
+
+      # Redirect our IO
+      # TODO: make this configurable
+      def redirect_io( simulate = false )
+        begin
+          STDIN.reopen '/dev/null'
+        rescue ::Exception
+        end
+
+        unless simulate
+          STDOUT.reopen '/dev/null', 'a'
+          STDERR.reopen '/dev/null', 'a'
+        end
+      end
     end
 
   end

data/lib/daemon_kit/arguments.rb

@@ -0,0 +1,151 @@
+require 'optparse'
+
+module DaemonKit
+
+  # A wrapper around OptParse for setting up arguments to the daemon
+  # process.
+  #
+  # TODO: Set rules for basic options that go for all daemons
+  # TODO: Load options from config/arguments.rb
+  class Arguments
+
+    # Default command
+    @default_command = 'run'
+
+    # Valid commands
+    @commands = [
+                 'start',
+                 'stop',
+                 'run'
+                ]
+
+    class << self
+
+      attr_reader :default_command, :commands
+
+      # Parse the argument values and return an array with the command
+      # name, config values and argument values
+      def parse( argv )
+        cmd, argv = self.command( argv )
+
+        return cmd, *self.configuration( argv )
+      end
+
+      # Parse the provided argument array for a given command, or
+      # return the default command and the remaining arguments
+      def command( argv )
+        # extract command or set default
+        cmd = self.commands.include?( argv[0] ) ? argv.shift : self.default_command
+
+        return cmd.to_sym, argv
+      end
+
+      # Extracts any values for arguments matching '--config' as well
+      # as some implication arguments like '-e'. Returns an array with
+      # the configs as the first value and the remaing args as the
+      # last value.
+      #
+      # To set a value on the default #Configuration instance, use the
+      # following notation:
+      #
+      #   --config attribute=value
+      #
+      # The above notation can be used several times to set different
+      # values.
+      #
+      # Special, or 'normal' arguments that are mapped to the default
+      # #Configuration instance are listed below:
+      #
+      #   -e value or --env value => environment
+      #   --pid pidfile           => pid_file
+      #
+      def configuration( argv )
+        configs = []
+
+        i = 0
+        while i < argv.size
+          if argv[i] == "--config"
+            argv.delete_at( i )
+            configs << argv.delete_at(i)
+          end
+
+          if argv[i] == "-e" || argv[i] == "--env"
+            argv.delete_at( i )
+            configs << "environment=#{argv.delete_at(i)}"
+          end
+
+          if argv[i] == "--pid"
+            argv.delete_at( i )
+            configs << "pid_file=#{argv.delete_at(i)}"
+          end
+
+          i += 1
+        end
+
+        return configs, argv
+      end
+
+      # Return the arguments remaining after running through #configuration
+      def arguments( argv )
+        self.configuration( argv ).last
+      end
+    end
+
+    attr_reader :options
+    
+    def initialize
+      @options = {}
+
+      @parser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [command] [options]"
+
+        opts.separator ""
+
+        opts.separator "Command is one of the following:"
+        opts.separator "    run   - Run the daemon without forking (default)"
+        opts.separator "    start - Run the daemon"
+        opts.separator "    stop  - Stop the running daemon"
+
+        opts.separator ""
+
+        opts.separator "Options can be:"
+
+        arg_file = File.join( DaemonKit.root, 'config', 'arguments.rb' )
+        eval(IO.read(arg_file), binding, arg_file) if File.exists?( arg_file )
+
+        opts.on("-e", "--env ENVIRONMENT", "Environment for the process", "Defaults to development") do
+          # Nothing, just here for show
+        end
+
+        opts.on("--pidfile PATH", "Path to the pidfile", "Defaults to log/#{DaemonKit.configuration.daemon_name}.pid") do
+          # Nothing, just here for show
+        end
+
+        opts.separator ""
+        opts.separator "Advanced configurations:"
+        opts.on("--config ATTRIBUTE=VALUE",
+                "Change values of the daemon-kit Configuration instance",
+                "Example: log_dir=/path/to/log-directory") do
+          # Nothing, just here for show
+        end
+
+        opts.separator ""
+
+        opts.separator "Common options:"
+        opts.on("-v", "--version", "Show version information and exit") do
+          puts "daemon-kit #{DaemonKit::VERSION} (http://github.com/kennethkalmer/daemon-kit)"
+          exit
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+    end
+
+    def parse( argv )
+      @parser.parse!( argv )
+    end
+  end
+end

data/lib/daemon_kit/commands/console.rb

@@ -0,0 +1,38 @@
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+require 'optparse'
+
+options = { :irb => irb }
+OptionParser.new do |opt|
+  opt.banner = "Usage: console [environment] [options]"
+  opt.on("--irb=[#{irb}]", 'Invoke a different irb.') { |v| options[:irb] = v }
+  opt.on("--debugger", 'Enable ruby-debugging for the console.') { |v| options[:debugger] = v }
+  opt.parse!(ARGV)
+end
+
+libs =  " -r irb/completion"
+libs << %( -r "#{DAEMON_ROOT}/config/environment")
+libs << " -r daemon_kit/console_daemon"
+
+if options[:debugger]
+  begin
+    require 'ruby-debug'
+    libs << " -r ruby-debug"
+    puts "=> Debugger enabled"
+  rescue Exception
+    puts "You need to install ruby-debug to run the console in debugging mode. With gems, use 'gem install ruby-debug'"
+    exit
+  end
+end
+
+ENV['DAEMON_ENV'] = case ARGV.first
+  when "p"; "production"
+  when "d"; "development"
+  when "t"; "test"
+  else
+    ARGV.first || ENV['DAEMON_ENV'] || 'development'
+end
+
+puts "Loading #{ENV['DAEMON_ENV']} environment (daemon-kit #{DaemonKit::VERSION})"
+
+exec "#{options[:irb]} #{libs} --simple-prompt"