rbg 0.9.1

data/bin/rbg

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'rbg'
+
+def die
+    puts "Usage: " + $0 + " run|start|stop|reload -c config_file [-E environment]"
+    Process.exit(1)
+end
+
+begin
+  command = nil
+  while arg = ARGV.shift
+    case arg
+    when '-c'
+      config_file = ARGV.shift
+    when '-E'
+      environment = ARGV.shift
+    else
+      command = arg
+    end
+  end
+  
+  die unless config_file
+  
+  case command
+  when 'run'
+    Rbg.start(config_file, {:background => false, :environment => environment})
+  when 'start'
+    Rbg.start(config_file, {:background => true, :environment => environment})
+  when 'stop'
+    Rbg.stop(config_file)
+  when 'reload'
+    Rbg.reload(config_file)
+  else
+    die
+  end
+rescue Rbg::Error => e
+  $stderr.puts "!!! #{e.message}"
+  Process.exit(1)
+end
+

data/lib/rbg.rb

@@ -0,0 +1,258 @@
+require 'rbg/config'
+
+module Rbg
+  class Error < StandardError; end
+  
+  class << self
+    
+    ## An array of child PIDs for the current process which have been spawned
+    attr_accessor :child_processes
+    
+    ## The path to the config file that was specified
+    attr_accessor :config_file
+    
+    ## Return a configration object for this backgroundable application.
+    def config
+      @config ||= Rbg::Config.new
+    end
+    
+    # Creates a 'parent' process. This is responsible for executing 'before_fork'
+    # and then forking the worker processes.
+    def start_parent
+      # Record the PID of this parent in the Master
+      self.child_processes << fork do
+        # Clear the child process list as this fork doesn't have any children yet
+        self.child_processes = Array.new
+
+        # Set the process name (Parent)
+        $0="#{self.config.name}[P]"
+
+        # Debug information
+        puts "New parent process: #{Process.pid}"
+        STDOUT.flush
+        
+        # Run the before_fork function
+        self.config.before_fork.call
+        
+        # Fork an appropriate number of workers
+        self.fork_workers(self.config.workers)
+        
+        # If we get a TERM, send the existing workers a TERM then exit
+        Signal.trap("TERM", proc {
+          # Debug output
+          puts "Parent got a TERM."
+          STDOUT.flush
+
+          # Send TERM to workers
+          kill_child_processes
+          
+          # Exit the parent
+          Process.exit(0)
+        })
+        
+        # Ending parent processes on INT is not useful or desirable
+        # especially when running in the foreground
+        Signal.trap('INT', proc {})
+        
+        # Parent loop, the purpose of this is simply to do nothing until we get a signal
+        # We may add memory management code here in the future
+        loop do
+          sleep 1
+        end
+        
+      end
+    end
+    
+    # Wrapper to fork multiple workers
+    def fork_workers(n)
+      n.times do |i|
+        self.fork_worker(i)
+      end
+    end
+    
+    # Fork a single worker
+    def fork_worker(i)
+      pid = fork do
+        # Set process name
+        $0="#{self.config.name}[#{i}]"
+        
+        # Ending workers on INT is not useful or desirable
+        Signal.trap('INT', proc {})
+        # Restore normal behaviour
+        Signal.trap('TERM', proc {Process.exit(0)})
+        
+        # Execure before_fork code
+        self.config.after_fork.call
+        
+        # The actual code to run
+        require self.config.script
+      end
+      
+      # Print some debug info and save the pid
+      puts "Spawned '#{self.config.name}[#{i}]' as PID #{pid}"
+      STDOUT.flush
+      
+      # Detach to eliminate Zombie processes later
+      Process.detach(pid)
+      
+      # Save the worker PID into the Parent's child process list
+      self.child_processes << pid
+    end
+    
+    # Kill all child processes
+    def kill_child_processes
+      puts 'Killing child processes...'
+      STDOUT.flush
+      self.child_processes.each do |p|
+        puts "Killing: #{p}"
+        STDOUT.flush
+        begin
+          Process.kill('TERM', p)
+        rescue
+          puts "Process already gone away"
+        end
+      end
+      # Clear the child process list because we just killed them all
+      self.child_processes = Array.new
+    end
+    
+    # This is the master process, it spawns some workers then loops
+    def master_process
+      # Log the master PID
+      puts "New master process: #{Process.pid}"
+      STDOUT.flush
+      
+      # Set the process name
+      $0="#{self.config.name}[M]"
+      
+      # Fork a Parent process
+      # This will load the before_fork in a clean process then fork the script as required
+      self.start_parent
+      
+      # If we get a USR1, send the existing workers a TERM before starting some new ones
+      Signal.trap("USR1", proc {
+        puts "Master got a USR1."
+        STDOUT.flush
+        self.kill_child_processes
+        load_config
+        self.start_parent
+      })
+      
+      # If we get a TERM, send the existing workers a TERM before bowing out
+      Signal.trap("TERM", proc {
+        puts "Master got a TERM."
+        STDOUT.flush
+        kill_child_processes
+        Process.exit(0)
+      })
+      
+      # INT is useful for when we don't want to background
+      Signal.trap("INT", proc {
+        puts "Master got an INT."
+        STDOUT.flush
+        kill_child_processes
+        Process.exit(0)
+      })
+      
+      # Main loop, the purpose of this is simply to do nothing until we get a signal
+      loop do
+        sleep 1
+      end
+    end
+    
+    # Load or reload the config file defined at startup
+    def load_config
+      @config = nil
+      if File.exist?(self.config_file.to_s)
+        load self.config_file
+      else
+        raise Error, "Configuration file not found at '#{config_file}'"
+      end
+    end
+    
+    def start(config_file, options = {})
+      options[:background]  ||= false
+      options[:environment] ||= "development"
+      $rbg_env = options[:environment].dup
+      
+      # Define the config file then load it
+      self.config_file = config_file
+      self.load_config
+      
+      # Initialize child process array
+      self.child_processes = Array.new
+      
+      if options[:background]
+        # Fork the master control process and return to a shell
+        master_pid = fork do
+          # Ignore input and log to a file
+          STDIN.reopen('/dev/null')
+          if self.config.log_path
+            STDOUT.reopen(self.config.log_path, 'a')
+            STDERR.reopen(self.config.log_path, 'a')
+          else
+            raise Error, "Log location not specified in '#{config_file}'"
+          end
+          
+          self.master_process
+        end
+        
+        # Ensure the process is properly backgrounded
+        Process.detach(master_pid)
+        if self.config.pid_path
+          File.open(self.config.pid_path, 'w') {|f| f.write(master_pid) }
+        end
+        
+        puts "Master started as PID #{master_pid}"
+      else
+        # Run using existing STDIN / STDOUT
+        self.master_process
+      end
+    end
+    
+    # Get the PID from the pidfile defined in the config
+    def pid_from_file
+      raise Error, "PID not defined in '#{config_file}'" unless self.config.pid_path
+      begin
+        pid = File.read(self.config.pid_path).strip.to_i
+      rescue
+        raise Error, "PID file not found"
+      end
+      return pid
+    end
+    
+    # Stop the running instance
+    def stop(config_file)
+      # Define the config file then load it
+      self.config_file = config_file
+      self.load_config
+      
+      pid = self.pid_from_file
+      
+      begin
+        Process.kill('TERM', pid)
+        puts "Sent TERM to PID #{pid}"
+      rescue
+        raise Error, "Process #{pid} not found"
+      end
+    end
+    
+    # Reload the running instance
+    def reload(config_file)
+      # Define the config file then load it
+      self.config_file = config_file
+      self.load_config
+      
+      pid = self.pid_from_file
+      
+      begin
+        Process.kill('USR1', pid)
+        puts "Sent USR1 to PID #{pid}"
+      rescue
+        raise Error, "Process #{pid} not found"
+      end
+    end
+    
+  end
+end
+

data/lib/rbg/config.rb

@@ -0,0 +1,40 @@
+module Rbg
+  class Config
+    
+    ## The name of the application as used in the proclist
+    attr_accessor :name
+    
+    ## The ruby script which should be backgrounded
+    attr_accessor :script
+    
+    ## Path to the log file for the master process
+    attr_accessor :log_path
+    
+    ## Path to the PID file for the master process
+    attr_accessor :pid_path
+    
+    ## Number of workers to start
+    attr_accessor :workers
+    
+    ## Block of code to be executed in the master process before the process
+    ## has been forked.
+    def before_fork(&block)
+      if block_given?
+        @before_fork = block
+      else
+        @before_fork
+      end
+    end
+    
+    ## Block of code to be executed in the child process after forking has
+    ## taken place.
+    def after_fork(&block)
+      if block_given?
+        @after_fork = block
+      else
+        @after_fork
+      end
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: rbg
+version: !ruby/object:Gem::Version 
+  hash: 57
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 1
+  version: 0.9.1
+platform: ruby
+authors: 
+- Charlie Smurthwaite
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-25 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: charlie@atechmedia.com
+executables: 
+- rbg
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/rbg
+- lib/rbg/config.rb
+- lib/rbg.rb
+has_rdoc: true
+homepage: http://www.atechmedia.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby Backgrounder allows multiple copies of ruby scripts to be run in the background and restarted
+test_files: []
+