resurrected_god 0.14.0

data/doc/intro.asciidoc

@@ -0,0 +1,20 @@
+God: The Ruby Framework for Process Management
+==============================================
+Tom Preston-Werner <tom@mojombo.com>
+
+God is an easy to configure, easy to extend monitoring framework written in
+Ruby.
+
+Keeping your server processes and tasks running should be a simple part of
+your deployment process. God aims to be the simplest, most powerful monitoring
+application available.
+
+Features
+--------
+
+* Config file is written in Ruby
+* Easily write your own custom conditions in Ruby
+* Supports both poll and event based conditions
+* Different poll conditions can have different intervals
+* Integrated notification system (write your own too!)
+* Easily control non-daemonizing scripts

data/ext/god/.gitignore

@@ -0,0 +1,5 @@
+Makefile
+kqueue_handler_ext.bundle
+kqueue_handler.o
+netlink_handler_ext.bundle
+netlink_handler.o

data/ext/god/extconf.rb

@@ -0,0 +1,56 @@
+require 'mkmf'
+
+fail = false
+
+def create_dummy_makefile
+  File.open("Makefile", 'w') do |f|
+    f.puts "all:"
+    f.puts "install:"
+  end
+end
+
+have_func('rb_wait_for_single_fd')
+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,133 @@
+#if defined(__FreeBSD__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__)
+
+#include <ruby.h>
+#include <sys/event.h>
+#include <sys/time.h>
+#include <errno.h>
+
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+  #include <ruby/io.h>
+#endif
+
+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;
+
+  (void)event;      //!< Silence warning about unused var, should be removed?
+
+  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, "%s", strerror(errno));
+  }
+
+  num_events = NUM_EVENTS;
+
+  return Qnil;
+}
+
+VALUE
+kqh_handle_events()
+{
+  int nevents, i, num_to_fetch;
+  struct kevent *events;
+
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+  rb_wait_for_single_fd(kq, RB_WAITFD_IN, NULL);
+#else
+  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);
+#endif
+  // 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, "%s", strerror(errno));
+  }
+
+  nevents = kevent(kq, NULL, 0, events, num_to_fetch, NULL);
+
+  if (-1 == nevents) {
+    free(events);
+    rb_raise(rb_eStandardError, "%s", 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 initialization 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,182 @@
+#ifdef __linux__ /* only build on linux */
+
+#include <ruby.h>
+
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+  #include <ruby/io.h>
+#endif
+
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <linux/connector.h>
+#define _LINUX_TIME_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;
+
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+  int ret;
+  if((ret = rb_wait_for_single_fd(nl_sock, RB_WAITFD_IN, NULL)) < 0){
+    rb_raise(rb_eStandardError, "%s", strerror(errno));
+  }
+  /* If there were no events detected, return */
+  if(!(ret & RB_WAITFD_IN)){
+    return INT2FIX(0);
+  }
+#else
+  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, "%s", strerror(errno));
+  }
+
+  /* If there were no events detected, return */
+  if (! FD_ISSET(nl_sock, &fds)) {
+    return INT2FIX(0);
+  }
+#endif
+
+  /* if there are events, make calls */
+  if (-1 == recv(nl_sock, buff, sizeof(buff), 0)) {
+    rb_raise(rb_eStandardError, "%s", strerror(errno));
+  }
+
+  hdr = (struct nlmsghdr *)buff;
+
+  if (NLMSG_ERROR == hdr->nlmsg_type) {
+    rb_raise(rb_eStandardError, "%s", 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, ID2SYM(rb_intern("parent_pid")), INT2FIX(event->event_data.fork.parent_pid));
+        rb_hash_aset(extra_data, ID2SYM(rb_intern("parent_thread_group_id")), INT2FIX(event->event_data.fork.parent_tgid));
+        rb_hash_aset(extra_data, ID2SYM(rb_intern("child_pid")), INT2FIX(event->event_data.fork.child_pid));
+        rb_hash_aset(extra_data, ID2SYM(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);
+
+      default:
+        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, "%s", 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, "%s", 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, "%s", 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/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

data/lib/god/behaviors/notify_when_flapping.rb

@@ -0,0 +1,51 @@
+module God
+  module Behaviors
+
+    class NotifyWhenFlapping < Behavior
+      attr_accessor :failures # number of failures
+      attr_accessor :seconds  # number of seconds
+      attr_accessor :notifier # class to notify with
+
+      def initialize
+        super
+        @startup_times = []
+      end
+
+      def valid?
+        valid = true
+        valid &= complain("Attribute 'failures' must be specified", self) unless self.failures
+        valid &= complain("Attribute 'seconds' must be specified", self) unless self.seconds
+        valid &= complain("Attribute 'notifier' must be specified", self) unless self.notifier
+
+        # Must take one arg or variable args
+        unless self.notifier.respond_to?(:notify) and [1,-1].include?(self.notifier.method(:notify).arity)
+          valid &= complain("The 'notifier' must have a method 'notify' which takes 1 or variable args", self)
+        end
+
+        valid
+      end
+
+      def before_start
+        now = Time.now.to_i
+        @startup_times << now
+        check_for_flapping(now)
+      end
+
+      def before_restart
+        now = Time.now.to_i
+        @startup_times << now
+        check_for_flapping(now)
+      end
+
+      private
+
+        def check_for_flapping(now)
+          @startup_times.select! {|time| time >= now - self.seconds }
+          if @startup_times.length >= self.failures
+            self.notifier.notify("#{self.watch.name} has called start/restart #{@startup_times.length} times in #{self.seconds} seconds")
+          end
+        end
+    end
+
+  end
+end