rsence 2.0.0.0.pre → 2.0.0.1.pre

data/lib/daemon/daemon.rb

@@ -8,9 +8,6 @@
  ##
  #++
 
-# Use the default configuration:
-require 'conf/default'
-
 # Use rubygems to load rack
 require 'rubygems'
 require 'rack'
@@ -47,247 +44,336 @@ require 'transporter/transporter'
 require 'http/broker'
 
 
-module RSence
-
-# adapted from:
-# http://snippets.dzone.com/posts/show/2265
+module ::RSence
 
-require 'fileutils'
+@@launch_pid = Process.pid
+def self.launch_pid
+  return @@launch_pid
+end
 
+# The Controller module handles the damonizing
+# operations of the process referred to as +daemon+
 module Daemon
   
-  class Base
-    def self.pid_fn
-      RSence.config[:daemon][:pid_fn]
-    end
-    def self.log_fn
-      RSence.config[:daemon][:log_fn]
-    end
-    def self.daemonize
-      Controller.daemonize(self)
+  # Writes the process id to disk, the pid_fn method of the daemon contains
+  # the name of the pid file.
+  def self.write_pid( daemon, pid )
+    File.open( daemon.pid_fn, 'w' ) do |pidfile|
+      pidfile.write( pid )
     end
   end
   
-  module PidFile
-    def self.store(daemon, pid)
-      dir_path_pid = File.split( daemon.pid_fn )[0]
-      FileUtils.mkdir_p( dir_path_pid ) unless File.exists? dir_path_pid
-      File.open(daemon.pid_fn, 'w') {|f| f << pid}
-    end
-    def self.recall(daemon)
-      IO.read(daemon.pid_fn).to_i rescue nil
-    end
+  # Reads the process id from disk, the pid_fn method of the daemon contains
+  # the name of the pid file. Returns nil on errors.
+  def self.read_pid( daemon )
+    File.read( daemon.pid_fn ).to_i rescue nil
   end
   
-  module Controller
-    
-    def self.print_status(daemon)
-      is_running = self.status(daemon)
-      puts "Riassence Framework is #{'not ' unless is_running}running"
+  def self.responds?( daemon )
+    wait_signal_response( daemon, 'USR2' )
+  end
+  
+  # Reads the pid file and calls the process.
+  # Returns true if the process responds, false otherwise (no process)
+  def self.status( daemon )
+    pid = read_pid( daemon )
+    return nil if not pid
+    return responds?( daemon )
+  end
+  
+  # Redirects standard input and errors to the log files
+  def self.start_logging( daemon )
+    outpath = "#{daemon.log_fn}.stdout"
+    errpath = "#{daemon.log_fn}.stderr"
+    STDOUT.reopen( outpath, (File.exist?( outpath ) ? 'a' : 'w') )
+    STDOUT.sync = true
+    STDERR.reopen( errpath, (File.exist?( errpath ) ? 'a' : 'w') )
+    STDERR.sync = true
+  end
+  
+  def self.write_signal_response( daemon, signal )
+    sig_fn = daemon.pid_fn+'.response.'+signal
+    File.open(sig_fn,'w') do |file|
+      file.write(Process.pid.to_s)
     end
-    
-    ## Status is not entirely reliable
-    def self.status(daemon)
-      if File.file?(daemon.pid_fn)
-        begin
-          pid = File.read(daemon.pid_fn).to_i
-          pid && Process.kill('USR2',pid)
-          return true
-        rescue Errno::ESRCH => e
-          return false
-        end
-      end
-      return false
+  end
+  
+  def self.delete_signal_response( daemon, signal )
+    sig_fn = daemon.pid_fn+'.response.'+signal
+    if File.file?( sig_fn )
+      File.delete( sig_fn )
     end
-    
-    def self.open_log( outpath, errpath )
-      dir_path_out = File.split( outpath )[0]
-      FileUtils.mkdir_p( dir_path_out ) unless File.exists? dir_path_out
-      dir_path_err = File.split( outpath )[0]
-      FileUtils.mkdir_p( dir_path_err ) unless File.exists? dir_path_err
-      if File.exist?( outpath )
-        STDOUT.reopen( outpath, "a" )
-      else
-        STDOUT.reopen( outpath, "w" )
+  end
+  
+  def self.wait_signal_response( daemon, signal, timeout = 10,
+                                 debug_pre = '<', debug_suf = '>', sleep_secs = 0.2 )
+    begin
+      if RSence.args[:verbose]
+        print debug_pre
+        STDOUT.flush
       end
-      if File.exist?( errpath )
-        STDERR.reopen( errpath, "a" )
-      else
-        STDERR.reopen( errpath, "w" )
+      pid = read_pid( daemon )
+      sig_fn = daemon.pid_fn+'.response.'+signal
+      File.delete( sig_fn ) if File.file?( sig_fn )
+      status = Process.kill( signal, pid )
+      time_out = Time.now + timeout
+      until time_out > Time.now or File.file?( sig_fn )
+        if RSence.args[:verbose]
+          print "."
+          STDOUT.flush
+        end
+        sleep sleep_secs
       end
-      STDOUT.sync = true
-      STDERR.sync = true
-    end
-    
-    def self.log_io(daemon)
-      outpath = "#{daemon.log_fn}.stdout"
-      errpath = "#{daemon.log_fn}.stderr"
-      if $DEBUG_MODE
-        Thread.new do
-          puts "Waiting 2 seconds before switching output to log file #{outpath} and .../#{File.split(errpath)[1]}"
-          sleep 2
-          puts "Switching to stdin and stdout to log mode. Follow the log file to see further server output."
-          self.open_log( outpath, errpath )
+      sleep sleep_secs
+      if File.file?( sig_fn )
+        sig_pid = File.read( sig_fn ).to_i
+        if sig_pid != pid
+          puts "Warning, signal PID mismatch. Expected #{pid}, got #{sig_pid}"
         end
+        File.delete( sig_fn )
       else
-        self.open_log( outpath, errpath )
+        puts "Warning, signal response file disappeared! Expected #{sig_fn}"
       end
+      puts debug_suf if RSence.args[:verbose]
+      return true
+    rescue Errno::ESRCH
+      return false
     end
+  end
+  
+  # Traps common kill signals
+  def self.trap_signals( daemon )
     
-    def self.daemonize(daemon)
-      cmd = ARGV[0]
-      if ['i386-mingw32','x86-mingw32'].include? RUBY_PLATFORM
-        if cmd == 'start'
-          warn "Running on Microsoft Windows: unable to background. Using the run command instead of start"
-          cmd = 'run'
-        elsif cmd != 'run'
-          puts "Invalid command: #{cmd.inspect}. Windows supports only run and help."
-          exit
-        end
-      elsif not cmd or not %w[status start stop restart save run].include?( cmd )
-        puts "Invalid command. Please specify one of the following: run, start, stop, restart, status, save or help."
+    # Triggered with 'kill -USR1 `cat rsence.pid`'
+    Signal.trap( 'USR1' ) do 
+      daemon.usr1
+      write_signal_response( daemon, 'USR1' )
+    end
+    Signal.trap('USR2') do 
+      daemon.usr2
+      write_signal_response( daemon, 'USR2' )
+    end
+    ['INT', 'TERM', 'KILL'].each do | signal |
+      Signal.trap( signal ) do
+        puts "RSence killed with signal #{signal.inspect}" if RSence.args[:verbose]
+        daemon.usr1
+        daemon.stop
+        # delete_signal_response( daemon, 'USR1' )
+        # delete_signal_response( daemon, 'USR2' )
+        File.delete( daemon.pid_fn ) if File.file?( daemon.pid_fn )
+        write_signal_response( daemon, signal )
+        puts "Shutdown complete."
         exit
       end
-      case cmd
-      when 'run'
-        puts "Starting as a foreground process."
-        puts "Enter CTRL-C to stop."
-        self.start_fg(daemon)
-      when 'status'
-        self.print_status(daemon)
-      when 'start'
-        self.start(daemon)
-      when 'stop'
-        self.stop(daemon)
-      when 'restart'
-        self.stop(daemon,true)
-        self.start(daemon)
-      when 'save'
-        self.save(daemon)
-      end
     end
-    def self.start_fg(daemon)
-      ['INT', 'TERM', 'KILL'].each do |signal|
-        Signal.trap(signal) do
-          puts "Got signal #{signal.inspect}"
-          daemon.stop
-          exit
+    # Signal.trap('HUP') do
+    #   daemon.restart
+    # end
+  end
+  
+  def self.handle_pid( daemon )
+    if RSence.pid_support?
+      is_running = status( daemon )
+      if is_running
+        puts "RSence is already running."
+        puts "Stop the existing process first: see 'rsence help stop'"
+        if RSence.launch_pid != Process.pid
+          Process.kill( 'INT', RSence.launch_pid )
         end
+        exit
+      elsif not is_running and File.file?( daemon.pid_fn )
+        puts "Stale pid file, removing.."
+        File.delete( daemon.pid_fn )
       end
+      trap_signals( daemon )
+      pid = Process.pid
+      write_pid( daemon, pid ) 
+      return pid
+    else
+      return false
+    end
+  end
+  
+  def self.run( daemon )
+    handle_pid( daemon )
+    daemon.run
+    exit
+  end
+  
+  def self.start( daemon )
+    fork do
+      exit if fork
+      handle_pid( daemon )
       daemon.start
+    end
+    Signal.trap('INT') do
+      puts "RSence startup failed. Please inspect the log and/or run in debug mode."
       exit
     end
-    def self.start(daemon)
-      is_running = self.status(daemon)
-      if is_running
-        puts "Riassence Framework is already running. Try restart."
-        exit
-      elsif not is_running and File.file?(daemon.pid_fn)
-        puts "Stale pid file, removing.."
-        FileUtils.rm(daemon.pid_fn)
-      end
-      fork do
-        Process.setsid
-        exit if fork
-        PidFile.store(daemon, Process.pid)
-        Signal.trap('USR1') do 
-          if @transporter != nil
-            @transporter.plugins.shutdown if @transporter.plugins
-            @transporter.sessions.shutdown if @transporter.session
-          end
-        end
-        Signal.trap('USR2') do 
-          puts "Alive."
-        end
-        ['INT', 'TERM', 'KILL'].each do |signal|
-          Signal.trap(signal) do
-            puts "Got signal #{signal.inspect}"
-            daemon.stop
-            exit
-          end
-        end
-        Signal.trap('HUP') {
-          daemon.restart
-        }
-        STDIN.reopen( "/dev/null" )
-        daemon.start
-      end
-      
-      timeout = Time.now + 10
-      sleep 0.1 until self.status(daemon) or timeout < Time.now
-      
-      if timeout < Time.now
-        puts "Riassence Framework did not start, please check the logfile."
-      else
-        puts "Riassence Framework is running now."
-      end
-      
-      sleep 2.5 if $DEBUG_MODE
-      
-      #Process.kill("USR2", File.read(daemon.pid_fn).to_i)
+    Signal.trap('TERM') do
+      puts "RSence is online at http://#{daemon.addr}:#{daemon.port}/"
+      exit
     end
-    def self.save(daemon,is_restart=false)
-      if !File.file?(daemon.pid_fn)
-        puts "Pid file not found. Is Riassence Framework started?"
-        return if is_restart
-        exit
-      end
-      pid = File.read(daemon.pid_fn).to_i
-      begin
-        pid && Process.kill("USR1", pid)
+    sleep 1 while true
+  end
+  
+  # Sends the USR1 signal to the process, which in turn
+  # calls the save method of the daemon.
+  def self.save( daemon )
+    status_ = status( daemon )
+    if status_
+      if wait_signal_response( daemon, 'USR1', 10, 'saving.', 'saved', 0.3 )
         puts "Session data saved."
-      rescue
-        puts "Error, no such pid (#{pid}) running"
+      else
+        puts "Warning: saving timed out! Session data not saved."
       end
+    elsif status_ == false
+      puts "Warning, no such process (#{pid}) running: unable to save."
+    elsif status_ == nil
+      puts "No pid file: unable to save."
+    else
+      throw "Unexpected process status: #{status_.inspect}"
     end
-    def self.stop(daemon,is_restart=false)
-      self.save(daemon,is_restart)
-      if !File.file?(daemon.pid_fn)
-        puts "Pid file not found. Is Riassence Framework started?"
-        return if is_restart
-        exit
-      end
-      pid = PidFile.recall(daemon)
-      begin
-        pid && Process.kill("TERM", pid)
-        puts "Riassence Framework is stopped now."
-      rescue
-        puts "Error, no such pid (#{pid}) running"
+  end
+  
+  # Sends the TERM signal to the process, which in turn
+  # calls the stop method of the daemon
+  def self.stop( daemon )#,is_restart=false)
+    status_ = status( daemon )
+    if status_
+      if wait_signal_response( daemon, 'TERM', 10, 'killing.', 'killed', 0.3 )
+        puts "RSence is terminated now."
+      else
+        puts "Warning: termination timed out!"
+        puts "RSence might still be running, please ensure manually."
       end
-      FileUtils.rm(daemon.pid_fn)
+    elsif status_ == false
+      puts "Warning, no such process (#{pid}) running."
+    elsif status_ == nil
+      puts "Warning, no pid file (process not running)."
+    else
+      throw "Unexpected process status: #{status_.inspect}"
     end
   end
+  
+  # Main entry point called from the daemon process passing +self+ as +daemon+.
+  def self.daemonize( daemon )
+    
+    # Uses the command-line tool command to decide what to do.
+    case RSence.cmd
+    when :run
+      run( daemon )
+    when :start
+      start( daemon )
+    when :stop
+      stop( daemon )
+    when :restart
+      stop( daemon )
+      start( daemon )
+    when :save
+      save( daemon )
+    end
+  end
+  
 end
 
-class HTTPDaemon < Daemon::Base
-  def self.start
+# Simple process control, constructed here and called from Daemon::Controller
+class HTTPDaemon
+  
+  def run
+    puts "Starting as a foreground process." if RSence.args[:verbose]
+    puts "Press CTRL-C to terminate."
+    
     @transporter = Transporter.new
     
-    unless ARGV.include?('--log-fg')
-      Daemon::Controller.log_io(self)
+    conf = RSence.config[:http_server]
+    
+    unless RSence.args[:log_fg]
+      Daemon.start_logging( self )
     end
     
     # This is the main http handler instance:
     @broker = Broker.start(
       @transporter,
-      RSence.config[:http_server][:rack_handler],
-      RSence.config[:http_server][:bind_address],
-      RSence.config[:http_server][:port]
+      conf[:rack_handler],
+      conf[:bind_address],
+      conf[:port]
     )
     
-    yield @broker if block_given?
-    
   end
-  def self.restart
-    self.stop
-    @broker = nil
-    self.start
+  
+  # Returns the pid file path.
+  def pid_fn
+    RSence.config[:daemon][:pid_fn]
+  end
+  
+  # Returns the log path.
+  def log_fn
+    RSence.config[:daemon][:log_fn]
+  end
+  
+  def addr
+    RSence.config[:http_server][:bind_address]
+  end
+  
+  def port
+    RSence.config[:http_server][:port]
   end
-  def self.stop
+  
+  # Called by Controller#start, contains RSence-specific operations
+  def start
+    
+    @transporter = Transporter.new
+    
+    conf = RSence.config[:http_server]
+    
+    unless RSence.args[:log_fg]
+      Daemon.start_logging( self )
+      STDIN.reopen( "/dev/null" )
+    end
+    
+    Process.setsid
+    
+    # This is the main http handler instance:
+    @broker = Broker.start(
+      @transporter,
+      conf[:rack_handler],
+      conf[:bind_address],
+      conf[:port]
+    )
+    yield @broker
+    
+  end
+  
+  # Called by Controller#stop, contains RSence-specific operations
+  def stop
     @transporter.plugins.shutdown
     @transporter.sessions.shutdown
   end
+  
+  # Called on USR1 signals (save data)
+  def usr1
+    save
+  end
+  
+  # Save state
+  def save
+    puts "Saving."
+    @transporter.plugins.delegate(:flush)
+    @transporter.sessions.store_sessions
+    puts "Saved."
+  end
+  
+  # Called on USR2 signals ("Alive?")
+  def usr2
+    puts "Alive."
+  end
+  
+  # Main entry point, daemonizes itself using Controller.
+  def daemonize!
+    Daemon.daemonize( self )
+  end
+  
 end
 
 end
-

data/lib/plugins/pluginmanager.rb

@@ -81,10 +81,9 @@ class PluginManager
       @sessions = transporter.sessions
     end
     @plugin_paths = plugin_paths
-    puts "Loading plugins..."
+    puts "Loading plugins..." if RSence.args[:verbose]
     scan_plugins
-    puts "Plugins loaded."
-    puts "Riassence Framework is online."
+    puts "Plugins loaded." if RSence.args[:verbose]
     if autoreload
       @thr = Thread.new do
         Thread.pass
@@ -123,7 +122,7 @@ class PluginManager
           if @registry.has_key?( bundle_name.to_sym )
             puts "Disabling bundle #{bundle_name}..."
             unload_bundle( bundle_name.to_sym )
-            if ARGV.include?('-say')
+            if RSence.args[:say]
               Thread.new do
                 Thread.pass
                 system(%{say "Unloaded #{bundle_name.to_s}."})
@@ -135,7 +134,7 @@ class PluginManager
             puts "Loading bundle #{bundle_name}..."
             load_bundle( bundle_path, bundle_name.to_sym, bundle_name+'.rb' )
             call( bundle_name.to_sym, :open )
-            if ARGV.include?('-say')
+            if RSence.args[:say]
               Thread.new do
                 Thread.pass
                 system(%{say "Loaded #{bundle_name.to_s}."})
@@ -149,7 +148,7 @@ class PluginManager
               unload_bundle( bundle_name.to_sym )
               load_bundle( bundle_path, bundle_name.to_sym, bundle_name+'.rb' )
               call( bundle_name.to_sym, :open )
-              if ARGV.include?('-say')
+              if RSence.args[:say]
                 Thread.new do
                   Thread.pass
                   system(%{say "Reloaded #{bundle_name.to_s}."})

data/lib/transporter/transporter.rb

@@ -34,11 +34,9 @@ class Transporter
     @valuemanager = ValueManager.new
     @sessions = SessionManager.new( self )
     @plugins = PluginManager.new( ::RSence.config[:plugin_paths], self, $DEBUG_MODE )
-    
-    # Used by:
-    #   plugins/main/main.rb
-    $SESSION = @sessions
-    
+    if RSence.launch_pid != Process.pid
+      Process.kill( 'TERM', RSence.launch_pid )
+    end
   end
   
   def servlet( request_type, request, response )
@@ -47,7 +45,7 @@ class Transporter
     # if $DEBUG_MODE and uri == $config[:index_html][:respond_address] and request_type == :get
     #   unless ARGV.include?('-no-rescan') or ARGV.include?('--no-rescan')
     #     puts "Reloading plugins."
-    #     if ARGV.include?('-say')
+    #     if RSence.args[:say]
     #       Thread.new do
     #         Thread.pass
     #         system('say "Reloading plugins."')
@@ -55,7 +53,7 @@ class Transporter
     #     end
     #     @plugins.rescan
     #     puts "Plugins reloaded."
-    #     if ARGV.include?('-say')
+    #     if RSence.args[:say]
     #       Thread.new do
     #         Thread.pass
     #         system('say "Plugins reloaded."')

data/plugins/client_pkg/client_pkg.rb

@@ -63,14 +63,17 @@ class ClientPkg < Servlet
       @log_file = nil
     end
     def log( str )
-      puts str
-      return
-      if @last_time < Time.now - 30
-        @last_time = Time.now
-        @log_file.write( %{--- #{@last_time.strftime("%Y-%m-%d %H:%M:%S")} ---\n} )
+      if ::RSence.args[:verbose]
+        puts str
+        return
+      else
+        if @last_time < Time.now - 30
+          @last_time = Time.now
+          @log_file.write( %{--- #{@last_time.strftime("%Y-%m-%d %H:%M:%S")} ---\n} )
+        end
+        @log_file.write( "#{str}\n" )
+        @log_file.flush
       end
-      @log_file.write( "#{str}\n" )
-      @log_file.flush
     end
     def open
       return if @log_file
@@ -104,7 +107,7 @@ class ClientPkg < Servlet
             if @client_build.bundle_changes( @last_change )
               rebuild_client
               puts "Autobuilt."
-              if ARGV.include?('-say')
+              if RSence.args[:say]
                 Thread.new do
                   Thread.pass
                   system('say "Autobuilt."')
@@ -169,7 +172,7 @@ class ClientPkg < Servlet
     
     @thr = false
     
-    @build_logger = BuildLogger.new( File.join(@path,'log','build_log') )
+    @build_logger = BuildLogger.new( File.join(::RSence.args[:env_path],'log','build_log') )
     @build_logger.open
     
     @client_build = ClientPkgBuild.new( ::RSence.config[:client_pkg], @build_logger )

data/plugins/client_pkg/lib/client_pkg_build.rb

@@ -538,7 +538,7 @@ class ClientPkgBuild
   ##    end
   ##    flush
   ##    run
-  ##    `say "Autobuild complete!"` if ARGV.include?('-say')
+  ##    `say "Autobuild complete!"` if RSence.args[:say]
   ##  end
   ##end