mojombo-god 0.7.7

data/bin/god

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+
+STDOUT.sync = true
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'rubygems'
+require 'optparse'
+require 'drb'
+
+begin
+  options = {:daemonize => true, :port => 17165, :syslog => true, :events => true}
+
+  opts = OptionParser.new do |opts|
+    opts.banner = <<-EOF
+  Usage:
+    Starting:
+      god [-c <config file>] [-p <port> | -b] [-P <file>] [-l <file>] [-D]
+      
+    Querying:
+      god <command> <argument> [-p <port>]
+      god <command> [-p <port>]
+      god -v
+      god -V (must be run as root to be accurate on Linux)
+      
+    Commands:
+      start <task or group name>         start task or group
+      restart <task or group name>       restart task or group
+      stop <task or group name>          stop task or group
+      monitor <task or group name>       monitor task or group
+      unmonitor <task or group name>     unmonitor task or group
+      remove <task or group name>        remove task or group from god
+      load <file>                        load a config into a running god
+      log <task name>                    show realtime log for given task
+      status                             show status of each task
+      quit                               stop god
+      terminate                          stop god and all tasks
+      check                              run self diagnostic
+      
+    Options:
+  EOF
+  
+    opts.on("-cCONFIG", "--config-file CONFIG", "Configuration file") do |x|
+      options[:config] = x
+    end
+    
+    opts.on("-pPORT", "--port PORT", "Communications port (default 17165)") do |x|
+      options[:port] = x
+    end
+    
+    opts.on("-b", "--auto-bind", "Auto-bind to an unused port number") do
+      options[:port] = "0"
+    end
+    
+    opts.on("-PFILE", "--pid FILE", "Where to write the PID file") do |x|
+      options[:pid] = x
+    end
+    
+    opts.on("-lFILE", "--log FILE", "Where to write the log file") do |x|
+      options[:log] = x
+    end
+    
+    opts.on("-D", "--no-daemonize", "Don't daemonize") do
+      options[:daemonize] = false
+    end
+    
+    opts.on("-v", "--version", "Print the version number and exit") do
+      options[:version] = true
+    end
+    
+    opts.on("-V", "Print extended version and build information") do
+      options[:info] = true
+    end
+    
+    opts.on("--log-level LEVEL", "Log level [debug|info|warn|error|fatal]") do |x|
+      options[:log_level] = x.to_sym
+    end
+    
+    opts.on("--no-syslog", "Disable output to syslog") do
+      options[:syslog] = false
+    end
+    
+    opts.on("--attach PID", "Quit god when the attached process dies") do |x|
+      options[:attach] = x
+    end
+    
+    opts.on("--no-events", "Disable the event system") do
+      options[:events] = false
+    end
+    
+    opts.on("--bleakhouse", "Enable bleakhouse profiling") do
+      options[:bleakhouse] = true
+    end
+  end
+  
+  opts.parse!
+  
+  # validate
+  if options[:log_level] && ![:debug, :info, :warn, :error, :fatal].include?(options[:log_level])
+    abort("Invalid log level '#{options[:log_level]}'")
+  end
+  
+  # dispatch
+  if !options[:config] && options[:version]
+    require 'god'
+    God::CLI::Version.version
+  elsif !options[:config] && options[:info]
+    require 'god'
+    God::EventHandler.load
+    God::CLI::Version.version_extended
+  elsif !options[:config] && command = ARGV[0]
+    require 'god'
+    God::EventHandler.load
+    God::CLI::Command.new(command, options, ARGV)
+  else
+    require 'god/cli/run'
+    God::CLI::Run.new(options)
+  end
+rescue Exception => e
+  if e.instance_of?(SystemExit)
+    raise
+  else
+    puts 'Uncaught exception'
+    puts e.message
+    puts e.backtrace.join("\n")
+  end
+end

data/examples/events.god

@@ -0,0 +1,84 @@
+# This example shows how you might keep a local development Rails server up
+# and running on your Mac.
+
+# Run with:
+# god -c /path/to/events.god
+
+RAILS_ROOT = ENV['GOD_TEST_RAILS_ROOT']
+
+%w{3002}.each do |port|
+  God.watch do |w|
+    w.name = "local-#{port}"
+    w.interval = 5.seconds
+    w.start = "mongrel_rails start -p #{port} -P #{RAILS_ROOT}/log/mongrel.#{port}.pid -c #{RAILS_ROOT} -d"
+    w.stop = "mongrel_rails stop -P #{RAILS_ROOT}/log/mongrel.#{port}.pid -c #{RAILS_ROOT}"
+    w.pid_file = File.join(RAILS_ROOT, "log/mongrel.#{port}.pid")
+    w.log = File.join(RAILS_ROOT, "log/commands.#{port}.log")
+  
+    # clean pid files before start if necessary
+    w.behavior(:clean_pid_file)
+  
+    # determine the state on startup
+    w.transition(:init, { true => :up, false => :start }) do |on|
+      on.condition(:process_running) do |c|
+        c.running = true
+      end
+    end
+  
+    # determine when process has finished starting
+    w.transition([:start, :restart], :up) do |on|
+      on.condition(:process_running) do |c|
+        c.running = true
+      end
+    
+      # failsafe
+      on.condition(:tries) do |c|
+        c.times = 8
+        c.within = 2.minutes
+        c.transition = :start
+      end
+    end
+
+    # start if process is not running
+    w.transition(:up, :start) do |on|
+      on.condition(:process_exits)
+    end
+  
+    # restart if memory or cpu is too high
+    w.transition(:up, :restart) do |on|
+      on.condition(:memory_usage) do |c|
+        c.interval = 20
+        c.above = 50.megabytes
+        c.times = [3, 5]
+      end
+    
+      on.condition(:cpu_usage) do |c|
+        c.interval = 10
+        c.above = 10.percent
+        c.times = 5
+      end
+    
+      on.condition(:http_response_code) do |c|
+        c.host = 'localhost'
+        c.port = port
+        c.path = '/'
+        c.code_is = 500
+        c.timeout = 10.seconds
+        c.times = [3, 5]
+      end
+    end
+  
+    # lifecycle
+    w.lifecycle do |on|
+      on.condition(:flapping) do |c|
+        c.to_state = [:start, :restart]
+        c.times = 5
+        c.within = 1.minute
+        c.transition = :unmonitored
+        c.retry_in = 10.minutes
+        c.retry_times = 5
+        c.retry_within = 2.hours
+      end
+    end
+  end
+end

data/examples/gravatar.god

@@ -0,0 +1,54 @@
+# run with:  god -c /path/to/gravatar.god
+# 
+# This is the actual config file used to keep the mongrels of
+# gravatar.com running.
+
+RAILS_ROOT = "/Users/tom/dev/gravatar2"
+
+%w{8200 8201 8202}.each do |port|
+  God.watch do |w|
+    w.name = "gravatar2-mongrel-#{port}"
+    w.interval = 30.seconds # default      
+    w.start = "mongrel_rails start -c #{RAILS_ROOT} -p #{port} \
+      -P #{RAILS_ROOT}/log/mongrel.#{port}.pid  -d"
+    w.stop = "mongrel_rails stop -P #{RAILS_ROOT}/log/mongrel.#{port}.pid"
+    w.restart = "mongrel_rails restart -P #{RAILS_ROOT}/log/mongrel.#{port}.pid"
+    w.start_grace = 10.seconds
+    w.restart_grace = 10.seconds
+    w.pid_file = File.join(RAILS_ROOT, "log/mongrel.#{port}.pid")
+    
+    w.behavior(:clean_pid_file)
+
+    w.start_if do |start|
+      start.condition(:process_running) do |c|
+        c.interval = 5.seconds
+        c.running = false
+      end
+    end
+    
+    w.restart_if do |restart|
+      restart.condition(:memory_usage) do |c|
+        c.above = 150.megabytes
+        c.times = [3, 5] # 3 out of 5 intervals
+      end
+    
+      restart.condition(:cpu_usage) do |c|
+        c.above = 50.percent
+        c.times = 5
+      end
+    end
+    
+    # lifecycle
+    w.lifecycle do |on|
+      on.condition(:flapping) do |c|
+        c.to_state = [:start, :restart]
+        c.times = 5
+        c.within = 5.minute
+        c.transition = :unmonitored
+        c.retry_in = 10.minutes
+        c.retry_times = 5
+        c.retry_within = 2.hours
+      end
+    end
+  end
+end

data/examples/single.god

@@ -0,0 +1,66 @@
+RAILS_ROOT = "/Users/tom/dev/gravatar2"
+
+God.watch do |w|
+  w.name = "local-3000"
+  w.interval = 5.seconds # default
+  w.start = "mongrel_rails start -c #{RAILS_ROOT} -P #{RAILS_ROOT}/log/mongrel.pid -p 3000 -d"
+  w.stop = "mongrel_rails stop -P #{RAILS_ROOT}/log/mongrel.pid"
+  w.restart = "mongrel_rails restart -P #{RAILS_ROOT}/log/mongrel.pid"
+  w.pid_file = File.join(RAILS_ROOT, "log/mongrel.pid")
+  
+  # clean pid files before start if necessary
+  w.behavior(:clean_pid_file)
+  
+  # determine the state on startup
+  w.transition(:init, { true => :up, false => :start }) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+  end
+  
+  # determine when process has finished starting
+  w.transition([:start, :restart], :up) do |on|
+    on.condition(:process_running) do |c|
+      c.running = true
+    end
+    
+    # failsafe
+    on.condition(:tries) do |c|
+      c.times = 5
+      c.transition = :start
+    end
+  end
+
+  # start if process is not running
+  w.transition(:up, :start) do |on|
+    on.condition(:process_exits)
+  end
+  
+  # restart if memory or cpu is too high
+  w.transition(:up, :restart) do |on|
+    on.condition(:memory_usage) do |c|
+      c.interval = 20
+      c.above = 50.megabytes
+      c.times = [3, 5]
+    end
+    
+    on.condition(:cpu_usage) do |c|
+      c.interval = 10
+      c.above = 10.percent
+      c.times = [3, 5]
+    end
+  end
+  
+  # lifecycle
+  w.lifecycle do |on|
+    on.condition(:flapping) do |c|
+      c.to_state = [:start, :restart]
+      c.times = 5
+      c.within = 5.minute
+      c.transition = :unmonitored
+      c.retry_in = 10.minutes
+      c.retry_times = 5
+      c.retry_within = 2.hours
+    end
+  end
+end

data/ext/god/extconf.rb

@@ -0,0 +1,55 @@
+require 'mkmf'
+
+fail = false
+
+def create_dummy_makefile
+  File.open("Makefile", 'w') do |f|
+    f.puts "all:"
+    f.puts "install:"
+  end
+end
+
+case RUBY_PLATFORM
+when /bsd/i, /darwin/i
+  unless have_header('sys/event.h')
+    puts
+    puts "Missing 'sys/event.h' header"
+    fail = true
+  end
+  
+  if fail
+    puts
+    puts "Events handler could not be compiled (see above error). Your god installation will not support event conditions."
+    create_dummy_makefile
+  else
+    create_makefile 'kqueue_handler_ext'
+  end
+when /linux/i
+  unless have_header('linux/netlink.h')
+    puts
+    puts "Missing 'linux/netlink.h' header(s)"
+    puts "You may need to install a header package for your system"
+    fail = true
+  end
+  
+  unless have_header('linux/connector.h') && have_header('linux/cn_proc.h')
+    puts
+    puts "Missing 'linux/connector.h', or 'linux/cn_proc.h' header(s)"
+    puts "These are only available in Linux kernel 2.6.15 and later (run `uname -a` to find yours)"
+    puts "You may need to install a header package for your system"
+    fail = true
+  end
+  
+  if fail
+    puts
+    puts "Events handler could not be compiled (see above error). Your god installation will not support event conditions."
+    create_dummy_makefile
+  else
+    create_makefile 'netlink_handler_ext'
+  end
+else
+  puts
+  puts "Unsupported platform '#{RUBY_PLATFORM}'. Supported platforms are BSD, DARWIN, and LINUX."
+  puts "Your god installation will not support event conditions."
+  create_dummy_makefile
+end

data/ext/god/kqueue_handler.c

@@ -0,0 +1,123 @@
+#if defined(__FreeBSD__) || defined(__APPLE__)
+
+#include <ruby.h>
+#include <sys/event.h>
+#include <sys/time.h>
+#include <errno.h>
+
+static VALUE mGod;
+static VALUE cKQueueHandler;
+static VALUE cEventHandler;
+
+static ID proc_exit;
+static ID proc_fork;
+static ID m_call;
+static ID m_size;
+static ID m_deregister;
+
+static int kq;
+int num_events;
+
+#define NUM_EVENTS FIX2INT(rb_funcall(rb_cv_get(cEventHandler, "@@actions"), m_size, 0))
+
+VALUE
+kqh_event_mask(VALUE klass, VALUE sym)
+{
+  ID id = SYM2ID(sym);
+  if (proc_exit == id) {
+    return UINT2NUM(NOTE_EXIT);
+  } else if (proc_fork == id) {
+    return UINT2NUM(NOTE_FORK);
+  } else {
+    rb_raise(rb_eNotImpError, "Event `%s` not implemented", rb_id2name(id));
+  }
+  
+  return Qnil;
+}
+
+  
+VALUE
+kqh_monitor_process(VALUE klass, VALUE pid, VALUE mask)
+{
+  struct kevent new_event;
+  ID event;
+  
+  u_int fflags = NUM2UINT(mask);
+  
+  EV_SET(&new_event, FIX2UINT(pid), EVFILT_PROC,
+         EV_ADD | EV_ENABLE, fflags, 0, 0);
+  
+  if (-1 == kevent(kq, &new_event, 1, NULL, 0, NULL)) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  }
+  
+  num_events = NUM_EVENTS;
+  
+  return Qnil;
+}
+
+VALUE
+kqh_handle_events()
+{
+  int nevents, i, num_to_fetch;
+  struct kevent *events;
+  fd_set read_set;
+  
+  FD_ZERO(&read_set);
+  FD_SET(kq, &read_set);
+  
+  // Don't actually run this method until we've got an event
+  rb_thread_select(kq + 1, &read_set, NULL, NULL, NULL);  
+  
+  // Grabbing num_events once for thread safety
+  num_to_fetch = num_events;
+  events = (struct kevent*)malloc(num_to_fetch * sizeof(struct kevent));
+  
+  if (NULL == events) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  }
+  
+  nevents = kevent(kq, NULL, 0, events, num_to_fetch, NULL);
+  
+  if (-1 == nevents) {
+    free(events);
+    rb_raise(rb_eStandardError, strerror(errno));
+  } else {
+    for (i = 0; i < nevents; i++) {
+      if (events[i].fflags & NOTE_EXIT) {
+        rb_funcall(cEventHandler, m_call, 2, INT2NUM(events[i].ident), ID2SYM(proc_exit));
+      } else if (events[i].fflags & NOTE_FORK) {
+        rb_funcall(cEventHandler, m_call, 2, INT2NUM(events[i].ident), ID2SYM(proc_fork));
+      }
+    }
+  }
+  
+  free(events);
+
+  return INT2FIX(nevents);
+}
+
+void
+Init_kqueue_handler_ext()
+{
+  kq = kqueue();
+  
+  if (kq == -1) {
+    rb_raise(rb_eStandardError, "kqueue initilization failed");
+  }
+  
+  proc_exit = rb_intern("proc_exit");
+  proc_fork = rb_intern("proc_fork");
+  m_call = rb_intern("call");
+  m_size = rb_intern("size");
+  m_deregister = rb_intern("deregister");
+  
+  mGod = rb_const_get(rb_cObject, rb_intern("God"));
+  cEventHandler = rb_const_get(mGod, rb_intern("EventHandler"));
+  cKQueueHandler = rb_define_class_under(mGod, "KQueueHandler", rb_cObject);
+  rb_define_singleton_method(cKQueueHandler, "monitor_process", kqh_monitor_process, 2);
+  rb_define_singleton_method(cKQueueHandler, "handle_events", kqh_handle_events, 0);
+  rb_define_singleton_method(cKQueueHandler, "event_mask", kqh_event_mask, 1);
+}
+
+#endif