cloud66-bluepill 0.0.62

data/lib/bluepill/process_conditions.rb

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

data/lib/bluepill/process_conditions/always_true.rb

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+module Bluepill
+  module ProcessConditions
+    class AlwaysTrue < ProcessCondition
+      def initialize(options = {})
+        @below = options[:below]
+      end
+
+      def run(pid, include_children)
+        1
+      end
+
+      def check(value)
+        true
+      end
+    end
+  end
+end

data/lib/bluepill/process_conditions/cpu_usage.rb

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+module Bluepill
+  module ProcessConditions
+    class CpuUsage < ProcessCondition
+      def initialize(options = {})
+        @below = options[:below]
+      end
+
+      def run(pid, include_children)
+        # third col in the ps axu output
+        System.cpu_usage(pid, include_children).to_f
+      end
+
+      def check(value)
+        value < @below
+      end
+    end
+  end
+end

data/lib/bluepill/process_conditions/file_time.rb

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+module Bluepill
+  module ProcessConditions
+    class FileTime < ProcessCondition
+      def initialize(options = {})
+        @below = options[:below]
+        @filename = options[:filename]
+      end
+
+      def run(pid, include_children)
+        if File.exists?(@filename)
+          Time.now()-File::mtime(@filename)
+        else
+          nil
+        end
+      rescue
+        $!
+      end
+
+      def check(value)
+        return false if value.nil?
+        return value < @below
+      end
+    end
+  end
+end

data/lib/bluepill/process_conditions/http.rb

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+require 'net/http'
+require 'uri'
+
+module Bluepill
+  module ProcessConditions
+    class Http < ProcessCondition
+      def initialize(options = {})
+        @uri = URI.parse(options[:url])
+        @kind = case options[:kind]
+                  when Fixnum then Net::HTTPResponse::CODE_TO_OBJ[options[:kind].to_s]
+                  when String, Symbol then Net.const_get("HTTP#{options[:kind].to_s.camelize}")
+                else
+                  Net::HTTPSuccess
+                end
+        @pattern = options[:pattern] || nil
+        @open_timeout = (options[:open_timeout] || options[:timeout] || 5).to_i
+        @read_timeout = (options[:read_timeout] || options[:timeout] || 5).to_i
+      end
+
+      def run(pid, include_children)
+        session = Net::HTTP.new(@uri.host, @uri.port)
+        if @uri.scheme == 'https'
+          require 'net/https'
+          session.use_ssl=true
+          session.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        session.open_timeout = @open_timeout
+        session.read_timeout = @read_timeout
+        hide_net_http_bug do
+          session.start do |http|
+            http.get(@uri.request_uri)
+          end
+        end
+      rescue
+        $!
+      end
+
+      def check(value)
+        return false unless value.kind_of?(@kind)
+        return true  unless @pattern
+        return false unless value.class.body_permitted?
+        @pattern === value.body
+      end
+
+    private
+      def hide_net_http_bug
+        yield
+      rescue NoMethodError => e
+        if e.to_s =~ /#{Regexp.escape(%q|undefined method `closed?' for nil:NilClass|)}/
+          raise Errno::ECONNREFUSED, "Connection refused attempting to contact #{@uri.scheme}://#{@uri.host}:#{@uri.port}"
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/bluepill/process_conditions/mem_usage.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+module Bluepill
+  module ProcessConditions
+    class MemUsage < ProcessCondition
+      MB = 1024 ** 2
+      FORMAT_STR = "%d%s"
+      MB_LABEL = "MB"
+      KB_LABEL = "KB"
+
+      def initialize(options = {})
+        @below = options[:below]
+      end
+
+      def run(pid, include_children)
+        # rss is on the 5th col
+        System.memory_usage(pid, include_children).to_f
+      end
+
+      def check(value)
+        value.kilobytes < @below
+      end
+
+      def format_value(value)
+        if value.kilobytes >= MB
+          FORMAT_STR % [(value / 1024).round, MB_LABEL]
+        else
+          FORMAT_STR % [value, KB_LABEL]
+        end
+      end
+    end
+  end
+end

data/lib/bluepill/process_conditions/process_condition.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+module Bluepill
+  module ProcessConditions
+    class ProcessCondition
+      def initialize(options = {})
+        @options = options
+      end
+
+      def run(pid, include_children)
+        raise "Implement in subclass!"
+      end
+
+      def check(value)
+        raise "Implement in subclass!"
+      end
+
+      def format_value(value)
+        value
+      end
+    end
+  end
+end

data/lib/bluepill/process_journal.rb

@@ -0,0 +1,219 @@
+require 'bluepill/system'
+
+module Bluepill
+  module ProcessJournal
+    extend self
+
+    class << self
+      attr_reader :logger
+      attr_reader :journal_base_dir
+
+      def logger=(new_logger)
+        @logger ||= new_logger
+      end
+
+      def base_dir=(base_dir)
+        @journal_base_dir ||= File.join(base_dir, "journals")
+        FileUtils.mkdir_p(@journal_base_dir) unless File.exists?(@journal_base_dir)
+        FileUtils.chmod(0777, @journal_base_dir)
+      end
+    end
+
+    def skip_pid?(pid)
+      !pid.is_a?(Integer) || pid <= 1
+    end
+
+    def skip_pgid?(pgid)
+      !pgid.is_a?(Integer) || pgid <= 1
+    end
+
+    # atomic operation on POSIX filesystems, since
+    # f.flock(File::LOCK_SH) is not available on all platforms
+    def acquire_atomic_fs_lock(name)
+      times = 0
+      name += '.lock'
+      Dir.mkdir name, 0700
+      logger.debug("Acquired lock #{name}")
+      yield
+    rescue Errno::EEXIST
+      times += 1
+      logger.debug("Waiting for lock #{name}")
+      sleep 1
+      unless times >= 10
+        retry
+      else
+        logger.info("Timeout waiting for lock #{name}")
+        raise "Timeout waiting for lock #{name}"
+      end
+    ensure
+      clear_atomic_fs_lock(name)
+    end
+
+    def clear_all_atomic_fs_locks(application_name = nil)
+	  if application_name.nil?
+		files = Dir['.*.lock']
+	  else
+	    files = Dir[".*.#{application_name}.lock"]
+	  end
+      files.each do |f|
+        System.delete_if_exists(f) if File.directory?(f)
+      end
+    end
+
+    def pid_journal_filename(journal_name)
+      File.join(@journal_base_dir, ".bluepill_pids_journal.#{journal_name}")
+    end
+
+    def pgid_journal_filename(journal_name)
+      File.join(@journal_base_dir, ".bluepill_pgids_journal.#{journal_name}")
+    end
+
+    def pid_journal(filename)
+      logger.debug("pid journal file: #{filename}")
+      result = File.open(filename, 'r').readlines.map(&:to_i).reject {|pid| skip_pid?(pid)}
+      logger.debug("pid journal = #{result.join(' ')}")
+      result
+    rescue Errno::ENOENT
+      []
+    end
+
+    def pgid_journal(filename)
+      logger.debug("pgid journal file: #{filename}")
+      result = File.open(filename, 'r').readlines.map(&:to_i).reject {|pgid| skip_pgid?(pgid)}
+      logger.debug("pgid journal = #{result.join(' ')}")
+      result
+    rescue Errno::ENOENT
+      []
+    end
+
+    def clear_atomic_fs_lock(name)
+      if File.directory?(name)
+        Dir.rmdir(name)
+        logger.debug("Cleared lock #{name}")
+      end
+    end
+
+    def kill_all_from_all_journals
+      Dir[".bluepill_pids_journal.*"].map { |x|
+        x.sub(/^\.bluepill_pids_journal\./,"")
+      }.reject { |y|
+        y =~ /\.lock$/
+      }.each do |journal_name|
+        kill_all_from_journal(journal_name)
+      end
+    end
+
+    def kill_all_from_journal(journal_name)
+      kill_all_pids_from_journal(journal_name)
+      kill_all_pgids_from_journal(journal_name)
+    end
+
+    def kill_all_pgids_from_journal(journal_name)
+      filename = pgid_journal_filename(journal_name)
+      j = pgid_journal(filename)
+      if j.length > 0
+        acquire_atomic_fs_lock(filename) do
+          j.each do |pgid|
+            begin
+              ::Process.kill('TERM', -pgid)
+              logger.info("Termed old process group #{pgid}")
+            rescue Errno::ESRCH
+              logger.debug("Unable to term missing process group #{pgid}")
+            end
+          end
+
+          if j.select { |pgid| System.pid_alive?(pgid) }.length > 1
+            sleep(1)
+            j.each do |pgid|
+              begin
+                ::Process.kill('KILL', -pgid)
+                logger.info("Killed old process group #{pgid}")
+              rescue Errno::ESRCH
+                logger.debug("Unable to kill missing process group #{pgid}")
+              end
+            end
+          end
+          System.delete_if_exists(filename) # reset journal
+          logger.debug('Journal cleanup completed')
+        end
+      else
+        logger.debug('No previous process journal - Skipping cleanup')
+      end
+    end
+
+    def kill_all_pids_from_journal(journal_name)
+      filename = pid_journal_filename(journal_name)
+      j = pid_journal(filename)
+      if j.length > 0
+        acquire_atomic_fs_lock(filename) do
+          j.each do |pid|
+            begin
+              ::Process.kill('TERM', pid)
+              logger.info("Termed old process #{pid}")
+            rescue Errno::ESRCH
+              logger.debug("Unable to term missing process #{pid}")
+            end
+          end
+
+          if j.select { |pid| System.pid_alive?(pid) }.length > 1
+            sleep(1)
+            j.each do |pid|
+              begin
+                ::Process.kill('KILL', pid)
+                logger.info("Killed old process #{pid}")
+              rescue Errno::ESRCH
+                logger.debug("Unable to kill missing process #{pid}")
+              end
+            end
+          end
+          System.delete_if_exists(filename) # reset journal
+          logger.debug('Journal cleanup completed')
+        end
+      else
+        logger.debug('No previous process journal - Skipping cleanup')
+      end
+    end
+
+    def append_pgid_to_journal(journal_name, pgid)
+      if skip_pgid?(pgid)
+        logger.debug("Skipping invalid pgid #{pgid} (class #{pgid.class})")
+        return
+      end
+
+      filename = pgid_journal_filename(journal_name)
+      acquire_atomic_fs_lock(filename) do
+        unless pgid_journal(filename).include?(pgid)
+          logger.debug("Saving pgid #{pgid} to process journal #{journal_name}")
+          File.open(filename, 'a+', 0600) { |f| f.puts(pgid) }
+          logger.info("Saved pgid #{pgid} to journal #{journal_name}")
+          logger.debug("Journal now = #{File.open(filename, 'r').read}")
+        else
+          logger.debug("Skipping duplicate pgid #{pgid} already in journal #{journal_name}")
+        end
+      end
+    end
+
+    def append_pid_to_journal(journal_name, pid)
+      begin
+        append_pgid_to_journal(journal_name, ::Process.getpgid(pid))
+      rescue Errno::ESRCH
+      end
+      if skip_pid?(pid)
+        logger.debug("Skipping invalid pid #{pid} (class #{pid.class})")
+        return
+      end
+
+      filename = pid_journal_filename(journal_name)
+      acquire_atomic_fs_lock(filename) do
+        unless pid_journal(filename).include?(pid)
+          logger.debug("Saving pid #{pid} to process journal #{journal_name}")
+          File.open(filename, 'a+', 0600) { |f| f.puts(pid) }
+          logger.info("Saved pid #{pid} to journal #{journal_name}")
+          logger.debug("Journal now = #{File.open(filename, 'r').read}")
+        else
+          logger.debug("Skipping duplicate pid #{pid} already in journal #{journal_name}")
+        end
+      end
+    end
+  end
+end

data/lib/bluepill/process_statistics.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+module Bluepill
+  class ProcessStatistics
+    STRFTIME = "%m/%d/%Y %H:%I:%S".freeze
+    EVENTS_TO_PERSIST = 10
+
+    attr_reader :events
+
+    # possibly persist this data.
+    def initialize
+      @events = Util::RotationalArray.new(EVENTS_TO_PERSIST)
+    end
+
+    def record_event(event, reason)
+      events.push([event, reason, Time.now])
+    end
+
+    def to_s
+      str = events.reverse.map do |(event, reason, time)|
+        "  #{event} at #{time.strftime(STRFTIME)} - #{reason || "unspecified"}"
+      end.join("\n")
+
+      "event history:\n#{str}"
+    end
+  end
+end
+