rsence 2.0.0.pre → 2.0.0.1.pre

data/lib/conf/default.rb

@@ -12,6 +12,10 @@ require 'rubygems'
 require 'rack'
 require 'yaml'
 
+if RUBY_VERSION.to_f >= 1.9
+  Encoding.default_external = Encoding::ASCII_8BIT
+end
+
 # Legacy:
 LIB_PATHS = []
 PIDPATH = File.join(SERVER_PATH,'var','run')
@@ -20,8 +24,6 @@ def load_legacy( local_config_file_path )
   require local_config_file_path[0..-4]
 end
 
-module RSence
-
 class Configuration
   def array_merge( target, source )
     source.each do |item|
@@ -55,10 +57,21 @@ class Configuration
       end
     end
   end
-  def initialize
+  def wizard
+    puts "Please answer the following questions, blank lines equal to the default in brackets:"
+    require 'conf/wizard'
+    if File.directory?( File.join( Dir.pwd, 'conf' ) )
+      wizard_conf_file = File.join( Dir.pwd, 'conf', 'local_conf.yaml' )
+    else
+      wizard_conf_file = File.join( SERVER_PATH, 'conf', 'local_conf.yaml' )
+    end
+    wizard_config_data = ConfigWizard.new(config).run( wizard_conf_file )
+    config.merge!( wizard_config_data )
+  end
+  def initialize(args)
     ## Paths for log and pid files
-    pidpath = File.join(SERVER_PATH,'var','run')
-    logpath = File.join(SERVER_PATH,'var','log')
+    pidpath = File.join( args[:env_path], 'run' )
+    logpath = File.join( args[:env_path], 'log' )
     
     yaml_conf_path = File.join( SERVER_PATH, 'conf', 'default_conf.yaml' )
     
@@ -69,8 +82,9 @@ class Configuration
     config = YAML.load( File.read( yaml_conf_path ) )
     config[:transporter_conf][:messages] = strings[:messages][:transporter]
     
-    default_plugins_path = File.join( SERVER_PATH, 'plugins' )
+    config[:client_pkg][:src_dirs].unshift( File.join( SERVER_PATH, 'js' ) )
     
+    default_plugins_path = File.join( SERVER_PATH, 'plugins' )
     unless config[:plugin_paths].include? default_plugins_path
       config[:plugin_paths].push( default_plugins_path )
     end
@@ -84,28 +98,31 @@ class Configuration
     ## Create default local configuratation override file, if it does not exist:
     local_config_file_paths = [
       File.join(SERVER_PATH,'conf','local_conf.yaml'),
+      '/etc/rsence/config.yaml',
+      File.expand_path('~/.rsence/config.yaml'),
       File.join( File.split( SERVER_PATH )[0], 'conf', 'local_conf.yaml' ),
-      File.join( Dir.pwd, 'conf', 'local_conf.yaml' ),
+      # File.join( Dir.pwd, 'conf', 'local_conf.yaml' ),
       File.join(SERVER_PATH,'conf','local_conf.rb'),
-      File.join( File.split( SERVER_PATH )[0], 'conf', 'local_conf.rb' ),
-      File.join( Dir.pwd, 'conf', 'local_conf.rb' )
+      # File.join( File.split( SERVER_PATH )[0], 'conf', 'local_conf.rb' ),
+      # File.join( Dir.pwd, 'conf', 'local_conf.rb' )
     ]
-    if ARGV.include?('--config')
-      argv_conf_file = ARGV[ARGV.index('--config')+1]
-      if not argv_conf_file.begin_with? '/'
-        argv_conf_file = File.join( Dir.pwd, conf_file )
-      end
-      local_config_file_paths.push( argv_conf_file )
+    
+    args[:conf_files].each do |conf_file|
+      local_config_file_paths.push( conf_file )
     end
     
-    local_config_file_path_found = false
     local_config_file_paths.each do |local_config_file_path|
       if File.exists? local_config_file_path and File.file? local_config_file_path
         if local_config_file_path.end_with? '.yaml'
+          puts "loading config file: #{local_config_file_path}" if args[:verbose]
           local_conf = YAML.load( File.read( local_config_file_path ) )
+          unless local_conf.class == Hash
+            warn "invalid configuration file: #{local_config_file_path.inspect}"
+            next
+          end
           hash_merge( config, local_conf )
-          local_config_file_path_found = true
         elsif local_config_file_path.end_with? '.rb'
+          warn "WARNING: '.rb' configuration files are deprecated!"
           # Legacy work-arounds
           prev_pidpath = PIDPATH
           prev_logpath = LOGPATH
@@ -115,47 +132,35 @@ class Configuration
           pidpath = PIDPATH if PIDPATH != prev_pidpath
           logpath = LOGPATH if LOGPATH != prev_logpath
           # /Legacy work-arounds
-          local_config_file_path_found = true
         else
           warn "Only Yaml and Ruby configuration files are allowed at this time."
         end
       end
     end
     
-    if not local_config_file_path_found or ARGV.include? '--run-wizard'
-      puts "NOTE:  No local configuration file found, running the, configuration wizard." unless ARGV.include? '--run-wizard'
-      puts "Please answer the following questions, blank lines equal to the default in brackets:"
-      require 'conf/wizard'
-      if File.directory?( File.join( Dir.pwd, 'conf' ) )
-        wizard_conf_file = File.join( Dir.pwd, 'conf', 'local_conf.yaml' )
-      else
-        wizard_conf_file = File.join( SERVER_PATH, 'conf', 'local_conf.yaml' )
-      end
-      wizard_config_data = ConfigWizard.new(config).run( wizard_conf_file )
-      config.merge!( wizard_config_data )
-    end
-    
-    if not config[:database].has_key?( :ses_db ) and config[:database].has_key?( :auth_setup )
-      warn "WARNING: The database is not configured with a :ses_db url."
-      warn "         You are advised to convert the :root_setup and :auth_setup keys of"
-      warn "         config[:database] to the new url format."
-      db_auth = config[:database][:auth_setup]
-      config[:database][:ses_db] = "mysql://#{db_auth[:user]}:#{db_auth[:pass]}@#{db_auth[:host]}:#{db_auth[:port]}/#{db_auth[:db]}"
-      warn "      -> Performed automatic conversion of :auth_setup as"
-      warn "         config[:database][:ses_db] = #{config[:database][:ses_db].inspect}"
+    env_plugins_path = File.join( args[:env_path], 'plugins' )
+    unless config[:plugin_paths].include? env_plugins_path
+      config[:plugin_paths].push( env_plugins_path )
     end
     
+    config[:trace] = true if args[:trace_js]
+    config[:debug_mode] = true if args[:debug]
+    config[:http_server][:latency] = args[:latency]
+    config[:http_server][:port] = args[:port] if args[:port]
+    config[:http_server][:bind_address] = args[:addr] if args[:addr]
+    config[:http_server][:rack_require] = args[:server] if args[:server]
+    config[:session_conf][:reset_sessions] = true if args[:reset_ses]
     
-    config[:trace] = true if ARGV.include?('--trace-js')
-    config[:debug_mode] = true if ARGV.include?('-d') or ARGV.include?('--debug')
-    config[:http_server][:latency] = ARGV[ARGV.index('--latency')+1].to_i if ARGV.include?('--latency')
-    config[:http_server][:port] = ARGV[ARGV.index('--port')+1].to_i if ARGV.include?('--port')
-    config[:http_server][:bind_address] = ARGV[ARGV.index('--addr')+1] if ARGV.include?('--addr')
-    config[:http_server][:rack_require] = ARGV[ARGV.index('--server')+1] if ARGV.include?('--server')
-    config[:session_conf][:reset_sessions] = true if ARGV.include?('--reset-sessions=true') or ARGV.include?('--reset-sessions')
     config[:daemon][:pid_fn] = File.join(pidpath, "rsence.pid") unless config[:daemon].has_key?(:pid_fn)
     config[:daemon][:log_fn] = File.join(logpath, "rsence") unless config[:daemon].has_key?(:log_fn)
     
+    if config[:database][:ses_db].start_with?('sqlite://')
+      db_url = config[:database][:ses_db].split('sqlite://')[1]
+      unless db_url.start_with?('/')
+        db_url = File.join( args[:env_path], db_url )
+        config[:database][:ses_db] = "sqlite://#{db_url}"
+      end
+    end
     
     ## Broker configuration
     [   ## POST-requests
@@ -210,11 +215,5 @@ class Configuration
   end
   attr_reader :config
 end
-@@config = Configuration.new.config
-def self.config
-  @@config
-end
-
-end
 
 

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
-