bluepill 0.0.6 → 0.0.7

data/Rakefile

@@ -15,6 +15,9 @@ begin
     gem.add_dependency("daemons", ">= 1.0.9")
     gem.add_dependency("pluginaweek-state_machine", ">= 0.8.0")
     gem.add_dependency("activesupport", ">= 2.3.4")
+
+    gem.files -= ["bin/sample_forking_server"]
+    gem.executables = ["bluepill"]
   end
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.0.7

data/bluepill.gemspec

@@ -5,11 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bluepill}
-  s.version = "0.0.6"
+  s.version = "0.0.7"
 
   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-10-22}
+  s.date = %q{2009-10-23}
+  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}
   s.executables = ["bluepill"]

data/lib/bluepill/application.rb

@@ -21,7 +21,7 @@ module Bluepill
         start_server
       rescue StandardError => e
         logger.err("Got exception: %s `%s`" % [e.class.name, e.message])
-        logger.err(e.backtrace.join("\n"))
+        e.backtrace.each {|l| logger.err(l)}
       end
     end
     
@@ -32,7 +32,7 @@ module Bluepill
         
         if self.groups.has_key?(nil)
           self.groups[nil].processes.each do |p|
-            buffer << "%s%s: %s" % [" " * depth, p.name, p.state]
+            buffer << "%s%s(pid:%s): %s" % [" " * depth, p.name, p.actual_pid.inspect, p.state]
             
             if p.monitor_children?
               depth += 2
@@ -52,7 +52,7 @@ module Bluepill
           group.processes.each do |p|
             depth += 2
             
-            buffer << "%s%s(pid:%d): %s" % [" " * depth, p.name, p.actual_pid, p.state]
+            buffer << "%s%s(pid:%s): %s" % [" " * depth, p.name, p.actual_pid.inspect, p.state]
             
             if p.monitor_children?
               depth += 2
@@ -149,8 +149,8 @@ private
             client.close
           end
         rescue StandardError => e
-          logger.err(e.inspect)
-          logger.err(e.backtrace.join("\n"))
+          logger.err("Got exception in cmd listener: %s `%s`" % [e.class.name, e.message])
+          e.backtrace.each {|l| logger.err(l)}
         end
       end
     end

data/lib/bluepill/process.rb

@@ -230,13 +230,16 @@ module Bluepill
       logger.warning "Executing start command: #{start_command}"
       
       if self.daemonize?
-        starter = lambda { drop_privileges; ::Kernel.exec(start_command) }
-        child_pid = Daemonize.call_as_daemon(starter)
+        child_pid = System.daemonize(start_command, :uid => self.uid, :gid => self.gid)
         File.open(pid_file, "w") {|f| f.write(child_pid)}
+        
       else
         # This is a self-daemonizing process
-        unless System.execute_blocking(start_command)
-          logger.warning "Start command execution returned non-zero exit code"
+        result = System.execute_blocking(start_command, :uid => self.uid, :gid => self.gid, :logger => logger)
+        
+        unless result[:exit_code].zero?
+          logger.warning "Start command execution returned non-zero exit code:"
+          logger.warning result.inspect
         end
       end
             
@@ -247,9 +250,11 @@ module Bluepill
       if stop_command
         cmd = stop_command.to_s.gsub("{{PID}}", actual_pid.to_s)
         logger.warning "Executing stop command: #{cmd}"
-        
-        unless System.execute_blocking(cmd)
-          logger.warning "Stop command execution returned non-zero exit code"
+
+        result = System.execute_blocking(cmd, :uid => self.uid, :gid => self.gid)
+        unless result[:exit_code].zero?
+          logger.warning "Stop command execution returned non-zero exit code:"
+          logger.warning result.inspect
         end
         
       else
@@ -265,8 +270,10 @@ module Bluepill
       if restart_command
         logger.warning "Executing restart command: #{restart_command}"
         
-        unless System.execute_blocking(restart_command)
-          logger.warning "Restart command execution returned non-zero exit code"
+        result = System.execute_blocking(restart_command, :uid => self.uid, :gid => self.gid)
+        unless result[:exit_code].zero?
+          logger.warning "Restart command execution returned non-zero exit code:"
+          logger.warning result.inspect
         end
         
         self.skip_ticks_for(restart_grace_time)
@@ -294,7 +301,14 @@ module Bluepill
     
     def actual_pid
       @actual_pid ||= begin
-        File.read(pid_file).to_i if pid_file && File.exists?(pid_file)
+        if pid_file
+          if File.exists?(pid_file)
+            File.read(pid_file).to_i 
+          else
+            logger.warning("pid_file #{pid_file} does not exist or cannot be read")
+            nil
+          end
+        end
       end
     end
     
@@ -310,24 +324,7 @@ module Bluepill
       File.unlink(pid_file) if pid_file && File.exists?(pid_file)
     end
     
-    def drop_privileges
-      begin
-        require 'etc'
-        
-        uid_num = Etc.getpwnam(self.uid).uid if self.uid
-        gid_num = Etc.getgrnam(self.gid).gid if self.gid
-
-        ::Process.groups = [gid_num] if self.gid
-        ::Process::Sys.setgid(gid_num) if self.gid
-        ::Process::Sys.setuid(uid_num) if self.uid
-      rescue ArgumentError, Errno::EPERM, Errno::ENOENT => e
-        # TODO: log exceptions elsewhere
-        File.open("/tmp/exception.log", "w+"){|f| puts e}
-      end
-    end
-    
-    
-    # Internal State Methods
+     # Internal State Methods
     def skip_ticks_for(seconds)
       # TODO: should this be addative or longest wins?
       #       i.e. if two calls for skip_ticks_for come in for 5 and 10, should it skip for 10 or 15?

data/lib/bluepill/system.rb

@@ -1,3 +1,5 @@
+require 'etc'
+
 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
@@ -28,21 +30,110 @@ module Bluepill
       end
     end
     
-    def execute_non_blocking(cmd)
-      if Daemonize.safefork
-        # In parent, return immediately
-        return
+    # Returns the pid of the child that executes the cmd
+    def daemonize(cmd, options = {})
+      rd, wr = IO.pipe
+
+      if child = Daemonize.safefork
+        # we do not wanna create zombies, so detach ourselves from the child exit status
+        ::Process.detach(child)
+        
+        # parent
+        wr.close
+        
+        daemon_id = rd.read.to_i
+        rd.close
+          
+        return daemon_id if daemon_id > 0
         
       else
-        # in child
-        ::Kernel.exec(cmd)
-        # execution should not reach here
+        # child
+        rd.close
+        
+        drop_privileges(options[:uid], options[:gid])
+        
+        daemon_id = Daemonize.call_as_daemon(lambda { ::Kernel.exec(cmd); exit }, nil, cmd)
+        
+        wr.write daemon_id        
+        wr.close
+        
         exit
       end
     end
     
-    def execute_blocking(cmd)
-      ::Kernel.system(cmd)
+    # Returns the stdout, stderr and exit code of the cmd
+    def execute_blocking(cmd, options = {})
+      rd, wr = IO.pipe
+      
+      if child = Daemonize.safefork
+        # parent
+        wr.close
+        
+        cmd_status = rd.read
+        rd.close
+        
+        ::Process.waitpid(child)
+        
+        return Marshal.load(cmd_status)
+        
+      else
+        # child
+        rd.close
+        
+        # create a child in which we can override the stdin, stdout and stderr
+        cmd_out_read, cmd_out_write = IO.pipe
+        cmd_err_read, cmd_err_write = IO.pipe
+        
+        pid = fork {
+          # grandchild
+          drop_privileges(options[:uid], options[:gid])
+          
+          # close unused fds so ancestors wont hang. This line is the only reason we are not
+          # using something like popen3. If this fd is not closed, the .read call on the parent
+          # will never return because "wr" would still be open in the "exec"-ed cmd
+          wr.close
+
+          # we do not care about stdin of cmd
+          STDIN.reopen("/dev/null")
+
+          # point stdout of cmd to somewhere we can read
+          cmd_out_read.close
+          STDOUT.reopen(cmd_out_write)
+          cmd_out_write.close
+
+          # same thing for stderr
+          cmd_err_read.close
+          STDERR.reopen(cmd_err_write)
+          cmd_err_write.close
+
+          # finally, replace grandchild with cmd
+          ::Kernel.exec(cmd)
+        }
+
+        # we do not use these ends of the pipes in the child
+        cmd_out_write.close
+        cmd_err_write.close
+        
+        # wait for the cmd to finish executing and acknowledge it's death
+        ::Process.waitpid(pid)
+        
+        # collect stdout, stderr and exitcode
+        result = {
+          :stdout => cmd_out_read.read,
+          :stderr => cmd_err_read.read,
+          :exit_code => $?.exitstatus
+        }
+
+        # We're done with these ends of the pipes as well
+        cmd_out_read.close
+        cmd_err_read.close
+        
+        # Time to tell the parent about what went down
+        wr.write Marshal.dump(result)
+        wr.close
+
+        exit  
+      end
     end
     
     def store
@@ -68,5 +159,16 @@ module Bluepill
         end
       end
     end
+    
+    # be sure to call this from a fork otherwise it will modify the attributes
+    # of the bluepill daemon
+    def drop_privileges(uid, gid)
+      uid_num = Etc.getpwnam(uid).uid if uid
+      gid_num = Etc.getgrnam(gid).gid if gid
+
+      ::Process.groups = [gid_num] if gid
+      ::Process::Sys.setgid(gid_num) if gid
+      ::Process::Sys.setuid(uid_num) if uid
+    end
   end
 end

data/lib/example.rb

@@ -1,12 +1,13 @@
 require 'rubygems'
 require 'bluepill'
+require 'logger'
 
 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|
-  2.times do |i|
+  0.times do |i|
     app.process("process_#{i}") do |process|
       process.pid_file = "#{ROOT_DIR}/pids/process_#{i}.pid"
       
@@ -21,7 +22,7 @@ Bluepill.application(:sample_app) do |app|
       process.restart_grace_time = 7.seconds
       process.stop_grace_time = 7.seconds
       
-      process.uid = "admin"
+      process.uid = "rohith"
       process.gid = "staff"
       
       # process.checks :cpu_usage, :every => 10, :below => 0.5, :times => [5, 5]
@@ -45,14 +46,18 @@ Bluepill.application(:sample_app) do |app|
     end
   end
   
-  0.times do |i|
+  1.times do |i|
     app.process("group_process_#{i}") do |process|
-      process.start_command = "sleep #{rand(30) + i}"
       process.group = "Poopfaced"
-      process.daemonize = true
-      process.pid_file = "#{ROOT_DIR}/pids/#{process.group}_process_#{i}.pid"
+      process.pid_file = "/Users/rohith/ffs/tmp/pids/mongrel_#{i}.pid"
+      process.start_command = "cd ~/ffs && mongrel_rails start -P #{process.pid_file} -p 3000 -d"
       
-      process.checks :always_true, :every => 10
+      process.start_grace_time = 10.seconds
+      
+      process.uid = "rohith"
+      process.gid = "staff"
+      
+      # process.checks :always_true, :every => 10
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bluepill
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors: 
 - Arya Asemanfar
@@ -11,8 +11,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-22 00:00:00 -07:00
-default_executable: 
+date: 2009-10-23 00:00:00 -07:00
+default_executable: bluepill
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec