bluepill 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,3 @@
+Copyright (c) 2009 arya garru
+license tbd
+

data/README.rdoc

@@ -0,0 +1,18 @@
+= little-blue-pill
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 garru. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "bluepill"
+    gem.summary = %Q{A process monitor written in Ruby with stability and minimalism in mind.}
+    gem.description = %Q{Bluepill keeps your daemons up while taking up as little resources as possible. After all you probably want the resources of your server to be used by whatever daemons you are running rather than the thing that's supposed to make sure they are brought back up, should they die or misbehave.}
+    gem.email = "entombedvirus@gmail.com"
+    gem.homepage = "http://github.com/arya/bluepill"
+    gem.authors = ["Arya Asemanfar", "Gary Tsang", "Rohith Ravi"]
+    gem.add_development_dependency "rspec"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+    gem.add_dependency("daemons", ">= 1.0.9")
+    gem.add_dependency("pluginaweek-state_machine", ">= 0.8.0")
+    gem.add_dependency("activesupport", ">= 2.0.2")
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "blue-pill #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/bluepill

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'optparse'
+require 'bluepill'
+
+# defaults
+options = {
+  :application => "all",
+  :log_file => "/var/log/bluepill.log"
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: bluepill [app] cmd [options]"
+  
+  opts.on("--logfile LOGFILE") do |file|
+    options[:log_file] = file
+  end
+  
+  opts.on("--base-dir DIR") do |base_dir|
+    options[:base_dir] = base_dir
+  end
+end.parse!
+
+ALLOWED_COMMANDS = %w(load status start stop restart log unmonitor quit)
+
+controller = Bluepill::Controller.new(options.slice(:base_dir))
+
+if controller.list.include?(ARGV.first)
+  options[:application] = ARGV.shift 
+elsif controller.list.length == 1 && ALLOWED_COMMANDS.include?(ARGV.first)
+  options[:application] = controller.list.first
+end
+
+options[:command] = ARGV.shift
+
+case options[:command]
+when "load"
+  file = ARGV.shift
+  eval(File.read(file))
+when "log"
+  pattern = ARGV.shift
+  pattern = controller.send_cmd(options[:application], :grep_pattern, pattern)
+  
+  cmd = "tail -n 100 -f #{options[:log_file]} | grep -E '#{pattern}'"
+  Kernel.exec(cmd)
+
+when *ALLOWED_COMMANDS
+  process_or_group_name = ARGV.shift
+  puts controller.send_cmd(options[:application], options[:command], process_or_group_name)
+
+else
+  "Unknown command `%s`" % options[:command]
+end

data/lib/bluepill.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+
+require 'syslog'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash'
+
+require 'bluepill/application'
+require 'bluepill/controller'
+require 'bluepill/socket'
+require "bluepill/process"
+require "bluepill/group"
+require "bluepill/logger"
+require "bluepill/condition_watch"
+require "bluepill/dsl"
+
+require "bluepill/process_conditions"
+require "bluepill/process_conditions/process_condition"
+require "bluepill/process_conditions/cpu_usage"
+require "bluepill/process_conditions/mem_usage"
+require "bluepill/process_conditions/always_true"
+
+require "bluepill/util/rotational_array"

data/lib/bluepill/application.rb

@@ -0,0 +1,213 @@
+require 'logger'
+
+module Bluepill
+  class Application
+    attr_accessor :name, :logger, :base_dir, :socket, :pid_file
+    attr_accessor :groups, :group_logger
+    
+    def initialize(name, options = {})
+      self.name = name
+      self.base_dir = options[:base_dir] ||= '/var/bluepill'
+      
+      self.logger = Bluepill::Logger.new
+      self.group_logger = Bluepill::Logger.new(self.logger, "#{self.name}:") if self.logger
+      
+      # self.groups = Hash.new { |h,k| h[k] = Group.new(k, :logger => self.group_logger) }
+      self.groups = Hash.new 
+
+      self.pid_file = File.join(self.base_dir, 'pids', self.name + ".pid")
+
+      @server = false
+      signal_trap
+    end
+        
+    def load
+      start_server
+    end
+    
+    def status
+      if(@server)
+        buffer = ""
+        if self.groups.has_key?(nil)
+          self.groups[nil].status.each do |line|
+            buffer << "%s: %s\n" % line
+          end
+          buffer << "\n"
+        end
+        self.groups.keys.compact.sort.each do |name|
+          group = self.groups[name]
+          buffer << "#{name}:\n"
+          group.status.each { |line| buffer << "  %s: %s\n" % line }
+          buffer << "\n"
+        end
+        buffer
+      else
+        send_to_server('status')
+      end
+    end
+    
+    def stop(process_or_group_name)
+      if(@server)
+        group = self.groups[process_or_group_name]
+        
+        if group
+          group.stop
+          
+        else
+          self.groups.values.each do |group|
+            group.stop(process_or_group_name)
+          end
+        end
+        "ok"
+      else
+        send_to_server("stop:#{process_or_group_name}")
+      end
+    end
+    
+    def start(process_or_group_name)
+      if(@server)
+        group = self.groups[process_or_group_name]
+        
+        if group
+          group.start
+          
+        else
+          self.groups.values.each do |group|
+            group.start(process_or_group_name)
+          end
+        end
+        "ok"
+      else
+        send_to_server("start:#{process_or_group_name}")
+      end
+    end
+
+    def restart(process_or_group_name)
+      if(@server)
+        group = self.groups[process_or_group_name]
+        
+        if group
+          group.restart
+          
+        else
+          self.groups.values.each do |group|
+            group.restart(process_or_group_name)
+          end
+        end
+        "ok"
+      else
+        send_to_server("restart:#{process_or_group_name}")
+      end
+    end
+
+    def unmonitor(process_or_group_name)
+      if(@server)
+        group = self.groups[process_or_group_name]
+        
+        if group
+          group.unmonitor
+          
+        else
+          self.groups.values.each do |group|
+            group.unmonitor(process_or_group_name)
+          end
+        end
+        "ok"
+      else
+        send_to_server("unmonitor:#{process_or_group_name}")
+      end
+    end
+    
+    def add_process(process, group = nil)
+      self.groups[group] ||= Group.new(group, :logger => self.group_logger)
+      self.groups[group].add_process(process)
+    end
+    
+    def send_to_server(method)
+      self.socket = Bluepill::Socket.new(name, base_dir).client 
+      socket.write(method + "\n")
+      buffer = ""
+      while(line = socket.gets)
+        buffer << line
+      end
+      return buffer
+    end
+
+private
+
+    def listener
+      Thread.new(self) do |app|
+        begin
+          loop do
+            logger.info("Server | Command loop started:")
+            client = socket.accept
+            logger.info("Server: Handling Request")
+            cmd = client.readline.strip
+            logger.info("Server: #{cmd}")
+            response = app.send(*cmd.split(":"))
+            logger.info("Server: Sending Response")
+            client.write(response)
+            client.close
+          end
+        rescue Exception => e
+          logger.info(e.inspect)
+        end
+      end
+    end
+
+    def start_server
+      if File.exists?(self.pid_file)
+        previous_pid = File.read(self.pid_file).to_i
+        begin
+          puts "Killing previous bluepilld[#{previous_pid}]"
+          ::Process.kill(2, previous_pid)
+        rescue Exception => e
+          exit unless e.is_a?(Errno::ESRCH)
+          # it was probably already dead
+        end
+        sleep 1 # wait for it to die
+      end
+      
+      Daemonize.daemonize
+      
+      @server = true
+      self.socket = Bluepill::Socket.new(name, base_dir).server
+      File.open(self.pid_file, 'w') { |x| x.write(::Process.pid) }
+      $0 = "bluepilld: #{self.name}"
+      self.groups.each {|name, group| group.start }
+      listener
+      run
+    end
+    
+    def run
+      loop do
+        self.groups.each do |_, group|
+          group.tick
+        end
+        sleep 1
+      end
+    end
+        
+    def cleanup
+      # self.socket.cleanup
+    end
+    
+    def signal_trap
+      
+      terminator = lambda do
+        puts "Terminating..."
+        cleanup
+        ::Kernel.exit
+      end
+      
+      Signal.trap("TERM", &terminator) 
+      Signal.trap("INT", &terminator) 
+    end
+   
+    def grep_pattern(query)
+      bluepilld = 'bluepill\[[[:digit:]]+\]:[[:space:]]+'
+      pattern = [self.name, query].join('|')
+      [bluepilld, '\[.*', Regexp.escape(pattern), '.*\]'].join
+    end
+  end
+end

data/lib/bluepill/application/client.rb

@@ -0,0 +1,7 @@
+module Bluepill
+  module Application
+    module Client
+      
+    end
+  end
+end

data/lib/bluepill/application/server.rb

@@ -0,0 +1,24 @@
+module Bluepill
+  module Application
+    module ServerMethods
+      
+      def status
+        buffer = ""
+        self.processes.each do | process |
+          buffer << "#{process.name} #{process.state}\n" +
+        end
+        buffer
+      end
+
+      def restart
+        self.socket = Bluepill::Socket.new(name, base_dir).client      
+        socket.send("restart\n", 0)
+      end
+
+      def stop
+        self.socket = Bluepill::Socket.new(name, base_dir).client      
+        socket.send("stop\n", 0)
+      end
+    end
+  end
+end

data/lib/bluepill/comm.rb

@@ -0,0 +1,5 @@
+module Bluepill
+  class Comm
+  
+  end
+end

data/lib/bluepill/condition_watch.rb

@@ -0,0 +1,52 @@
+module Bluepill
+  class ConditionWatch
+    attr_accessor :logger
+    def initialize(name, options = {})
+      @name = name
+
+      @logger = options.delete(:logger)      
+      @fires = options.has_key?(:fires) ? [options.delete(:fires)].flatten : [:restart]
+      @every = options.delete(:every)
+      @times = options.delete(:times) || [1,1]
+      @times = [@times, @times] unless @times.is_a?(Array) # handles :times => 5
+
+      self.clear_history!
+      
+      @process_condition = ProcessConditions.name_to_class(@name).new(options)
+    end
+    
+    def run(pid, tick_number = Time.now.to_i)
+      if @last_ran_at.nil? || (@last_ran_at + @every) <= tick_number
+        @last_ran_at = tick_number
+        self.record_value(@process_condition.run(pid))
+        return @fires if self.fired?
+      end
+      []
+    end
+    
+    def record_value(value)
+      # TODO: record value in ProcessStatistics
+      self.logger.info(self.to_s) if self.logger
+      @history[@history_index] = [value, @process_condition.check(value)]
+      @history_index = (@history_index + 1) % @history.size
+    end
+    
+    def clear_history!
+      @last_ran_at = nil
+      @history = Array.new(@times[1])
+      @history_index = 0
+    end
+    
+    def fired?
+      @history.select {|v| !v[1] }.size >= @times[0]
+    end
+    
+    def to_s
+      # TODO: this will be out of order because of the way history values are assigned
+      # use (@history[(@history_index - 1)..1] + @history[0..(@history_index - 1)]).
+      #       collect {|v| "#{v[0]}#{v[1] ? '' : '*'}"}.join(", ")
+      # but that's gross so... it's gonna be out of order till we figure out a better way to get it in order
+      @history.collect {|v| "#{v[0]}#{v[1] ? '' : '*'}"}.join(", ")
+    end
+  end
+end

data/lib/bluepill/controller.rb

@@ -0,0 +1,22 @@
+module Bluepill
+  class Controller
+    attr_accessor :base_dir, :sockets_dir, :pids_dir
+    attr_accessor :applications
+    
+    def initialize(options = {})
+      self.base_dir = options[:base_dir] || '/var/bluepill'
+      self.sockets_dir = File.join(base_dir, 'socks')
+      self.pids_dir = File.join(base_dir, 'pids')
+      self.applications = Hash.new 
+    end
+    
+    def list
+      Dir[File.join(sockets_dir, "*.sock")].map{|x| File.basename(x, ".sock")}
+    end
+    
+    def send_cmd(application, command, *args)
+      applications[application] ||= Application.new(application, {:base_dir => base_dir})
+      applications[application].send(command.to_sym, *args.compact)
+    end
+  end
+end

data/lib/bluepill/dsl.rb

@@ -0,0 +1,46 @@
+require 'ostruct'
+module Bluepill
+  def self.application(app_name, options = {}, &block)
+    app = Application.new(app_name.to_s, options, &block)
+   
+    process_proxy = Class.new do
+      attr_reader :attributes, :watches
+      def initialize
+        @attributes = {}
+        @watches = {}
+      end
+      
+      def method_missing(name, *args)
+        if args.size == 1 && name.to_s =~ /^(.*)=$/
+          @attributes[$1.to_sym] = args.first
+        else
+          super
+        end
+      end
+      
+      def checks(name, options = {})
+        @watches[name] = options
+      end
+    end
+    
+    app_proxy = Class.new do
+      @@app = app
+      @@process_proxy = process_proxy
+      
+      def process(process_name, &process_block)
+        process_proxy = @@process_proxy.new
+        process_block.call(process_proxy)
+        group = process_proxy.attributes.delete(:group)
+        process = Bluepill::Process.new(process_name, process_proxy.attributes)
+        process_proxy.watches.each do |name, opts|  
+          process.add_watch(name, opts)
+        end
+        
+        @@app.add_process(process, group)
+      end
+    end
+    
+    yield(app_proxy.new)
+    app.load
+  end
+end

data/lib/bluepill/group.rb

@@ -0,0 +1,53 @@
+module Bluepill
+  class Group
+    attr_accessor :name, :processes, :logger
+    attr_accessor :process_logger
+    
+    def initialize(name, options = {})
+      self.name = name
+      self.processes = []
+      self.logger = options[:logger]
+      
+      if self.logger
+        logger_prefix = self.name ? "#{self.name}:" : nil
+        self.process_logger = Bluepill::Logger.new(self.logger, logger_prefix) 
+      end
+    end
+    
+    def add_process(process)
+      process.logger = Logger.new(self.process_logger, process.name)
+      self.processes << process
+    end
+    
+    def tick
+      self.each_process do |process|
+        process.tick
+      end
+    end
+
+    # proxied events
+    [:start, :unmonitor, :stop, :restart].each do |event|
+      eval <<-END
+        def #{event}(process_name = nil)
+          self.each_process do |process|
+            process.dispatch!("#{event}") if process_name.nil? || process.name == process_name
+          end
+        end      
+      END
+    end
+    
+    def status
+      status = []
+      self.each_process do |process|
+        status << [process.name, process.state]
+      end
+      status
+    end
+    
+    
+    protected
+    def each_process(&block)
+      self.processes.each(&block)
+    end
+  end
+end

data/lib/bluepill/logger.rb

@@ -0,0 +1,17 @@
+module Bluepill
+  class Logger
+    def initialize(logger = nil, prefix = nil)
+      @logger = logger || Syslog.open('bluepill', Syslog::LOG_PID | Syslog::LOG_CONS, Syslog::LOG_LOCAL6)
+      @prefix = prefix
+    end
+    
+    [:emerg, :alert, :crit, :err, :warning, :notice, :info, :debug].each do |method|
+      eval <<-END
+        def #{method}(*args)
+          with_prefix = args.collect {|s| "\#{@prefix}\#{s}" }
+          @logger.#{method}(*with_prefix)
+        end
+      END
+    end
+  end
+end

data/lib/bluepill/process.rb

@@ -0,0 +1,201 @@
+require "state_machine"
+require "daemons"
+
+module Bluepill
+  class Process
+    CONFIGURABLE_ATTRIBUTES = [:start_command, :stop_command, :restart_command, :daemonize, :pid_file, :start_grace_time, :stop_grace_time, :restart_grace_time]
+    
+    attr_accessor :name, :watches, :logger, :skip_ticks_until
+    attr_accessor *CONFIGURABLE_ATTRIBUTES
+    
+    state_machine :initial => :unmonitored do      
+      state :unmonitored, :up, :down
+      
+      event :tick do
+        transition :unmonitored => :unmonitored
+        
+        transition :up => :up, :if => :process_running?
+        transition :up => :down, :unless => :process_running?
+
+        transition :down => :up, :if => lambda {|process| process.process_running? || process.start_process }
+      end
+      
+      event :start do
+        transition :unmonitored => :up, :if => lambda {|process| process.process_running? || process.start_process }
+        transition :up => :up
+        transition :down => :up, :if => :start_process
+      end
+      
+      event :stop do
+        transition [:unmonitored, :down] => :unmonitored
+        transition :up => :unmonitored, :if => :stop_process
+      end
+      
+      event :restart do
+        transition all => :up, :if => :restart_process
+      end
+      
+      event :unmonitor do
+        transition all => :unmonitored
+      end
+      
+      after_transition any => any do |process, transition|
+        unless transition.loopback?
+          process.record_transition(transition.to_name) 
+          # process.logger.info "Going from #{transition.from_name} => #{transition.to_name}"
+        end
+      end
+      
+    end
+
+    def tick
+      return if self.skip_ticks_until && self.skip_ticks_until > Time.now.to_i
+      self.skip_ticks_until = nil
+
+      # clear the momoization per tick
+      @process_running = nil
+      
+      # run state machine transitions
+      super
+
+      
+      if process_running?
+        run_watches
+      end
+    end
+    
+    def initialize(process_name, options = {})      
+      @name = process_name
+      @transition_history = Util::RotationalArray.new(10)
+      @watches = []
+      
+      @stop_grace_time = @start_grace_time = @restart_grace_time = 3
+      
+      CONFIGURABLE_ATTRIBUTES.each do |attribute_name|
+        self.send("#{attribute_name}=", options[attribute_name]) if options.has_key?(attribute_name)
+      end
+      
+      raise ArgumentError, "Please specify a pid_file or the demonize option" if pid_file.nil? && !daemonize?
+      
+      # Let state_machine do its initialization stuff
+      super()
+    end
+    
+    def add_watch(name, options = {})
+      self.watches << ConditionWatch.new(name, options.merge(:logger => self.watch_logger))
+    end
+    
+    def daemonize?
+      !!self.daemonize
+    end
+    
+    def dispatch!(event)
+      logger.info "Got stop"
+      self.send("#{event}!")
+    end
+    
+    def process_running?(force = false)
+      @process_running = nil if force
+      @process_running ||= signal_process(0)
+    end
+    
+    def start_process
+      self.clear_pid
+      if daemonize?
+        starter = lambda {::Kernel.exec(start_command)}
+        child_pid = Daemonize.call_as_daemon(starter)
+        File.open(pid_file, "w") {|f| f.write(child_pid)}
+        
+      else
+        # This is a self-daemonizing process
+        system(start_command)
+      end
+      
+      skip_ticks_for(start_grace_time)
+      
+      true
+    end
+    
+    def stop_process
+      self.clear_pid
+      if stop_command
+        system(stop_command)
+      else
+        signal_process("TERM")
+        
+        wait_until = Time.now.to_i + stop_grace_time
+        while process_running?(true)
+          if wait_until <= Time.now.to_i
+            signal_process("KILL")
+            break
+          end
+          sleep 0.1
+        end
+      end
+
+      skip_ticks_for(stop_grace_time)
+      
+      true
+    end
+    
+    def restart_process
+      self.clear_pid
+      if restart_command
+        system(restart_command)
+        skip_ticks_for(restart_grace_time)
+        
+      else
+        stop_process
+        start_process
+      end
+    end
+    
+    def skip_ticks_for(seconds)
+      self.skip_ticks_until = (self.skip_ticks_until || Time.now.to_i) + seconds
+    end
+
+    def run_watches
+      now = Time.now.to_i
+
+      threads = self.watches.collect do |watch|
+        Thread.new { Thread.current[:events] = watch.run(self.actual_pid, now) }
+      end
+      
+      @transitioned = false
+      
+      threads.inject([]) do |events, thread|
+        thread.join
+        events << thread[:events]
+      end.flatten.uniq.each do |event|
+        break if @transitioned
+        self.dispatch!(event)
+      end
+    end
+    
+    def record_transition(state_name)
+      @transitioned = true
+      # do other stuff here?
+    end
+    
+    def signal_process(code)
+      ::Process.kill(code, actual_pid)
+      true
+    rescue
+      false
+    end
+    
+    def actual_pid
+      @actual_pid ||= File.read(pid_file).to_i if File.exists?(pid_file)
+    end
+    
+    def clear_pid
+      @actual_pid = nil
+      File.unlink(pid_file) if File.exists?(pid_file)
+    end
+    
+    def watch_logger
+      @watch_logger ||= Logger.new(self.logger, "#{self.name}:") if self.logger
+    end
+  end
+end
+ 

data/lib/bluepill/process_conditions.rb

@@ -0,0 +1,7 @@
+module Bluepill
+  module ProcessConditions
+    def self.name_to_class(name)
+      "#{self}::#{name.to_s.camelcase}".constantize
+    end
+  end
+end

data/lib/bluepill/process_conditions/always_true.rb

@@ -0,0 +1,17 @@
+module Bluepill
+  module ProcessConditions
+    class AlwaysTrue < ProcessCondition
+      def initialize(options = {})
+        @below = options[:below]
+      end
+      
+      def run(pid)
+        1
+      end
+      
+      def check(value)
+        true
+      end
+    end
+  end
+end

data/lib/bluepill/process_conditions/cpu_usage.rb

@@ -0,0 +1,17 @@
+module Bluepill
+  module ProcessConditions
+    class CpuUsage < ProcessCondition
+      def initialize(options = {})
+        @below = options[:below]
+      end
+      
+      def run(pid)
+        `ps ux -p #{pid} | tail -1 | awk '{print $3}'`.to_f
+      end
+      
+      def check(value)
+        value < @below
+      end
+    end
+  end
+end

data/lib/bluepill/process_conditions/mem_usage.rb

@@ -0,0 +1,17 @@
+module Bluepill
+  module ProcessConditions
+    class MemUsage < ProcessCondition
+      def initialize(options = {})
+        @below = options[:below]
+      end
+      
+      def run(pid)
+        `ps ux -p #{pid} | tail -1 | awk '{print $5}'`.to_f
+      end
+      
+      def check(value)
+        value < @below
+      end
+    end
+  end
+end

data/lib/bluepill/process_conditions/process_condition.rb

@@ -0,0 +1,13 @@
+module Bluepill
+  module ProcessConditions
+    class ProcessCondition  
+      def run(pid)
+        raise "Implement in subclass!"
+      end
+      
+      def check(value)
+        raise "Implement in subclass!"
+      end
+    end
+  end
+end

data/lib/bluepill/socket.rb

@@ -0,0 +1,43 @@
+require 'socket'
+
+module Bluepill
+  class Socket
+    attr_accessor :name, :base_dir, :socket
+    
+    def initialize(name, base_dir)
+      self.name = name
+      self.base_dir = base_dir
+      @isserver = false
+    end
+
+    def client
+      self.socket = UNIXSocket.open(socket_name)
+    end
+    
+    def server
+      @isserver = true
+      begin
+        self.socket = UNIXServer.open(socket_name)
+      rescue Errno::EADDRINUSE
+        #if sock file has been created.  test to see if there is a server
+        tmp_socket = UNIXSocket.open(socket_name) rescue nil
+        if tmp_socket.nil?
+          cleanup
+          retry
+        else
+          raise Exception.new("Server is already running")
+        end
+      end
+    end
+    
+    def cleanup
+      File.delete(socket_name) if @isserver      
+    end
+    
+    def socket_name
+      @socket_name ||= File.join(base_dir, 'socks', name + ".sock") 
+    end
+    
+  end
+end
+ 

data/lib/bluepill/util/rotational_array.rb

@@ -0,0 +1,34 @@
+module Bluepill
+  module Util
+   class RotationalArray < Array
+     def initialize(size)
+       super
+       @index = 0
+     end
+     
+     def push(value)
+       self[@index] = value
+       @index = (@index + 1) % self.size
+       puts @index
+     end
+     
+     alias_method :<<, :push
+     
+     def pop
+       raise "Cannot call pop on a rotational array"
+     end
+
+     def shift
+       raise "Cannot call shift on a rotational array"
+     end
+
+     def unshift
+       raise "Cannot call unshift on a rotational array"
+     end
+     
+     def last
+       self[@index - 1]
+     end
+   end
+ end
+end

data/lib/example.rb

@@ -0,0 +1,73 @@
+require 'rubygems'
+require 'bluepill'
+
+ROOT_DIR = "/tmp/bp"
+
+# application = Bluepill::Application.new("poop", 'base_dir' => '/tmp/bp')
+# 
+# process = Bluepill::Process.new("hello_world") do |process|
+#   process.start_command = "sleep 5"
+#   process.daemonize = true
+#   process.pid_file = "/tmp/bp/sleep.pid"
+# end
+# 
+# process.add_watch("AlwaysTrue", :every => 5)
+# 
+# application.processes << process
+# process.dispatch!("start")
+# 
+# application.start
+
+
+Bluepill.application(:sample_app, :base_dir => ROOT_DIR) do |app|
+  2.times do |i|
+    app.process("process_#{i}") do |process|
+      process.start_command = "echo 'Process #{i}' && sleep #{rand(15) + i}"
+      process.daemonize = true
+      process.pid_file = "#{ROOT_DIR}/pids/process_#{i}.pid"
+      
+      process.checks :always_true, :every => 2
+    end
+  end
+  
+  10.times do |i|
+    app.process("group_process_#{i}") do |process|
+      process.start_command = "sleep #{rand(15) + i}"
+      process.group = "Poopfaced"
+      process.daemonize = true
+      process.pid_file = "#{ROOT_DIR}/pids/process_#{i}.pid"
+      
+      process.checks :always_true, :every => 2
+    end
+  end
+end
+
+
+# Bluepill.watch do
+#   start_command "start_process -P file.pid"
+#   stop_command "stop_process -P file.pid"
+#   pid_file 'file.pid'
+#   
+#   checks do |checks|
+#     checks.mem_usage :every => 15.minutes,
+#                   :below => 250.megabytes,
+#                   :fires => :restart
+#                   
+#     checks.cpu_usage  :every 10.seconds,
+#                 :below => 50.percent,
+#                 :fires => :restart
+#                 
+#     checks.custom_method  :custom_params => :to_be_sent_to_the_custom_condition,
+#                           :fires => [:stop, :custom_event, :start]
+#                           
+#     checks.deadly_condition :every => 20.seconds,
+#                             :fires => :stop
+#   end
+#  
+#   handles(:restart) do |process|
+#     # process has pid
+#     process.transition :down
+#     process.transition :up
+#     run "some commands -P #{process.pid}"
+#   end
+# end

data/spec/blue-pill_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Bluepill" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/process_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe "Bluepill:Process" do
+  it "should raise exceptions unless properly initialized" do
+    lambda {
+      Bluepill::Process.new
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should construct a valid object when properly initialized" do
+    lambda {
+      Bluepill::Process.new("test_process") do |p|
+        # The absolute minimum to construct a valid process
+        p.start_command = "/dev/null"
+        p.pid_file = "/var/run/test_process.pid"
+      end
+    }.should_not raise_error
+  end
+  
+end
+
+describe "A Bluepill::Process object" do
+  before(:each) do
+    @process = Bluepill::Process.new("test_process") do |p|
+      p.start_command = "hai"
+      p.daemonize = true
+    end
+  end
+  
+  it "should be in the unmonitored state after construction" do
+    @process.should be_unmonitored
+  end  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require "rubygems"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'bluepill'
+require 'spec'
+require 'spec/autorun'
+require "ruby-debug"
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: bluepill
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Arya Asemanfar
+- Gary Tsang
+- Rohith Ravi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-05 00:00:00 -07:00
+default_executable: bluepill
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: pluginaweek-state_machine
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+    version: 
+description: Bluepill keeps your daemons up while taking up as little resources as possible. After all you probably want the resources of your server to be used by whatever daemons you are running rather than the thing that's supposed to make sure they are brought back up, should they die or misbehave.
+email: entombedvirus@gmail.com
+executables: 
+- bluepill
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/bluepill
+- lib/bluepill.rb
+- lib/bluepill/application.rb
+- lib/bluepill/application/client.rb
+- lib/bluepill/application/server.rb
+- lib/bluepill/comm.rb
+- lib/bluepill/condition_watch.rb
+- lib/bluepill/controller.rb
+- lib/bluepill/dsl.rb
+- lib/bluepill/group.rb
+- lib/bluepill/logger.rb
+- lib/bluepill/process.rb
+- lib/bluepill/process_conditions.rb
+- lib/bluepill/process_conditions/always_true.rb
+- lib/bluepill/process_conditions/cpu_usage.rb
+- lib/bluepill/process_conditions/mem_usage.rb
+- lib/bluepill/process_conditions/process_condition.rb
+- lib/bluepill/socket.rb
+- lib/bluepill/util/rotational_array.rb
+- lib/example.rb
+- spec/blue-pill_spec.rb
+- spec/process_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/arya/bluepill
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.2
+signing_key: 
+specification_version: 3
+summary: A process monitor written in Ruby with stability and minimalism in mind.
+test_files: 
+- spec/blue-pill_spec.rb
+- spec/process_spec.rb
+- spec/spec_helper.rb