daemon-kit 0.1.3

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

@@ -0,0 +1,27 @@
+# Generated jabber daemon
+
+# 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/jabber.yml' accordingly or this
+# daemon won't work as advertised.
+
+# This block gets called every time a message has been received from a
+# valid master.
+DaemonKit::Jabber.received_messages do |message|
+  # Simple echo service
+  DaemonKit::Jabber.deliver( message.from, message.body )
+end
+
+# Run our Jabber bot
+DaemonKit::Jabber.run

data/lib/daemon_kit.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+
+module DaemonKit
+  VERSION = '0.1.3'
+  
+  autoload :Initializer, 'daemon_kit/initializer'
+  autoload :Application, 'daemon_kit/application'
+  autoload :Cron,        'daemon_kit/cron'
+  autoload :Jabber,      'daemon_kit/jabber'
+  autoload :AMQP,        'daemon_kit/amqp'
+end

data/lib/daemon_kit/amqp.rb

@@ -0,0 +1,41 @@
+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 ||= (
+          config = YAML.load_file( "#{DAEMON_ROOT}/config/amqp.yml" )[DAEMON_ENV]
+          raise ArgumentError, "Missing AMQP configuration for #{DAEMON_ENV} environment" if config.nil?
+          new( config )
+        )
+      end
+
+      private :new
+
+      def run(&block)
+        instance.run(&block)
+      end
+    end
+
+    def initialize( config = {} )
+      @config = config.inject({}) { |m,c| m[c[0].to_sym] = c[1]; m } # symbolize_keys 
+    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
+      ::AMQP.start(@config, &block)
+    end
+  end
+end

data/lib/daemon_kit/application.rb

@@ -0,0 +1,34 @@
+require 'daemons'
+
+module DaemonKit
+
+  # Class responsible for making the daemons run and keep them running.
+  class Application
+
+    class << self
+
+      # Run the file as a daemon
+      def run( 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 }
+
+        options[:dir_mode]        = DaemonKit.configuration.dir_mode || :normal
+        options[:dir]             = DaemonKit.configuration.dir      || "log"
+        options[:multiple]        = DaemonKit.configuration.multiple
+        options[:force_kill_wait] = DaemonKit.configuration.force_kill_wait if DaemonKit.configuration.force_kill_wait
+
+        Daemons.run( file, options )
+      end
+
+      # Call this from inside a daemonized process to complete the
+      # initialization process
+      def running!
+        DaemonKit::Initializer.continue!
+      end
+
+    end
+
+  end
+end

data/lib/daemon_kit/cron.rb

@@ -0,0 +1,38 @@
+module DaemonKit
+  
+  # Thin wrapper around rufus-scheduler gem, specifically designed to ease
+  # configuration of a scheduler and provide some added simplicity.
+  class Cron
+
+    @@instance = nil
+
+    attr_reader :scheduler
+    
+    class << self
+      
+      def instance
+        @instance ||= new
+      end
+
+      def scheduler
+        instance.scheduler
+      end
+      
+      private :new
+
+      def run
+        DaemonKit.logger.info "Starting rufus-scheduler"
+
+        begin
+          instance.scheduler.join
+        rescue Interrupt
+          DaemonKit.logger.warn "Scheduler interrupted"
+        end
+      end
+    end
+
+    def initialize
+      @scheduler = Rufus::Scheduler.start_new
+    end
+  end
+end

data/lib/daemon_kit/initializer.rb

@@ -0,0 +1,255 @@
+require 'logger'
+require 'pathname'
+
+DAEMON_ENV = (ENV['DAEMON_ENV'] || 'development').dup unless defined?(DAEMON_ENV)
+
+$:.unshift File.dirname(__FILE__) + '/..'
+require 'daemon_kit'
+
+module DaemonKit
+
+  class << self
+
+    def logger
+      @logger
+    end
+
+    def logger=( logger )
+      @logger = logger
+    end
+
+    def configuration
+      @configuration
+    end
+
+    def configuration=( configuration )
+      @configuration = configuration
+    end
+
+    def trap( *args, &block )
+      self.configuration.trap( *args, &block )
+    end
+    
+  end
+  
+
+  # This class does all the nightmare work of setting up a working
+  # environment for your daemon.
+  class Initializer
+
+    attr_reader :configuration
+    
+    def self.run( configuration = Configuration.new )
+      yield configuration if block_given?
+      initializer = new configuration
+      initializer.before_daemonize
+      initializer
+    end
+
+    def self.continue!
+      initializer = new DaemonKit.configuration
+      initializer.after_daemonize
+    end
+
+    def self.shutdown
+      DaemonKit.logger.warn "Shutting down"
+      exit
+    end
+    
+    def initialize( configuration )
+      @configuration = configuration
+    end
+
+    def before_daemonize
+      DaemonKit.configuration = @configuration
+      
+      set_load_path
+      load_gems
+      load_patches
+      load_environment
+    end
+
+    def after_daemonize
+      initialize_logger
+      initialize_signal_traps
+    end
+    
+    def set_load_path
+      configuration.load_paths.each do |d|
+        $:.unshift( "#{DAEMON_ROOT}/#{d}" ) if File.directory?( "#{DAEMON_ROOT}/#{d}" )
+      end
+    end
+
+    def load_gems
+      
+    end
+
+    def load_patches
+      if !!configuration.force_kill_wait
+        require 'daemon_kit/patches/force_kill_wait'
+      end
+    end
+
+    def load_environment
+      return if @environment_loaded
+      @environment_loaded = true
+      
+      config = configuration
+      
+      eval(IO.read(configuration.environment_path), binding, configuration.environment_path)
+      
+      eval(IO.read(configuration.daemon_initializer), binding, configuration.daemon_initializer) if File.exist?( configuration.daemon_initializer )
+    end
+
+    def initialize_logger
+      return if DaemonKit.logger
+      
+      unless logger = configuration.logger
+        logger = Logger.new( configuration.log_path )
+        logger.level = configuration.log_level
+      end
+      
+      DaemonKit.logger = logger
+
+      configuration.trap("USR1") {
+        DaemonKit.logger.level = DaemonKit.logger.debug? ? Logger::INFO : Logger::DEBUG
+        DaemonKit.logger.info "Log level changed to #{DaemonKit.logger.debug? ? 'DEBUG' : 'INFO' }"
+      }
+      configuration.trap("USR2") {
+        DaemonKit.logger.level = Logger::DEBUG
+        DaemonKit.logger.info "Log level changed to DEBUG"
+      }
+
+      DaemonKit.logger.info "DaemonKit up and running in #{DAEMON_ENV} mode"
+    end
+
+    def initialize_signal_traps
+      term_proc = Proc.new { DaemonKit::Initializer.shutdown }
+      configuration.trap( 'INT', term_proc )
+      configuration.trap( 'TERM', term_proc )
+    end
+    
+  end
+  
+  # Holds our various configuration values
+  class Configuration
+    # Root to the daemon
+    attr_reader :root_path
+
+    # List of load paths
+    attr_accessor :load_paths
+
+    # The log level to use, defaults to DEBUG
+    attr_accessor :log_level
+
+    # Path to the log file, defaults to 'log/<environment>.log'
+    attr_accessor :log_path
+
+    # :system, 
+    attr_accessor :dir_mode
+
+    # Path to the log file, defaults to 'log/<environment>.log'
+    attr_accessor :dir
+
+    # Provide a custom logger to use
+    attr_accessor :logger
+
+    # The application name
+    attr_accessor :daemon_name
+
+    # Allow multiple copies to run?
+    attr_accessor :multiple
+
+    # Use the force kill patch? Give the number of seconds
+    attr_accessor :force_kill_wait
+
+    # Collection of signal traps
+    attr_reader :signal_traps
+
+    def initialize
+      set_root_path!
+      
+      self.load_paths = default_load_paths
+      self.log_level  = default_log_level
+      self.log_path   = default_log_path
+
+      self.multiple = false
+      self.force_kill_wait = false
+
+      @signal_traps = {}
+    end
+
+    def environment
+      ::DAEMON_ENV
+    end
+
+    # The path to the current environment's file (<tt>development.rb</tt>, etc.). By
+    # default the file is at <tt>config/environments/#{environment}.rb</tt>.
+    def environment_path
+      "#{root_path}/config/environments/#{environment}.rb"
+    end
+
+    def daemon_initializer
+      "#{root_path}/config/initializers/#{self.daemon_name}.rb"
+    end
+    
+    # Add a trap for the specified signal, can be code block or a proc
+    def trap( signal, proc = nil, &block )
+      return if proc.nil? && !block_given?
+      
+      unless @signal_traps.has_key?( signal )
+        set_trap( signal )
+      end
+      
+      @signal_traps[signal].unshift( proc || block )
+    end
+    
+    protected
+
+    def run_traps( signal )
+      DaemonKit.logger.info "Running signal traps for #{signal}"
+      self.signal_traps[ signal ].each { |trap| trap.call }
+    end
+    
+    private
+
+    def set_trap( signal )
+      DaemonKit.logger.info "Setting up trap for #{signal}"
+      @signal_traps[ signal ] = []
+      Signal.trap( signal, Proc.new { self.run_traps( signal ) } )
+    end
+    
+    def set_root_path!
+      raise "DAEMON_ROOT is not set" unless defined?(::DAEMON_ROOT)
+      raise "DAEMON_ROOT is not a directory" unless defined?(::DAEMON_ROOT)
+
+      @root_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(::DAEMON_ROOT)
+
+        # Otherwise use Pathname#realpath which respects symlinks.
+        else
+          Pathname.new(::DAEMON_ROOT).realpath.to_s
+        end
+
+      Object.const_set(:RELATIVE_DAEMON_ROOT, ::DAEMON_ROOT.dup) unless defined?(::RELATIVE_DAEMON_ROOT)
+      ::DAEMON_ROOT.replace @root_path
+    end
+
+    def default_load_paths
+      [ 'lib' ]
+    end
+    
+    def default_log_path
+      File.join(root_path, 'log', "#{environment}.log")
+    end
+
+    def default_log_level
+      environment == 'production' ? Logger::INFO : Logger::DEBUG
+    end
+  end
+  
+  
+end

data/lib/daemon_kit/jabber.rb

@@ -0,0 +1,172 @@
+require 'yaml'
+
+module DaemonKit
+  # Thin wrapper around xmpp4r-simple, specifically designed to ease
+  # configuration of a jabber daemon and provide some added simplicity.
+  class Jabber
+
+    # Jabber connection
+    attr_reader :connection
+
+    @@instance = nil
+    @@message_handler = nil
+    @@presence_handler = nil
+    @@subscription_handler = nil
+    
+    class << self
+
+      # Deliver a message to the specified jid.
+      def deliver( jid, message )
+        instance.connection.deliver( jid, message )
+      end
+      
+      # Use this instead of initializing, keeps it singleton
+      def instance
+        @instance ||= (
+          config = YAML.load_file( "#{DAEMON_ROOT}/config/jabber.yml" )[DAEMON_ENV]
+          raise ArgumentError, "Missing Jabber configuration for #{DAEMON_ENV} environment" if config.nil?
+          new( config )
+        )
+        @instance.startup!
+      end
+      private :new
+
+      def run
+        DaemonKit.logger.info "Starting jabber loop"
+        
+        loop do
+          process_messages
+          process_updates
+          process_subscriptions
+
+          begin
+            sleep 1
+          rescue Interrupt
+            DaemonKit.logger.warn "Jabber loop interrupted"
+            break
+          end
+        end
+      end
+      
+      def process_messages
+        @message_handler ||= Proc.new { |m| DaemonKit.logger.info "Received message from #{m.from}: #{m.body}" }
+
+        instance.valid_messages { |m| @message_handler.call(m) }
+      end
+
+      def process_updates
+        @presence_handler ||= Proc.new { |friend, old_presence, new_presence|
+          DaemonKit.logger.debug "Received presence update: #{friend} went from #{old_presence} to #{new_presence}"
+        }
+
+        instance.connection.presence_updates { |friend, old_presence, new_presence|
+          @presence_handler.call(friend, old_presence, new_presence)
+        }
+        
+      end
+
+      def process_subscriptions
+        @subscription_handler ||= Proc.new { |friend,presence| DaemonKit.logger.debug "Received presence update from #{friend}: #{presence}" }
+
+        instance.connection.subscription_requests { |friend,presence| @subscription_handler.call(friend,presence) }
+      end
+        
+      def received_messages(&block)
+        @message_handler = block
+      end
+      
+      def presence_updates(&block)
+        @presence_handler = block
+      end
+
+      def subscription_requests(&block)
+        @subscription_handler = block
+      end
+      
+    end
+
+    def initialize( options = {} )
+      @jabber_id  = options.delete("jabber_id")
+      @password   = options.delete("password")
+      @resource   = options.delete("resource") || 'daemon_kit'
+      @masters    = options.delete("masters") || []
+      @supporters = options.delete("supporters") || []
+
+      raise ArgumentError if [ @jabber_id, @password ].any? { |a| a.nil? }
+    end
+
+    def startup!
+      return self if @booted
+
+      connect!
+      setup_roster!
+
+      DaemonKit.trap( 'INT', Proc.new { self.shutdown! } )
+      DaemonKit.trap( 'TERM', Proc.new { self.shutdown! } )
+      
+      @booted = true
+
+      self
+    end
+
+    def shutdown!
+      DaemonKit.logger.warn "Disconnecting jabber connection"
+      self.connection.disconnect
+    end
+
+    def contacts
+      @masters + @supporters
+    end
+
+    def valid_messages(&block)
+      self.connection.received_messages.each do |message|
+        next unless valid_master?( message.from )
+
+        busy do
+          block.call message
+        end
+      end
+    end
+
+    def valid_master?( jid )
+      @masters.include?( jid.strip.to_s )
+    end
+
+    def busy(&block)
+      self.connection.status(:dnd, "Working...")
+      yield
+      self.connection.status(:chat, self.status_line )
+    end
+
+    def status_line
+      "#{DaemonKit.configuration.daemon_name} ready for instructions"
+    end
+    
+    private
+    
+    def connect!
+      jid = @jabber_id + '/' + @resource
+
+      @connection = ::Jabber::Simple.new( jid, @password, nil, self.status_line )
+    end
+
+    def setup_roster!
+      # cleanup the roster
+      self.connection.roster.items.each_pair do |jid, roster_item|
+        jid = jid.strip.to_s
+        unless self.contacts.include?( jid )
+          self.connection.remove( jid )
+        end
+      end
+
+      # add missing contacts
+      self.contacts.each do |jid|
+        unless self.connection.subscribed_to?( jid )
+          self.connection.add( jid )
+          #self.connection.accept_subscription( jid )
+        end
+      end
+    end
+    
+  end
+end