god 0.1.0 → 0.2.0

data/History.txt

@@ -1,4 +1,12 @@
-== 1.0.0 / 2007-06-11
+== 0.2.0
+
+* Rewrote innards to use a state and event based lifecycle
+* Basic support for events via kqueue (bsd/darwin) and netlink/pec (linux) [kevinclark]
+* Added advanced syntax (simple syntax calls advanced api underneath)
+* Condition returns have changed meaning. With simple syntax, a true return activates block
+* Updated http://god.rubygorge.org with updated simple config and new advanced config
+
+== 0.1.0 / 2007-07-07
 
 * 1 major enhancement
   * Birthday!

data/Manifest.txt

@@ -5,6 +5,10 @@ Rakefile
 bin/god
 examples/gravatar.god
 examples/local.god
+ext/god/Makefile
+ext/god/extconf.rb
+ext/god/kqueue_handler.c
+ext/god/netlink_handler.c
 lib/god.rb
 lib/god/base.rb
 lib/god/behavior.rb
@@ -13,22 +17,30 @@ lib/god/condition.rb
 lib/god/conditions/always.rb
 lib/god/conditions/cpu_usage.rb
 lib/god/conditions/memory_usage.rb
-lib/god/conditions/process_not_running.rb
+lib/god/conditions/process_exits.rb
+lib/god/conditions/process_running.rb
 lib/god/conditions/timeline.rb
 lib/god/errors.rb
+lib/god/event_handler.rb
+lib/god/event_handlers/kqueue_handler.rb
+lib/god/event_handlers/netlink_handler.rb
+lib/god/hub.rb
 lib/god/meddle.rb
+lib/god/metric.rb
 lib/god/reporter.rb
 lib/god/server.rb
 lib/god/system/process.rb
 lib/god/timer.rb
 lib/god/watch.rb
 test/configs/real.rb
+test/configs/test.rb
 test/helper.rb
 test/suite.rb
 test/test_behavior.rb
 test/test_condition.rb
 test/test_god.rb
 test/test_meddle.rb
+test/test_metric.rb
 test/test_reporter.rb
 test/test_server.rb
 test/test_system_process.rb

data/README.txt

@@ -1,5 +1,7 @@
 god
     by Tom Preston-Werner
+       Kevin Clark (kqueue/netlink support)
+       
     http://god.rubyforge.org
 
 == DESCRIPTION:

data/Rakefile

@@ -2,9 +2,8 @@
 
 require 'rubygems'
 require 'hoe'
-require './lib/god.rb'
 
-Hoe.new('god', God::VERSION) do |p|
+Hoe.new('god', '0.2.0') do |p|
   p.rubyforge_name = 'god'
   p.author = 'Tom Preston-Werner'
   p.email = 'tom@rubyisawesome.com'
@@ -13,6 +12,7 @@ Hoe.new('god', God::VERSION) do |p|
   p.description = "God is an easy to configure, easy to extend monitoring framework written in Ruby."
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
   p.extra_deps << ['daemons', '>=1.0.7']
+  p.spec_extras = {:extensions => ['ext/god/extconf.rb']}
 end
 
 desc "Open an irb session preloaded with this library"

data/examples/gravatar.god

@@ -1,3 +1,5 @@
+# run with:  god start -c /path/to/gravatar.god
+# 
 # This is the actual config file used to keep the mongrels of
 # gravatar.com running.
 
@@ -8,8 +10,11 @@ God.meddle do |god|
     god.watch do |w|
       w.name = "gravatar2-mongrel-#{port}"
       w.interval = 30 # seconds
-      w.start = "mongrel_rails cluster::start --only #{port} -c #{RAILS_ROOT}"
-      w.stop = "mongrel_rails cluster::stop --only #{port} -c #{RAILS_ROOT}"
+      w.start = "mongrel_rails cluster::start --only #{port} \
+        -C #{RAILS_ROOT}/config/mongrel_cluster.yml"
+      w.stop = "mongrel_rails cluster::stop --only #{port} \
+        -C #{RAILS_ROOT}/config/mongrel_cluster.yml"
+      w.grace = 10 # seconds
       
       pid_file = File.join(RAILS_ROOT, "log/mongrel.#{port}.pid")
       
@@ -19,6 +24,7 @@ God.meddle do |god|
 
       w.start_if do |start|
         start.condition(:process_not_running) do |c|
+          c.interval = 5 # seconds
           c.pid_file = pid_file
         end
       end

data/examples/local.god

@@ -2,15 +2,14 @@
 # and running on your Mac.
 
 # Run with:
-# god local.god
+# god start -c /path/to/local.god
 
 RAILS_ROOT = "/Users/tom/dev/powerset/querytopia"
 
 God.meddle do |god|
-  god.interval = 5 # seconds
-  
   god.watch do |w|
     w.name = "local-3000"
+    w.interval = 5 # seconds
     w.start = "mongrel_rails start -P ./log/mongrel.pid -c #{RAILS_ROOT} -d"
     w.stop = "mongrel_rails stop -P ./log/mongrel.pid -c #{RAILS_ROOT}"
     w.grace = 5
@@ -24,7 +23,7 @@ God.meddle do |god|
   
     # start if process is not running
     w.start_if do |start|
-      start.condition(:process_not_running) do |c|
+      start.condition(:process_exits) do |c|
         c.pid_file = pid_file
       end
     end
@@ -48,6 +47,7 @@ God.meddle do |god|
   # clear old session files
   god.watch do |w|    
     w.name = "local-session-cleanup"
+    w.interval = 60 # seconds
     w.cwd = File.join(RAILS_ROOT, 'tmp/sessions')
     w.start = lambda do
       Dir['ruby_sess.*'].select { |f| File.mtime(f) < Time.now - (7 * 24 * 60 * 60) }.each { |f| File.delete(f) }

data/ext/god/Makefile

@@ -0,0 +1,149 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /usr/local/lib/ruby/1.8/i686-darwin8.9.1
+hdrdir = $(topdir)
+VPATH = $(srcdir):$(topdir):$(hdrdir)
+prefix = $(DESTDIR)/usr/local
+exec_prefix = $(prefix)
+sitedir = $(DESTDIR)/p/libdata/ruby
+rubylibdir = $(libdir)/ruby/$(ruby_version)
+docdir = $(datarootdir)/doc/$(PACKAGE)
+dvidir = $(docdir)
+datarootdir = $(prefix)/share
+archdir = $(rubylibdir)/$(arch)
+sbindir = $(exec_prefix)/sbin
+psdir = $(docdir)
+localedir = $(datarootdir)/locale
+htmldir = $(docdir)
+datadir = $(datarootdir)
+includedir = $(prefix)/include
+infodir = $(datarootdir)/info
+sysconfdir = $(prefix)/etc
+mandir = $(datarootdir)/man
+libdir = $(exec_prefix)/lib
+sharedstatedir = $(prefix)/com
+oldincludedir = $(DESTDIR)/usr/include
+pdfdir = $(docdir)
+sitearchdir = $(sitelibdir)/$(sitearch)
+bindir = $(exec_prefix)/bin
+localstatedir = $(prefix)/var
+sitelibdir = $(sitedir)/$(ruby_version)
+libexecdir = $(exec_prefix)/libexec
+
+CC = gcc
+LIBRUBY = $(LIBRUBY_A)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = 
+LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static
+
+RUBY_EXTCONF_H = 
+CFLAGS   =  -fno-common -g -O2 -pipe -fno-common 
+INCFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir)
+CPPFLAGS =  
+CXXFLAGS = $(CFLAGS) 
+DLDFLAGS =   
+LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby
+arch = i686-darwin8.9.1
+sitearch = i686-darwin8.9.1
+ruby_version = 1.8
+ruby = /usr/local/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = $(libdir)
+LIBPATH =  -L"$(libdir)"
+DEFFILE = 
+
+CLEANFILES = 
+DISTCLEANFILES = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS =   -lpthread -ldl -lobjc  
+SRCS = kqueue_handler.c netlink_handler.c
+OBJS = kqueue_handler.o netlink_handler.o
+TARGET = kqueue_handler_ext
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle $(TARGET).il? $(TARGET).tds $(TARGET).map
+CLEANOBJS     = *.o *.a *.s[ol] *.pdb *.exp *.bak
+
+all:		$(DLLIB)
+static:		$(STATIC_LIB)
+
+clean:
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean:	clean
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+
+realclean:	distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $<
+
+$(DLLIB): $(OBJS)
+	@-$(RM) $@
+	$(LDSHARED) $(DLDFLAGS) $(LIBPATH) -o $@ $(OBJS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): ruby.h defines.h

data/ext/god/extconf.rb

@@ -0,0 +1,8 @@
+require 'mkmf'
+
+case RUBY_PLATFORM
+when /bsd/i, /darwin/i
+  create_makefile 'kqueue_handler_ext'
+when /linux/i
+  create_makefile 'netlink_handler_ext'
+end

data/ext/god/kqueue_handler.c

@@ -0,0 +1,122 @@
+#if defined(__FreeBSD__) || defined(__APPLE__)
+
+#include <ruby.h>
+#include <sys/event.h>
+#include <sys/time.h>
+#include <errno.h>
+
+static VALUE cKQueueHandler;
+static VALUE cEventHandler;
+static VALUE mGod;
+
+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) {
+    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,140 @@
+#ifdef __linux__ /* only build on linux */
+
+#include <ruby.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <linux/connector.h>
+#include <linux/cn_proc.h>
+#include <errno.h>
+
+static VALUE cNetlinkHandler;
+static VALUE cEventHandler;
+static VALUE mGod;
+
+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;
+  
+  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);
+        }
+      
+        rb_funcall(cEventHandler, m_call, 2, INT2FIX(event->event_data.exit.process_pid), ID2SYM(proc_exit));
+        return INT2FIX(1);
+      
+      /* TODO: On fork, call and pass pid of child */
+      case PROC_EVENT_FORK:
+        if (Qnil == rb_funcall(cEventHandler, m_watching_pid, 1, INT2FIX(event->event_data.fork.parent_pid))) {
+          return INT2FIX(0);
+        }
+      
+        rb_funcall(cEventHandler, m_call, 2, INT2FIX(event->event_data.fork.parent_pid), ID2SYM(proc_fork));
+        return INT2FIX(1);
+    }
+  }
+  
+  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);
+  
+  bzero(&sa_nl, sizeof(sa_nl));
+  sa_nl.nl_family = AF_NETLINK;
+  sa_nl.nl_groups = CN_IDX_PROC;
+  sa_nl.nl_pid    = getpid();
+  
+  bind(nl_sock, (struct sockaddr *)&sa_nl, sizeof(sa_nl));
+  
+  /* 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->len = sizeof(int);
+  msg->data[0] = 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