cloud66-bluepill 0.0.62

data/bin/bluepill

@@ -0,0 +1,124 @@
+#! /usr/bin/env ruby
+require 'optparse'
+require 'bluepill'
+
+begin
+  require 'rbconfig'
+rescue LoadError
+end
+
+RbConfig = Config unless Object.const_defined?(:RbConfig)
+
+# Default options
+options = {
+  :log_file   => "/var/log/bluepill.log",
+  :base_dir   => "/var/run/bluepill",
+  :privileged => true,
+  :timeout    => 10,
+  :attempts   => 1
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: 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 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 "bluepill, version #{Bluepill::VERSION}"
+    exit
+  end
+
+  opts.on("--[no-]privileged", "Allow/disallow to run #{$0} as non-privileged process. disallowed by default") do |v|
+    options[:privileged] = v
+  end
+
+  opts.on('-t', '--timeout Seconds', Integer, "Timeout for commands sent to the daemon, in seconds. Defaults to 10.") do |timeout|
+    options[:timeout] = timeout
+  end
+
+  opts.on('--attempts Count', Integer, "Attempts for commands sent to the daemon, in seconds. Defaults to 1.") do |attempts|
+    options[:attempts] = attempts
+  end
+
+  help = proc do
+    puts opts
+    puts
+    puts "Commands:"
+    puts "    load CONFIG_FILE\t\tLoads new instance of 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 bluepill"
+    puts
+    puts "See http://github.com/arya/bluepill for README"
+    exit
+  end
+
+  opts.on_tail('-h','--help', 'Show this message', &help)
+  help.call if ARGV.empty?
+end.parse!
+
+# Check for root
+if options[:privileged] && ::Process.euid != 0
+  $stderr.puts "You must run bluepill as root or use --no-privileged option."
+  exit(3)
+end
+
+APPLICATION_COMMANDS = %w(status start stop restart unmonitor quit log)
+
+controller = Bluepill::Controller.new(options.slice(:base_dir, :log_file))
+
+if controller.running_applications.include?(File.basename($0)) && File.symlink?($0)
+  # bluepill was called as a symlink with the name of the target application
+  options[:application] = File.basename($0)
+elsif controller.running_applications.include?(ARGV.first)
+  # the first arg is the application name
+  options[:application] = ARGV.shift
+elsif APPLICATION_COMMANDS.include?(ARGV.first)
+  if controller.running_applications.length == 1
+    # there is only one, let's just use that
+    options[:application] = controller.running_applications.first
+  elsif controller.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:"
+    controller.running_applications.each_with_index do |app, index|
+      $stderr.puts "  #{index + 1}. #{app}"
+    end
+    $stderr.puts "Usage: 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 bluepill daemons.\nTo start a bluepill daemon, use: bluepill load <config file>"
+    exit(2)
+  end
+end
+
+options[:command] = ARGV.shift
+
+if options[:command] == "load"
+  file = ARGV.shift
+  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(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    load_path = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+    file_path = File.expand_path(file)
+
+    exec(ruby, "-I#{load_path}", '-rbluepill', file_path)
+    
+  else
+    $stderr.puts "Can't find file: #{file}"
+  end
+else
+  target = ARGV.shift
+  controller.handle_command(options[:application], options[:command], target)
+end
+

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,37 @@
+# -*- encoding: utf-8 -*-
+
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+
+require "bluepill/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cloud66-bluepill"
+  s.version     = Bluepill::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Arya Asemanfar", "Gary Tsang", "Rohith Ravi", "Cloud66"]
+  s.email       = ["entombedvirus@gmail.com"]
+  s.homepage    = "http://github.com/arya/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. Forked from http://github.com/arya/bluepill}
+
+  s.add_dependency 'daemons', ['~> 1.1.4']
+  s.add_dependency 'state_machine', '~> 1.1.0'
+  s.add_dependency 'activesupport', '>= 3.0.0'
+  s.add_dependency 'i18n', '>= 0.5.0'
+
+  s.add_development_dependency 'bundler', '>= 1.0.10'
+  s.add_development_dependency 'rake', '!= 0.9.0'
+  s.add_development_dependency 'rspec', '~> 2.12.0'
+  s.add_development_dependency 'rspec-core', '~> 2.12.0'
+  s.add_development_dependency 'rspec-expectations', '~> 2.12.0'
+  s.add_development_dependency 'rspec-mocks', '~> 2.12.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