evented_bluepill 0.0.47 → 0.0.50

data/lib/{bluepill → evented_bluepill}/controller.rb

@@ -1,27 +1,36 @@
 # -*- encoding: utf-8 -*-
-
 require 'fileutils'
+require 'rbconfig'
+
+require 'evented_bluepill/options'
 
-module Bluepill
+module EventedBluepill
   class Controller
-    attr_accessor :base_dir, :log_file, :sockets_dir, :pids_dir
+    attr_accessor :base_dir, :log_file
 
-    def initialize(options = {})
-      self.log_file = options[:log_file]
-      self.base_dir = options[:base_dir]
-      self.sockets_dir = File.join(base_dir, 'socks')
-      self.pids_dir = File.join(base_dir, 'pids')
+    def initialize()
+      self.log_file = EventedBluepill::Options[:log_file]
+      self.base_dir = EventedBluepill::Options[:base_dir]
 
       setup_dir_structure
       cleanup_bluepill_directory
     end
 
-    def running_applications
-      Dir[File.join(sockets_dir, "*.sock")].map{|x| File.basename(x, ".sock")}
-    end
-
     def handle_command(application, command, *args)
       case command.to_sym
+      when :load
+        file = args.first
+        if File.exists?(file)
+          # Restart the ruby interpreter for the config file so that anything loaded here
+          # does not stay in memory for the daemon
+          ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+          load_path = File.expand_path("#{File.dirname(__FILE__)}/../")
+          file_path = File.expand_path(file)
+
+          exec(ruby, "-I#{load_path}", '-revented_bluepill', file_path)
+        else
+          $stderr.puts "Can't find file: #{file}"
+        end
       when :status
         puts self.send_to_daemon(application, :status, *args)
       when *Application::PROCESS_COMMANDS
@@ -39,9 +48,9 @@ module Bluepill
         pid = pid_for(application)
         if System.pid_alive?(pid)
           ::Process.kill("TERM", pid)
-          puts "Killing bluepilld[#{pid}]"
+          puts "Killing evented_bluepilld[#{pid}]"
         else
-          puts "bluepilld[#{pid}] not running"
+          puts "evented_bluepilld[#{pid}] not running"
         end
       when :log
         log_file_location = self.send_to_daemon(application, :log_file)
@@ -83,14 +92,15 @@ module Bluepill
       pattern = [application, query].compact.join(':')
       ['\[.*', Regexp.escape(pattern), '.*'].compact.join
     end
+
     private
 
     def cleanup_bluepill_directory
-      self.running_applications.each do |app|
+      EventedBluepill::Options.running_applications.each do |app|
         pid = pid_for(app)
         if !pid || !System.pid_alive?(pid)
-          pid_file = File.join(self.pids_dir, "#{app}.pid")
-          sock_file = File.join(self.sockets_dir, "#{app}.sock")
+          pid_file = File.join(EventedBluepill::Options.pids_dir, "#{app}.pid")
+          sock_file = File.join(EventedBluepill::Options.sockets_dir, "#{app}.sock")
           File.unlink(pid_file) if File.exists?(pid_file)
           File.unlink(sock_file) if File.exists?(sock_file)
         end
@@ -103,7 +113,7 @@ module Bluepill
     end
 
     def setup_dir_structure
-      [@sockets_dir, @pids_dir].each do |dir|
+      [EventedBluepill::Options.sockets_dir, EventedBluepill::Options.pids_dir].each do |dir|
         FileUtils.mkdir_p(dir) unless File.exists?(dir)
       end
     end
@@ -111,8 +121,8 @@ module Bluepill
     def verify_version!(application)
       begin
         version = Socket.client_command(base_dir, application, "version")
-        if version != Bluepill::VERSION
-          abort("The running version of your daemon seems to be out of date.\nDaemon Version: #{version}, CLI Version: #{Bluepill::VERSION}")
+        if version != EventedBluepill::VERSION::STRING
+          abort("The running version of your daemon seems to be out of date.\nDaemon Version: #{version}, CLI Version: #{EventedBluepill::VERSION::STRING}")
         end
       rescue ArgumentError
         abort("The running version of your daemon seems to be out of date.")

data/lib/{bluepill → evented_bluepill}/dsl/app_proxy.rb

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
 
-require 'bluepill/application'
-require 'bluepill/dsl/process_factory'
+require 'evented_bluepill/application'
+require 'evented_bluepill/dsl/process_factory'
 
-module Bluepill
+module EventedBluepill
   class AppProxy
     APP_ATTRIBUTES = [:working_dir, :uid, :gid, :environment]
 

data/lib/{bluepill → evented_bluepill}/dsl/process_factory.rb

@@ -1,8 +1,8 @@
 # -*- encoding: utf-8 -*-
 
-require 'bluepill/dsl/process_proxy'
+require 'evented_bluepill/dsl/process_proxy'
 
-module Bluepill
+module EventedBluepill
   class ProcessFactory
     attr_reader :attributes
 
@@ -17,7 +17,7 @@ module Bluepill
     def create_process(name, pids_dir)
       self.assign_default_pid_file(name, pids_dir)
       
-      process = Bluepill::ProcessProxy.new(name, @attributes, @process_block)
+      process = EventedBluepill::ProcessProxy.new(name, @attributes, @process_block)
       child_process_block = @attributes.delete(:child_process_block)
       @attributes[:child_process_factory] = ProcessFactory.new(@attributes, child_process_block) if @attributes[:monitor_children]
       
@@ -31,9 +31,12 @@ module Bluepill
       attributes[:actual_pid] = pid
       attributes[:logger] = logger
 
-      child = Bluepill::ProcessProxy.new(name, attributes, @process_block)
+      child = EventedBluepill::ProcessProxy.new(name, attributes, @process_block)
       self.validate_child_process! child
-      child.to_process
+      process = child.to_process
+      
+      process.determine_initial_state
+      process
     end
 
     protected

data/lib/{bluepill → evented_bluepill}/dsl/process_proxy.rb

@@ -1,8 +1,8 @@
 # -*- encoding: utf-8 -*-
 
-require 'bluepill/process'
+require 'evented_bluepill/process'
 
-module Bluepill
+module EventedBluepill
   class ProcessProxy
     attr_reader :attributes, :watches, :name
     def initialize(process_name, attributes, process_block)
@@ -33,7 +33,7 @@ module Bluepill
     end
 
     def to_process
-      Bluepill::Process.new(@name, @watches, @attributes)
+      EventedBluepill::Process.new(@name, @watches, @attributes)
     end
   end
 end

data/lib/{bluepill → evented_bluepill}/dsl.rb

@@ -1,8 +1,11 @@
 # -*- encoding: utf-8 -*-
 
-require 'bluepill/dsl/app_proxy'
+require 'active_support/core_ext/numeric'
+require 'active_support/core_ext/hash'
 
-module Bluepill
+require 'evented_bluepill/dsl/app_proxy'
+
+module EventedBluepill
   def self.application(app_name, options = {}, &block)
     app_proxy = AppProxy.new(app_name, options)
     yield(app_proxy)

data/lib/{bluepill → evented_bluepill}/event.rb

@@ -2,7 +2,7 @@
 
 require 'coolio'
 
-module Bluepill
+module EventedBluepill
   module Event
     extend self
 

data/lib/{bluepill → evented_bluepill}/group.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 
-module Bluepill
+module EventedBluepill
   class GroupTimer < Coolio::TimerWatcher
     def initialize(process, event)
       @process = process
@@ -43,7 +43,7 @@ module Bluepill
           self.processes.each do |process|
             next if process_name && process_name != process.name
             affected << [self.name, process.name].join(":")
-            Bluepill::Event.attach(Bluepill::GroupTimer.new(process, "#{event}"))
+            EventedBluepill::Event.attach(EventedBluepill::GroupTimer.new(process, "#{event}"))
           end
           affected
         end

data/lib/{bluepill → evented_bluepill}/logger.rb

@@ -1,6 +1,9 @@
 # -*- encoding: utf-8 -*-
 
-module Bluepill
+require 'syslog'
+require 'logger'
+
+module EventedBluepill
   class Logger
     LOG_METHODS = [:emerg, :alert, :crit, :err, :warning, :notice, :info, :debug]
 
@@ -47,7 +50,7 @@ module Bluepill
         LoggerAdapter.new(@options[:log_file])
       else
         Syslog.close if Syslog.opened? # need to explictly close it before reopening it
-        Syslog.open(@options[:identity] || 'bluepilld', Syslog::LOG_PID, Syslog::LOG_LOCAL6)
+        Syslog.open(@options[:identity] || 'evented_bluepilld', Syslog::LOG_PID, Syslog::LOG_LOCAL6)
       end
     end
 

data/lib/evented_bluepill/options.rb

@@ -0,0 +1,121 @@
+# -*- encoding: utf-8 -*-
+require 'optparse'
+
+require 'evented_bluepill/version'
+
+module EventedBluepill
+  module Options
+    extend self
+
+    APPLICATION_COMMANDS = %w(status start stop restart unmonitor quit log)
+
+    # Default options
+    @options = {
+      :log_file   => "/var/log/evented_bluepill.log",
+      :base_dir   => "/var/evented_bluepill",
+      :privileged => true
+    }
+
+    def parse!
+      parse_options!
+      parse_application!
+
+      # Check for root
+      unless privileged?
+        $stderr.puts "You must run evented_bluepill as root or use --no-privileged option."
+        exit(3)
+      end
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+    def running_applications
+      Dir[File.join(EventedBluepill::Options.sockets_dir, "*.sock")].map {|x| File.basename(x, ".sock")}
+    end
+
+    def sockets_dir
+      File.join(@options[:base_dir], 'socks')
+    end
+
+    def pids_dir
+      File.join(@options[:base_dir], 'pids')
+    end
+
+    def privileged?
+      !@options[:privileged] || ::Process.euid == 0
+    end
+
+    private
+
+    def parse_options!
+      OptionParser.new do |opts|
+        opts.banner = "Usage: evented_bluepill [app] cmd [options]"
+        opts.on('-l', "--logfile LOGFILE", "Path to logfile, defaults to #{@options[:log_file]}") do |file|
+          @options[:log_file] = file
+        end
+
+        opts.on('-c', "--base-dir DIR", "Directory to store evented_bluepill socket and pid files, defaults to #{@options[:base_dir]}") do |base_dir|
+          @options[:base_dir] = base_dir
+        end
+
+        opts.on("-v", "--version") do
+          puts "evented_bluepill, version #{EventedBluepill::VERSION::STRING}"
+          exit
+        end
+
+        opts.on("--[no-]privileged", "Allow/disallow to run #{$0} as non-privileged process. disallowed by default") do |v|
+          @options[:privileged] = v
+        end
+
+        help = proc do
+          puts opts
+          puts
+          puts "Commands:"
+          puts "    load CONFIG_FILE\t\tLoads new instance of evented_bluepill using the specified config file"
+          puts "    status\t\t\tLists the status of the proceses for the specified app"
+          puts "    start [TARGET]\t\tIssues the start command for the target process or group, defaults to all processes"
+          puts "    stop [TARGET]\t\tIssues the stop command for the target process or group, defaults to all processes"
+          puts "    restart [TARGET]\t\tIssues the restart command for the target process or group, defaults to all processes"
+          puts "    unmonitor [TARGET]\t\tStop monitoring target process or group, defaults to all processes"
+          puts "    log [TARGET]\t\tShow the log for the specified process or group, defaults to all for app"
+          puts "    quit\t\t\tStop evented_bluepill"
+          puts
+          puts "See http://github.com/msnexploder/evented_bluepill for README"
+          exit
+        end
+
+        opts.on_tail('-h','--help', 'Show this message', &help)
+        help.call if ARGV.empty?
+      end.parse!
+    end
+
+    def parse_application!
+      if running_applications.include?(File.basename($0)) && File.symlink?($0)
+        # evented_bluepill was called as a symlink with the name of the target application
+        options[:application] = File.basename($0)
+      elsif running_applications.include?(ARGV.first)
+        # the first arg is the application name
+        options[:application] = ARGV.shift
+      elsif APPLICATION_COMMANDS.include?(ARGV.first)
+        if running_applications.length == 1
+          # there is only one, let's just use that
+          options[:application] = running_applications.first
+        elsif running_applications.length > 1
+          # There is more than one, tell them the list and exit
+          $stderr.puts "You must specify an application name to run that command. Here's the list of running applications:"
+          running_applications.each_with_index do |app, index|
+            $stderr.puts "  #{index + 1}. #{app}"
+          end
+          $stderr.puts "Usage: evented_bluepill [app] cmd [options]"
+          exit(1)
+        else
+          # There are none running AND they aren't trying to start one
+          $stderr.puts "Error: There are no running evented_bluepill daemons.\nTo start a evented_bluepill daemon, use: evented_bluepill load <config file>"
+          exit(2)
+        end
+      end
+    end
+  end
+end

data/lib/{bluepill → evented_bluepill}/process.rb

@@ -1,9 +1,13 @@
 # -*- encoding: utf-8 -*-
 
+require 'timeout'
+
 require 'state_machine'
 require 'daemons'
 
-module Bluepill
+require 'evented_bluepill/process_conditions'
+
+module EventedBluepill
   class ProcessTimer < Coolio::TimerWatcher
     attr_accessor :process
 
@@ -111,7 +115,6 @@ module Bluepill
 
     def initialize(process_name, checks, options = {})
       @name = process_name
-      @transition_history = Util::RotationalArray.new(10)
       @watches = []
       @triggers = []
       @children_timer = []
@@ -120,7 +123,7 @@ module Bluepill
       self.logger = options[:logger]
 
       checks.each do |name, opts|
-        if Bluepill::Trigger[name]
+        if EventedBluepill::Trigger[name]
           self.add_trigger(name, opts)
         else
           self.add_watch(name, opts)
@@ -174,7 +177,7 @@ module Bluepill
 
     # Watch related methods
     def add_watch(name, options = {})
-      self.watches << ConditionWatch.new(name, self, options.merge(:logger => self.logger))
+      self.watches << ProcessConditions[name].new(name, self, options.merge(:logger => self.logger))
     end
 
     def add_trigger(name, options = {})
@@ -185,7 +188,7 @@ module Bluepill
       if self.process_running?(true)
         self.state = 'up'
       else
-        # TODO: or "unmonitored" if bluepill was started in no auto-start mode.
+        # TODO: or "unmonitored" if evented_bluepill was started in no auto-start mode.
         self.state = 'down'
       end
 
@@ -194,10 +197,10 @@ module Bluepill
     end
 
     def set_timer
-      @timer = Bluepill::ProcessTimer.new(self)
-      Bluepill::Event.attach(self.timer)
+      @timer = EventedBluepill::ProcessTimer.new(self)
+      EventedBluepill::Event.attach(self.timer)
 
-      self.watches.each {|w| Bluepill::Event.attach(w) }
+      self.watches.each {|w| EventedBluepill::Event.attach(w) }
     end
 
     def handle_user_command(cmd)
@@ -370,13 +373,6 @@ module Bluepill
         logger = self.logger.prefix_with(name)
 
         child = self.child_process_factory.create_child_process(name, child_pid, logger)
-
-        child.initialize_state_machines
-        child.state = "up"
-
-        child.set_timer
-        child.watches.each {|w| w.process = child }
-
         @children_timer << child.timer
       end
     end
@@ -404,7 +400,7 @@ module Bluepill
 
     rescue Timeout::Error
       logger.err "Execution is taking longer than expected. Unmonitoring."
-      logger.err "Did you forget to tell bluepill to daemonize this process?"
+      logger.err "Did you forget to tell evented_bluepill to daemonize this process?"
       self.dispatch!("unmonitor")
     end
   end

data/lib/{bluepill → evented_bluepill}/process_conditions/always_true.rb

@@ -1,13 +1,17 @@
 # -*- encoding: utf-8 -*-
 
-module Bluepill
+require 'evented_bluepill/process_conditions/process_condition'
+
+module EventedBluepill
   module ProcessConditions
     class AlwaysTrue < ProcessCondition
-      def initialize(options = {})
+      def initialize(name, process, options = {})
         @below = options[:below]
+        
+        super
       end
 
-      def run(pid)
+      def run
         1
       end
 

data/lib/evented_bluepill/process_conditions/cpu_usage.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'evented_bluepill/process_conditions/process_condition'
+require 'evented_bluepill/system'
+
+module EventedBluepill
+  module ProcessConditions
+    class CpuUsage < ProcessCondition
+      def initialize(name, process, options = {})
+        @below = options[:below]
+
+        super
+      end
+
+      def run
+        # third col in the ps axu output
+        EventedBluepill::System.cpu_usage(process.actual_pid).to_f
+      end
+
+      def check(value)
+        value < @below
+      end
+    end
+  end
+end

data/lib/{bluepill → evented_bluepill}/process_conditions/http.rb

@@ -3,10 +3,13 @@
 require 'net/http'
 require 'uri'
 
-module Bluepill
+require 'evented_bluepill/process_conditions/process_condition'
+
+# really this needs reworking
+module EventedBluepill
   module ProcessConditions
     class Http < ProcessCondition
-      def initialize(options = {})
+      def initialize(name, process, options = {})
         @uri = URI.parse(options[:url])
         @kind = case options[:kind]
                   when Fixnum then Net::HTTPResponse::CODE_TO_OBJ[options[:kind].to_s]
@@ -17,9 +20,11 @@ module Bluepill
         @pattern = options[:pattern] || nil
         @open_timeout = (options[:open_timeout] || options[:timeout] || 5).to_i
         @read_timeout = (options[:read_timeout] || options[:timeout] || 5).to_i
+        
+        super
       end
 
-      def run(pid)
+      def run
         session = Net::HTTP.new(@uri.host, @uri.port)
         session.open_timeout = @open_timeout
         session.read_timeout = @read_timeout

data/lib/evented_bluepill/process_conditions/mem_usage.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+require 'active_support/core_ext/numeric/bytes'
+
+require 'evented_bluepill/process_conditions/process_condition'
+require 'evented_bluepill/system'
+
+module EventedBluepill
+  module ProcessConditions
+    class MemUsage < ProcessCondition
+      KB = 1024.0
+      MB = KB ** 2
+      FORMAT_STR = "%.1f%s"
+      MB_LABEL = "MB"
+      KB_LABEL = "KB"
+
+      def initialize(name, process, options = {})
+        @below = options[:below]
+
+        super
+      end
+
+      def run
+        # rss is on the 5th col
+        EventedBluepill::System.memory_usage(process.actual_pid).to_f.kilobytes
+      end
+
+      def check(value)
+        value < @below
+      end
+
+      def format_value(value)
+        if value >= MB
+          FORMAT_STR % [(value / MB), MB_LABEL]
+        else
+          FORMAT_STR % [(value / KB), KB_LABEL]
+        end
+      end
+    end
+  end
+end

data/lib/evented_bluepill/process_conditions/process_condition.rb

@@ -0,0 +1,72 @@
+# -*- encoding: utf-8 -*-
+
+require 'coolio'
+
+require 'evented_bluepill/util/rotational_array'
+
+module EventedBluepill
+  module ProcessConditions
+    class HistoryValue < Struct.new(:value, :critical)
+    end
+
+    class ProcessCondition < Coolio::TimerWatcher
+      attr_accessor :logger
+      attr_reader :every, :process_condition, :fires, :process, :name
+
+      def initialize(name, process, options = {})
+        @name = name
+
+        @logger = options.delete(:logger)
+        @fires = options.delete(:fires) || :restart
+        @every = options.delete(:every)
+        @times = options.delete(:times) || [1,1]
+        @times = [@times, @times] unless @times.is_a?(Array) # handles :times => 5
+        @process = process
+
+        self.clear_history!
+
+        super(@every, true)
+      end
+
+      def run
+        raise "Implement in subclass!"
+      end
+
+      def check(value)
+        raise "Implement in subclass!"
+      end
+
+      def format_value(value)
+        value
+      end
+
+      def clear_history!
+        @history = EventedBluepill::Util::RotationalArray.new(@times.last)
+      end
+
+      def to_s
+        data = @history.collect {|v| "#{v.value}#{'*' unless v.critical}"}.join(", ")
+        "#{@name}: [#{data}]"
+      end
+
+      protected
+
+      def fired?
+        @history.count {|v| not v.critical} >= @times.first
+      end
+
+      private
+
+      def on_timer
+        value = self.run
+        @history << HistoryValue.new(self.format_value(value), self.check(value))
+        self.logger.info(self.to_s)
+
+        if self.fired?
+          @process.dispatch!(self.fires, self.to_s)
+          logger.info "#{self.name} dispatched: #{self.fires}"
+        end
+      end
+    end
+  end
+end

data/lib/{bluepill → evented_bluepill}/process_conditions.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 
-module Bluepill
+module EventedBluepill
   module ProcessConditions
     def self.[](name)
       const_get(name.to_s.camelcase)
@@ -8,7 +8,7 @@ module Bluepill
   end
 end
 
-require "bluepill/process_conditions/process_condition"
+require 'evented_bluepill/process_conditions/process_condition'
 Dir["#{File.dirname(__FILE__)}/process_conditions/*.rb"].each do |pc|
   require pc
 end

data/lib/{bluepill → evented_bluepill}/process_statistics.rb

@@ -1,11 +1,14 @@
 # -*- encoding: utf-8 -*-
 
-module Bluepill
+require 'evented_bluepill/util/rotational_array'
+
+module EventedBluepill
   class ProcessStatistics
     STRFTIME = "%m/%d/%Y %H:%I:%S"
+
     # possibly persist this data.
-    def initialize
-      @events = Util::RotationalArray.new(10)
+    def initialize(size = 10)
+      @events = EventedBluepill::Util::RotationalArray.new(size)
     end
 
     def record_event(event, reason)
@@ -13,14 +16,11 @@ module Bluepill
     end
 
     def to_s
-      str = []
-      @events.each do |(event, reason, time)|
+      str = @events.reverse.collect do |(event, reason, time)|
         str << "  #{event} at #{time.strftime(STRFTIME)} - #{reason || "unspecified"}"
-      end
-      if str.size > 0
-        str << "event history:"
-      end
-      str.reverse.join("\n")
+      end.join("\n")
+
+      "event history:\n#{str}"
     end
   end
 end