strobemonkey-god 0.7.13

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

data/ext/god/netlink_handler.c

@@ -0,0 +1,167 @@
+#ifdef __linux__ /* only build on linux */
+
+#include <ruby.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <linux/connector.h>
+#include <linux/cn_proc.h>
+#include <errno.h>
+
+static VALUE mGod;
+static VALUE cNetlinkHandler;
+static VALUE cEventHandler;
+
+static ID proc_exit;
+static ID proc_fork;
+static ID m_call;
+static ID m_watching_pid;
+
+static int nl_sock;   /* socket for netlink connection  */
+
+
+VALUE
+nlh_handle_events()
+{
+  char buff[CONNECTOR_MAX_MSG_SIZE];
+  struct nlmsghdr *hdr;
+  struct proc_event *event;
+  
+  VALUE extra_data;
+  
+  fd_set fds;
+  
+  FD_ZERO(&fds);
+  FD_SET(nl_sock, &fds);
+    
+  if (0 > rb_thread_select(nl_sock + 1, &fds, NULL, NULL, NULL)) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  }
+  
+  /* If there were no events detected, return */
+  if (! FD_ISSET(nl_sock, &fds)) {
+    return INT2FIX(0);
+  }
+  
+  /* if there are events, make calls */  
+  if (-1 == recv(nl_sock, buff, sizeof(buff), 0)) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  }
+  
+  hdr = (struct nlmsghdr *)buff;
+  
+  if (NLMSG_ERROR == hdr->nlmsg_type) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  } else if (NLMSG_DONE == hdr->nlmsg_type) {    
+    
+    event = (struct proc_event *)((struct cn_msg *)NLMSG_DATA(hdr))->data;
+    
+    switch(event->what) {
+      case PROC_EVENT_EXIT:
+        if (Qnil == rb_funcall(cEventHandler, m_watching_pid, 1, INT2FIX(event->event_data.exit.process_pid))) {
+          return INT2FIX(0);
+        }
+      
+        extra_data = rb_hash_new();
+        rb_hash_aset(extra_data, ID2SYM(rb_intern("pid")), INT2FIX(event->event_data.exit.process_pid));
+        rb_hash_aset(extra_data, ID2SYM(rb_intern("exit_code")), INT2FIX(event->event_data.exit.exit_code));
+        rb_hash_aset(extra_data, ID2SYM(rb_intern("exit_signal")), INT2FIX(event->event_data.exit.exit_signal));
+        rb_hash_aset(extra_data, ID2SYM(rb_intern("thread_group_id")), INT2FIX(event->event_data.exit.process_tgid));
+
+        rb_funcall(cEventHandler, m_call, 3, INT2FIX(event->event_data.exit.process_pid), ID2SYM(proc_exit), extra_data);
+        return INT2FIX(1);
+      
+      case PROC_EVENT_FORK:
+        if (Qnil == rb_funcall(cEventHandler, m_watching_pid, 1, INT2FIX(event->event_data.fork.parent_pid))) {
+          return INT2FIX(0);
+        }
+        
+        extra_data = rb_hash_new();
+        rb_hash_aset(extra_data, rb_intern("parent_pid"), INT2FIX(event->event_data.fork.parent_pid));
+        rb_hash_aset(extra_data, rb_intern("parent_thread_group_id"), INT2FIX(event->event_data.fork.parent_tgid));
+        rb_hash_aset(extra_data, rb_intern("child_pid"), INT2FIX(event->event_data.fork.child_pid));
+        rb_hash_aset(extra_data, rb_intern("child_thread_group_id"), INT2FIX(event->event_data.fork.child_tgid));
+      
+        rb_funcall(cEventHandler, m_call, 3, INT2FIX(event->event_data.fork.parent_pid), ID2SYM(proc_fork), extra_data);
+        return INT2FIX(1);
+
+      case PROC_EVENT_NONE:
+      case PROC_EVENT_EXEC:
+      case PROC_EVENT_UID:
+      case PROC_EVENT_GID:
+        break;
+    }
+  }
+  
+  return Qnil;
+}
+
+
+#define NL_MESSAGE_SIZE (sizeof(struct nlmsghdr) + sizeof(struct cn_msg) + \
+                         sizeof(int))
+
+void
+connect_to_netlink()
+{
+  struct sockaddr_nl sa_nl; /* netlink interface info */
+  char buff[NL_MESSAGE_SIZE];
+  struct nlmsghdr *hdr; /* for telling netlink what we want */
+  struct cn_msg *msg;   /* the actual connector message */
+  
+  /* connect to netlink socket */
+  nl_sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
+  
+  if (-1 == nl_sock) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  }
+  
+  bzero(&sa_nl, sizeof(sa_nl));
+  sa_nl.nl_family = AF_NETLINK;
+  sa_nl.nl_groups = CN_IDX_PROC;
+  sa_nl.nl_pid    = getpid();
+  
+  if (-1 == bind(nl_sock, (struct sockaddr *)&sa_nl, sizeof(sa_nl))) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  }
+  
+  /* Fill header */
+  hdr = (struct nlmsghdr *)buff;
+  hdr->nlmsg_len = NL_MESSAGE_SIZE;
+  hdr->nlmsg_type = NLMSG_DONE;
+  hdr->nlmsg_flags = 0;
+  hdr->nlmsg_seq = 0;
+  hdr->nlmsg_pid = getpid();
+  
+  /* Fill message */
+  msg = (struct cn_msg *)NLMSG_DATA(hdr);
+  msg->id.idx = CN_IDX_PROC;  /* Connecting to process information */
+  msg->id.val = CN_VAL_PROC;
+  msg->seq = 0;
+  msg->ack = 0;
+  msg->flags = 0;
+  msg->len = sizeof(int);
+  *(int*)msg->data = PROC_CN_MCAST_LISTEN;
+  
+  if (-1 == send(nl_sock, hdr, hdr->nlmsg_len, 0)) {
+    rb_raise(rb_eStandardError, strerror(errno));
+  }
+}
+
+void
+Init_netlink_handler_ext()
+{ 
+  proc_exit = rb_intern("proc_exit");
+  proc_fork = rb_intern("proc_fork");
+  m_call = rb_intern("call");
+  m_watching_pid = rb_intern("watching_pid?");
+  
+  mGod = rb_const_get(rb_cObject, rb_intern("God"));
+  cEventHandler = rb_const_get(mGod, rb_intern("EventHandler"));
+  cNetlinkHandler = rb_define_class_under(mGod, "NetlinkHandler", rb_cObject);
+  rb_define_singleton_method(cNetlinkHandler, "handle_events", nlh_handle_events, 0);
+  
+  connect_to_netlink();
+}
+
+#endif

data/init/god

@@ -0,0 +1,42 @@
+#!/bin/bash
+#
+# god       Startup script for god (http://god.rubyforge.org)
+#
+# chkconfig: - 85 15
+# description: God is an easy to configure, easy to extend monitoring \
+#              framework written in Ruby.
+#              
+
+CONF_DIR=/etc/god
+
+RETVAL=0
+
+# Go no further if config directory is missing.
+[ -d "$CONF_DIR" ] || exit 0
+
+case "$1" in
+    start)
+      # Create pid directory
+      ruby /usr/bin/god -c $CONF_DIR/master.conf
+      RETVAL=$?
+  ;;
+    stop)
+      ruby /usr/bin/god terminate
+      RETVAL=$?
+  ;;
+    restart)
+      ruby /usr/bin/god terminate
+      ruby /usr/bin/god -c $CONF_DIR/master.conf
+      RETVAL=$?
+  ;;
+    status)
+      ruby /usr/bin/god status
+      RETVAL=$?
+  ;;
+    *)
+      echo "Usage: god {start|stop|restart|status}"
+      exit 1
+  ;;
+esac      
+
+exit $RETVAL

data/lib/god/behavior.rb

@@ -0,0 +1,52 @@
+module God
+  
+  class Behavior
+    include Configurable
+    
+    attr_accessor :watch
+    
+    # Generate a Behavior of the given kind. The proper class is found by camel casing the
+    # kind (which is given as an underscored symbol).
+    #   +kind+ is the underscored symbol representing the class (e.g. foo_bar for God::Behaviors::FooBar)
+    def self.generate(kind, watch)
+      sym = kind.to_s.capitalize.gsub(/_(.)/){$1.upcase}.intern
+      b = God::Behaviors.const_get(sym).new
+      b.watch = watch
+      b
+    rescue NameError
+      raise NoSuchBehaviorError.new("No Behavior found with the class name God::Behaviors::#{sym}")
+    end
+    
+    def valid?
+      true
+    end
+        
+    #######
+    
+    def before_start
+    end
+    
+    def after_start
+    end
+    
+    def before_restart
+    end
+    
+    def after_restart
+    end
+    
+    def before_stop
+    end
+    
+    def after_stop
+    end
+    
+    # Construct the friendly name of this Behavior, looks like:
+    #
+    # Behavior FooBar on Watch 'baz'
+    def friendly_name
+      "Behavior " + super + " on Watch '#{self.watch.name}'"
+    end
+  end
+  
+end

data/lib/god/behaviors/clean_pid_file.rb

@@ -0,0 +1,21 @@
+module God
+  module Behaviors
+    
+    class CleanPidFile < Behavior
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'pid_file' must be specified", self) if self.watch.pid_file.nil?
+        valid
+      end
+  
+      def before_start
+        File.delete(self.watch.pid_file)
+        
+        "deleted pid file"
+      rescue
+        "no pid file to delete"
+      end
+    end
+  
+  end
+end

data/lib/god/behaviors/clean_unix_socket.rb

@@ -0,0 +1,21 @@
+module God
+  module Behaviors
+    
+    class CleanUnixSocket < Behavior
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'unix_socket' must be specified", self) if self.watch.unix_socket.nil?
+        valid
+      end 
+      
+      def before_start 
+        File.delete(self.watch.unix_socket)
+        
+        "deleted unix socket" 
+      rescue 
+        "no unix socket to delete" 
+      end
+    end
+  
+  end
+end