ryansch-bluepill 0.0.53

data/bin/bpsv

@@ -0,0 +1,3 @@
+#!/bin/bash
+target=`basename $0`
+exec bluepill $1 $target 

data/bin/sample_forking_server

@@ -0,0 +1,53 @@
+#! /usr/bin/env ruby
+
+# This is a modified version found at http://tomayko.com/writings/unicorn-is-unix
+# It is modified to trigger various states like increase memory consumption so that 
+# I could write watches for them.
+
+# Instructions for running the test
+# 
+# (1) Edit the example config and fix the path to this file. Around line 16.
+# (2) Load up the config and run the bluepill daemon
+# (3) Run watch -n0.2 'sudo ruby bin/bluepill status 2>/dev/null; echo; ps ajxu | egrep "(CPU|forking|bluepill|sleep|ruby)" | grep -v grep | sort'
+# (4) After verifying that the "sleep" workers are properly being restarted, telnet to localhost 4242 and say something. You should get it echoed back and the worker which answered your request should now be over the allowed memory limit
+# (5) Observe the worker being killed in the watch you started in step 3.
+
+require 'socket'
+
+port = ARGV[0].to_i
+port = 4242 if port == 0
+
+acceptor = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+address = Socket.pack_sockaddr_in(port, '127.0.0.1')
+acceptor.bind(address)
+acceptor.listen(10)
+
+children = []
+trap('EXIT') { acceptor.close; children.each {|c| Process.kill('QUIT', c)} }
+
+
+3.times do
+  children << fork do
+    trap('QUIT') {$0 = "forking_server| QUIT received shutting down gracefully..."; sleep 5; exit}
+    trap('INT') {$0 = "forking_server| INT received shutting down UN-gracefully..."; sleep 3; exit}
+    
+    puts "child #$$ accepting on shared socket (localhost:#{port})"
+    loop {
+      socket, addr = acceptor.accept
+      socket.write "child #$$ echo> "
+      socket.flush
+      message = socket.gets
+      socket.write message
+      socket.close
+      puts "child #$$ echo'd: '#{message.strip}'"
+      
+      # cause a spike in mem usage
+      temp = "*" * (100 * 1024)
+    }
+    exit
+  end
+end
+
+trap('INT') { puts "\nbailing" ; exit }
+
+Process.waitall

data/bluepill.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+
+require "bluepill/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ryansch-bluepill"
+  s.version     = Bluepill::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Arya Asemanfar", "Gary Tsang", "Rohith Ravi", "Ryan Schlesinger"]
+  s.email       = ["ryan@instanceinc.com"]
+  s.homepage    = "http://github.com/ryansch/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.0'
+  s.add_dependency 'state_machine', '~> 0.9.4'
+  s.add_dependency 'activesupport', '>= 3.0.0'
+  s.add_dependency 'i18n', '>= 0.5.0'
+
+  s.add_development_dependency 'bundler', '>= 1.0.10'
+
+  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,36 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems'
+
+require 'thread'
+require 'monitor'
+require 'syslog'
+require 'timeout'
+require 'logger'
+
+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/logger"
+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,203 @@
+# -*- 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
+    attr_accessor :groups, :work_queue
+    attr_accessor :pids_dir, :log_file
+
+    def initialize(name, options = {})
+      self.name = name
+
+      @foreground   = options[:foreground]
+      self.log_file = options[:log_file]
+      self.base_dir = options[:base_dir] || '/var/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.groups = {}
+
+      self.logger = Bluepill::Logger.new(:log_file => self.log_file, :stdout => foreground?).prefix_with(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.prefix_with(group_name))
+      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
+            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.err("Got exception in cmd listener: %s `%s`" % [e.class.name, e.message])
+            e.backtrace.each {|l| logger.err(l)}
+          ensure
+            begin
+              client.close
+            rescue IOError
+              # closed stream
+            end
+          end
+        end
+      end
+    end
+
+    def start_server
+      self.kill_previous_bluepill
+
+      Daemonize.daemonize unless foreground?
+
+      self.logger.reopen
+
+      $0 = "bluepilld: #{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.reopen 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 bluepilld[#{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
+            10.times do |i|
+              sleep 0.5
+              break unless System.pid_alive?(previous_pid)
+            end
+
+            if System.pid_alive?(previous_pid)
+              $stderr.puts "Previous bluepilld[#{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