kostya-bluepill 0.0.60.1

data/bluepill.gemspec

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+
+require "bluepill/version"
+
+Gem::Specification.new do |s|
+  s.name        = "kostya-bluepill"
+  s.version     = Bluepill::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Arya Asemanfar", "Gary Tsang", "Rohith Ravi"]
+  s.email       = ["entombedvirus@gmail.com"]
+  s.homepage    = "http://github.com/kostya/bluepill"
+  s.summary     = %q{A process monitor written in Ruby with stability and minimalism in mind.}
+  s.description = %q{Bluepill keeps your daemons up while taking up as little resources as possible. After all you probably want the resources of your server to be used by whatever daemons you are running rather than the thing that's supposed to make sure they are brought back up, should they die or misbehave.}
+
+  s.add_dependency 'daemons', ['~> 1.1.4', '<= 1.1.6']
+  s.add_dependency 'state_machine', '~> 1.1.0'
+  s.add_dependency 'activesupport', '>= 3.0.0'
+  s.add_dependency 'i18n', '>= 0.5.0'
+  s.add_dependency 'madvertise-logging'
+
+  s.add_development_dependency 'bundler', '>= 1.0.10'
+  s.add_development_dependency 'rake', '!= 0.9.0'
+  s.add_development_dependency 'rspec-core', '~> 2.0'
+  s.add_development_dependency 'rspec-expectations', '~> 2.0'
+  s.add_development_dependency 'rr', '~> 1.0'
+  s.add_development_dependency 'faker', '~> 0.9'
+  s.add_development_dependency 'yard', '~> 0.7'
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths    = ["lib"]
+  s.extra_rdoc_files = ["LICENSE", "README.md"]
+end
+

data/examples/example.rb

@@ -0,0 +1,87 @@
+require 'rubygems'
+require 'bluepill'
+require 'logger'
+
+ROOT_DIR = "/tmp/bp"
+
+# Watch with
+# watch -n0.2 'ps axu | egrep "(CPU|forking|bluepill|sleep)" | grep -v grep | sort'
+Bluepill.application(:sample_app) do |app|
+  0.times do |i|
+    app.process("process_#{i}") do |process|
+      process.pid_file = "#{ROOT_DIR}/pids/process_#{i}.pid"
+
+      # Example of use of pid_command option to find memcached process
+      # process.pid_command = "ps -ef | awk '/memcached$/{ print $2 }'"
+
+      # I could not figure out a portable way to
+      # specify the path to the sample forking server across the diff developer laptops.
+      # Since this code is eval'ed we cannot reliably use __FILE__
+      process.start_command = "/Users/rohith/work/bluepill/bin/sample_forking_server #{4242 + i}"
+      process.stop_command = "kill -INT {{PID}}"
+      process.daemonize = true
+
+      process.start_grace_time = 1.seconds
+      process.restart_grace_time = 7.seconds
+      process.stop_grace_time = 7.seconds
+
+      process.uid = "rohith"
+      process.gid = "staff"
+
+      # process.checks :cpu_usage, :every => 10, :below => 0.5, :times => [5, 5]
+      process.checks :flapping, :times => 2, :within => 30.seconds, :retry_in => 7.seconds
+
+      process.monitor_children do |child_process|
+        # child_process.checks :cpu_usage,
+        #   :every => 10,
+        #   :below => 0.5,
+        #   :times => [5, 5]
+
+        # child_process.checks :mem_usage,
+        #   :every => 3,
+        #   :below => 600.kilobytes,
+        #   :times => [3, 5],
+        #   :fires => [:stop]
+
+        child_process.stop_command = "kill -QUIT {{PID}}"
+        # child_process.checks :flapping, :times => 2, :within => 30.seconds, :retry_in => 7.seconds
+      end
+    end
+  end
+
+  0.times do |i|
+    app.process("group_process_#{i}") do |process|
+      process.group = "group_1"
+      process.pid_file = "/Users/rohith/ffs/tmp/pids/mongrel_#{i}.pid"
+      process.start_command = "cd ~/ffs && mongrel_rails start -P #{process.pid_file} -p 3000 -d"
+
+      process.start_grace_time = 10.seconds
+
+      process.uid = "rohith"
+      process.gid = "staff"
+
+      # process.checks :always_true, :every => 10
+    end
+  end
+
+  1.times do |i|
+    app.process("group_process_#{i}") do |process|
+      process.auto_start = false
+
+      process.uid = "rohith"
+      process.gid = "wheel"
+
+      process.stderr = "/tmp/err.log"
+      process.stdout = "/tmp/err.log"
+
+
+      process.group = "grouped"
+      process.start_command = %Q{cd /tmp && ruby -e '$stderr.puts("hello stderr");$stdout.puts("hello stdout"); $stdout.flush; $stderr.flush; sleep 10'}
+      process.daemonize = true
+      process.pid_file = "/tmp/noperm/p_#{process.group}_#{i}.pid"
+
+      # process.checks :always_true, :every => 5
+    end
+  end
+end
+

data/examples/new_example.rb

@@ -0,0 +1,89 @@
+require 'rubygems'
+require 'bluepill'
+require 'logger'
+
+# Note that this syntax supported from bluepill 0.0.50
+
+ROOT_DIR = "/tmp/bp"
+
+# Watch with
+# watch -n0.2 'ps axu | egrep "(CPU|forking|bluepill|sleep)" | grep -v grep | sort'
+Bluepill.application(:sample_app) do
+  0.times do |i|
+    process("process_#{i}") do
+      pid_file "#{ROOT_DIR}/pids/process_#{i}.pid"
+
+      # Example of use of pid_command option to find memcached process
+      # pid_command = "ps -ef | awk '/memcached$/{ print $2 }'"
+
+      # I could not figure out a portable way to
+      # specify the path to the sample forking server across the diff developer laptops.
+      # Since this code is eval'ed we cannot reliably use __FILE__
+      start_command "/Users/rohith/work/bluepill/bin/sample_forking_server #{4242 + i}"
+      stop_command "kill -INT {{PID}}"
+      daemonize!
+
+      start_grace_time 1.seconds
+      restart_grace_time 7.seconds
+      stop_grace_time 7.seconds
+
+      uid "rohith"
+      gid "staff"
+
+      # checks :cpu_usage, :every => 10, :below => 0.5, :times => [5, 5]
+      checks :flapping, :times => 2, :within => 30.seconds, :retry_in => 7.seconds
+
+      monitor_children do
+        # checks :cpu_usage,
+        #   :every => 10,
+        #   :below => 0.5,
+        #   :times => [5, 5]
+
+        # checks :mem_usage,
+        #   :every => 3,
+        #   :below => 600.kilobytes,
+        #   :times => [3, 5],
+        #   :fires => [:stop]
+
+        stop_command "kill -QUIT {{PID}}"
+        # checks :flapping, :times => 2, :within => 30.seconds, :retry_in => 7.seconds
+      end
+    end
+  end
+
+  0.times do |i|
+    process("group_process_#{i}") do
+      group "group_1"
+      pid_file "/Users/rohith/ffs/tmp/pids/mongrel_#{i}.pid"
+      start_command "cd ~/ffs && mongrel_rails start -P #{pid_file} -p 3000 -d"
+
+      start_grace_time 10.seconds
+
+      uid "rohith"
+      gid "staff"
+
+      # checks :always_true, :every => 10
+    end
+  end
+
+  1.times do |i|
+    process("group_process_#{i}") do
+      auto_start false
+
+      uid "rohith"
+      gid "wheel"
+
+      stderr "/tmp/err.log"
+      stdout "/tmp/err.log"
+
+
+      group "grouped"
+      start_command %Q{cd /tmp && ruby -e '$stderr.puts("hello stderr");$stdout.puts("hello stdout"); $stdout.flush; $stderr.flush; sleep 10'}
+      daemonize!
+      pid_file "/tmp/noperm/p_#{group}_#{i}.pid"
+
+      # checks :always_true, :every => 5
+    end
+  end
+end
+

data/examples/new_runit_example.rb

@@ -0,0 +1,29 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'bluepill'
+require 'logger'
+
+# ATTENTION:
+# You must declare only one application per config when foreground mode specified
+#
+# http://github.com/Undev/runit-man used as example of monitored application.
+
+# Note that this syntax supported from bluepill 0.0.50
+
+Bluepill.application(:runit_man, :foreground => true) do
+  process("runit-man") do
+    pid_file        "/etc/service/runit-man/supervise/pid"
+
+    start_command   "/usr/bin/sv start runit-man"
+    stop_command    "/usr/bin/sv stop runit-man"
+    restart_command "/usr/bin/sv restart runit-man"
+
+    start_grace_time   1.seconds
+    restart_grace_time 7.seconds
+    stop_grace_time    7.seconds
+
+    checks :http, :within => 30.seconds, :retry_in => 7.seconds, :every => 30.seconds,
+      :url => 'http://localhost:4567/', :kind => :success, :pattern => /html/, :timeout => 3.seconds
+  end
+end
+

data/examples/runit_example.rb

@@ -0,0 +1,26 @@
+#! /usr/bin/env ruby
+require 'rubygems'
+require 'bluepill'
+require 'logger'
+
+# ATTENTION:
+# You must declare only one application per config when foreground mode specified
+#
+# http://github.com/Undev/runit-man used as example of monitored application.
+
+Bluepill.application(:runit_man, :foreground => true) do |app|
+  app.process("runit-man") do |process|
+    process.pid_file = "/etc/service/runit-man/supervise/pid"
+
+    process.start_command   = "/usr/bin/sv start runit-man"
+    process.stop_command    = "/usr/bin/sv stop runit-man"
+    process.restart_command = "/usr/bin/sv restart runit-man"
+
+    process.start_grace_time   = 1.seconds
+    process.restart_grace_time = 7.seconds
+    process.stop_grace_time    = 7.seconds
+
+    process.checks :http, :within => 30.seconds, :retry_in => 7.seconds, :every => 30.seconds,
+      :url => 'http://localhost:4567/', :kind => :success, :pattern => /html/, :timeout => 3.seconds
+  end
+end

data/lib/bluepill.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems'
+
+require 'bundler/setup' if ENV['BUNDLE_GEMFILE'] && File.exists?(ENV['BUNDLE_GEMFILE'])
+
+require 'thread'
+require 'monitor'
+require 'syslog'
+require 'timeout'
+
+require 'madvertise-logging'
+
+require 'active_support/inflector'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/numeric'
+require 'active_support/duration'
+
+require 'bluepill/dsl/process_proxy'
+require 'bluepill/dsl/process_factory'
+require 'bluepill/dsl/app_proxy'
+
+require 'bluepill/application'
+require 'bluepill/controller'
+require 'bluepill/socket'
+require "bluepill/process"
+require "bluepill/process_statistics"
+require "bluepill/group"
+require "bluepill/condition_watch"
+require 'bluepill/trigger'
+require 'bluepill/triggers/flapping'
+require "bluepill/dsl"
+require "bluepill/system"
+
+require "bluepill/process_conditions"
+
+require "bluepill/util/rotational_array"
+
+require "bluepill/version"

data/lib/bluepill/application.rb

@@ -0,0 +1,201 @@
+# -*- encoding: utf-8 -*-
+require 'thread'
+
+module Bluepill
+  class Application
+    PROCESS_COMMANDS = [:start, :stop, :restart, :unmonitor, :status]
+
+    attr_accessor :name, :logger, :base_dir, :socket, :pid_file, :kill_timeout
+    attr_accessor :groups, :work_queue
+    attr_accessor :pids_dir
+
+    def initialize(name, options = {})
+      self.name = name
+
+      @foreground   = options[:foreground]
+      self.base_dir = options[:base_dir] || File.join(ENV['HOME'], '.bluepill')
+      self.pid_file = File.join(self.base_dir, 'pids', self.name + ".pid")
+      self.pids_dir = File.join(self.base_dir, 'pids', self.name)
+      self.kill_timeout = options[:kill_timeout] || 10
+
+      self.groups = {}
+
+      self.logger = Madvertise::Logging::ImprovedLogger.new(foreground? ? :syslog : STDERR, "bluepill-#{self.name}")
+
+      self.setup_signal_traps
+      self.setup_pids_dir
+
+      @mutex = Mutex.new
+    end
+
+    def foreground?
+      !!@foreground
+    end
+
+    def mutex(&b)
+      @mutex.synchronize(&b)
+    end
+
+    def load
+      begin
+        self.start_server
+      rescue StandardError => e
+        $stderr.puts "Failed to start bluepill:"
+        $stderr.puts "%s `%s`" % [e.class.name, e.message]
+        $stderr.puts e.backtrace
+        exit(5)
+      end
+    end
+
+    PROCESS_COMMANDS.each do |command|
+      class_eval <<-END
+        def #{command}(group_name = nil, process_name = nil)
+          self.send_to_process_or_group(:#{command}, group_name, process_name)
+        end
+      END
+    end
+
+    def add_process(process, group_name = nil)
+      group_name = group_name.to_s if group_name
+
+      self.groups[group_name] ||= Group.new(group_name, :logger => self.logger)
+      self.groups[group_name].add_process(process)
+    end
+
+    def version
+      Bluepill::VERSION
+    end
+
+    protected
+    def send_to_process_or_group(method, group_name, process_name)
+      if group_name.nil? && process_name.nil?
+        self.groups.values.collect do |group|
+          group.send(method)
+        end.flatten
+      elsif self.groups.key?(group_name)
+        self.groups[group_name].send(method, process_name)
+      elsif process_name.nil?
+        # they must be targeting just by process name
+        process_name = group_name
+        self.groups.values.collect do |group|
+          group.send(method, process_name)
+        end.flatten
+      else
+        []
+      end
+    end
+
+    def start_listener
+      @listener_thread.kill if @listener_thread
+      @listener_thread = Thread.new do
+        loop do
+          begin
+            client = self.socket.accept
+            client.close_on_exec = true  if client.respond_to?(:close_on_exec=)
+            command, *args = client.readline.strip.split(":")
+            response = begin
+              mutex { self.send(command, *args) }
+            rescue Exception => e
+              e
+            end
+            client.write(Marshal.dump(response))
+          rescue StandardError => e
+            logger.exception(e)
+          ensure
+            begin
+              client.close
+            rescue IOError
+              # closed stream
+            end
+          end
+        end
+      end
+    end
+
+    def start_server
+      self.kill_previous_bluepill
+
+      Daemonize.daemonize unless foreground?
+
+      $0 = "bluepill: #{self.name}"
+
+      self.groups.each {|_, group| group.determine_initial_state }
+
+
+      self.write_pid_file
+      self.socket = Bluepill::Socket.server(self.base_dir, self.name)
+      self.start_listener
+
+      self.run
+    end
+
+    def run
+      @running = true # set to false by signal trap
+      while @running
+        mutex do
+          System.reset_data
+          self.groups.each { |_, group| group.tick }
+        end
+        sleep 1
+      end
+      cleanup
+    end
+
+    def cleanup
+      File.unlink(self.socket.path) if self.socket
+      File.unlink(self.pid_file) if File.exists?(self.pid_file)
+    end
+
+    def setup_signal_traps
+      terminator = Proc.new do
+        puts "Terminating..."
+        @running = false
+      end
+
+      Signal.trap("TERM", &terminator)
+      Signal.trap("INT", &terminator)
+
+      Signal.trap("HUP") do
+        self.logger.close if self.logger
+      end
+    end
+
+    def setup_pids_dir
+      FileUtils.mkdir_p(self.pids_dir) unless File.exists?(self.pids_dir)
+      # we need everybody to be able to write to the pids_dir as processes managed by
+      # bluepill will be writing to this dir after they've dropped privileges
+      FileUtils.chmod(0777, self.pids_dir)
+    end
+
+    def kill_previous_bluepill
+      if File.exists?(self.pid_file)
+        previous_pid = File.read(self.pid_file).to_i
+        if System.pid_alive?(previous_pid)
+          begin
+            ::Process.kill(0, previous_pid)
+            puts "Killing previous bluepill[#{previous_pid}]"
+            ::Process.kill(2, previous_pid)
+          rescue Exception => e
+            $stderr.puts "Encountered error trying to kill previous bluepill:"
+            $stderr.puts "#{e.class}: #{e.message}"
+            exit(4) unless e.is_a?(Errno::ESRCH)
+          else
+            kill_timeout.times do |i|
+              sleep 0.5
+              break unless System.pid_alive?(previous_pid)
+            end
+
+            if System.pid_alive?(previous_pid)
+              $stderr.puts "Previous bluepill[#{previous_pid}] didn't die"
+              exit(4)
+            end
+          end
+        end
+      end
+    end
+
+    def write_pid_file
+      File.open(self.pid_file, 'w') { |x| x.write(::Process.pid) }
+    end
+  end
+end