amqp-daemon-kit 0.1.8.1

data/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] == "--pidfile"
+            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/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/lib/daemon_kit/commands/destroy.rb

@@ -0,0 +1,10 @@
+require 'daemon_kit/generators'
+DaemonKit::Generators.configure!
+
+if ARGV.size == 0
+  DaemonKit::Generators.help
+  exit
+end
+
+name = ARGV.shift
+DaemonKit::Generators.invoke name, ARGV, :behaviour => :revoke, :destination_root => DaemonKit.root

data/lib/daemon_kit/commands/generate.rb

@@ -0,0 +1,10 @@
+require 'daemon_kit/generators'
+DaemonKit::Generators.configure!
+
+if ARGV.size == 0
+  DaemonKit::Generators.help
+  exit
+end
+
+name = ARGV.shift
+DaemonKit::Generators.invoke name, ARGV, :behaviour => :invoke, :destination_root => DaemonKit.root

data/lib/daemon_kit/config.rb

@@ -0,0 +1,113 @@
+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
+        if @data.respond_to?( method_name.to_s )
+          return @data.send( method_name.to_s )
+        elsif @data.respond_to?( method_name.to_s.gsub(/\-/, '_') )
+          return @data.send( method_name.to_s.gsub(/\-/, '_') )
+        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.gsub(/\-/, '_')}
+            fetch("#{k}")
+          end
+        KEY
+      end
+
+      hash.each do |(key, value)|
+        case value
+          when Hash then extend_hash( value )
+        end
+      end
+    end
+  end
+end

data/lib/daemon_kit/console_daemon.rb

@@ -0,0 +1,2 @@
+# Load and configure our daemon process, without daemonizing
+DaemonKit::Application.running!

data/lib/daemon_kit/core_ext.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/core_ext/string'

data/lib/daemon_kit/core_ext/configurable.rb

@@ -0,0 +1,96 @@
+module DaemonKit
+
+  # Provide some advanced helpers for managing access to instance variables.
+  module Configurable
+
+    def self.included(base) #:nodoc:
+      base.class_eval <<-EOF
+        @configurables = {}
+        @configurable_defaults = {}
+
+        class << self
+          attr_reader :configurables, :configurable_defaults
+        end
+      EOF
+
+      base.extend( ClassMethods )
+      base.send( :include, InstanceMethods )
+    end
+
+    module ClassMethods
+
+      # Create a configurable value on any instance, which can contain
+      # a default value, and/or be locked.
+      #
+      # Create a standard getter/setter without a default value
+      #
+      #   configurable :foo
+      #
+      # Create a getter/setter with a default value
+      #
+      #   configurable :foo, true
+      #
+      # The final argument can be an options hash, which currently
+      # respects only one key: +locked+ (false by default). Locking a
+      # configurable means the value can only be set once by the
+      # setter method.
+      #
+      #   configurable :foo, :locked => true
+      #
+      # As long as the getter method (+foo+) returns nil, the standard
+      # setter method will work. As soon as the getter returns a
+      # non-nil value the setter won't set a new value. To set a new
+      # value you'll have to explicitly use the #set instance method.
+      def configurable( name, *args )
+        opts = args.last.is_a?( Hash ) ? args.pop : {}
+        opts = { :locked => false }.merge( opts )
+
+        default = args.size <= 1 ? args.pop : args
+
+        name = name.to_sym
+
+        self.configurables[ name ] = opts
+        self.configurable_defaults[ name ] = default
+
+        class_eval( <<-EOF, __FILE__, __LINE__ )
+          def #{name}                                    # def foo
+            if _configurables[:#{name}].nil?             #   if _configurables[:foo].nil?
+              self.class.configurable_defaults[:#{name}] #     self.class.configurable_defaults[:foo]
+            else                                         #   else
+              _configurables[:#{name}]                   #     _configurables[:foo]
+            end                                          #   end
+          end                                            #
+
+          def #{name}=( value )                              # def foo=( value )
+            if #{name}.nil? ||                               #   if foo.nil? ||
+                !self.class.configurables[:#{name}][:locked] #       !self.class.configurables[:foo][:locked]
+                                                             #
+              _configurables[:#{name}] = value               #     _configurables[:foo] = value
+            end                                              #   end
+          end                                                # end
+        EOF
+      end
+
+    end
+
+    module InstanceMethods
+
+      # Force the value of a configurable to be set without any
+      # respect for it's locked status.
+      def set( name, value )
+        name = name.to_sym
+
+        if self.class.configurables.has_key?( name )
+          _configurables[ name ] = value
+        end
+      end
+
+      private
+
+      def _configurables
+        @_configurables ||= {}
+      end
+
+    end
+  end
+end

data/lib/daemon_kit/core_ext/string.rb

@@ -0,0 +1,22 @@
+require 'pathname'
+
+class String
+
+  # Assuming the string is a file or path name, convert it into an
+  # absolute path.
+  def to_absolute_path
+    # Pathname is incompatible with Windows, but Windows doesn't have
+    # real symlinks so File.expand_path is safe.
+    if RUBY_PLATFORM =~ /(:?mswin|mingw)/
+      File.expand_path( self )
+
+      # Otherwise use Pathname#realpath which respects symlinks.
+    else
+      begin
+        File.expand_path( Pathname.new( self ).realpath.to_s )
+      rescue Errno::ENOENT
+        File.expand_path( Pathname.new( self ).cleanpath.to_s )
+      end
+    end
+  end
+end