rsence 2.0.0.6.pre → 2.0.0.7.pre

data/INSTALL.rdoc

@@ -7,6 +7,7 @@ If you already have a working ruby environment and know what to do, the easiest
 
  gem install rsence --pre
 
+
 Otherwise, follow these instructions:
 
 
@@ -30,7 +31,6 @@ This step applies only to Mac OS X 10.4 Tiger and 10.5 Leopard
 
   sudo port install ruby +thread_hooks
   sudo port install rb-rubygems
-  sudo port install sqlite3-ruby
 
 ==== 1.1.2 Mac OS X 10.6
 
@@ -47,35 +47,49 @@ This step applies only to Debian, Ubuntu and similar Linux distributions.
 
 * Install these packages:
 
-  sudo apt-get install build-essential ruby-full sqlite3-ruby rubygems rake
+  sudo apt-get install build-essential ruby-full rubygems rake
 
 
 === 1.3. Microsoft Windows
 
-Minimal Windows compatibility (Windows has no support for background processes and other UNIX-like features. It works fine for development, but it's not a suggested environment for production.
-Windows compatibility is tested on Windows XP SP3.
-
-Install ruby 1.8.7:
-* Download *ruby 1.8.7* (or newer) from http://rubyinstaller.org/download.html
-* Follow included instructions
-* Install the *Development Kit* (same page)
-  
-Install rmagick first from:
-* Download *rmagick-win32* from http://rubyforge.org/projects/rmagick/
-* Follow included instructions
-  
-Install the *sqlite3.dll* from:
-* Download *sqlitedll* from http://www.sqlite.org/download.html
-* Extract *sqlite3.dll* into C:\\ruby\\bin or other directory in PATH
-
-In the command prompt run:
-  gem install rsence-deps
+RSence works just fine on Windows too, with a few limitations.
+Windows compatibility has been officially tested on Windows XP SP3 and Windows 7 (64 bit).
+
+==== 1.3.1. Install ruby 1.8.7:
+* Download Ruby 1.8.7-p249 (RC2) from http://rubyinstaller.org/download.html
+* Run the downloaded exe to install ruby
+  * In the installation and destination prompt, check these options:
+    * [x] Add Ruby executables to your PATH
+    * [x] Associate .rb and .rbw files with this Ruby installation
+* Download and Install the Development Kit from http://rubyinstaller.org/download.html
+  * Extract the included directories into the directory where you installed ruby.
+    * It's C:\ruby by default.
+
+==== 1.3.2. Install RSence
+* In the command prompt, run:
+  gem update --system
+  gem install rsence --pre
+  rsence help
+
+==== 1.3.3. Create RSence environment
+
+This assumes you have \my_projects directory.
+Also, the 'my_project' project directory is just for illustration purposes.
+Use something else instead of those.
+
+* In the command prompt, run:
+  cd \my_projects
+  rsence initenv my_project
+* Answer the quetions
+* In the command prompt, run:
+  rsence run my_project
+* Open your web browser in the address as configured.
+  * If the address is 0.0.0.0, ether 127.0.0.1 instead.
+
+==== 1.3.4. Windows limitations
+If you install the sqlite dll and the sqlite3-ruby gem, you'll gain persistent sessions and the "Warning: Session database is not available. Can't use persistent sessions" message will disappear when starting up rsence. It's not, however depended on in the default install, because it's not strictly required and makes the first installation much easier.
+Backgrounding is not yet implemented, because POSIX signals are not fully implemented in windows and backgrounding requires some windows service hooks.
 
-NOTICE:
-* Configure http with either *mongrel* or *webrick*
-* Ensure the session database string doesn't include the "C:" -part (when using sqlite)
-* Only the *run* (foreground) mode is supported; no start, stop, restart etc commands because backgrounding isn't possible on Windows unless configured as a Service
-* Prefix all commands with ruby
 
 === 1.99. Other UNIX / Linux systems:
 

data/VERSION

@@ -1 +1 @@
-2.0.0.6.pre
+2.0.0.7.pre

data/conf/default_conf.yaml

@@ -59,9 +59,6 @@
   #
   # Rack handler to use, defaults to thin
   :rack_require: mongrel
-  #
-  # The rack handler; entered automatically.
-  :rack_handler: null
 #
 # When enabled, sets http cache headers
 # to cache content as long as possible.

data/lib/conf/default.rb

@@ -13,8 +13,16 @@ require 'rack'
 require 'yaml'
 
 if RUBY_VERSION.to_f >= 1.9
-  # Encoding.default_external = Encoding::BINARY
-  # Encoding.default_internal = Encoding::BINARY
+  # --
+  # Ruby 1.9 encoding defaults.
+  # This is clearly not enough but a good start for fixing the encoding madness.
+  # ++
+  Encoding.default_external = Encoding::BINARY
+  Encoding.default_internal = Encoding::BINARY
+  # --
+  # Ruby 1.9 doesn't have String#each anymore.
+  # This is a backwards-compatible work-around.
+  # ++
   class String
     def each 
       self.split($/).each { |e| yield e } 
@@ -22,15 +30,10 @@ if RUBY_VERSION.to_f >= 1.9
   end
 end
 
-# Legacy:
-LIB_PATHS = []
-PIDPATH = File.join(SERVER_PATH,'var','run')
-LOGPATH = File.join(SERVER_PATH,'var','log')
-def load_legacy( local_config_file_path )
-  require local_config_file_path[0..-4]
-end
-
+# Configuration handles config files and such.
 class Configuration
+  
+  # Method for combining two arrays
   def array_merge( target, source )
     source.each do |item|
       unless target.include?(item)
@@ -48,6 +51,8 @@ class Configuration
       end
     end
   end
+  
+  # Method for combining two hashes.
   def hash_merge( target, source )
     source.each do |key,item|
       if not target.has_key?key or target[key] != item
@@ -63,60 +68,57 @@ class Configuration
       end
     end
   end
-  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
+  
+  # The args structure comes from RSence::ARGVParser
+  # The dont_expand_path is for special cases, when
+  # Configuration is used without running RSence.
   def initialize( args, dont_expand_path=false )
+    
     ## Paths for log and pid files
     pidpath = File.join( args[:env_path], 'run' )
     logpath = File.join( args[:env_path], 'log' )
     
+    # The default configuration path, this one is distributed with the system.
     yaml_conf_path = File.join( SERVER_PATH, 'conf', 'default_conf.yaml' )
     
+    # Parses the default configuration from yaml first.
+    # This is used as the basis for overriding the defaults in various other config files.
+    config = YAML.load( File.read( yaml_conf_path ) )
+    
+    # The default strings for various messages, this one is distributed with the system.
     yaml_strings_path = File.join( SERVER_PATH, 'conf', 'default_strings.yaml' )
     strings = YAML.load( File.read( yaml_strings_path ) )
     
-    ## Global configuration hash
-    config = YAML.load( File.read( yaml_conf_path ) )
+    # Transporter-specific strings are set.
     config[:transporter_conf][:messages] = strings[:messages][:transporter]
     
+    # Makes the distribution 'js' directory containing the client core the
+    # first client package source directory.
     config[:client_pkg][:src_dirs].unshift( File.join( SERVER_PATH, 'js' ) )
     
+    # The distributed standard plugins are in this directory.
     default_plugins_path = File.join( SERVER_PATH, 'plugins' )
     unless config[:plugin_paths].include? default_plugins_path
       config[:plugin_paths].push( default_plugins_path )
     end
     
-    ## Paths of server libraries
-    lib_paths  = [
-      ## already included in launch.rb; override this one in local config, if needed
-      #File.join( SERVER_PATH, 'lib' )
-    ]
+    # Paths to add to $LOAD_PATH after all configuration files are read.
+    lib_paths  = []
     
-    ## Create default local configuratation override file, if it does not exist:
+    # List of configuration files to look for.
     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(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.yaml' )
     ]
     
+    # Add the additional config files optionally specified in ARGVParser
     args[:conf_files].each do |conf_file|
       local_config_file_paths.push( conf_file )
     end
     
+    # Loads the configuration files
     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'
@@ -127,29 +129,24 @@ class Configuration
             next
           end
           hash_merge( config, local_conf )
-        elsif local_config_file_path.end_with? '.rb'
-          warn "WARNING: '.rb' configuration files are deprecated!"
-          # Legacy work-arounds
-          prev_pidpath = PIDPATH
-          prev_logpath = LOGPATH
-          # /Legacy work-arounds
-          load_legacy( local_config_file_path )
-          # Legacy work-arounds
-          pidpath = PIDPATH if PIDPATH != prev_pidpath
-          logpath = LOGPATH if LOGPATH != prev_logpath
-          # /Legacy work-arounds
         else
-          warn "Only Yaml and Ruby configuration files are allowed at this time."
+          warn "Only Yaml configuration files are supported."
         end
       end
     end
     
+    # Adds the plugins directory of the environment
+    # to the configuration automatically
     env_plugins_path = File.expand_path( 'plugins', args[:env_path] )
     unless config[:plugin_paths].include? env_plugins_path
       config[:plugin_paths].push( env_plugins_path )
     end
+    
+    # At this point, configuration files are read and ready.
+    
     puts "plugin paths: #{config[:plugin_paths].inspect}" if args[:debug]
     
+    # Override configuration options with command-line-options.
     config[:trace] = true if args[:trace_js]
     config[:debug_mode] = true if args[:debug]
     config[:http_server][:latency] = args[:latency]
@@ -158,23 +155,26 @@ class Configuration
     config[:http_server][:rack_require] = args[:server] if args[:server]
     config[:session_conf][:reset_sessions] = true if args[:reset_ses]
     
+    config[:client_pkg][:no_obfuscation] = true if args[:client_pkg_no_obfuscation]
+    config[:client_pkg][:no_whitespace_removal] = true if args[:client_pkg_no_whitespace_removal]
+    
+    # Sets the default pid and log paths used by the HTTPDaemon
     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)
     
+    # Check database path for sqlite databases.
     if config[:database][:ses_db].start_with?('sqlite://') and not dont_expand_path
       db_url = File.expand_path( config[:database][:ses_db].split('sqlite://')[1], args[:env_path] )
       config[:database][:ses_db] = "sqlite://#{db_url}"
     end
     
-    ## Broker configuration
+    # Sets the various standard url prefixes:
     [   ## POST-requests
         # broker_key      # default_uri
         # The default responder for transporter requests.
       [ :x,               File.join(config[:base_url],'x') ],
         # The default responder for cookie-enabled "handshake" transporter requests
       [ :hello,           File.join(config[:base_url],'hello') ],
-        # The default responder for SOAP -requests
-      [ :soap,            File.join(config[:base_url],'SOAP') ],
         # The default responder for file uploads
       [ :u,               File.join(config[:base_url],'U') ],
       
@@ -199,30 +199,29 @@ class Configuration
         config[:broker_urls][broker_key] = default_uri
       end
     end
-    # if RUBY_VERSION.to_f >= 1.9
-    #   config[:no_gzip] = true
-    # end
+    
+    if RUBY_VERSION.to_f >= 1.9
+      # The encodings mess up compression when using ruby1.9
+      warn "Disabling gzip support for ruby 1.9" if args[:debug]
+      config[:no_gzip] = true
+    end
+    
     # The default address of the index_html plugin
     unless config[:index_html].has_key?(:respond_address)
       config[:index_html][:respond_address] = File.join(config[:base_url])
     end
     
-    config[:client_pkg][:no_obfuscation] = true if args[:client_pkg_no_obfuscation]
-    config[:client_pkg][:no_whitespace_removal] = true if args[:client_pkg_no_whitespace_removal]
-    
     ## Uses the lib paths as search paths
+    lib_paths.merge( config[:lib_paths] ) if config.has_key?(:lib_paths)
     lib_paths.each do |lib_path|
       $LOAD_PATH << lib_path
     end
     
-    ## Legacy:
-    LIB_PATHS.each do |lib_path|
-      $LOAD_PATH << lib_path
-    end
-    
     @config = config
   end
+  
   attr_reader :config
+  
 end
 
 

data/lib/daemon/daemon.rb

@@ -10,29 +10,6 @@
 
 # Use rubygems to load rack
 require 'rubygems'
-require 'rack'
-
-# Loads the selected web-server (default is 'thin')
-require RSence.config[:http_server][:rack_require]
-
-# Methods that return rack the selected handler
-def rack_webrick_handler;  Rack::Handler::WEBrick;  end
-def rack_ebb_handler;      Rack::Handler::Ebb;      end
-def rack_thin_handler;     Rack::Handler::Thin;     end
-def rack_mongrel_handler;  Rack::Handler::Mongrel;  end
-def rack_unicorn_handler;  Rack::Handler::Unicorn;  end
-def rack_rainbows_handler; Rack::Handler::Rainbows; end
-
-# Selects the handler for Rack
-RSence.config[:http_server][:rack_handler] = self.method({
-  'fuzed'    => :rack_fuzed_handler,
-  'webrick'  => :rack_webrick_handler,
-  'ebb'      => :rack_ebb_handler,
-  'thin'     => :rack_thin_handler,
-  'mongrel'  => :rack_mongrel_handler,
-  'unicorn'  => :rack_unicorn_handler,
-  'rainbows' => :rack_rainbows_handler
-}[RSence.config[:http_server][:rack_require]]).call
 
 # Transporter is the top-level handler for calls coming from the javascript COMM.Transporter.
 require 'transporter/transporter'
@@ -42,327 +19,339 @@ require 'http/broker'
 
 
 module ::RSence
+  
+  @@launch_pid = Process.pid
+  
+  # Returns the pid of the process when starting up.
+  # PID is different for the forked child process(es)
+  def self.launch_pid
+    return @@launch_pid
+  end
 
-@@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
-  
-  # 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 )
+  # The Controller module handles the damonizing
+  # operations of the process referred to as +daemon+
+  module Daemon
+  
+    # 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
-  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
+    # 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
   
-  def self.responds?( daemon )
-    wait_signal_response( daemon, 'USR2' )
-  end
+    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
+    # 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
+    # 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 )
-    pid = Process.pid.to_s
-    pid_fn = daemon.pid_fn
-    RSence::SIGComm.write_signal_response( pid, pid_fn, signal )
-  end
+    # Writes a signal response file containing the pid.
+    def self.write_signal_response( daemon, signal )
+      pid = Process.pid.to_s
+      pid_fn = daemon.pid_fn
+      RSence::SIGComm.write_signal_response( pid, pid_fn, signal )
+    end
   
-  def self.delete_signal_response( daemon, signal )
-    pid_fn = daemon.pid_fn
-    RSence::SIGComm.delete_signal_response( pid_fn )
-  end
+    # Removes a signal response file.
+    def self.delete_signal_response( daemon, signal )
+      pid_fn = daemon.pid_fn
+      RSence::SIGComm.delete_signal_response( pid_fn )
+    end
   
-  def self.wait_signal_response( daemon, signal, timeout = 10,
-                                 debug_pre = false, debug_suf = false, sleep_secs = 0.2 )
-    pid = read_pid( daemon )
-    pid_fn = daemon.pid_fn
-    return RSence::SIGComm.wait_signal_response( pid, pid_fn, signal, timeout, debug_pre, debug_suf, sleep_secs )
-  end
+    # Waits for a signal response.
+    def self.wait_signal_response( daemon, signal, timeout = 10,
+                                   debug_pre = false, debug_suf = false, sleep_secs = 0.2 )
+      pid = read_pid( daemon )
+      pid_fn = daemon.pid_fn
+      return RSence::SIGComm.wait_signal_response( pid, pid_fn, signal, timeout, debug_pre, debug_suf, sleep_secs )
+    end
   
-  def self.trap_windows_signals( daemon )
-    ['INT'].each do | signal |
-      Signal.trap( signal ) do
-        puts "RSence killed with signal #{signal.inspect}" if RSence.args[:verbose]
-        daemon.usr1
-        daemon.stop
-        puts "Shutdown complete."
-        exit
+    # Signal trapping for windows.
+    # The only supported POSIX signal trappable seems to be INT (CTRL-C).
+    def self.trap_windows_signals( daemon )
+      ['INT'].each do | signal |
+        Signal.trap( signal ) do
+          puts "RSence killed with signal #{signal.inspect}" if RSence.args[:verbose]
+          daemon.usr1
+          daemon.stop
+          puts "Shutdown complete."
+          exit
+        end
       end
     end
-  end
   
-  # Traps common kill signals
-  def self.trap_signals( daemon )
+    # Traps common POSIX signals
+    def self.trap_signals( daemon )
     
-    # 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]
+      # 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_stale_pids( daemon )
+          write_signal_response( daemon, signal )
+          puts "Shutdown complete."
+          exit
+        end
+      end
+      Signal.trap('HUP') do
         daemon.stop
-        delete_stale_pids( daemon )
-        write_signal_response( daemon, signal )
-        puts "Shutdown complete."
-        exit
+        daemon.start
       end
     end
-    Signal.trap('HUP') do
-      daemon.stop
-      daemon.start
-    end
-  end
   
-  def self.delete_stale_pids( daemon )
-    ( pid_fn_path, pid_fn_name ) = File.split( daemon.pid_fn )
-    Dir.entries( pid_fn_path ).each do | item_fn |
-      item_path = File.join( pid_fn_path, item_fn )
-      if item_fn.start_with?( pid_fn_name ) and File.file?( item_path )
-        puts "Stale pid file (#{item_fn}), removing.." if RSence.args[:verbose]
-        File.delete( item_path )
+    # Removes all pid files that were left around if a process died unexpectedly.
+    def self.delete_stale_pids( daemon )
+      ( pid_fn_path, pid_fn_name ) = File.split( daemon.pid_fn )
+      Dir.entries( pid_fn_path ).each do | item_fn |
+        item_path = File.join( pid_fn_path, item_fn )
+        if item_fn.start_with?( pid_fn_name ) and File.file?( item_path )
+          puts "Stale pid file (#{item_fn}), removing.." if RSence.args[:verbose]
+          File.delete( item_path )
+        end
       end
     end
-  end
   
-  def self.init_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 )
+    # Creates pid file and traps signal.
+    def self.init_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
+          delete_stale_pids( daemon )
         end
-        exit
-      elsif not is_running
-        delete_stale_pids( daemon )
+        trap_signals( daemon )
+        pid = Process.pid
+        write_pid( daemon, pid ) 
+        return pid
+      else
+        trap_windows_signals( daemon )
+        return false
       end
-      trap_signals( daemon )
-      pid = Process.pid
-      write_pid( daemon, pid ) 
-      return pid
-    else
-      trap_windows_signals( daemon )
-      return false
     end
-  end
   
-  def self.run( daemon )
-    init_pid( daemon )
-    daemon.run
-    exit
-  end
-  
-  def self.start( daemon )
-    fork do
-      exit if fork
+    # Inits the pid, signals and then starts the server in the foreground
+    def self.run( daemon )
       init_pid( daemon )
-      daemon.start
-    end
-    Signal.trap('INT') do
-      puts "RSence startup failed. Please inspect the log and/or run in debug mode."
+      daemon.run
       exit
     end
-    Signal.trap('TERM') do
-      puts "RSence is online at http://#{daemon.addr}:#{daemon.port}/"
-      exit
+  
+    # Inits the pid, signals and then starts the daemon in
+    # the background and waits until the daemon sends the TERM signal.
+    def self.start( daemon )
+      fork do
+        exit if fork
+        init_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
+      Signal.trap('TERM') do
+        puts "RSence is online at http://#{daemon.addr}:#{daemon.port}/"
+        exit
+      end
+      sleep 1 while true
     end
-    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."
+    # 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."
+        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
-        puts "Warning: saving timed out! Session data not saved."
+        throw "Unexpected process status: #{status_.inspect}"
       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
-  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."
+    # 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
+      elsif status_ == false
+        puts "Warning, no such process (#{read_pid(daemon)}) running."
+      elsif status_ == nil
+        puts "Warning, no pid file (process not running)."
       else
-        puts "Warning: termination timed out!"
-        puts "RSence might still be running, please ensure manually."
+        throw "Unexpected process status: #{status_.inspect}"
       end
-    elsif status_ == false
-      puts "Warning, no such process (#{read_pid(daemon)}) 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 )
+    # 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 )
+      # 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
   
-end
+  end
 
-# Simple process control, constructed here and called from Daemon::Controller
-class HTTPDaemon
+  # 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."
+    # RSence top-level run handler. Almost identical to start.
+    def run
     
-    @transporter = Transporter.new
+      puts "Starting as a foreground process." if RSence.args[:verbose]
+      puts "Press CTRL-C to terminate."
     
-    conf = RSence.config[:http_server]
+      @transporter = Transporter.new
     
-    unless RSence.args[:log_fg]
-      Daemon.start_logging( self )
-    end
+      conf = RSence.config[:http_server]
     
-    # This is the main http handler instance:
-    @broker = Broker.start(
-      @transporter,
-      conf[:rack_handler],
-      conf[:bind_address],
-      conf[:port]
-    )
+      unless RSence.args[:log_fg]
+        Daemon.start_logging( self )
+      end
     
-  end
+      # This is the main http handler instance:
+      @broker = Broker.start(
+        @transporter,
+        conf
+      )
+    
+    end
   
-  # Returns the pid file path.
-  def pid_fn
-    RSence.config[:daemon][:pid_fn]
-  end
+    # 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
+    # Returns the log path.
+    def log_fn
+      RSence.config[:daemon][:log_fn]
+    end
   
-  def addr
-    RSence.config[:http_server][:bind_address]
-  end
+    # Returns the configured bind address
+    def addr
+      RSence.config[:http_server][:bind_address]
+    end
   
-  def port
-    RSence.config[:http_server][:port]
-  end
+    # Returns the configured port.
+    def port
+      RSence.config[:http_server][:port]
+    end
   
-  # Called by Controller#start, contains RSence-specific operations
-  def start
+    # Called by Controller#start, contains RSence-specific operations
+    def start
     
-    @transporter = Transporter.new
+      @transporter = Transporter.new
     
-    conf = RSence.config[:http_server]
+      conf = RSence.config[:http_server]
     
-    unless RSence.args[:log_fg]
-      Daemon.start_logging( self )
-      STDIN.reopen( "/dev/null" )
-    end
+      unless RSence.args[:log_fg]
+        Daemon.start_logging( self )
+        STDIN.reopen( "/dev/null" )
+      end
     
-    Process.setsid
+      Process.setsid
     
-    # This is the main http handler instance:
-    @broker = Broker.start(
-      @transporter,
-      conf[:rack_handler],
-      conf[:bind_address],
-      conf[:port]
-    )
-    yield @broker
+      # This is the main http handler instance:
+      @broker = Broker.start(
+        @transporter,
+        conf
+      )
+      yield @broker
     
-  end
+    end
   
-  # Called by Controller#stop, contains RSence-specific operations
-  def stop
-    @transporter.shutdown
-  end
+    # Called by Controller#stop, contains RSence-specific operations
+    def stop
+      @transporter.shutdown
+    end
   
-  # Called on USR1 signals (save data)
-  def usr1
-    save
-  end
+    # Called on USR1 signals (save data)
+    def usr1
+      save
+    end
   
-  # Save state
-  def save
-    puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} -- Saving state..."
-    transporter_state = @transporter.online?
-    @transporter.online = false
-    @transporter.plugins.delegate(:flush)
-    @transporter.sessions.store_sessions
-    @transporter.online = transporter_state
-    puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} -- State saved."
-  end
+    # Save state
+    def save
+      puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} -- Saving state..."
+      transporter_state = @transporter.online?
+      @transporter.online = false
+      @transporter.plugins.delegate(:flush)
+      @transporter.sessions.store_sessions
+      @transporter.online = transporter_state
+      puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} -- State saved."
+    end
   
-  # Called on USR2 signals ("Alive?")
-  def usr2
-    puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} -- RSence version #{RSence.version} is running."
-  end
+    # Called on USR2 signals ("Alive?")
+    def usr2
+      puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} -- RSence version #{RSence.version} is running."
+    end
   
-  # Main entry point, daemonizes itself using Controller.
-  def daemonize!
-    Daemon.daemonize( self )
-  end
+    # Main entry point, daemonizes itself using Controller.
+    def daemonize!
+      Daemon.daemonize( self )
+    end
   
-end
-
+  end
 end