apphunkd 0.9.0

data/vendor/daemon-kit/lib/daemon_kit/amqp.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+
+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/vendor/daemon-kit/lib/daemon_kit/application.rb

@@ -0,0 +1,187 @@
+require 'timeout'
+
+module DaemonKit
+
+  # Class responsible for making the daemons run and keep them running.
+  class Application
+
+    class << self
+
+      # Run the specified file as a daemon process.
+      def exec( file )
+        raise DaemonNotFound.new( file ) unless File.exist?( file )
+
+        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 )
+
+        DaemonKit.configuration.log_stdout = true
+
+        require file
+      end
+
+      # Run our file properly
+      def start( file )
+        self.drop_privileges
+        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?
+
+                seconds -= 1
+                sleep 1
+              end
+            end
+          rescue Timeout::Error
+            Process.kill( 'KILL', target_pid )
+          end
+        end
+
+        if @pid_file.running?
+          puts "Process still running, leaving pidfile behind! Consider using configuration.force_kill_wait."
+        else
+          @pid_file.cleanup
+        end
+      end
+
+      # Call this from inside a daemonized process to complete the
+      # initialization process
+      def running!
+        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
+
+      def drop_privileges
+        if DaemonKit.configuration.group
+          begin
+            group = Etc.getgrnam( DaemonKit.configuration.group )
+            Process::Sys.setgid( group.gid.to_i )
+          rescue => e
+            $stderr.puts "Caught exception while trying to drop group privileges: #{e.message}"
+          end
+        end
+        if DaemonKit.configuration.user
+          begin
+            user = Etc.getpwnam( DaemonKit.configuration.user )
+            Process::Sys.setuid( user.uid.to_i )
+          rescue => e
+            $stderr.puts "Caught exception while trying to drop user privileges: #{e.message}"
+          end
+        end
+      end
+    end
+
+  end
+end

data/vendor/daemon-kit/lib/daemon_kit/arguments.rb

@@ -0,0 +1,165 @@
+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
+      #   -l path or --log path   => /path/to/log/file
+      #
+      def configuration( argv )
+        configs = []
+
+        i = 0
+        while i < argv.size
+          if argv[i] == "--config"
+            argv.delete_at( i )
+            configs << argv.delete_at(i)
+            next
+          end
+
+          if argv[i] == "-e" || argv[i] == "--env"
+            argv.delete_at( i )
+            configs << "environment=#{argv.delete_at(i)}"
+            next
+          end
+
+          if argv[i] == "-l" || argv[i] == "--log"
+            argv.delete_at( i )
+            configs << "log_path=#{argv.delete_at(i)}"
+            next
+          end
+
+          if argv[i] == "--pid"
+            argv.delete_at( i )
+            configs << "pid_file=#{argv.delete_at(i)}"
+            next
+          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.on("-l", "--log /path/to/logfile", "Path to the log file", "Defaults to log/[environment].log") 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/vendor/daemon-kit/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"

data/vendor/daemon-kit/lib/daemon_kit/config.rb

@@ -0,0 +1,108 @@
+module DaemonKit
+
+  # Simplify simple config file loading for daemons. Assumes the
+  # config files all live in DAEMON_ROOT/config and are YAML
+  # files. Loaded configs are accessed like a hash with string
+  # keys.
+  #
+  # Config files can either be keyed by environment (default behavior)
+  # or be a normal hash.
+  #
+  # Load a config by passing the filename (with or without the .yml
+  # extension) to #load.
+  #
+  # At this stage the configs are read-only.
+  #
+  # Any of the keys can be called as methods as well.
+  class Config
+
+    class << self
+
+      # Load the +config+.yml file from DAEMON_ROOT/config
+      def load( config )
+        config = config.to_s
+        config += '.yml' unless config =~ /\.yml$/
+
+        path = File.join( DAEMON_ROOT, 'config', config )
+
+        raise ArgumentError, "Can't find #{path}" unless File.exists?( path )
+
+        new( YAML.load_file( path ) )
+      end
+
+      # Return the +config+.yml file as a raw hash.
+      def hash( config, symbolize = false )
+        self.load( config ).to_h( symbolize )
+      end
+
+    end
+
+    # Expects a hash, looks for DAEMON_ENV key
+    def initialize( config_data ) #:nodoc:
+      if config_data.has_key?( DAEMON_ENV )
+        self.data = config_data[ DAEMON_ENV ]
+      else
+        self.data = config_data
+      end
+    end
+
+    # Pick out a config by name
+    def []( key )
+      @data[ key.to_s ]
+    end
+
+    # Return the internal hash structure used, optionally symbolizing
+    # the first level of keys in the hash
+    def to_h( symbolize = false )
+      symbolize ? @data.symbolize_keys : @data
+    end
+
+    def method_missing( method_name, *args ) #:nodoc:
+      unless method_name.to_s =~ /[\w_]+=$/
+        if @data.keys.include?( method_name.to_s )
+          return @data.send( method_name.to_s )
+        end
+      end
+
+      super
+    end
+
+    def data=( hash )
+      @data = hash
+      class << @data
+        def symbolize_keys( hash = self )
+          hash.inject({}) { |result, (key, value)|
+            new_key = case key
+                    when String then key.to_sym
+                    else key
+                    end
+            new_value = case value
+                    when Hash then symbolize_keys(value)
+                    else value
+                    end
+            result[new_key] = new_value
+            result
+          }
+        end
+      end
+
+      extend_hash( @data )
+    end
+
+    def extend_hash( hash )
+      hash.keys.each do |k|
+        hash.instance_eval <<-KEY
+          def #{k}
+            fetch("#{k}")
+          end
+        KEY
+      end
+
+      hash.each do |(key, value)|
+        case value
+          when Hash then extend_hash( value )
+        end
+      end
+    end
+  end
+end