d13n 0.5.2

data/lib/d13n/configuration/manager.rb

@@ -0,0 +1,239 @@
+
+module D13n::Configuration
+  class Manager
+    def [](key)
+      @cache[key]
+    end
+
+    def has_key?(key)
+      @cache.has_key?(key)
+    end
+
+    def keys
+      @cache.keys
+    end
+
+    def key(value)
+      @cache.key(value)
+    end
+
+    def alias_key_for(value)
+      alias_for(key(value))
+    end
+
+    def alias_for(key)
+      @alias_cache[key]
+    end
+
+    def initialize
+      reset_to_defaults
+      @callbacks = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def remove_config_type(sym)
+      source = case sym
+      when :environment   then @environment_source
+      when :server        then @server_source
+      when :manual        then @manual_source
+      when :yaml          then @yaml_source
+      when :default       then @default_source
+      end
+
+      remove_config(source)
+    end
+
+    def remove_config(source)
+      case source
+      when EnvironmentSource  then @environment_source   = nil
+      when ServerSource       then @server_source        = nil
+      when ManualSource       then @manual_source        = nil
+      when YamlSource         then @yaml_source          = nil
+      when DefaultSource      then @default_source       = nil
+      end
+
+      reset_cache
+      reset_alias
+      invoke_callbacks(:remove, source)
+      log_config(:remove, source)
+    end
+
+    def replace_or_add_config(source)
+      source.freeze
+
+      invoke_callbacks(:add, source)
+      case source
+      when EnvironmentSource  then @environment_source   = source
+      when ServerSource       then @server_source        = source
+      when ManualSource       then @manual_source        = source
+      when YamlSource         then @yaml_source          = source
+      when DefaultSource      then @default_source       = source
+      else
+        D13n.logger.warn("Invalid config format; config will be ignored: #{source}")
+      end
+
+      reset_cache
+      reset_alias
+      log_config(:add, source)
+    end
+
+    def source(key)
+      config_stack.each do |config|
+        if config.respond_to?(key.to_sym) || config.has_key?(key.to_sym)
+          return config
+        end
+      end
+    end
+
+    def fetch(key)
+      config_stack.each do |config|
+        next unless config
+        accessor = key.to_sym
+
+        if config.has_key?(accessor)
+          evaluated = evaluate_procs(config[accessor])
+          begin
+            return apply_transformations(accessor, evaluated)
+          rescue
+            next
+          end
+        end
+      end
+      nil
+    end
+
+    def apply_transformations(key, value)
+      if transform = transform_from_default(key)
+        begin
+          transform.call(value)
+        rescue => e
+          D13n.logger.error("Error applying transformation for #{key}, pre-transform value was: #{value}.", e)
+          raise e
+        end
+      else
+        value
+      end
+    end
+
+    def transform_from_default(key)
+      D13n::Configuration::DefaultSource.transform_for(key)
+    end
+
+    def evaluate_procs(value)
+      if value.respond_to?(:call)
+        instance_eval(&value)
+      else
+        value
+      end
+    end
+
+    # Generally only useful during initial construction and tests
+    def reset_to_defaults
+      @environment_source   = EnvironmentSource.new
+      @server_source        = nil
+      @manual_source        = nil
+      @yaml_source          = nil
+      @default_source       = DefaultSource.new
+      reset_cache
+      reset_alias
+    end
+
+    def reset_cache
+      @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
+    end
+
+    def reset_alias
+      @alias_cache = @default_source.default_alias
+    end
+
+    def log_config(direction, source)
+      D13n.logger.debug do
+        "Updating config (#{direction}) from #{source.class}. Results: #{flattened.inspect}"
+      end
+    end
+
+    def register_callback(key, &proc)
+      @callbacks[key] << proc
+      proc.call(@cache[key])
+    end
+
+    def invoke_callbacks(direction, source)
+      return unless source
+      source.keys.each do |key|
+
+        if @cache[key] != source[key]
+          @callbacks[key].each do |proc|
+            if direction == :add
+              proc.call(source[key])
+            else
+              proc.call(@cache[key])
+            end
+          end
+        end
+      end
+    end
+
+    def flattened
+      config_stack.reverse.inject({}) do |flat,layer|
+        thawed_layer = layer.to_hash.dup
+        thawed_layer.each do |k,v|
+          begin
+            thawed_layer[k] = instance_eval(&v) if v.respond_to?(:call)
+          rescue => e
+            D13n.logger.debug("#{e.class.name} : #{e.message} - when accessing config key #{k}")
+            thawed_layer[k] = nil
+          end
+          thawed_layer.delete(:config)
+        end
+        flat.merge(thawed_layer.to_hash)
+      end
+    end
+
+    def apply_mask(hash)
+      MASK_DEFAULTS. \
+        select {|_, proc| proc.call}. \
+        each {|key, _| hash.delete(key) }
+      hash
+    end
+
+    def to_hash
+      DottedHash.new(apply_mask(flattened)).to_hash
+    end
+
+    def to_collector_hash
+      DottedHash.new(apply_mask(flattened)).to_hash.delete_if do |k, v|
+        default = DEFAULTS[k]
+        if default
+          default[:exclude_from_reported_settings]
+        else
+          false
+        end
+      end
+    end
+
+    def app_name
+      D13n.config[:app_name]
+    end
+
+    private
+
+    def config_stack
+      stack = [@environment_source,
+               @server_source,
+               @manual_source,
+               @yaml_source,
+               @default_source]
+
+      stack.compact!
+      stack
+    end
+
+  end
+end
+
+require 'd13n/configuration/mask_defaults'
+require 'd13n/configuration/dotted_hash'
+require 'd13n/configuration/default_source'
+require 'd13n/configuration/yaml_source'
+require 'd13n/configuration/environment_source'
+require 'd13n/configuration/server_source'
+require 'd13n/configuration/manual_source'

data/lib/d13n/configuration/manual_source.rb

@@ -0,0 +1,4 @@
+module D13n::Configuration
+  class ManualSource < DottedHash
+  end
+end

data/lib/d13n/configuration/mask_defaults.rb

@@ -0,0 +1,6 @@
+module D13n
+  module Configuration
+    MASK_DEFAULTS = {
+    }
+  end
+end

data/lib/d13n/configuration/server_source.rb

@@ -0,0 +1,83 @@
+module D13n::Configuration
+  class ServerSource < DottedHash
+    SERVICE_PREFIXES = /^service/i
+    PROPERTY_PREFIXES = /^property/i
+    IDC_PREFIXES = /^idc/i
+    CLIENT_PREFIXES = /^client/i
+    JURISDICTION_PREFIXES = /^jurisdiction/i
+
+    attr_accessor :type_map
+
+    def initialize(connect_reply)
+      #filter_keys(connect_reply)
+      @type_map = {}
+
+      DEFAULTS.each do |config_setting, value|
+        self.type_map[config_setting] = value[:type]
+      end
+
+      super(connect_reply)
+    end
+
+    def set_keys_by_type()
+      self.keys.each do |key|
+        set_key_by_type(key)
+      end
+    end
+
+    def set_key_by_type(config_key)
+      value = self[config_key]
+      type = self.type_map[config_key]
+
+      if type == String
+        self[config_key] = value.to_s
+      elsif type == Integer
+        self[config_key] = value.to_i
+      elsif type == Float
+        self[config_key] = value.to_f
+      elsif type == Symbol
+        self[config_key] = value.to_sym
+      elsif type == Array
+        self[config_key] = value.split(/\s*,\s*/)
+      elsif type == D13n::Configuration::Boolean
+        if value =~ /false|off|no/i
+          self[config_key] = false
+        elsif value != nil
+          self[config_key] = true
+        end
+      else
+        D13n.logger.info("#{config_key} does not have a corresponding configuration setting (#{config_key} does not exist).")
+        self[config_key] = value
+      end
+    end
+
+    def self.build(connect_reply)
+      instance = new(connect_reply)
+      self.filter_keys(instance)
+      instance
+    end
+
+    def self.filter_keys(instance)
+      instance.delete_if do |key, _|
+        s_key = key.to_s
+        if s_key.match(SERVICE_PREFIXES) || s_key.match(PROPERTY_PREFIXES) || s_key.match(IDC_PREFIXES) || s_key.match(CLIENT_PREFIXES) || s_key.match(JURISDICTION_PREFIXES)
+          false
+        else
+          setting_spec = DEFAULTS[key.to_sym]
+          if setting_spec
+            if setting_spec[:allowed_from_server]
+              instance.set_key_by_type(key)
+              false # it's allowed, so don't delete it
+            else
+              D13n.logger.warn("Ignoring server-sent config for '#{key}' - this setting cannot be set from the server")
+              true # delete it
+            end
+          else
+            D13n.logger.debug("Ignoring unrecognized config key from server: '#{key}'")
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/d13n/configuration/yaml_source.rb

@@ -0,0 +1,66 @@
+require 'yaml'
+module D13n::Configuration
+  class YamlSource < DottedHash
+    attr_accessor :file_path, :failures
+
+    def initialize(path,env)
+      config = {}
+      @failures = []
+
+      begin
+        @file_path = validate_config_file(path)
+        return unless @file_path
+
+        D13n.logger.info("Reading configuration from #{path} (#{Dir.pwd})")
+        raw_file = File.read(@file_path)
+        erb_file = process_erb(raw_file)
+        config   = process_yaml(erb_file, env, config, @file_path)
+      rescue ScriptError, StandardError => e
+        log_failure("Failed to read or parse configuration file at #{path}", e)
+      end
+
+      super(config, true)
+    end
+
+    protected
+
+    def validate_config_file(path)
+      expanded_path = File.expand_path(path)
+
+      if path.empty? || !File.exist?(expanded_path)
+        return
+      end
+
+      expanded_path
+    end
+
+    def process_erb(file)
+      begin
+        file.gsub!(/^\s*#.*$/, '#')
+
+        ERB.new(file).result(binding)
+      rescue Exception => e
+        log_failure("Failed ERB processing configuration file. This is typically caused by a Ruby error in <% %> templating blocks in your axle.yml file.", e)
+      ensure
+
+      end
+    end
+
+    def process_yaml(file, env, config, path)
+     if file
+      confighash = YAML.load(file)
+      unless confighash.key?(env)
+        log_failure("Config file at #{path} doesn't include a '#{env}' section!")
+      end
+      config = confighash[env] || {}
+      end
+
+      config
+    end
+
+    def log_failure(*messages)
+      D13n.logger.error(*messages)
+      @failures << messages
+    end
+  end
+end

data/lib/d13n/configuration.rb

@@ -0,0 +1,6 @@
+require 'd13n/configuration/manager'
+
+module D13n
+  module Configuration  
+  end
+end

data/lib/d13n/ext/string.rb

@@ -0,0 +1,17 @@
+class String
+  # By default, +camelize+ converts strings to UpperCamelCase.
+  #
+  #   'active_record'.camelize                # => "ActiveRecord"
+  def camelize
+    string = self
+    string.split('_').map{ |e| e.capitalize }.join
+  end
+  
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/d13n/logger/log_once.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module D13n
+  class Logger
+    module LogOnce
+      NUM_LOG_ONCE_KEYS = 1000
+
+      def log_once(level, key, *msgs)
+        return if @already_logged.include?(key)
+
+        if @already_logged.size >= NUM_LOG_ONCE_KEYS && key.kind_of?(String)
+          return
+        end
+
+        @already_logged[key] = true
+
+        self.send(level, *msgs)
+      end
+
+      def clear_already_logged
+        @already_logged = {}
+      end
+    end
+  end
+end

data/lib/d13n/logger/memory_logger.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+module D13n
+  class Logger
+    class MemoryLogger
+      include LogOnce
+      def initialize
+        @messages = []
+      end
+
+      def is_startup_logger?
+        true
+      end
+
+      attr_accessor :messages, :level, :log_formatter
+
+      def fatal(*msgs, &blk)
+        messages << [:fatal, msgs, blk]
+      end
+
+      def error(*msgs, &blk)
+        messages << [:error, msgs, blk]
+      end
+
+      def warn(*msgs, &blk)
+        messages << [:warn, msgs, blk]
+      end
+
+      def info(*msgs, &blk)
+        messages << [:info, msgs, blk]
+      end
+
+      def debug(*msgs, &blk)
+        messages << [:debug, msgs, blk]
+      end
+
+      def log_exception(level, e, backtrace_level=level)
+        messages << [:log_exception, [level, e, backtrace_level]]
+      end
+
+      def dump(logger)
+        messages.each do |(method, args, blk)|
+          logger.send(method, *args, &blk)
+        end
+        messages.clear
+      end
+    end
+  end
+end

data/lib/d13n/logger/null_logger.rb

@@ -0,0 +1,16 @@
+module D13n
+  class Logger
+    class NullLogger
+      include Singleton
+      def fatal(*args); end
+      def error(*args); end
+      def warn(*args);  end
+      def info(*args);  end
+      def debug(*args); end
+
+      def method_missing(method, *args, &blk)
+        nil
+      end
+    end
+  end
+end