rsence-pre 2.1.0.1.pre

data/lib/conf/default.rb

@@ -0,0 +1,219 @@
+##   RSence
+ #   Copyright 2008 Riassence Inc.
+ #   http://riassence.com/
+ #
+ #   You should have received a copy of the GNU General Public License along
+ #   with this software package. If not, contact licensing@riassence.com
+ ##
+
+
+require 'rubygems'
+require 'rack'
+require 'yaml'
+
+
+
+require 'util/ruby19_fixes' if RUBY_VERSION.to_f >= 1.9
+
+
+module RSence
+  
+  
+  # Configuration handles config files and such.
+  class Configuration
+  
+    # Combines the Arrays `target` and `source` recursively.
+    # @param [Array] target Gets merged with `source`
+    # @param [Array] source Has its items pushed to `target` unless an identical item already exists in `target`. If an item class is a Hash, then uses {#hash_merge} to combine them.
+    def array_merge( target, source )
+      source.each do |item|
+        unless target.include?(item)
+          if item.class == Array
+            sub_arr = []
+            array_merge( sub_arr, item )
+            target.push( sub_arr )
+          elsif item.class == Hash
+            sub_hash = {}
+            hash_merge( sub_hash, item )
+            target.push( sub_hash )
+          else
+            target.push( item )
+          end
+        end
+      end
+    end
+  
+    # Combines the Hashes `target` and `source` recursively.
+    # @param [Hash] target Gets merged with `source`
+    # @param [Hash] source Has its items merged to `target` unless a key with an identical value already exists in `target`. If an item class is Array, then uses {#array_merge} to combine them.
+    def hash_merge( target, source )
+      source.each do |key,item|
+        if not target.has_key?key or target[key] != item
+          if item.class == Array
+            target[key] = [] unless target.has_key?(key)
+            array_merge( target[key], item )
+          elsif item.class == Hash
+            target[key] = {} unless target.has_key?key
+            hash_merge( target[key], item )
+          else
+            target[key] = item
+          end
+        end
+      end
+    end
+  
+    # @param args A parsed structure of the command-line arguments.
+    # @param dont_expand_path Is reserved 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 ) )
+    
+      # 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 to add to $LOAD_PATH after all configuration files are read.
+      lib_paths  = []
+    
+      # 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' )
+      ]
+    
+      # 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'
+            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 )
+          else
+            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]
+      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[: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
+    
+      # 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 file uploads
+        [ :u,               File.join(config[:base_url],'U') ],
+      
+          ## GET-requests
+          # broker_key      # default_uri
+          # The default address of built javascript and theme packages
+        [ :h,               File.join(config[:base_url],'H/') ],
+          # The default address of the ticketserve :img -category
+        [ :i,               File.join(config[:base_url],'i/') ],
+          # The default address of the ticketserve :rsrc -category
+        [ :d,               File.join(config[:base_url],'d/') ],
+          # The default address of the ticketserve :file -category
+        [ :f,               File.join(config[:base_url],'f/') ],
+          # The default address of the ticketserve :blobobj -category
+        [ :b,               File.join(config[:base_url],'b/') ],
+        # The default address of the favicon
+        [ :favicon,         '/favicon.ico' ],
+        # The default address of the "empty" iframe of uploader
+        [ :uploader_iframe, File.join(config[:base_url],'U/iframe_html') ],
+      ].each do |broker_key, default_uri|
+        unless config[:broker_urls].has_key?( broker_key )
+          config[:broker_urls][broker_key] = default_uri
+        end
+      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
+    
+      ## Uses the lib paths as search paths
+      lib_paths += config[:lib_paths] if config.has_key?(:lib_paths)
+      lib_paths.each do |lib_path|
+        lib_path = File.expand_path( lib_path, args[:env_path] ) if lib_path.start_with? './'
+        $LOAD_PATH << lib_path
+      end
+      @config = config
+    end
+  
+    attr_reader :config
+  
+  end
+end
+

data/lib/daemon/daemon.rb

@@ -0,0 +1,387 @@
+##   RSence
+ #   Copyright 2008 Riassence Inc.
+ #   http://riassence.com/
+ #
+ #   You should have received a copy of the GNU General Public License along
+ #   with this software package. If not, contact licensing@riassence.com
+ ##
+
+
+# Use rubygems to load rack
+require 'rubygems'
+
+# Transporter is the top-level handler for calls coming from the javascript COMM.Transporter.
+require 'transporter/transporter'
+
+# Broker routes requests to the correct handler
+require 'http/broker'
+
+
+module RSence
+  
+  # @private  The process id of the launch process (usually the PID of the 'rsence' command)
+  @@launch_pid = Process.pid
+  
+  # @private  Returns the pid of the process when starting up.
+  #   PID is different for the forked child process or processes
+  def self.launch_pid
+    return @@launch_pid
+  end
+
+  # @private  The Controller module handles the daemonizing
+  #   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
+  
+    # 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, 'INFO' )
+    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
+  
+    # 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
+  
+    # 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
+  
+    # 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
+  
+    # 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
+  
+    # 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
+      # Signal.trap( 'PWR' ) do 
+      #   daemon.pwr
+      #   write_signal_response( daemon, 'PWR' )
+      # end
+      Signal.trap( 'ALRM' ) do 
+        daemon.alrm
+        write_signal_response( daemon, 'ALRM' )
+      end
+      Signal.trap( 'INFO' ) do 
+        daemon.info
+        write_signal_response( daemon, 'INFO' )
+      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
+        daemon.start
+      end
+    end
+  
+    # 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
+  
+    # 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
+        trap_signals( daemon )
+        pid = Process.pid
+        write_pid( daemon, pid ) 
+        return pid
+      else
+        trap_windows_signals( daemon )
+        return false
+      end
+    end
+  
+    # Inits the pid, signals and then starts the server in the foreground
+    def self.run( daemon )
+      init_pid( daemon )
+      daemon.run
+      exit
+    end
+  
+    # 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
+  
+    # Sends the PWR 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, 'PWR', 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
+        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."
+        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
+        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
+
+  # @private  Simple process control, constructed here and called from Daemon::Controller
+  class HTTPDaemon
+    
+    # RSence top-level run handler. Almost identical to start.
+    def run
+    
+      puts "Starting as a foreground process." if RSence.args[:verbose]
+      puts "Press CTRL-C to terminate."
+    
+      @transporter = Transporter.new
+    
+      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,
+        conf
+      )
+    
+    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 configured bind address
+    def addr
+      RSence.config[:http_server][:bind_address]
+    end
+    
+    # Returns the configured port.
+    def port
+      RSence.config[:http_server][:port]
+    end
+    
+    # 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
+      )
+      yield @broker
+    
+    end
+    
+    # Called by Controller#stop, contains RSence-specific operations
+    def stop
+      @transporter.shutdown
+    end
+    
+    # # Called on PWR signals (save data)
+    # def pwr
+    #   save
+    # end
+    
+    # Called on INFO signals ("Alive?")
+    def info
+      puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} -- RSence version #{RSence.version} is running."
+    end
+    
+    # Called on ALRM signals (save data, reload all plugins manually)
+    def alrm
+      save
+      @transporter.plugins.shutdown
+      @transporter.plugins.init_bundles!
+    end
+    
+    # Called on usr1 signals (updates bundles manually, like the regular intervals of the -a switch and forces client to be rebuilt)
+    def usr1
+      @transporter.plugins.update_bundles!
+      # @transporter.plugins.client_pkg.rebuild_client
+    end
+    
+    # Called on USR2 signals
+    def usr2
+      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
+    
+    # Main entry point, daemonizes itself using Controller.
+    def daemonize!
+      Daemon.daemonize( self )
+    end
+  
+  end
+end

data/lib/daemon/sigcomm.rb

@@ -0,0 +1,64 @@
+##   RSence
+ #   Copyright 2010 Riassence Inc.
+ #   http://riassence.com/
+ #
+ #   You should have received a copy of the GNU General Public License along
+ #   with this software package. If not, contact licensing@riassence.com
+ ##
+
+
+
+module RSence
+  
+  # @private RSence async signal communication handler, uses temporary files for communication.
+  #   Utilized by ARGVParser and Daemon.
+  module SIGComm
+    def self.delete_signal_response( pid_fn )
+      sig_fn = pid_fn+'.response.'+signal
+      if File.file?( sig_fn )
+        File.delete( sig_fn )
+      end
+    end
+    def self.write_signal_response( pid, pid_fn, signal )
+      sig_fn = pid_fn+'.response.'+signal
+      File.open(sig_fn,'w') do |file|
+        file.write( pid.to_s )
+      end
+    end
+    def self.wait_signal_response( pid, pid_fn, signal, timeout = 10,
+                                   debug_pre = false, debug_suf = false,
+                                   sleep_secs = 0.2, verbose=nil )
+      sig_fn = pid_fn+'.response.'+signal
+      verbose = RSence.args[:verbose] if verbose == nil
+      begin
+        if verbose and debug_pre
+          print debug_pre
+        end
+        File.delete( sig_fn ) if File.exists?( sig_fn )
+        status = Process.kill( signal, pid )
+        time_out = Time.now + timeout
+        until (time_out < Time.now) or File.exists?( sig_fn )
+          if verbose
+            print "."
+            STDOUT.flush
+          end
+          sleep sleep_secs
+        end
+        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
+          puts "Warning, signal response file disappeared! Expected #{sig_fn}"
+        end
+        puts debug_suf if verbose and debug_suf
+        return true
+      rescue Errno::ESRCH
+        return false
+      end
+    end
+  end
+end
+