kennethkalmer-daemon-kit 0.1.6 → 0.1.7.3

data/app_generators/daemon_kit/templates/script/console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'daemon_kit/commands/console'

data/app_generators/daemon_kit/templates/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:daemon, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/app_generators/daemon_kit/templates/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:daemon, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/daemon_generators/deploy_capistrano/deploy_capistrano_generator.rb

@@ -0,0 +1,35 @@
+class DeployCapistranoGenerator < RubiGen::Base
+
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+  end
+
+  def manifest
+    record do |m|
+
+      m.file      "Capfile", "Capfile"
+      m.directory "config"
+      m.template  "config/deploy.rb", "config/deploy.rb"
+      m.directory "config/deploy"
+      m.template  "config/deploy/staging.rb", "config/deploy/staging.rb"
+      m.template  "config/deploy/production.rb", "config/deploy/production.rb"
+      m.directory "config/environments"
+      m.file      "config/environments/staging.rb", "config/environments/staging.rb", :collision => :skip
+      m.readme    "USAGE"
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates the required capistrano configurations for deploying your daemon code
+to remote servers.
+
+USAGE: #{$0} #{spec.name} daemon-name
+EOS
+    end
+end

data/daemon_generators/deploy_capistrano/templates/Capfile

@@ -0,0 +1,10 @@
+unless respond_to?(:namespace) # cap2 differentiator
+  $stderr.puts "Requires capistrano version 2"
+  exit 1
+end
+
+require 'config/boot'
+load DaemonKit.framework_root + '/lib/daemon_kit/deployment/capistrano.rb'
+
+Dir['config/deploy/recipes/*.rb'].each { |plugin| load(plugin) }
+load 'config/deploy.rb'

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/production.rb

@@ -0,0 +1,6 @@
+#set :deploy_to, "/svc/<%= name %>" # defaults to "/u/apps/#{application}"
+#set :user, "<% name %>"            # defaults to the currently logged in user
+set :daemon_env, 'production'
+
+set :domain, 'example.com'
+server domain

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

@@ -0,0 +1,6 @@
+#set :deploy_to, "/svc/<%= name %>" # defaults to "/u/apps/#{application}"
+#set :user, "<% name %>"            # defaults to the currently logged in user
+set :daemon_env, 'staging'
+
+set :domain, 'example.com'
+server domain

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

@@ -0,0 +1,51 @@
+# Modified capistrano recipe, based on the standard 'deploy' recipe
+# provided by capistrano but without the Rails-specific dependencies
+
+set :stages, %w(staging production)
+set :default_stage, "staging"
+require "capistrano/ext/multistage"
+
+# Set some globals
+default_run_options[:pty] = true
+set :application, "<%= name %>"
+
+# Deployment
+set :deploy_to, "/svc/#{application}"
+#set :user, 'someone'
+
+# Get repo configuration
+set :repository, "git@github.com:yourname/#{application}.git"
+set :scm, "git"
+set :branch, "master"
+set :deploy_via, :remote_cache
+set :git_enable_submodules, 1
+
+# No sudo
+set :use_sudo, false
+
+# File list in the config_files setting will be copied from the
+# 'deploy_to' directory into config, overwriting files from the repo
+# with the same name
+set :config_files, %w{}
+
+# List any work directories here that you need persisted between
+# deployments. They are created in 'deploy_to'/shared and symlinked
+# into the root directory of the deployment.
+set :shared_children, %w{log tmp}
+
+# Record our dependencies
+depend :remote, :gem, "daemon-kit", ">=0.0.0"
+
+# Hook into capistrano's events
+before "deploy:update_code", "deploy:check"
+
+# Create some tasks related to deployment
+namespace :deploy do
+
+  desc "Get the current revision of the deployed code"
+  task :get_current_version do
+    run "cat #{current_path}/REVISION" do |ch, stream, out|
+      puts "Current revision: " + out.chomp
+    end
+  end
+end

data/lib/daemon_kit/application.rb

@@ -1,4 +1,4 @@
-require 'daemons'
+require 'timeout'
 
 module DaemonKit
 
@@ -7,29 +7,153 @@ 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?
+          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