ripta-daemon-kit 0.1.0.2

data/lib/daemon_kit/application.rb

@@ -0,0 +1,32 @@
+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, :dir_mode => :normal, :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/initializer.rb

@@ -0,0 +1,249 @@
+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
+
+    # 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

data/lib/daemon_kit/patches/force_kill_wait.rb

@@ -0,0 +1,120 @@
+# Shamelessly taken from http://blog.rapleaf.com/dev/?p=19
+
+require 'rubygems'
+require 'daemons'
+require 'timeout'
+
+module Daemons
+
+  class ApplicationGroup
+
+    # We want to redefine find_applications to not rely on
+    # pidfiles (e.g. find application if pidfile is gone)
+    # We recreate the pid files if they're not there.
+    def find_applications(dir)
+      # Find pid_files, like original implementation
+      pid_files = PidFile.find_files(dir, app_name)
+      @monitor = Monitor.find(dir, app_name + '_monitor')
+      pid_files.reject! {|f| f =~ /_monitor.pid$/}
+      
+      # Find the missing pids based on the UNIX pids
+      pidfile_pids = pid_files.map {|pf| PidFile.existing(pf).pid}
+      missing_pids = unix_pids - pidfile_pids
+
+      # Create pidfiles that are gone
+      if missing_pids.size > 0
+        puts "[daemons_ext]: #{missing_pids.size} missing pidfiles: " + 
+             "#{missing_pids.inspect}... creating pid file(s)."
+        missing_pids.each do |pid|
+          pidfile = PidFile.new(dir, app_name, multiple)
+          pidfile.pid = pid # Doesn't seem to matter if it's a string or Fixnum
+        end
+      end
+
+      # Now get all the pid file again
+      pid_files = PidFile.find_files(dir, app_name)
+
+      return pid_files.map {|f|
+        app = Application.new(self, {}, PidFile.existing(f))
+        setup_app(app)
+        app
+      }
+    end
+
+    # Specify :force_kill_wait => (seconds to wait) and this method will
+    # block until the process is dead.  It first sends a TERM signal, then
+    # a KILL signal (-9) if the process hasn't died after the wait time.
+    def stop_all(force = false)
+      @monitor.stop if @monitor
+      
+      wait = options[:force_kill_wait].to_i
+      if wait > 0
+        puts "[daemons_ext]: Killing #{app_name} with force after #{wait} secs."
+
+        # Send term first, don't delete PID files.
+        @applications.each {|a| a.send_sig('TERM')}
+
+        begin
+          started_at = Time.now
+          Timeout::timeout(wait) do
+            num_pids = unix_pids.size
+            while num_pids > 0
+              time_left = wait - (Time.now - started_at)
+              puts "[daemons_ext]: Waiting #{time_left.round} secs on " +
+                   "#{num_pids} #{app_name}(s)..."
+              sleep 1
+              num_pids = unix_pids.size
+            end 
+          end
+        rescue Timeout::Error
+          @applications.each {|a| a.send_sig('KILL')}
+        ensure
+          # Delete Pidfiles
+          @applications.each {|a| a.zap!}
+        end
+
+        puts "[daemons_ext]: All #{app_name}(s) dead."
+      else
+        @applications.each {|a| 
+          if force
+            begin; a.stop; rescue ::Exception; end
+          else
+            a.stop
+          end
+        }
+      end
+    end
+    
+    private
+
+    # Find UNIX pids based on app_name.  CAUTION: This has only been tested on
+    # Mac OS X and CentOS.
+    def unix_pids
+      pids = []
+      x = `ps auxw | grep -v grep | awk '{print $2, $11}' | grep #{app_name}`
+      if x && x.chomp!
+        processes = x.split(/\n/).compact
+        processes = processes.delete_if do |p|
+          pid, name = p.split(/\s/)
+          # We want to make sure that the first part of the process name matches
+          # so that app_name matches app_name_22
+          app_name != name[0..(app_name.length - 1)]
+        end
+        pids = processes.map {|p| p.split(/\s/)[0].to_i}
+      end
+
+      pids
+    end
+
+  end
+
+  class Application
+
+    # Send signal to the process, rescue if process deson't exist
+    def send_sig(sig)
+      Process.kill(sig, @pid.pid) rescue Errno::ESRCH
+    end
+
+  end
+
+end

data/lib/daemon_kit/tasks/framework.rake

@@ -0,0 +1,75 @@
+namespace :daemon_kit do
+  namespace :freeze do
+    desc "Lock this application to the current gem (by unpacking it into vendor/daemon_kit)"
+    task :gems do
+      deps = %w()
+      require 'rubygems'
+      require 'rubygems/gem_runner'
+
+      kit = (version = ENV['VERSION']) ?
+        Gem.cache.find_name('daemon-kit', "= #{version}").first :
+        Gem.cache.find_name('daemon-kit').sort_by { |g| g.version }.last
+
+      version ||= kit.version
+
+      unless kit
+        puts "No daemon_kit gem #{version} is installed.  Do 'gem list daemon_kit' to see what you have available."
+        exit
+      end
+
+      puts "Freezing the gem for DaemonKit #{kit.version}"
+      rm_rf   "vendor/daemon_kit"
+      mkdir_p "vendor/daemon_kit"
+
+      begin
+        chdir("vendor/daemon_kit") do
+          kit.dependencies.select { |g| deps.include? g.name }.each do |g|
+            Gem::GemRunner.new.run(["unpack", g.name, "--version", g.version_requirements.to_s])
+            mv(Dir.glob("#{g.name}*").first, g.name)
+          end
+
+          Gem::GemRunner.new.run(["unpack", "daemon-kit", "--version", "=#{version}"])
+          FileUtils.mv(Dir.glob("daemon-kit*").first, "daemon-kit")
+        end
+      rescue Exception
+        rm_rf "vendor/daemon_kit"
+        raise
+      end
+    end
+
+    desc 'Lock to latest edge daemon_kit'
+    task :edge do
+      require 'open-uri'
+      #version = ENV["RELEASE"] || "edge"
+      commits = "http://github.com/api/v1/yaml/kennethkalmer/daemon-kit/commits/master"
+      url     = "http://github.com/kennethkalmer/daemon-kit/zipball/master"
+
+      rm_rf   "vendor/daemon_kit"
+      mkdir_p "vendor/daemon_kit"
+      
+      chdir 'vendor/daemon_kit' do
+        latest_revision = YAML.load(open(commits))["commits"].first["id"]
+        
+        puts "Downloading DaemonKit from #{url}"
+        File.open('daemon-kit.zip', 'wb') do |dst|
+          open url do |src|
+            while chunk = src.read(4096)
+              dst << chunk
+            end
+          end
+        end
+
+        puts 'Unpacking DaemonKit'
+        rm_rf 'daemon-kit'
+        `unzip daemon-kit.zip`
+        FileUtils.mv(Dir.glob("kennethkalmer-daemon-kit*").first, "daemon-kit")
+        %w(daemon-kit.zip).each do |goner|
+          rm_f goner
+        end
+
+        touch "REVISION_#{latest_revision}"
+      end
+    end
+    
+  end
+end

data/lib/daemon_kit/tasks.rb

@@ -0,0 +1,2 @@
+# Load all the take tasks in the gem
+Dir[File.join(File.dirname(__FILE__), '**/*.rake')].each { |rake| load rake }

data/lib/daemon_kit.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+
+require 'daemon_kit/initializer'
+require 'daemon_kit/application'
+
+module DaemonKit
+  VERSION = '0.1.0.2'
+end

data/rubygems_generators/install_rspec/USAGE

@@ -0,0 +1,5 @@
+Description:
+  
+  
+Usage:
+