kostya-bluepill 0.0.60.1

data/.gitignore

@@ -0,0 +1,10 @@
+*.sw?
+.DS_Store
+coverage/
+.yardoc/
+doc/
+pkg/
+*.gem
+.bundle/
+Gemfile.lock
+.idea

data/.rspec

@@ -0,0 +1 @@
+-r ./spec/spec_helper.rb -c -f progress

data/DESIGN.md

@@ -0,0 +1,10 @@
+## Bluepill Design
+Here are just some bullet points of the design. We'll add details later.
+
+ * Each process monitors a single _application_, so you can have multiple bluepill processes on a system
+ * Use rotational arrays for storing historical data for monitoring process conditions
+ * Memo-ize output of _ps_ per tick as an optimization for applications with many processes
+ * Use socket files to communicate between CLI and daemon
+ * DSL is a separate layer, the core of the monitoring just uses regular initializers, etc. DSL is simply for ease of use and should not interfere with business logic
+ * Sequentially process user issued commands so no weird race cases occur
+ * Triggers are notified by the state machine on any process state transitions

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+# Specify your gem's dependencies in bluepill.gemspec
+gemspec
+
+# YARD helper for ruby 1.8 (already embedded into ruby 1.9)
+gem "ripper", :platforms => :ruby_18, :group => :development
+
+# Code coverage tool that works on Ruby 1.9
+gem "simplecov", ">= 0.4.0", :platforms => :ruby_19, :group => :test

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Arya Asemanfar, Rohith Ravi, Gary Tsang
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,305 @@
+# Bluepill
+Bluepill is a simple process monitoring tool written in Ruby. 
+
+## Installation
+It's hosted on [rubygems.org][rubygems].
+
+    sudo gem install bluepill
+
+In order to take advantage of logging with syslog, you also need to setup your syslog to log the local6 facility. Edit the appropriate config file for your syslogger (/etc/syslog.conf for syslog) and add a line for local6:
+
+    local6.*          /var/log/bluepill.log
+
+You'll also want to add _/var/log/bluepill.log_ to _/etc/logrotate.d/syslog_ so that it gets rotated.
+
+Lastly, create the _/var/run/bluepill_ directory for bluepill to store its pid and sock files.
+
+## Usage
+### Config
+Bluepill organizes processes into 3 levels: application -> group -> process. Each process has a few attributes that tell bluepill how to start, stop, and restart it, where to look or put the pid file, what process conditions to monitor and the options for each of those.
+
+The minimum config file looks something like this:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+      end
+    end
+```
+
+Note that since we specified a PID file and start command, bluepill assumes the process will daemonize itself. If we wanted bluepill to daemonize it for us, we can do (note we still need to specify a PID file):
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+        process.daemonize = true
+      end
+    end
+```
+
+If you don't specify a stop command, a TERM signal will be sent by default. Similarly, the default restart action is to issue stop and then start.
+
+Now if we want to do something more meaningful, like actually monitor the process, we do:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+        
+        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3
+      end
+    end
+```
+
+We added a line that checks every 10 seconds to make sure the cpu usage of this process is below 5 percent; 3 failed checks results in a restart. We can specify a two-element array for the _times_ option to say that it 3 out of 5 failed attempts results in a restart.
+
+To watch memory usage, we just add one more line:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+
+        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3        
+        process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
+      end
+    end
+ ```
+
+We can tell bluepill to give a process some grace time to start/stop/restart before resuming monitoring:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+        process.start_grace_time = 3.seconds
+        process.stop_grace_time = 5.seconds
+        process.restart_grace_time = 8.seconds
+
+        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3        
+        process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
+      end
+    end
+```
+
+We can group processes by name:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      5.times do |i|
+        app.process("process_name_#{i}") do |process|
+          process.group = "mongrels"
+          process.start_command = "/usr/bin/some_start_command"
+          process.pid_file = "/tmp/some_pid_file.pid"
+        end
+      end
+    end
+```
+
+If you want to run the process as someone other than root:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+        process.uid = "deploy"
+        process.gid = "deploy"
+
+        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3        
+        process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
+      end
+    end
+```
+
+If you want to include one or more supplementary groups:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+        process.uid = "deploy"
+        process.gid = "deploy"
+        process.supplementary_groups = ['rvm']
+
+        process.checks :cpu_usage, :every => 10.seconds, :below => 5, :times => 3
+        process.checks :mem_usage, :every => 10.seconds, :below => 100.megabytes, :times => [3,5]
+      end
+    end
+```
+
+You can also set an app-wide uid/gid:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.uid = "deploy"
+      app.gid = "deploy"
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+      end
+    end
+```
+
+To check for flapping:
+
+```ruby
+    process.checks :flapping, :times => 2, :within => 30.seconds, :retry_in => 7.seconds
+```
+
+To set the working directory to _cd_ into when starting the command:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+        process.working_dir = "/path/to/some_directory"
+      end
+    end
+```
+
+You can also have an app-wide working directory:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.working_dir = "/path/to/some_directory"
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+      end
+    end
+```
+
+Note: We also set the PWD in the environment to the working dir you specify. This is useful for when the working dir is a symlink. Unicorn in particular will cd into the environment variable in PWD when it re-execs to deal with a change in the symlink.
+
+By default, bluepill will send a SIGTERM to your process when stopping.
+To change the stop command:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+        process.stop_command = "/user/bin/some_stop_command"
+      end
+    end
+```
+
+If you'd like to send a signal or signals to your process to stop it:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/some_start_command"
+        process.pid_file = "/tmp/some_pid_file.pid"
+        process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+      end
+    end
+```
+
+We added a line that will send a SIGQUIT, wait 30 seconds and check to
+see if the process is still up, send a SIGTERM, wait 5 seconds and check
+to see if the process is still up, and finally send a SIGKILL.
+
+And lastly, to monitor child processes:
+
+```ruby
+    process.monitor_children do |child_process|
+      child_process.checks :cpu_usage, :every => 10, :below => 5, :times => 3
+      child_process.checks :mem_usage, :every => 10, :below => 100.megabytes, :times => [3, 5]
+      
+      child_process.stop_command = "kill -QUIT {{PID}}"
+    end
+```
+
+Note {{PID}} will be substituted for the pid of process in both the stop and restart commands.
+
+### A Note About Output Redirection
+
+While you can specify shell tricks like the following in the start_command of a process:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "cd /tmp/some_dir && SOME_VAR=1 /usr/bin/some_start_command > /tmp/server.log 2>&1"
+        process.pid_file = "/tmp/some_pid_file.pid"
+      end
+    end
+```
+
+We recommend that you _not_ do that and instead use the config options to capture output from your daemons. Like so:
+
+```ruby
+    Bluepill.application("app_name") do |app|
+      app.process("process_name") do |process|
+        process.start_command = "/usr/bin/env SOME_VAR=1 /usr/bin/some_start_command"
+        
+        process.working_dir = "/tmp/some_dir"
+        process.stdout = process.stderr = "/tmp/server.log"
+        
+        process.pid_file = "/tmp/some_pid_file.pid"
+      end
+    end
+```
+
+The main benefit of using the config options is that Bluepill will be able to monitor the correct process instead of just watching the shell that spawned your actual server.
+
+### CLI
+To start a bluepill process and load a config:
+
+    sudo bluepill load /path/to/production.pill
+
+To act on a process or group:
+
+    sudo bluepill <start|stop|restart|unmonitor> <process_or_group_name>
+
+To view process statuses:
+
+    sudo bluepill status
+
+To view the log for a process or group:
+
+    sudo bluepill log <process_or_group_name>
+
+To quit bluepill:
+
+    sudo bluepill quit
+
+### Logging  
+By default, bluepill uses syslog local6 facility as described in the installation section. But if for any reason you don&apos;t want to use syslog, you can use a log file. You can do this by setting the :log\_file option in the config:
+
+```ruby
+    Bluepill.application("app_name", :log_file => "/path/to/bluepill.log") do |app|
+      # ...
+    end
+```
+
+Keep in mind that you still need to set up log rotation (described in the installation section) to keep the log file from growing huge.
+    
+### Extra options
+You can run bluepill in the foreground:
+
+```ruby
+    Bluepill.application("app_name", :foreground => true) do |app|
+      # ...
+    end
+```
+
+Note that You must define only one application per config when using foreground mode.
+
+## Links
+Code: [http://github.com/arya/bluepill](http://github.com/arya/bluepill)  
+Bugs/Features: [http://github.com/arya/bluepill/issues](http://github.com/arya/bluepill/issues)  
+Mailing List: [http://groups.google.com/group/bluepill-rb](http://groups.google.com/group/bluepill-rb)
+
+
+[rubygems]: http://rubygems.org/gems/bluepill

data/Rakefile

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+begin
+  require 'bundler'
+  Bundler::GemHelper.install_tasks
+rescue LoadError
+  $stderr.puts "Bundler not installed. You should install it with: gem install bundler"
+end
+
+$LOAD_PATH << File.expand_path('./lib', File.dirname(__FILE__))
+require 'bluepill/version'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+
+  if RUBY_VERSION >= '1.9'
+    RSpec::Core::RakeTask.new(:cov) do |t|
+      ENV['ENABLE_SIMPLECOV'] = '1'
+      t.ruby_opts = '-w'
+      t.rcov_opts = %q[-Ilib --exclude "spec/*,gems/*"]
+    end
+  end
+rescue LoadError
+  $stderr.puts "RSpec not available. Install it with: gem install rspec-core rspec-expectations rr faker"
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |yard|
+    yard.options << "--title='bluepill #{Bluepill::VERSION}'"
+
+  end
+rescue LoadError
+  $stderr.puts "Please install YARD with: gem install yard"
+end
+

data/bin/bluepill

@@ -0,0 +1,104 @@
+#! /usr/bin/env ruby
+require 'optparse'
+require 'bluepill'
+
+begin
+  require 'rbconfig'
+rescue LoadError
+end
+
+RbConfig = Config unless Object.const_defined?(:RbConfig)
+
+# Default options
+options = {
+  :base_dir => File.join(ENV['HOME'], '.bluepill'),
+  :timeout => 10,
+  :attempts  => 1
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: bluepill [app] cmd [options]"
+  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('-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 "    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!
+
+APPLICATION_COMMANDS = %w(status start stop restart unmonitor quit)
+
+controller = Bluepill::Controller.new(options.slice(:base_dir))
+
+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