class RSence::Configuration

Configuration handles config files and such.

Attributes

config[R]

Public Class Methods

new( args, dont_expand_path=false ) click to toggle source

@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.

# File lib/rsence/default_config.rb, line 63
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[:daemon][:http_delayed_start] = args[:http_delayed_start] if args[:http_delayed_start] != nil

  config[:client_pkg][:no_obfuscation] = args[:client_pkg_no_obfuscation]
  config[:client_pkg][:no_whitespace_removal] = args[:client_pkg_no_whitespace_removal]

  # Sets the default pid and log paths used by the HTTPDaemon
  if config[:daemon].has_key?(:pid_fn)
    config[:daemon][:pid_fn] = File.join(pidpath, config[:daemon][:pid_fn] )
  else
    config[:daemon][:pid_fn] = File.join(pidpath, "rsence.pid")
  end
  if config[:daemon].has_key?(:log_fn)
    config[:daemon][:log_fn] = File.join(logpath, config[:daemon][:log_fn] )
  else
    config[:daemon][:log_fn] = File.join(logpath, "rsence")
  end

  # 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

Public Instance Methods

array_merge( target, source ) click to toggle source

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.

# File lib/rsence/default_config.rb, line 24
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
hash_merge( target, source ) click to toggle source

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.

# File lib/rsence/default_config.rb, line 45
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