process_control 0.1.0

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2011-07-13
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,8 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/process_control
+lib/process_control.rb
+test/test_process_control.rb

data/README.txt

@@ -0,0 +1,93 @@
+= process_control
+
+* http://cyberconnect.biz/opensource
+
+== DESCRIPTION:
+
+Process Control is a wrapper to allow easy control for any external daemon type process.  The
+Process Control app is minimal, such that there should never be any errors and the process can
+run in a daemon state yielding a consistant means for controlling a child process.  The child 
+process being controlled is done so via signals, QUIT, CONT, HUP, USR1 and TERM (see SIGNALS 
+section).
+
+== FEATURES
+
+* Monitor interval: Sleep time between each cycle.
+* Monitor exec: Child command to execute.  Command should be a standalone daemon 
+  that doesn't not exit.
+* Monitor exec_live_cfg, optional config file to be passed to the exec attribute if you have more
+  than one config file.  If your application being controlled only requires one config file put
+  the config parameter in the exec string itself.
+* Monitor exec_maintenance_cfg config file to use when your application is in maintenance mode
+* Monitor kill_signal: Signal to use when stopping the child process, defalting to TERM.
+* Monitor kill_children: If the child process defined by exec launches additional processes,
+  kill all children of the exec process.
+* Monitor usr1: User defined Proc to execute.  This is usefull for external system monitoring.  
+  For example, the Proc could create a tmp file, and when USR1 is sent to the process_control pid
+  that tmp file would be created.  Now the external monotor has an easy means to ensure that the
+  process_control process is functioning properly.
+* Monitors the process launched defined by exec, and if not found running, starts it.
+
+== SIGNALS
+
+Signals need to be sent to the process_control process and not the child spawned.  Process Control in turn will perform actions based on the signal provided.
+
+* QUIT: Kill the child process, and puts the monitoring of the child process in a halt state.  If exec_live_cfg and exec_maintenance_cfg are set, swap the config file from live to maintenance and start the process.  Multiple config files are handy when you have down time to a web site and you need to display a certain page to the user while you upgrade your application.
+* CONT: Start the child process, and enables the monitor to restart the child process if found not running.  If exec_live_cfg and exec_maintenance_cfg are set the config file is set to live before the application is started.
+* HUP:  Restart the child process
+* TERM: Stop both the child process and process_control itself
+* USR1: Execute the Proc code block defined in the config
+
+== SYNOPSIS:
+
+/usr/bin/process_control --config <full path to config file>
+
+Example config file for a web agent running as a daemon, outside of the web framework itself.  If
+the code below was saved in a file named /tmp/start_cert.rb you would launch cert.rb via process_control by:
+
+process_control --config /tmp/start_cert.rb
+
+ProcessControl.run { |monitor|
+  monitor.interval = 10
+  monitor.exec = "ruby /cyber_platform/vendor/plugins/phased_layer_tunnel/agents/cert.rb"
+  monitor.kill_children = true
+  monitor.kill_signal='TERM'
+  monitor.usr1 = Proc.new {
+    status_f = "/share/status/cyber_platform_cert.rb"
+    begin
+      FileUtils.rm_f status_f if File.exists?(status_f)
+    rescue => e
+    end
+    begin
+      fd = File.open(status_f, 'w+')
+      fd.close
+    rescue => e
+    end
+  }
+  monitor.monitor # required last line, or child process will not be launched
+}
+
+Example for nginx hosting a rails application given live and maintenance configurations.  When QUIT is sent to process_control the maintenance config file will be utilized so that users will still be able to access the site, but given an explanation there's maintenance.  And when CONT is sent, toggle the config back to live, restoring the full functionality of the application:
+
+ProcessControl.run { |monitor|
+  monitor.interval = 10
+  monitor.exec = "/usr/local/nginx/sbin/nginx -c"
+  monitor.exec_live_cfg = "/cyber_platform/config/nginx.conf"
+  monitor.exec_maintenance_cfg = "/cyber_platform/config/nginx.conf.maintenance"
+  monitor.kill_children = false
+  monitor.kill_signal='QUIT'
+  monitor.monitor # required last line, or child process will not be launched
+}
+
+
+== REQUIREMENTS:
+
+Tested on GNU/Linux, but should work on other variants of Unix type OS's as well.
+
+== INSTALL:
+
+* sudo gem install process_control
+
+== LICENSE:
+
+GPLv3: http://www.gnu.org/licenses/gpl.html 

data/Rakefile

@@ -0,0 +1,26 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+
+Hoe.spec 'process_control' do
+  # HEY! If you fill these out in ~/.hoe_template/Rakefile.erb then
+  # you'll never have to touch them again!
+  # (delete this comment too, of course)
+
+  # developer('FIX', 'FIX@example.com')
+
+  # self.rubyforge_name = 'process_controlx' # if different than 'process_control'
+  developer('', 'cliff.cyphers@gmail.com')
+  extra_deps << 'platform_helpers'
+  extra_deps << 'wait_for'
+  extra_deps << 'process_mgt'
+end
+
+# vim: syntax=ruby

data/bin/process_control

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+
+require 'rubygems'
+require 'process_mgt'
+require 'process_control'
+require 'getoptlong'
+
+module Init
+  def run
+    opts = GetoptLong.new( [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+                           [ '--config', '-c', GetoptLong::REQUIRED_ARGUMENT ],
+                           [ '--exec', '-e', GetoptLong::REQUIRED_ARGUMENT ] )
+    dir = nil
+    name = nil
+    repetitions = 1
+    opts.each { |opt, arg|
+      case opt
+        when '--help'
+          RDoc::usage
+        when '--config'
+          type = 'config'
+          f = File.expand_path("#{arg}")
+          raise StandardError, "config file not found: #{f}" unless File.exists?(f)
+          self_pid = Process.pid
+          #p "SELF: #{self_pid}" 
+          all_pids = ProcessMgt.pids_with_children(:search => "--config #{arg}")
+          #p "ALL_PIDS: #{all_pids}" 
+          kill_pids = all_pids.gsub(/#{self_pid}/, '')
+          #p "KILL_PIDS: #{kill_pids}"
+          ProcessMgt.kill(:pid_list => kill_pids)
+          #ProcessMgt.kill(:search => "--config #{arg}")
+          load f
+        when '--exec'
+          type = 'exec'
+          begin
+            ProcessControl.run { |monitor|
+              monitor.interval = 5
+              monitor.exec = arg
+              monitor.kill_children = true
+              monitor.kill_signal='TERM'
+              monitor.monitor
+            }
+          rescue => e
+          end
+      end
+    }
+  end
+
+  module_function :run
+end
+
+Init.run
+

data/lib/process_control.rb

@@ -0,0 +1,155 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+require 'rubygems'
+require 'wait_for'
+BASE = File.expand_path(File.dirname(__FILE__)) + '/..'
+require "process_mgt"
+
+
+class ProcessHellFire
+  attr_accessor :exec, :interval, :kill_children, :exec_live_cfg, :exec_maintenance_cfg, :kill_signal, :usr1
+  def initialize
+    @exec = ''
+    @orig_exec = ''
+    @wait_until_timeout = 0
+    @wait_until_proc = nil
+    @kill_children = kill_children
+    @interval = interval
+    @restart_items = []
+    @exec_live_cfg = ''
+    @exec_maintenance_cfg = ''
+    @kill_signal = 'TERM'
+    @restart = true
+    @usr1= ''
+    @mode = 'live'
+  end
+
+  def logger
+    begin
+      require BASE + '/lib/log'
+      include InlineLogger
+    rescue => e
+      puts "EEEEE: #{e.inspect}"
+    end
+  end
+
+  def wait_until(timeout=10, proc_='')
+    raise StandardError unless proc_.kind_of?(Proc)
+    @wait_until_timeout = timeout
+    @wait_until_proc = proc_
+  end
+
+  def restart_on_condition(condition)
+    @restart_items << condition
+  end
+ 
+   
+  def monitor
+    raise StandardError if @exec == '' || @interval < 2
+    set_traps
+    while true
+      exec = use_exec
+      pids = ProcessMgt.pids_with_children(:search => exec, :exclude => 'process_control')
+      res=false
+      @restart_items.each { |item|
+        begin
+          next unless item.respond_to?(:call)
+          res = item.call
+          break if res == true
+        rescue => e
+        end
+      }
+      if (pids == '' || res) && @restart
+        restart 
+      end
+      sleep @interval
+    end
+  end
+
+  def stop
+    stop_items = []
+
+    if @exec_live_cfg == '' && @exec_maintenance_cfg == ''
+      stop_items << @exec
+    else
+      stop_items += [@exec_live_cfg, @exec_maintenance_cfg]
+    end
+
+    stop_items.each { |exec|
+      p "stop with exec: #{exec}"
+      begin
+        if @kill_children
+          ProcessMgt.kill(:search => exec, :with_children => nil, :force => true, :exclude => 'process_control')
+        else
+          ProcessMgt.kill(:search => exec, :signal => @kill_signal, :exclude => 'process_control')
+        end
+      rescue => e
+        puts "EEEEE: #{e.inspect}"
+      end
+    }
+  end
+
+  def start
+    cfg = use_exec
+    Thread.new {
+      begin
+        Process.fork {Process.exec(cfg)}
+        @pid, status = Process.wait2
+      rescue => e
+        p e.inspect
+      end
+    }
+    wait_for(@wait_until_timeout) { @wait_until_proc } if @wait_until_proc.kind_of?(Proc)
+  end
+
+  def restart
+    stop
+    start 
+  end
+
+  def use_exec
+    if @exec_live_cfg != '' && @exec_maintenance_cfg != ''
+      if @mode == 'live'
+        return "#{@exec} #{@exec_live_cfg}"
+      else
+        return "#{@exec} #{@exec_maintenance_cfg}"
+      end
+    else
+      return @exec
+    end
+  end
+
+  def set_traps
+    trap('TERM') { 
+      stop
+      exit
+    }
+    trap('HUP') { restart }
+    trap('QUIT') { 
+      @mode = 'maintenance'
+      @restart = false
+      restart
+    }
+    trap('CONT') { 
+      @mode = 'live'
+      restart
+      @restart = true
+    }
+    trap('USR1') { @usr1.call if @usr1.kind_of?(Proc) }
+  end
+
+  private :set_traps, :start, :stop, :restart, :use_exec
+end
+
+module ProcessControl
+  VERSION = '0.1.0'
+  def self.run(&blk)
+    raise ArgumentError unless block_given?
+    cfg = ProcessHellFire.new()
+    yield cfg 
+  end 
+end

data/test/test_process_control.rb

@@ -0,0 +1,16 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+require "./lib/process_control"
+require 'process_mgt'
+require "test/unit"
+
+class TestProcessControl < Test::Unit::TestCase
+  def test_
+  end
+
+
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: process_control
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- ""
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: platform_helpers
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: wait_for
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: process_mgt
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.12"
+  type: :development
+  version_requirements: *id004
+description: |-
+  Process Control is a wrapper to allow easy control for any external daemon type process.  The
+  Process Control app is minimal, such that there should never be any errors and the process can
+  run in a daemon state yielding a consistant means for controlling a child process.  The child 
+  process being controlled is done so via signals, QUIT, CONT, HUP, USR1 and TERM (see SIGNALS 
+  section).
+email: 
+- cliff.cyphers@gmail.com
+executables: 
+- process_control
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/process_control
+- lib/process_control.rb
+- test/test_process_control.rb
+- .gemtest
+homepage: http://cyberconnect.biz/opensource
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: process_control
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: Process Control is a wrapper to allow easy control for any external daemon type process
+test_files: 
+- test/test_process_control.rb