kennethkalmer-daemon-kit 0.1.7.9 → 0.1.7.10

data/daemon_generators/ruote/templates/config/initializers/ruote.rb

@@ -0,0 +1,13 @@
+begin
+  require 'json'
+rescue LoadError
+  $stderr.puts "Missing json gem. Please run 'gem install json'"
+  exit 1
+end
+
+begin
+  require 'amqp'
+  require 'mq'
+rescue LoadError
+  $stderr.puts "Missing amqp gem. Please run 'gem install amqp' if you wish to use the AMQP participant/listener pair in ruote"
+end

data/daemon_generators/ruote/templates/config/ruote.yml

@@ -0,0 +1,23 @@
+# Sample configuration file for a remote participant daemon
+
+# If your using the AMQP listener/participant pair in ruote, you only
+# need to specify the names of the queues to subscribe to.
+
+defaults: &defaults
+  amqp:
+    queues:
+      - work1
+      #- work2
+      #- work3
+
+development:
+  <<: *defaults
+
+test:
+  <<: *defaults
+
+staging:
+  <<: *defaults
+
+production:
+  <<: *defaults

data/daemon_generators/ruote/templates/lib/daemon.rb

@@ -0,0 +1,4 @@
+# Your starting point for daemon specific classes. This directory is
+# already included in your load path, so no need to specify it.
+
+require 'sample'

data/daemon_generators/ruote/templates/lib/sample.rb

@@ -0,0 +1,26 @@
+require 'open-uri'
+
+# Sample pseudo participant
+#
+# See http://gist.github.com/144861 for a test engine
+class Sample < DaemonKit::RuotePseudoParticipant
+
+  on_exception :dammit
+
+  on_complete do |workitem|
+    workitem['success'] = true
+  end
+
+  def quote
+    workitem["quote"] = open("http://www.iheartquotes.com/api/v1/random").read
+  end
+
+  def err
+    raise ArgumentError, "Does not compute"
+  end
+
+  def dammit( exception )
+    workitem["error"] = exception.message
+  end
+
+end

data/daemon_generators/ruote/templates/libexec/daemon.rb

@@ -0,0 +1,33 @@
+# Generated remote participant for the ruote workflow engine
+# (http://openwferu.rubyforge.org)
+
+# Do your post daemonization configuration here
+# At minimum you need just the first line (without the block), or a lot
+# of strange things might start happening...
+DaemonKit::Application.running! do |config|
+  # Trap signals with blocks or procs
+  # config.trap( 'INT' ) do
+  #   # do something clever
+  # end
+  # config.trap( 'TERM', Proc.new { puts 'Going down' } )
+end
+
+# IMPORTANT CONFIGURATION NOTE
+#
+# Please review and update 'config/amqp.yml' accordingly if you wish to use
+# AMQP as a transport mechanism for workitems sent between ruote and this
+# daemon.
+
+# Configuration of the remote participant shell
+DaemonKit::RuoteParticipants.configure do |config|
+  # Use AMQP as a workitem transport mechanism
+  config.use :amqp
+
+  # Register your classes as pseudo-participants, with work being delegated
+  # according to the 'command' parameter passed in the process definition
+  config.register Sample
+end
+
+DaemonKit::RuoteParticipants.run do
+  # Place any additional daemon-specific code in here...
+end

data/lib/daemon_kit.rb

@@ -1,15 +1,24 @@
 # TODO: Strip this out eventually so we can run without rubygems
 require 'rubygems'
 
+# Seems in 1.9 we need to load openssl before em or there is failures all around.
+# But we need to consider that people might not have ssl in the first place.
+if RUBY_VERSION >= "1.9"
+  begin
+    require 'openssl'
+  rescue LoadError
+  end
+end
 require 'eventmachine'
 
 require File.dirname(__FILE__) + '/daemon_kit/core_ext'
+require File.dirname(__FILE__) + '/daemon_kit/exceptions'
 
 $:.unshift( File.dirname(__FILE__).to_absolute_path ) unless
   $:.include?( File.dirname(__FILE__).to_absolute_path )
 
 module DaemonKit
-  VERSION = '0.1.7.9'
+  VERSION = '0.1.7.10'
 
   autoload :Initializer,    'daemon_kit/initializer'
   autoload :Application,    'daemon_kit/application'
@@ -21,10 +30,13 @@ module DaemonKit
   autoload :EM,             'daemon_kit/em'
   autoload :Configurable,   'daemon_kit/core_ext/configurable'
 
-  autoload :Cron,   'daemon_kit/cron'
-  autoload :Jabber, 'daemon_kit/jabber'
-  autoload :AMQP,   'daemon_kit/amqp'
-  autoload :Nanite, 'daemon_kit/nanite'
+  autoload :Cron,                   'daemon_kit/cron'
+  autoload :Jabber,                 'daemon_kit/jabber'
+  autoload :AMQP,                   'daemon_kit/amqp'
+  autoload :Nanite,                 'daemon_kit/nanite'
+  autoload :RuoteParticipants,      'daemon_kit/ruote_participants'
+  autoload :RuoteWorkitem,          'daemon_kit/ruote_workitem'
+  autoload :RuotePseudoParticipant, 'daemon_kit/ruote_pseudo_participant'
 
   class << self
     def logger

data/lib/daemon_kit/application.rb

@@ -40,6 +40,7 @@ module DaemonKit
 
       # Run our file properly
       def start( file )
+        self.drop_privileges
         self.daemonize
         self.chroot
         self.clean_fd
@@ -161,6 +162,25 @@ module DaemonKit
           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

data/lib/daemon_kit/arguments.rb

@@ -68,21 +68,25 @@ module DaemonKit
           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

data/lib/daemon_kit/config.rb

@@ -40,9 +40,9 @@ module DaemonKit
     # Expects a hash, looks for DAEMON_ENV key
     def initialize( config_data ) #:nodoc:
       if config_data.has_key?( DAEMON_ENV )
-        @data = config_data[ DAEMON_ENV ]
+        self.data = config_data[ DAEMON_ENV ]
       else
-        @data = config_data
+        self.data = config_data
       end
     end
 
@@ -54,17 +54,55 @@ module DaemonKit
     # Return the internal hash structure used, optionally symbolizing
     # the first level of keys in the hash
     def to_h( symbolize = false )
-      symbolize ? @data.inject({}) { |m,c| m[c[0].to_sym] = c[1]; m } : @data
+      symbolize ? @data.symbolize_keys : @data
     end
 
     def method_missing( method_name, *args ) #:nodoc:
-      # don't match setters
       unless method_name.to_s =~ /[\w_]+=$/
-        # pick a key if we have it
-        return @data[ method_name.to_s ] if @data.keys.include?( method_name.to_s )
+        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

data/lib/daemon_kit/exceptions.rb

@@ -0,0 +1,8 @@
+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
+end

data/lib/daemon_kit/initializer.rb

@@ -37,6 +37,10 @@ module DaemonKit
       self.configuration.trap( *args, &block )
     end
 
+    def at_shutdown( &block )
+      self.configuration.at_shutdown( &block )
+    end
+
   end
 
 
@@ -63,9 +67,17 @@ module DaemonKit
     def self.shutdown( clean = 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}"
@@ -87,6 +99,8 @@ module DaemonKit
     end
 
     def after_daemonize
+      set_umask
+
       initialize_logger
       initialize_signal_traps
 
@@ -97,6 +111,14 @@ module DaemonKit
       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
@@ -138,6 +160,10 @@ module DaemonKit
       end
     end
 
+    def set_umask
+      File.umask configuration.umask
+    end
+
     def initialize_logger
       return if DaemonKit.logger
 
@@ -246,11 +272,23 @@ module DaemonKit
     # 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!
@@ -267,6 +305,7 @@ module DaemonKit
       self.safety_net = DaemonKit::Safety.instance
 
       @signal_traps = {}
+      @shutdown_hooks = []
     end
 
     def environment
@@ -294,6 +333,13 @@ module DaemonKit
       @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

data/lib/daemon_kit/ruote_participants.rb

@@ -0,0 +1,119 @@
+module DaemonKit
+  # Class that cleanly abstracts away the different remote participants in
+  # ruote and allows daemon writers to just worry about processing workitems
+  # without worrying over the transport mechanism or anything else...
+  class RuoteParticipants
+
+    class << self
+
+      # Configure this daemon as a remote participant to ruote.
+      def configure(&block)
+        instance.configure(&block)
+      end
+
+      # Activate and run the remote participant code, calling the optional
+      # block for additional daemon logic.
+      def run(&block)
+        instance.run(&block)
+      end
+
+      private :new
+
+      def instance
+        @instance ||= new
+      end
+
+      private
+
+      def instance=( obj )
+        @instance = obj
+      end
+    end
+
+    attr_reader :participants
+
+    def initialize
+      @transports = []
+      @participants = {}
+
+      @configuration = Config.load('ruote')
+    end
+
+    # Yields +self+ and configures the remote participants
+    def configure(&block)
+      block.call( self )
+
+      @transports.freeze
+      @participants.freeze
+    end
+
+    # Enable the use of a specific transport for workitems. Can be :amqp to use
+    # the AMQPParticipant/AMQPListener pair in ruote.
+    def use( transport )
+      @transports << transport
+    end
+
+    # Register classes as pseudo-participants. Two styles of registration are
+    # supported:
+    #
+    #   register( Foo )
+    #   register( 'short', ShortParticipant )
+    #
+    # The first format uses the class name (downcased and underscored) as the
+    # key for identifying the pseudo-participant, the second uses the the
+    # provided key.
+    #
+    # Pseudo-participant classes are instantiated when registered, and the
+    # instances are re-used.
+    def register( *args )
+      key, klass = if args.size == 1
+        [ underscore( args.first.to_s ), args.first ]
+      else
+        [ args[0].to_s, args[1] ]
+      end
+
+      @participants[ key ] = klass.new
+    end
+
+    # Run the participants
+    def run(&block)
+      run_amqp! if @transports.include?( :amqp )
+    end
+
+    private
+
+    def run_amqp!
+      AMQP.run do
+        mq = ::MQ.new
+        queues = @configuration['amqp']['queues'].to_a
+
+        queues.each do |q|
+          DaemonKit.logger.debug("Subscribing to #{q} for workitems")
+
+          cmdq = mq.queue( q, :durable => true )
+          cmdq.subscribe( :ack => true ) do |header, message|
+            safely do
+              DaemonKit.logger.debug("Received workitem: #{message.inspect}")
+
+              RuoteWorkitem.process( :amqp, message )
+
+              DaemonKit.logger.debug("Processed workitem.")
+
+              header.ack
+            end
+          end
+        end
+      end
+    end
+
+    # Shamelessly lifted from the ActiveSupport inflector
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+
+end