queso-daemon-kit 0.1.7.10

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

@@ -0,0 +1,62 @@
+# 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.10'
+
+  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 :AbstractLogger, 'daemon_kit/abstract_logger'
+  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 :RuoteParticipants,      'daemon_kit/ruote_participants'
+  autoload :RuoteWorkitem,          'daemon_kit/ruote_workitem'
+  autoload :RuotePseudoParticipant, 'daemon_kit/ruote_pseudo_participant'
+
+  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/abstract_logger.rb

@@ -0,0 +1,235 @@
+require 'logger'
+
+module DaemonKit
+  # One of the key parts of succesful background processes is adequate
+  # logging. The AbstractLogger aims to simplify logging from inside
+  # daemon processes by providing additional useful information with
+  # each log line, including calling file name and line number and
+  # support for cleanly logging exceptions.
+  #
+  # The logger can be accessed through #DaemonKit.logger.
+  #
+  # AbstractLogger provides an interface that is fully compatible with
+  # the Logger class provided by Ruby's Standard Library, and is
+  # extended with some additional conveniences.
+  #
+  # The AbstractLogger supports different backends, by default it uses
+  # a Logger instance, but can by swapped out for a SysLogLogger
+  # logger as well.
+  class AbstractLogger
+
+    attr_accessor :copy_to_stdout
+
+    @severities = {
+      :debug   => Logger::DEBUG,
+      :info    => Logger::INFO,
+      :warn    => Logger::WARN,
+      :error   => Logger::ERROR,
+      :fatal   => Logger::FATAL,
+      :unknown => Logger::UNKNOWN
+    }
+
+    @silencer = true
+
+    class << self
+      attr_reader :severities
+      attr_accessor :silencer
+    end
+
+    # Optional log path, defaults to
+    # <em>DAEMON_ROOT/log/DAEMON_ENV.log</em>
+    def initialize( log_path = nil )
+      if log_path.to_s == "syslog"
+        @backend = :syslog
+      else
+        @logger_file = log_path || "#{DAEMON_ROOT}/log/#{DAEMON_ENV}.log"
+        @backend = :logger
+      end
+
+      @copy_to_stdout = false
+    end
+
+    # Silence the logger for the duration of the block.
+    def silence( temporary_level = :error )
+      if self.class.silencer
+        begin
+          old_level, self.level = self.level, temporary_level
+          yield self
+        ensure
+          self.level = old_level
+        end
+      else
+        yield self
+      end
+    end
+
+    def debug( msg )
+      add( :debug, msg )
+    end
+
+    def debug?
+      self.level == :debug
+    end
+
+    def info( msg )
+      add( :info, msg )
+    end
+
+    def info?
+      self.level == :info
+    end
+
+    def warn( msg )
+      add( :warn, msg )
+    end
+
+    def warn?
+      self.level == :warn
+    end
+
+    def error( msg )
+      add( :error, msg )
+    end
+
+    def error?
+      self.level == :error
+    end
+
+    def fatal( msg )
+      add( :fatal, msg )
+    end
+
+    def fatal?
+      self.level == :fatal
+    end
+
+    def unknown( msg )
+      add( :unknown, msg )
+    end
+
+    def unknown?
+      self.level == :unknown
+    end
+
+    def exception( e )
+      message = "EXCEPTION: #{e.message}: #{clean_trace( e.backtrace )}"
+      self.add( :error, message, true )
+    end
+
+    def add( severity, message, skip_caller = false )
+      message = "#{called(caller)}: #{message}" unless skip_caller
+
+      self.logger.add( self.class.severities[ severity ] ) { message }
+
+      STDOUT.puts( message ) if self.copy_to_stdout
+    end
+
+    def level
+      self.class.severities.invert[ @logger.level ]
+    end
+
+    def level=( level )
+      level = ( Symbol === level ? self.class.severities[ level ] : level )
+      self.logger.level = level
+    end
+
+    def logger
+      @logger ||= create_logger
+    end
+
+    def logger=( logger )
+      if logger.is_a?( Symbol )
+        @backend = logger
+        @logger.close rescue nil
+        @logger = create_logger
+      else
+        @logger.close rescue nil
+        @logger = logger
+      end
+    end
+
+    def clean_trace( trace )
+      trace = trace.map { |l| l.gsub(DAEMON_ROOT, '') }
+      trace = trace.reject { |l| l =~ /gems\/daemon[\-_]kit/ }
+      trace = trace.reject { |l| l =~ /vendor\/daemon[\-_]kit/ }
+      trace
+    end
+
+    def close
+      case @backend
+      when :logger
+        self.logger.close
+        @logger = nil
+      end
+    end
+
+    private
+
+    def called( trace )
+      l = trace.detect('unknown:0') { |l| l.index('abstract_logger.rb').nil? }
+      file, num, _ = l.split(':')
+
+      [ File.basename(file), num ].join(':')
+    end
+
+    def create_logger
+      case @backend
+      when :logger
+        create_standard_logger
+      when :syslog
+        create_syslog_logger
+      end
+    end
+
+    def create_standard_logger
+      log_path = File.dirname( @logger_file )
+      unless File.directory?( log_path )
+        begin
+          FileUtils.mkdir_p( log_path )
+        rescue
+          STDERR.puts "#{log_path} not writable, using STDERR for logging"
+          @logger_file = STDERR
+        end
+      end
+
+      l = Logger.new( @logger_file )
+      l.formatter = Formatter.new
+      l.progname = if DaemonKit.configuration
+                     DaemonKit.configuration.daemon_name
+                   else
+                     File.basename($0)
+                   end
+      l
+    end
+
+    def create_syslog_logger
+      begin
+        require 'syslog_logger'
+        SyslogLogger.new( DaemonKit.configuration ? DaemonKit.configuration.daemon_name : File.basename($0) )
+      rescue LoadError
+        self.logger = :logger
+        self.error( "Couldn't load syslog_logger gem, reverting to standard logger" )
+      end
+    end
+
+    class Formatter
+
+      # YYYY:MM:DD HH:MM:SS.MS daemon_name(pid) level: message
+      @format = "%s %s(%d) [%s] %s\n"
+
+      class << self
+        attr_accessor :format
+      end
+
+      def call(severity, time, progname, msg)
+        self.class.format % [ format_time( time ), progname, $$, severity, msg.to_s ]
+      end
+
+      private
+
+      def format_time( time )
+        time.strftime( "%Y-%m-%d %H:%M:%S." ) + time.usec.to_s
+      end
+    end
+  end
+end

data/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/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