godhead 0.0.2 → 0.0.3

data/lib/godhead/recipes.rb

@@ -1,9 +1,13 @@
 module Godhead
   autoload :BeanstalkdRecipe,    'godhead/recipes/beanstalkd_recipe.rb'
   autoload :GenericWorkerRecipe, 'godhead/recipes/generic_worker_recipe.rb'
+  autoload :MemcachedRecipe,     'godhead/recipes/memcached_recipe.rb'
+  autoload :MongrelRecipe,       'godhead/recipes/mongrel_recipe.rb'
   autoload :NginxRecipe,         'godhead/recipes/nginx_recipe.rb'
+  autoload :NginxRunnerRecipe,   'godhead/recipes/nginx_recipe.rb'
+  autoload :StarlingRecipe,      'godhead/recipes/starling_recipe.rb'
   autoload :ThinRecipe,          'godhead/recipes/thin_recipe.rb'
   autoload :TyrantRecipe,        'godhead/recipes/tyrant_recipe.rb'
-  autoload :MemcachedRecipe,     'godhead/recipes/memcached_recipe.rb'
-  autoload :StarlingRecipe,      'godhead/recipes/starling_recipe.rb'
+  autoload :UnicornRecipe,       'godhead/recipes/unicorn_recipe.rb'
+  autoload :WorklingRecipe,      'godhead/recipes/workling_recipe.rb'
 end

data/lib/godhead/recipes/beanstalkd_recipe.rb

@@ -1,12 +1,13 @@
 module Godhead
   class BeanstalkdRecipe < GodRecipe
     DEFAULT_OPTIONS = {
-      :listen_on       => '0.0.0.0',
-      :port            => 11300,
-      :max_job_size    => '65535',
-      :max_cpu_usage   => 20.percent,
-      :max_mem_usage   => 500.megabytes,
-      :runner_path => '/usr/local/bin/beanstalkd',
+      :listen_on        => '0.0.0.0',
+      :port             => 11300,
+      :max_job_size     => '65535',
+      :default_interval => 1.minute,
+      :max_cpu_usage    => 20.percent,
+      :max_mem_usage    => 500.megabytes,
+      :runner_path      => '/usr/local/bin/beanstalkd',
     }
     def self.default_options() super.deep_merge(Godhead::BeanstalkdRecipe::DEFAULT_OPTIONS) ; end
 
@@ -19,6 +20,12 @@ module Godhead
         "-z #{options[:max_job_size]}",
       ].flatten.compact.join(" ")
     end
+
+    # don't try to invent a pid_file -- by default god will find and make one
+    # and will handle task killing/restarting/etc.
+    def pid_file()
+      nil
+    end
   end
 end
 

data/lib/godhead/recipes/delayed_job_recipe.rb

@@ -0,0 +1,126 @@
+
+# FIXME -- turn this into a godhead recipe
+
+# ===========================================================================
+#
+# From http://github.com/blog/229-dj-god
+#
+
+# rails_root = "/data/github/current"
+# 20.times do |num|
+#   God.watch do |w|
+#     w.name = "dj-#{num}"
+#     w.group = 'dj'
+#     w.interval = 30.seconds
+#     w.start = "rake -f #{rails_root}/Rakefile production jobs:work"
+#
+#     w.uid = 'git'
+#     w.gid = 'git'
+#
+#     # retart if memory gets too high
+#     w.transition(:up, :restart) do |on|
+#       on.condition(:memory_usage) do |c|
+#         c.above = 300.megabytes
+#         c.times = 2
+#       end
+#     end
+#
+#     # 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
+#         c.interval = 5.seconds
+#       end
+#
+#       # failsafe
+#       on.condition(:tries) do |c|
+#         c.times = 5
+#         c.transition = :start
+#         c.interval = 5.seconds
+#       end
+#     end
+#
+#     # start if process is not running
+#     w.transition(:up, :start) do |on|
+#       on.condition(:process_running) do |c|
+#         c.running = false
+#       end
+#     end
+#   end
+# end
+
+# ===========================================================================
+#
+# from http://livollmers.net/index.php/2008/11/05/asynchronous-mail-with-delayedjob-god-daemons/
+#
+
+# God.watch do |w|
+#      w.name = "delayed_job_worker"
+#      w.interval = 10.seconds
+#      w.start = "#{RAILS_ROOT}/script/delayed_job_worker_control start -- production"
+#      w.stop = "#{RAILS_ROOT}/script/delayed_job_worker_control stop"
+#      w.restart = "#{RAILS_ROOT}/script/delayed_job_worker_control restart"
+#      w.start_grace = 10.seconds
+#      w.restart_grace = 10.seconds
+#      w.pid_file = "#{RAILS_ROOT}/tmp/pids/delayed_job_worker.pid"
+#
+#      w.uid = "deploy"
+#      w.gid = "root"
+#      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
+#
+#      w.restart_if do |restart|
+#        restart.condition(:memory_usage) do |c|
+#          c.above = 100.megabytes
+#          c.times = [3, 5]
+#        end
+#
+#        restart.condition(:cpu_usage) do |c|
+#          c.above = 50.percent
+#          c.times = 5
+#        end
+#      end
+#
+#      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/lib/godhead/recipes/generic_worker_recipe.rb

@@ -1,6 +1,6 @@
 module Godhead
   #
-  # Starling monitoring recipe
+  # Generic worker process monitoring recipe
   #
   class GenericWorkerRecipe < GodRecipe
     DEFAULT_OPTIONS = {
@@ -14,6 +14,7 @@ module Godhead
 
     def initialize _options={}
       super _options
+      p [options, handle, process_log_file]
       raise "need a runner path" unless options[:runner_path]
     end
 
@@ -23,16 +24,24 @@ module Godhead
     end
 
     # don't try to invent a pid_file -- by default god will find and make one
-    def pid_file
-      options[:pid_file]
+    # and will handle task killing/restarting/etc.
+    def pid_file()
+      nil
+    end
+
+    def setup_watcher watcher
+      super
+      watcher.log = process_log_file
     end
 
     def start_command
-      [
+      cmd = [
         "sudo",
         (options[:user] ? "-u #{options[:user]}" : nil),
-        options[:runner_path]
+        options[:runner_path],
       ].flatten.compact.join(" ")
+      p ['worker command', cmd]
+      cmd
     end
 
   end

data/lib/godhead/recipes/memcached_recipe.rb

@@ -1,6 +1,6 @@
 module Godhead
   #
-  # Nginx monitoring recipe
+  # Memcached monitoring recipe
   #
   class MemcachedRecipe < GodRecipe
     DEFAULT_OPTIONS = {

data/lib/godhead/recipes/mongrel_recipe.rb

@@ -0,0 +1,29 @@
+module Godhead
+  class MongrelRecipe < GodRecipe
+    DEFAULT_OPTIONS = {
+      :default_interval => 30.seconds,
+      :max_cpu_usage    => 50.percent,
+      :max_mem_usage    => 150.megabytes,
+      :port             => 5000,
+      :runner_path      => 'mongrel_rails', # path to mongrel_rails. Override this in the site config file.
+      :runner_conf      => nil,
+      :pid_file         => nil,
+    }
+    def self.default_options() super.deep_merge(DEFAULT_OPTIONS) ; end
+
+    # Call the thin runner script
+    def tell_runner action
+      [
+        options[:runner_path],
+        action,
+        "--config=#{options[:runner_conf]}",
+        "--port=#{  options[:port]}",
+        "--pid=#{pid_file}",
+        (action == 'stop' ? nil : '-d'),
+      ].flatten.compact.join(" ")
+    end
+    def start_command()   tell_runner :start   end
+    def restart_command() tell_runner :restart end
+    def stop_command()    tell_runner :stop    end
+  end
+end

data/lib/godhead/recipes/mysql_recipe.rb

@@ -0,0 +1,20 @@
+module Godhead
+  #
+  # Mysql monitoring recipe
+  #
+  # Pretty standard, but speed up the flapping window -- starts and restarts
+  # should be fast, and we don't want the server down for long.
+  class MysqlRecipe < GodRecipe
+    DEFAULT_OPTIONS = {
+      :flapping_window   => 2.minutes,
+      :flapping_retry_in => 30.minutes,      
+      :max_cpu_usage     => nil,
+      :max_mem_usage     => nil,
+      :pid_file          => "/var/run/mysqld/mysqld.pid",
+      :port              => 80,
+    }
+    def self.default_options() super.deep_merge(DEFAULT_OPTIONS) ; end
+    # uses 'service mysql start' and so forth for task management
+    include Godhead::RunsAsService
+  end
+end

data/lib/godhead/recipes/nginx_recipe.rb

@@ -2,21 +2,37 @@ module Godhead
   #
   # Nginx monitoring recipe
   #
+  # This defines standard options for nginx, and leaves it to subclasses to
+  # define the start_command and conf path and so forth.
+  #
+  # The nginx monitor not only watches the PID but also checks for a correct
+  # http_response_code
   class GenericNginxRecipe < GodRecipe
     DEFAULT_OPTIONS = {
-      :max_cpu_usage   => 20.percent,
-      :max_mem_usage   => 500.megabytes,
+      :max_cpu_usage   => nil,
+      :max_mem_usage   => nil,
       :pid_file        => "/var/run/nginx/nginx.pid",
+      :port            => 80,
     }
     def self.default_options() super.deep_merge(DEFAULT_OPTIONS) ; end
 
-    def self.recipe_name
-      'nginx'
+    # restart if can't contact server
+    def setup_restart watcher
+      super watcher
+      watcher.restart_if do |restart|
+        restart.condition(:http_response_code) do |c|
+          c.host        = 'localhost'
+          c.port        = options[:port]
+          c.path        = '/'
+          c.timeout     = 3.seconds
+          c.times       = [4, 5] # 4 out of 5 times failure
+          c.code_is_not = 200
+        end
+      end
     end
 
-    def mkdirs!
-      FileUtils.mkdir_p File.dirname(options[:pid_file])
-      super
+    def self.recipe_name
+      'nginx'
     end
   end
 
@@ -67,3 +83,4 @@ end
 #   -p prefix     : set prefix path (default: /usr/local/nginx/)
 #   -c filename   : set configuration file (default: /slice/etc/nginx/nginx.conf)
 #   -g directives : set global directives out of configuration file
+

data/lib/godhead/recipes/resque_recipe.rb

@@ -0,0 +1,63 @@
+# module Godhead
+#   #
+#   # Resque monitoring recipe
+#   #
+#   # inspired by http://railscasts.com/episodes/130-monitoring-with-god
+#   class ResqueRecipe < GodRecipe
+#     DEFAULT_OPTIONS = {
+#       :max_cpu_usage   => 30.percent,
+#       :max_mem_usage   => 100.megabytes,
+#       #
+#       :port            => 22122,
+#       :runner_dir      => ENV['RAILS_ROOT'],
+#       :runner_env      => ENV['RAILS_ENV'],
+#       # uid => nil,
+#       # gid => nil,
+#     }
+#     def self.default_options() super.deep_merge(DEFAULT_OPTIONS) ; end
+# 
+#     def start_command
+#       "env QUEUE=critical,high,low /usr/bin/rake -f #{options[:runner_dir]}/Rakefile #{options[:runner_env]} resque:work"
+#     end
+#   end
+# end
+
+
+#     # restart if memory gets too high
+#     w.transition(:up, :restart) do |on|
+#       on.condition(:memory_usage) do |c|
+#         c.above = 350.megabytes
+#         c.times = 2
+#       end
+#     end
+#  
+#     # 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
+#         c.interval = 5.seconds
+#       end
+#  
+#       # failsafe
+#       on.condition(:tries) do |c|
+#         c.times = 5
+#         c.transition = :start
+#         c.interval = 5.seconds
+#       end
+#     end
+#  
+#     # start if process is not running
+#     w.transition(:up, :start) do |on|
+#       on.condition(:process_running) do |c|
+#         c.running = false
+#       end
+#     end
+#   end
+# end

data/lib/godhead/recipes/starling_recipe.rb

@@ -2,10 +2,11 @@ module Godhead
   #
   # Starling monitoring recipe
   #
+  # inspired by http://railscasts.com/episodes/130-monitoring-with-god
   class StarlingRecipe < GodRecipe
     DEFAULT_OPTIONS = {
-      :max_cpu_usage   => 20.percent,
-      :max_mem_usage   => 50.megabytes,
+      :max_cpu_usage   => 30.percent,
+      :max_mem_usage   => 20.megabytes,
       #
       :port            => 22122,
     }

data/lib/godhead/recipes/thin_recipe.rb

@@ -1,36 +1,29 @@
 module Godhead
   class ThinRecipe < GodRecipe
     DEFAULT_OPTIONS = {
-      :port            => 3000,
-      :runner_path     => '/usr/bin/thin',        # path to thin. Override this in the site config file.
-      :runner_conf     => nil,
-      :pid_file        => nil,
+      :default_interval => 180.seconds,
+      :port             => 3000,
+      :thin_port_offset => 3000,
+      :runner_path      => '/usr/bin/thin',        # path to thin. Override this in the site config file.
+      :runner_conf      => nil,
+      :pid_file         => nil,
     }
     def self.default_options() super.deep_merge(DEFAULT_OPTIONS) ; end
 
-    #     w.start         = "thin -s 3 -C #{YUPFRONT_CONFIG}  start"
-    def tell_thin action
+    # Call the thin runner script
+    def tell_runner action
       [
         options[:runner_path],
         "--config=#{options[:runner_conf]}",
         "--rackup=#{options[:rackup_file]}",
         "--port=#{  options[:port]}",
         "--pid=#{pid_file}",
+        # "--only=#{options[:port].to_i - options[:thin_port_offset].to_i}",
         action
       ].flatten.compact.join(" ")
     end
-
-    def start_command
-      tell_thin :start
-    end
-
-    def restart_command
-      tell_thin :restart
-    end
-
-    def stop_command
-      tell_thin :stop
-    end
+    def start_command()   tell_runner :start   end
+    def restart_command() tell_runner :restart end
+    def stop_command()    tell_runner :stop    end
   end
-
 end