bluepill 0.0.24 → 0.0.25

data/README.md

@@ -211,9 +211,10 @@ By default, bluepill uses syslog local6 facility as described in the installatio
 
 Keep in mind that you still need to set up log rotation (described in the installation section) to keep the log file from growing huge.
     
-## Contribute
+## Links
 Code: [http://github.com/arya/bluepill](http://github.com/arya/bluepill)  
 Bugs/Features: [http://github.com/arya/bluepill/issues](http://github.com/arya/bluepill/issues)  
+Mailing List: [http://groups.google.com/group/bluepill-rb](http://groups.google.com/group/bluepill-rb)
 
 
 [gemcutter]: http://gemcutter.org

data/VERSION

@@ -1 +1 @@
-0.0.24
+0.0.25

data/bin/bluepill

@@ -20,16 +20,16 @@ OptionParser.new do |opts|
   opts.on('-l', "--logfile LOGFILE", "Path to logfile, defaults to #{options[:log_file]}") do |file|
     options[:log_file] = file
   end
-  
+
   opts.on('-c', "--base-dir DIR", "Directory to store bluepill socket and pid files, defaults to #{options[:base_dir]}") do |base_dir|
     options[:base_dir] = base_dir
   end
-  
+
   opts.on("-v", "--version") do
     puts "bluepill, version #{Bluepill::VERSION}"
     exit
   end
-  
+
   help = lambda do
     puts opts
     puts
@@ -46,18 +46,18 @@ OptionParser.new do |opts|
     puts "See http://github.com/arya/bluepill for README"
     exit
   end
-    
+
   opts.on_tail('-h','--help', 'Show this message', &help)
   help.call if ARGV.empty?
 end.parse!
 
 APPLICATION_COMMANDS = %w(status start stop restart unmonitor quit log)
 
-controller = Bluepill::Controller.new(options.slice(:base_dir))
+controller = Bluepill::Controller.new(options.slice(:base_dir, :log_file))
 
 if controller.running_applications.include?(ARGV.first)
   # the first arg is the application name
-  options[:application] = ARGV.shift 
+  options[:application] = ARGV.shift
 elsif APPLICATION_COMMANDS.include?(ARGV.first)
   if controller.running_applications.length == 1
     # there is only one, let's just use that
@@ -79,26 +79,22 @@ end
 
 options[:command] = ARGV.shift
 
-case options[:command]
-when "load"
-  config_file = ARGV.shift
-  if File.exists?(config_file)
-    eval(File.read(config_file))
+if options[:command] == "load"
+  file = ARGV.shift
+  if File.exists?(file)
+    # Restart the ruby interpreter for the config file so that anything loaded here
+    # does not stay in memory for the daemon
+    require 'rbconfig'
+    ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+    load_path = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+    file_path = File.expand_path(file)
+
+    exec(ruby, "-I#{load_path}", '-rbluepill', file_path)
+    
   else
     $stderr.puts "Can't find file: #{file}"
   end
-when "log"
-  requested_pattern = ARGV.shift
-  grep_pattern = controller.send_command_to_application(options[:application], :grep_pattern, requested_pattern)
-  
-  tail = "tail -n 100 -f #{options[:log_file]} | grep -E '#{grep_pattern}'"
-  puts "Tailing log for #{requested_pattern}..."
-  Kernel.exec(tail)
-
-when *APPLICATION_COMMANDS
-  target = ARGV.shift
-  puts controller.send_command_to_application(options[:application], options[:command], target)
-  
 else
-  puts "Unknown command `%s` (or application `%s` has not been loaded yet)" % [options[:command], options[:command]]
+  target = ARGV.shift
+  controller.handle_command(options[:application], options[:command], target)
 end

data/bluepill.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bluepill}
-  s.version = "0.0.24"
+  s.version = "0.0.25"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Arya Asemanfar", "Gary Tsang", "Rohith Ravi"]
-  s.date = %q{2009-11-24}
+  s.date = %q{2009-11-30}
   s.default_executable = %q{bluepill}
   s.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.}
   s.email = %q{entombedvirus@gmail.com}

data/lib/bluepill/application.rb

@@ -1,25 +1,30 @@
 module Bluepill
   class Application
+    PROCESS_COMMANDS = [:start, :stop, :restart, :unmonitor]
+    
     attr_accessor :name, :logger, :base_dir, :socket, :pid_file
-    attr_accessor :groups, :work_queue, :socket_timeout
+    attr_accessor :groups, :work_queue
+    attr_accessor :pids_dir, :log_file
 
     def initialize(name, options = {})
       self.name = name
-      self.base_dir = options[:base_dir] ||= '/var/bluepill'
-      self.socket_timeout = options[:socket_timeout] ||= 10
-      
-      self.logger = Bluepill::Logger.new(options.slice(:log_file)).prefix_with(self.name)
-      
-      self.groups = Hash.new 
 
+      self.log_file = options[:log_file]      
+      self.base_dir = options[:base_dir] || '/var/bluepill'
       self.pid_file = File.join(self.base_dir, 'pids', self.name + ".pid")
+      self.pids_dir = File.join(self.base_dir, 'pids', self.name)
+
+      self.groups = {}
       
-      @server = false
+      self.logger = Bluepill::Logger.new(:log_file => self.log_file).prefix_with(self.name)
+      
+      self.setup_signal_traps
+      self.setup_pids_dir
     end
         
     def load
       begin
-        start_server
+        self.start_server
       rescue StandardError => e
         $stderr.puts "Failed to start bluepill:"
         $stderr.puts "%s `%s`" % [e.class.name, e.message]
@@ -29,132 +34,88 @@ module Bluepill
     end
     
     def status
-      if(@server)
-        buffer = []
-        depth = 0
-        
-        if self.groups.has_key?(nil)
-          self.groups[nil].processes.each do |p|
-            buffer << "%s%s(pid:%s): %s" % [" " * depth, p.name, p.actual_pid.inspect, p.state]
-            
-            if p.monitor_children?
-              depth += 2
-              p.children.each do |c|
-                buffer << "%s%s: %s" % [" " * depth, c.name, c.state]
-              end
-              depth -= 2
-            end
-          end
-        end
+      buffer = []
+      depth = 0
+      
+      if self.groups.has_key?(nil)
+        self.groups[nil].processes.each do |p|
+          buffer << "%s%s(pid:%s): %s" % [" " * depth, p.name, p.actual_pid.inspect, p.state]
 
-        self.groups.each do |group_name, group|
-          next if group_name.nil?
-          
-          buffer << "\n#{group_name}"
-          
-          group.processes.each do |p|
+          if p.monitor_children?
             depth += 2
-            
-            buffer << "%s%s(pid:%s): %s" % [" " * depth, p.name, p.actual_pid.inspect, p.state]
-            
-            if p.monitor_children?
-              depth += 2
-              p.children.each do |c|
-                buffer << "%s%s: %s" % [" " * depth, c.name, c.state]
-              end
-              depth -= 2
+            p.children.each do |c|
+              buffer << "%s%s: %s" % [" " * depth, c.name, c.state]
             end
-            
             depth -= 2
           end
         end
-        
-        buffer.join("\n")
-        
-      else
-        send_to_server('status')
       end
-    end
-    
-    def stop(process_or_group_name)
-      send_to_process_or_group(:stop, process_or_group_name)
-    end
-    
-    def start(process_or_group_name)
-      send_to_process_or_group(:start, process_or_group_name)
-    end
 
-    def restart(process_or_group_name)
-      send_to_process_or_group(:restart, process_or_group_name)
-    end
+      self.groups.each do |group_name, group|
+        next if group_name.nil?
 
-    def unmonitor(process_or_group_name)
-      send_to_process_or_group(:unmonitor, process_or_group_name)
-    end
-    
-    def send_to_process_or_group(method, process_or_group_name, async = true)      
-      if(@server)
-        if async
-          self.work_queue.push([method, process_or_group_name])
-        else
-          group = self.groups[process_or_group_name]
-          if group
-            group.send(method)  
-          else
-            self.groups.values.each do |group|
-              group.send(method, process_or_group_name)
+        buffer << "\n#{group_name}"
+
+        group.processes.each do |p|
+          depth += 2
+
+          buffer << "%s%s(pid:%s): %s" % [" " * depth, p.name, p.actual_pid.inspect, p.state]
+
+          if p.monitor_children?
+            depth += 2
+            p.children.each do |c|
+              buffer << "%s%s: %s" % [" " * depth, c.name, c.state]
             end
+            depth -= 2
           end
+
+          depth -= 2
         end
-        return "ok"
-      else
-        send_to_server("#{method}:#{process_or_group_name}")
       end
+
+      buffer.join("\n")
     end
     
-    def quit
-      if @server
-        ::Process.kill("TERM", 0)
-        "Terminating bluepill[#{::Process.pid}]"
-      else
-        send_to_server("quit")
-      end
+    PROCESS_COMMANDS.each do |command|
+      class_eval <<-END
+        def #{command}(group_name, process_name = nil)
+          puts "got #{command}"
+          self.send_to_process_or_group(:#{command}, group_name, process_name)
+        end
+      END
     end
     
     def add_process(process, group_name = nil)
+      group_name = group_name.to_s if group_name
+      
       self.groups[group_name] ||= Group.new(group_name, :logger => self.logger.prefix_with(group_name))
       self.groups[group_name].add_process(process)
     end
-    
-    def send_to_server(method)
-      buffer = ""
-      begin
-        status = Timeout::timeout(self.socket_timeout) do
-          self.socket = Bluepill::Socket.new(name, base_dir).client # Something that should be interrupted if it takes too much time...
-          socket.write(method + "\n")
-          while(line = socket.gets)
-            buffer << line
-          end
-        end
-      rescue Timeout::Error
-        abort("Socket Timeout: Server may not be responding")
-      rescue Errno::ECONNREFUSED
-        abort("Connection Refused: Server is not running")
+
+    protected
+    def send_to_process_or_group(method, group_name, process_name)
+      if self.groups.key?(group_name)
+        self.groups[group_name].send(method, process_name)
+      elsif process_name.nil?
+        # they must be targeting just by process name
+        process_name = group_name
+        self.groups.values.collect do |group|
+          group.send(method, process_name)
+        end.flatten
+      else
+        []
       end
-      buffer
     end
 
-    private
-
     def start_listener
       @listener_thread.kill if @listener_thread
-      @listener_thread = Thread.new(self) do |app|
+      @listener_thread = Thread.new do
         begin
           loop do
-            client = app.socket.accept
-            cmd = client.readline.strip
-            response = app.send(*cmd.split(":"))
-            client.write(response)
+            client = self.socket.accept
+            command, *args = client.readline.strip.split(":")
+            response = self.send(command, *args)
+            client.write(Marshal.dump(response))
             client.close
           end
         rescue StandardError => e
@@ -164,93 +125,88 @@ module Bluepill
       end
     end
     
-    def start_worker
-      @worker_thread.kill if @worker_thread
-      @worker_thread = Thread.new(self) do |app|
-        loop do
-          begin
-            job = app.work_queue.pop
-            send_to_process_or_group(job[0], job[1], false)
-          rescue StandardError => e
-            logger.err("Error while trying to execute %s from work_queue" % job.inspect)
-            logger.err("%s: `%s`" % [e.class.name, e.message])
-          end
-        end
-      end
-    end
-    
     def start_server
-      if File.exists?(self.pid_file)
-        previous_pid = File.read(self.pid_file).to_i
-        begin
-          ::Process.kill(0, previous_pid)
-          puts "Killing previous bluepilld[#{previous_pid}]"
-          ::Process.kill(2, previous_pid)
-        rescue Exception => e
-          exit unless e.is_a?(Errno::ESRCH)
-        else
-          5.times do |i|
-            sleep 0.5
-            break unless System.pid_alive?(previous_pid)
-          end
-          
-          if System.pid_alive?(previous_pid)
-            $stderr.puts "Previous bluepilld[#{previous_pid}] didn't die"
-            exit(4)
-          end
-        end
-      end
+      self.kill_previous_bluepill
       
       Daemonize.daemonize
+      
       self.logger.reopen
       
-      @server = true
       $0 = "bluepilld: #{self.name}"
       
-      self.work_queue = Queue.new
-      
-      self.socket = Bluepill::Socket.new(name, base_dir).server
-      File.open(self.pid_file, 'w') { |x| x.write(::Process.pid) }
+      self.groups.each {|_, group| group.boot }
+
       
-      self.groups.each {|_, group| group.boot! }
+      self.write_pid_file
+      self.socket = Bluepill::Socket.server(self.base_dir, self.name)
+      self.start_listener
       
-      setup_signal_traps
-      start_listener
-      start_worker
-      run
+      self.run
     end
     
     def run
-      loop do
+      @running = true # set to false by signal trap
+      while @running
         System.reset_data
-        
-        self.groups.each do |_, group|
-          group.tick
-        end
+        self.groups.each { |_, group| group.tick }
         sleep 1
       end
+      cleanup
+    end
+    
+    def cleanup
+      File.unlink(self.socket.path) if self.socket
+      File.unlink(self.pid_file) if File.exists?(self.pid_file)
     end
     
     def setup_signal_traps
       terminator = lambda do
         puts "Terminating..."
-        File.unlink(self.socket.path) if self.socket
-        File.unlink(self.pid_file) if File.exists?(self.pid_file)
-        ::Kernel.exit
+        @running = false
       end
       
       Signal.trap("TERM", &terminator) 
       Signal.trap("INT", &terminator) 
       
       Signal.trap("HUP") do
-        self.logger.reopen
+        self.logger.reopen if self.logger
       end
     end
-   
-    def grep_pattern(query = nil)
-      bluepilld = 'bluepilld\[[[:digit:]]+\]:[[:space:]]+'
-      pattern = [self.name, query].compact.join(':')
-      [bluepilld, '\[.*', Regexp.escape(pattern), '.*'].join
+    
+    def setup_pids_dir
+      FileUtils.mkdir_p(self.pids_dir) unless File.exists?(self.pids_dir)
+      # we need everybody to be able to write to the pids_dir as processes managed by
+      # bluepill will be writing to this dir after they've dropped privileges
+      FileUtils.chmod(0777, self.pids_dir)
+    end
+    
+    def kill_previous_bluepill
+      if File.exists?(self.pid_file)
+        previous_pid = File.read(self.pid_file).to_i
+        begin
+          ::Process.kill(0, previous_pid)
+          puts "Killing previous bluepilld[#{previous_pid}]"
+          ::Process.kill(2, previous_pid)
+        rescue Exception => e
+          $stderr.puts "Encountered error trying to kill previous bluepill:"
+          $stderr.puts "#{e.class}: #{e.message}"
+          exit(4) unless e.is_a?(Errno::ESRCH)
+        else
+          10.times do |i|
+            sleep 0.5
+            break unless System.pid_alive?(previous_pid)
+          end
+          
+          if System.pid_alive?(previous_pid)
+            $stderr.puts "Previous bluepilld[#{previous_pid}] didn't die"
+            exit(4)
+          end
+        end
+      end
+    end
+    
+    def write_pid_file
+      File.open(self.pid_file, 'w') { |x| x.write(::Process.pid) }
     end
   end
 end

data/lib/bluepill/condition_watch.rb

@@ -9,7 +9,7 @@ module Bluepill
       @logger = options.delete(:logger)      
       @fires = options.has_key?(:fires) ? Array(options.delete(:fires)) : [:restart]
       @every = options.delete(:every)
-      @times = options[:times] || [1,1]
+      @times = options.delete(:times) || [1,1]
       @times = [@times, @times] unless @times.is_a?(Array) # handles :times => 5
 
       self.clear_history!

data/lib/bluepill/controller.rb

@@ -2,14 +2,14 @@ require 'fileutils'
 
 module Bluepill
   class Controller
-    attr_accessor :base_dir, :sockets_dir, :pids_dir
-    attr_accessor :applications
+    attr_accessor :base_dir, :log_file, :sockets_dir, :pids_dir
     
     def initialize(options = {})
+      self.log_file = options[:log_file]
       self.base_dir = options[:base_dir]
       self.sockets_dir = File.join(base_dir, 'socks')
       self.pids_dir = File.join(base_dir, 'pids')
-      self.applications = Hash.new 
+      
       setup_dir_structure
       cleanup_bluepill_directory
     end
@@ -18,11 +18,67 @@ module Bluepill
       Dir[File.join(sockets_dir, "*.sock")].map{|x| File.basename(x, ".sock")}
     end
     
-    def send_command_to_application(application, command, *args)
-      applications[application] ||= Application.new(application, {:base_dir => base_dir})
-      applications[application].send(command.to_sym, *args.compact)
+    def handle_command(application, command, *args)
+      case command.to_sym
+      when *Application::PROCESS_COMMANDS
+        # these need to be sent to the daemon and the results printed out
+        affected = self.send_to_daemon(application, command, *args)
+        if affected.empty?
+          puts "No processes effected"
+        else
+          puts "Sent #{command} to:"
+          affected.each do |process|
+            puts "  #{process}"
+          end
+        end
+      when :status
+        puts self.send_to_daemon(application, :status, *args)
+      when :quit
+        pid = pid_for(application)
+        if System.pid_alive?(pid)
+          ::Process.kill("TERM", pid)
+          puts "Killing bluepilld[#{pid}]"
+        else
+          puts "bluepilld[#{pid}] not running"
+        end
+      when :log
+        log_file_location = self.send_to_daemon(application, :log_file)
+        log_file_location = self.log_file if log_file_location.to_s.strip.empty?
+        
+        requested_pattern = args.first
+        grep_pattern = self.grep_pattern(application, requested_pattern)
+        
+        tail = "tail -n 100 -f #{log_file_location} | grep -E '#{grep_pattern}'"
+        puts "Tailing log for #{requested_pattern}..."
+        Kernel.exec(tail)
+      else
+        $stderr.puts "Unknown command `%s` (or application `%s` has not been loaded yet)" % [command, command]
+      end
     end
     
+    def send_to_daemon(application, command, *args)
+
+      begin
+        Timeout::timeout(Socket::TIMEOUT) do
+          buffer = ""
+          socket = Socket.client(base_dir, application) # Something that should be interrupted if it takes too much time...
+          socket.puts(([command] + args).join(":"))
+          while line = socket.gets
+            buffer << line
+          end
+          Marshal.load(buffer)
+        end
+      rescue Timeout::Error
+        abort("Socket Timeout: Server may not be responding")
+      rescue Errno::ECONNREFUSED
+        abort("Connection Refused: Server is not running")
+      end
+    end
+    
+    def grep_pattern(application, query = nil)
+      pattern = [application, query].compact.join(':')
+      ['\[.*', Regexp.escape(pattern), '.*'].compact.join
+    end
     private
     
     def cleanup_bluepill_directory

data/lib/bluepill/dsl.rb

@@ -58,6 +58,7 @@ module Bluepill
             process.add_watch(name, opts)
           end
         end
+
         process
       end
     end
@@ -65,23 +66,38 @@ module Bluepill
     app_proxy = Class.new do
       @@app = app
       @@process_proxy = process_proxy
-      @@process_names = Hash.new # becuase I don't want to require Set just for validations
+      @@process_keys = Hash.new # because I don't want to require Set just for validations
+      @@pid_files = Hash.new
       attr_accessor :working_dir, :uid, :gid
       
       def validate_process(process, process_name)
-        if @@process_names.key?(process_name)
-          $stderr.puts "Config Error: You have two entries for the process name '#{process_name}'"
+        # validate uniqueness of group:process
+        process_key = [process.attributes[:group], process_name].join(":")
+        if @@process_keys.key?(process_key)
+          $stderr.print "Config Error: You have two entries for the process name '#{process_name}'"
+          $stderr.print " in the group '#{process.attributes[:group]}'" if process.attributes.key?(:group)
+          $stderr.puts
           exit(6)
         else
-          @@process_names[process_name] = 0
+          @@process_keys[process_key] = 0
         end
         
-        [:start_command, :pid_file].each do |required_attr|
+        # validate required attributes
+        [:start_command].each do |required_attr|
           if !process.attributes.key?(required_attr)
             $stderr.puts "Config Error: You must specify a #{required_attr} for '#{process_name}'"
             exit(6)
           end
         end
+        
+        # validate uniqueness of pid files
+        pid_key = process.pid_file.strip
+        if @@pid_files.key?(pid_key)
+          $stderr.puts "Config Error: You have two entries with the pid file: #{process.pid_file}"
+          exit(6)
+        else
+          @@pid_files[pid_key] = 0
+        end
       end
       
       def process(process_name, &process_block)
@@ -89,11 +105,15 @@ module Bluepill
         process_block.call(process_proxy)
         set_app_wide_attributes(process_proxy)
         
+        assign_default_pid_file(process_proxy, process_name)
+        
         validate_process(process_proxy, process_name)
         
         group = process_proxy.attributes.delete(:group)        
         process = process_proxy.to_process(process_name)
         
+        
+        
         @@app.add_process(process, group)
       end
       
@@ -104,6 +124,14 @@ module Bluepill
           end
         end
       end
+      
+      def assign_default_pid_file(process_proxy, process_name)
+        unless process_proxy.attributes.key?(:pid_file)
+          group_name = process_proxy.attributes["group"]
+          default_pid_name = [group_name, process_name].compact.join('_').gsub(/[^A-Za-z0-9_\-]/, "_")
+          process_proxy.pid_file = File.join(@@app.pids_dir, default_pid_name + ".pid")
+        end
+      end
     end
     
     yield(app_proxy.new)

data/lib/bluepill/group.rb

@@ -21,15 +21,18 @@ module Bluepill
     end
 
     # proxied events
-    [:start, :unmonitor, :stop, :restart, :boot!].each do |event|
+    [:start, :unmonitor, :stop, :restart, :boot].each do |event|
       class_eval <<-END
         def #{event}(process_name = nil)
           threads = []
+          affected = []
           self.processes.each do |process|
             next if process_name && process_name != process.name
+            affected << [self.name, process.name].join(":")
             threads << Thread.new { process.handle_user_command("#{event}") }
           end
           threads.each { |t| t.join }
+          affected
         end      
       END
     end

data/lib/bluepill/process.rb

@@ -192,7 +192,7 @@ module Bluepill
     
     def handle_user_command(cmd)
       case cmd
-      when "boot!"
+      when "boot"
         # This is only called when bluepill is initially starting up
         if process_running?(true)
           # process was running even before bluepill was

data/lib/bluepill/socket.rb

@@ -1,41 +1,35 @@
 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
-    end
+  module Socket
+    TIMEOUT = 10
+    extend self
 
-    def client
-      self.socket = UNIXSocket.open(socket_name)
+    def client(base_dir, name)
+      UNIXSocket.open(socket_path(base_dir, name))
     end
     
-    def server
+    def server(base_dir, name)
+      socket_path = self.socket_path(base_dir, name)
       begin
-        self.socket = UNIXServer.open(socket_name)
+        UNIXServer.open(socket_path)
       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
+        begin
+          return UNIXSocket.open(socket_path)
+        rescue Errno::ECONNREFUSED
+          File.delete(socket_path)
+          return UNIXServer.open(socket_path)
         else
-          raise Exception.new("Server is already running")
+          logger.err("Server is already running!")
+          exit(7)
         end
       end
     end
     
-    def cleanup
-      File.delete(socket_name)
+    def socket_path(base_dir, name)
+      File.join(base_dir, 'socks', name + ".sock") 
     end
-    
-    def socket_name
-      @socket_name ||= File.join(base_dir, 'socks', name + ".sock") 
-    end
-    
   end
 end
  

data/lib/bluepill/system.rb

@@ -4,6 +4,7 @@ module Bluepill
   # This class represents the system that bluepill is running on.. It's mainly used to memoize
   # results of running ps auxx etc so that every watch in the every process will not result in a fork
   module System
+    APPEND_MODE = "a"
     extend self
     
     # The position of each field in ps output
@@ -209,15 +210,15 @@ module Bluepill
     end
     
     def redirect_io(io_in, io_out, io_err)
-      $stdin.reopen(streams[io_in]) if io_in
+      $stdin.reopen(io_in) if io_in
       
       if !io_out.nil? && !io_err.nil? && io_out == io_err
-        $stdout.reopen(io_out)
+        $stdout.reopen(io_out, APPEND_MODE)
         $stderr.reopen($stdout)
         
       else
-        $stdout.reopen(io_out) if io_out
-        $stderr.reopen(io_err) if io_err
+        $stdout.reopen(io_out, APPEND_MODE) if io_out
+        $stderr.reopen(io_err, APPEND_MODE) if io_err
       end
     end
   end

data/lib/bluepill/version.rb

@@ -1,3 +1,3 @@
 module Bluepill
-  VERSION = "0.0.24"
+  VERSION = "0.0.25"
 end

data/lib/example.rb

@@ -1,12 +1,18 @@
-require 'rubygems'
-require 'bluepill'
-require 'logger'
+module Bluepill
+  module ProcessConditions
+    class ProcMemUsage < MemUsage
+      def run(pid)
+        rand(1000)
+      end
+    end
+  end
+end
 
 ROOT_DIR = "/tmp/bp"
 
 # Watch with 
 # watch -n0.2 'ps axu | egrep "(CPU|forking|bluepill|sleep)" | grep -v grep | sort'
-Bluepill.application(:sample_app) do |app|
+Bluepill.application(:sample_app, :log_file => "/Users/arya/Desktop/bp.log") do |app|
   0.times do |i|
     app.process("process_#{i}") do |process|
       process.pid_file = "#{ROOT_DIR}/pids/process_#{i}.pid"
@@ -61,7 +67,7 @@ Bluepill.application(:sample_app) do |app|
     end
   end
   
-  1.times do |i|
+  2.times do |i|
     app.process("group_process_#{i}") do |process|
       process.uid = "arya"
       process.gid = "wheel"
@@ -71,10 +77,9 @@ Bluepill.application(:sample_app) do |app|
 
       
       process.group = "grouped"
-      # process.start_command = %Q{cd /tmp && ruby -e '$stderr.puts("hello stderr");$stdout.puts("hello stdout"); $stdout.flush; $stderr.flush; sleep 10'}
-      process.start_command = "sleep 10"
+      process.start_command = %Q{ruby -e '$stderr.puts("hello stderr");$stdout.puts("hello stdout"); $stdout.flush; $stderr.flush; sleep 10'}
       process.daemonize = true
-      process.pid_file = "/tmp/p_#{process.group}_#{i}.pid"
+      # process.pid_file = "/tmp/p_#{process.group}#{i}_.pid"
       
       # process.checks :always_true, :every => 5
       process.checks :cpu_usage, 
@@ -87,6 +92,11 @@ Bluepill.application(:sample_app) do |app|
         :below => 600.megabytes, 
         :times => [3, 5], 
         :fires => [:stop]
+        
+      process.checks :proc_mem_usage, 
+        :every => 3, 
+        :below => 600.megabytes, 
+        :times => [3, 5]
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bluepill
 version: !ruby/object:Gem::Version 
-  version: 0.0.24
+  version: 0.0.25
 platform: ruby
 authors: 
 - Arya Asemanfar
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-24 00:00:00 -08:00
+date: 2009-11-30 00:00:00 -08:00
 default_executable: bluepill
 dependencies: 
 - !ruby/object:Gem::Dependency