fwissr 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  data.tar.gz: 933e4bc006d16954c87cc4f7b1290ec7fde652a4
+  metadata.gz: 2213070acd5d61baf5ebb2e5ae1188547aafb402
+SHA512: 
+  data.tar.gz: 42223b4c419f6c65e4ff88f35abfd14d787448bc79fb3aebdd1ab40746764e7542a42d10a4730f70aa86212192af708220dd4c6344cbc860afb79e088bd12fae
+  metadata.gz: 7f223d8a1d5f91a943b0fb0ac51fcc862a448f4279fa5479db8319a7441d20c36bb558f6eb8b2bd841bb1c6a37d4d3d4c29bdfc603a0cc5cdeea73e94ce052dc

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Fotonauts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,384 @@
+Fwissr
+======
+
+A simple configuration registry tool by Fotonauts.
+
+
+Install
+=======
+
+```bash
+$ [sudo] gem install fwissr
+```
+
+Or add it to your `Gemfile`.
+
+
+Usage
+=====
+
+Create the main `fwissr.json` configuration file in either `/etc/fwissr/` or `~/.fwissr/` directory:
+
+```json
+{
+  "foo" : "bar",
+  "horn" : { "loud" : true, "sounds": [ "TUuuUuuuu", "tiiiiiiIIiii" ] }
+}
+```
+
+In your application, you can access `fwissr`'s global registry that way:
+
+```ruby
+require 'fwissr'
+
+Fwissr['/foo']
+# => "bar"
+
+Fwissr['/horn']
+# => { "loud" => true, "sounds" => [ "TUuuUuuuu", "tiiiiiiIIiii" ] }
+
+Fwissr['/horn/loud']
+# => true
+
+Fwissr['/horn/sounds']
+# => [ "TUuuUuuuu", "tiiiiiiIIiii" ]
+```
+
+In bash you can call the `fwissr` tool:
+
+```bash
+$ fwissr /foo
+bar
+
+# json output
+$ fwissr -j /horn
+{ "loud" : true, "sounds": [ "TUuuUuuuu", "tiiiiiiIIiii" ] }
+
+# pretty print json output
+$ fwissr -j -p /horn
+{
+  "loud": true,
+  "sound": [
+    "TUuuUuuuu",
+    "tiiiiiiIIiii"
+  ]
+}
+
+# dump registry with pretty print json output
+# NOTE: yes, that's the same as 'fwissr -jp /'
+$ fwissr --dump -jp
+{
+  "horn": {
+    "loud": true,
+    "sound": [
+      "TUuuUuuuu",
+      "tiiiiiiIIiii"
+    ]
+  }
+}
+```
+
+
+Additional configuration file
+=============================
+
+In addition to the main `fwissr.json` configuration file, all files in `/etc/fwissr/` and `~/.fwissr/` directories are automatically loaded. The settings for these additional configurations are prefixed with the file name.
+
+You can provide more configuration file locations with the `fwissr_sources` setting in `fwissr.json`:
+
+```json
+{
+  "fwissr_sources": [
+    { "filepath": "/etc/my_app.json" }
+  ]
+}
+```
+
+For example, with that `/etc/my_app.json`:
+
+```json
+{ "foo": "bar", "bar": "baz" }
+```
+
+settings are accessed that way:
+
+```ruby
+require 'fwissr'
+
+Fwissr['/my_app']
+# => { "foo" => "bar", "bar" => "baz" }
+
+Fwissr['/my_app/foo']
+# => "bar"
+
+Fwissr['/my_app/bar']
+# => "baz"
+```
+
+You can bypass that behaviour with the `top_level` setting:
+
+```json
+{
+  "fwissr_sources": [
+    { "filepath": "/etc/my_app.json", "top_level": true }
+  ]
+}
+```
+
+With the `top_level` setting activated the configuration settings are added to registry root:
+
+```ruby
+require 'fwissr'
+
+Fwissr['/']
+# => { "foo" => "bar", "bar" => "baz" }
+
+Fwissr['/foo']
+# => "bar"
+
+Fwissr['/bar']
+# => "baz"
+```
+
+Fwissr supports `.json` and `.yaml` configuration files.
+
+
+Directory of configuration files
+================================
+
+If the `filepath` setting is a directory then all the configuration files in that directory (but NOT in subdirectories) are imported:
+
+```json
+{
+  "fwissr_sources": [
+    { "filepath": "/mnt/my_app/conf/" },
+  ],
+}
+```
+
+With `/mnt/my_app/conf/database.yaml`:
+
+```yaml
+production:
+  adapter: mysql2
+  encoding: utf8
+  database: my_app_db
+  username: my_app_user
+  password: my_app_pass
+  host: db.my_app.com
+```
+
+and `/mnt/my_app/conf/credentials.json`:
+
+```json
+{ "key": "i5qw64816c", "code": "448e4wef161" }
+```
+
+settings are accessed that way:
+
+```ruby
+require 'fwissr'
+
+Fwissr['/database']
+# => { "production" => { "adapter" => "mysql2", "encoding" => "utf8", "database" => "my_app_db", "username" => "my_app_user", "password" => "my_app_pass", "host" => "db.my_app.com" } }
+
+Fwissr['/database/production/host']
+# => "db.my_app.com"
+
+Fwissr['/credentials']
+# => { "key" => "i5qw64816c", "code" => "448e4wef161" }
+
+Fwissr['/credentials/key']
+# => "i5qw64816c"
+```
+
+
+File name mapping to setting path
+=================================
+
+Use dots in file name to define a path for configuration settings.
+
+For example:
+
+```json
+{
+  "fwissr_sources": [
+    { "filepath": "/etc/my_app.database.slave.json" }
+  ]
+}
+```
+
+with that `/etc/my_app.database.slave.json`:
+
+```json
+{ "host": "db.my_app.com", "port": "1337" }
+```
+
+settings are accessed that way:
+
+```ruby
+require 'fwissr'
+
+Fwissr['/my_app/database/slave/host']
+# => "db.my_app.com"
+
+Fwissr['/my_app/database/slave/port']
+# => "1337"
+```
+
+
+Mongodb source
+==============
+
+You can define a mongob collection as a configuration source:
+
+```json
+{
+  "fwissr_sources": [
+    { "mongodb": "mongodb://db1.example.net/my_app", "collection": "config" }
+  ]
+}
+```
+
+Each document in the collection is a setting for that configuration.
+
+The `_id` document field is the setting key, and the `value` document field is the setting value.
+
+For example:
+
+```
+> db["my_app.stuff"].find()
+{ "_id" : "foo", "value" : "bar" }
+{ "_id" : "database", "value" : { "host": "db.my_app.com", "port": "1337" } }
+```
+
+```ruby
+require 'mongo'
+require 'fwissr'
+
+Fwissr['/my_app/stuff/foo']
+# => "bar"
+
+Fwissr['/my_app/stuff/database']
+# => { "host": "db.my_app.com", "port": "1337" }
+
+Fwissr['/my_app/stuff/database/port']
+# => "1337"
+```
+
+As with configuration files you can use dots in collection name to define a path for configuration settings. The `top_level` setting is also supported to bypass that behaviour. Note that the `fwissr` collection is by default a `top_level` configuration.
+
+Fwissr supports both the official `mongo` ruby driver and the `mongoid`'s `moped` driver. Don't forget to require one of these gems.
+
+
+Refreshing registry
+===================
+
+Enable registry auto-update with the `refresh` source setting.
+
+For example:
+
+```json
+{
+  "fwissr_sources": [
+    { "filepath": "/etc/my_app/my_app.json" },
+    { "filepath": "/etc/my_app/stuff.json", "refresh": true },
+    { "mongodb": "mongodb://db1.example.net/my_app", "collection": "production" },
+    { "mongodb": "mongodb://db1.example.net/my_app", "collection": "config", "refresh": true }
+  ]
+}
+```
+
+The `/etc/my_app/my_app.json` configuration file and the `production` mongodb collection are read once, whereas the settings holded by the `/etc/my_app/stuff.json` configuration file and the `config` mongodb collection expire periodically and re-fetched.
+
+The default freshness is 30 seconds, but you can change it with the `fwissr_refresh_period` setting:
+
+```json
+{
+  "fwissr_sources": [
+    { "filepath": "/etc/my_app/my_app.json" },
+    { "filepath": "/etc/my_app/stuff.json", "refresh": true },
+    { "mongodb": "mongodb://db1.example.net/my_app", "collection": "production" },
+    { "mongodb": "mongodb://db1.example.net/my_app", "collection": "config", "refresh": true }
+   ],
+  "fwissr_refresh_period": 60
+}
+```
+
+The refresh is done periodically in a thread:
+
+```ruby
+require 'fwissr'
+
+Fwissr['/stuff/foo']
+# => "bar"
+
+# > Change '/etc/my_app/stuff.json' file by setting: {"foo":"baz"}
+
+# Wait 2 minutes
+sleep(120)
+
+# The new value is now in the registry
+Fwissr['/stuff/foo']
+# => "baz"
+```
+
+
+Create a custom registry
+========================
+
+`fwissr` is intended to be easy to setup: just create a configuration file and that configuration is accessible via the global registry. But if you need to, you can create your own custom registry.
+
+```ruby
+require 'fwissr'
+
+# create a custom registry
+registry = Fwissr::Registry.new('refresh_period' => 20)
+
+# add configuration sources to registry
+registry.add_source(Fwissr::Source.from_settings({ 'filepath': '/etc/my_app/my_app.json' }))
+registry.add_source(Fwissr::Source.from_settings({ 'filepath': '/etc/my_app/stuff.json', 'refresh': true }))
+registry.add_source(Fwissr::Source.from_settings({ 'mongodb': 'mongodb://db1.example.net/my_app', 'collection': 'production' }))
+registry.add_source(Fwissr::Source.from_settings({ 'mongodb': 'mongodb://db1.example.net/my_app', 'collection': 'config', 'refresh': true }))
+
+registry['/stuff/foo']
+# => 'bar'
+```
+
+
+Create a custom source
+======================
+
+Currently `Fwissr::Source::File` and `Fwissr::Source::Mongodb` are the two kinds of possible registry sources, but you can define your own source:
+
+
+```ruby
+class MyFwissrSource < Fwissr::Source
+
+  def initialize(db_handler, options = { })
+    super(options)
+
+    @db_handler = db_handler
+  end
+
+  def fetch_conf
+    @db_handler.find('my_conf').to_hash
+    # => { 'foo' => [ 'bar', 'baz' ] }
+  end
+
+end # class MyFwissrSource
+
+registry = Fwissr::Registry.new('refresh_period' => 20)
+registry.add_source(MyFwissrSource.new(my_db_handler, 'refresh' => true))
+
+registry['/foo']
+# => [ 'bar', 'baz' ]
+```
+
+
+Credits
+=======
+
+The Fotonauts team: http://www.fotopedia.com
+
+Copyright (c) 2013 Fotonauts released under the MIT license.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rake'
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/./lib")
+require 'fwissr'
+
+task :default => :list
+task :list do
+  system 'rake -T'
+end
+
+##############################################################################
+# SYNTAX CHECKING
+##############################################################################
+desc 'Check code syntax'
+task :check_syntax do
+  `find . -name "*.rb" |xargs -n1 ruby -c |grep -v "Syntax OK"`
+  puts "* Done"
+end
+
+##############################################################################
+# Stats
+##############################################################################
+desc 'Show some stats about the code'
+task :stats do
+  line_count = proc do |path|
+    Dir[path].collect { |f| File.open(f).readlines.reject { |l| l =~ /(^\s*(\#|\/\*))|^\s*$/ }.size }.inject(0){ |sum,n| sum += n }
+  end
+  comment_count = proc do |path|
+    Dir[path].collect { |f| File.open(f).readlines.select { |l| l =~ /^\s*\#/ }.size }.inject(0) { |sum,n| sum += n }
+  end
+  lib     = line_count['lib/**/*.rb']
+  comment = comment_count['lib/**/*.rb']
+  ext     = line_count['ext/**/*.{c,h}']
+  spec    = line_count['spec/**/*.rb']
+
+  comment_ratio = '%1.2f' % (comment.to_f / lib.to_f)
+  spec_ratio = '%1.2f' % (spec.to_f / lib.to_f)
+
+  puts '/======================\\'
+  puts '| Part            LOC  |'
+  puts '|======================|'
+  puts "| lib             #{lib.to_s.ljust(5)}|"
+  puts "| lib comments    #{comment.to_s.ljust(5)}|"
+  puts "| ext             #{ext.to_s.ljust(5)}|"
+  puts "| spec            #{spec.to_s.ljust(5)}|"
+  puts '| ratios:              |'
+  puts "|   lib/comment   #{comment_ratio.to_s.ljust(5)}|"
+  puts "|   lib/spec      #{spec_ratio.to_s.ljust(5)}|"
+  puts '\======================/'
+end

data/bin/fwissr

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'pp'
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'fwissr'
+
+begin
+  # parse arguments
+  args = Fwissr.parse_args!(ARGV)
+
+  # get value
+  result = if args[:dump]
+    Fwissr.dump
+  else
+    Fwissr.get(args[:key])
+  end
+
+  # display result
+  if args[:json]
+    if FWISSR_USE_YAJL
+      yajl_options = args[:pretty] ? { :pretty => true, :indent => "  " } : { }
+      puts Yajl::Encoder.encode(result, yajl_options)
+    else
+      puts args[:pretty] ? JSON.pretty_generate(result) : result.to_json
+    end
+  elsif args[:inspect]
+    if args[:pretty]
+      pp result
+    else
+      puts result.inspect
+    end
+  else
+    puts result
+  end
+rescue => ex
+  puts "#{ex.message}"
+  raise ex
+end

data/lib/fwissr.rb

@@ -0,0 +1,267 @@
+require 'rubygems'
+require 'optparse'
+
+require 'yaml'
+
+FWISSR_USE_YAJL = true
+
+if FWISSR_USE_YAJL
+  require 'yajl'
+else
+  require 'json'
+end
+
+
+require 'fwissr/version'
+require 'fwissr/source'
+require 'fwissr/registry'
+
+module Fwissr
+
+  # default path where main conf file is located
+  DEFAULT_MAIN_CONF_PATH = "/etc/fwissr"
+
+  # default directory (relative to current user's home) where user's main conf file is located
+  DEFAULT_MAIN_USER_CONF_DIR = ".fwissr"
+
+  # main conf file
+  MAIN_CONF_FILE = "fwissr.json"
+
+  class << self
+    attr_writer :main_conf_path, :main_user_conf_path
+
+    # Get config files directory
+    def main_conf_path
+      @main_conf_path ||= DEFAULT_MAIN_CONF_PATH
+    end
+
+    # Get user's specific config files directory
+    def main_user_conf_path
+      @main_user_conf_path ||= File.join(Fwissr.find_home, DEFAULT_MAIN_USER_CONF_DIR)
+    end
+
+    # finds the user's home directory
+    #
+    # Borrowed from rubygems
+    def find_home
+      ['HOME', 'USERPROFILE'].each do |homekey|
+        return ENV[homekey] if ENV[homekey]
+      end
+
+      if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
+        return "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
+      end
+
+      begin
+        File.expand_path("~")
+      rescue
+        if File::ALT_SEPARATOR then
+            "C:/"
+        else
+            "/"
+        end
+      end
+    end
+
+    # Parse command line arguments
+    def parse_args!(argv)
+      args = {
+        :inspect  => false,
+        :json     => false,
+        :dump     => false,
+        :pretty   => false,
+      }
+
+      # define parser
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: fwissr [-ijph] <key>\nWith key:\n\t#{Fwissr.keys.sort.join("\n\t")}\n\n"
+
+        opts.define_head "The configuration registry."
+
+        opts.on("-i", "--inspect", "Returns 'inspected' result") do
+          args[:inspect] = true
+        end
+
+        opts.on("-j", "--json", "Returns result in json") do
+          args[:json] = true
+        end
+
+        opts.on("--dump", "Dump all keys and values") do
+          args[:dump] = true
+        end
+
+        opts.on("-p", "--pretty", "Pretty output") do
+          args[:pretty] = true
+        end
+
+        opts.on("-?", "-h", "--help", "Show this help message") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("--version", "Show version") do
+          puts Fwissr::VERSION
+          exit
+        end
+
+      end
+
+      # parse what we have on the command line
+      opt_parser.parse!(argv)
+
+      # get key
+      if argv.empty? && !args[:dump]
+        puts "Please specify the key, e.g. 'fwissr /fqdn'"
+        puts opt_parser
+        exit
+      end
+
+      args[:key] = argv.first unless argv.empty?
+
+      args
+    end
+
+
+    #
+    # Global Registry
+    #
+    #
+    # NOTE: Parses main conf files (/etc/fwissr/fwissr.json and ~/.fwissr/fwissr.json) then uses 'fwissr_sources' setting to setup additional sources
+    #
+    # Example of /etc/fwissr/fwissr.json file:
+    #
+    #  {
+    #    'fwissr_sources': [
+    #      { 'filepath': '/mnt/my_app/conf/' },
+    #      { 'filepath': '/etc/my_app.json' },
+    #      { 'mongodb': 'mongodb://db1.example.net/my_app', 'collection': 'config', 'refresh': true },
+    #    ],
+    #    'fwissr_refresh_period': 30,
+    # }
+    #
+
+    # access global registry with Fwissr['/foo/bar']
+    def global_registry
+      @global_registry ||= begin
+        result = Fwissr::Registry.new('refresh_period' => self.main_conf['fwissr_refresh_period'])
+
+        # check main conf files
+        if File.exists?(self.main_conf_path) || File.exists?(self.main_user_conf_path)
+          # setup main conf files sources
+          if File.exists?(self.main_conf_path)
+            result.add_source(Fwissr::Source.from_settings({ 'filepath' => self.main_conf_path }))
+          end
+
+          if File.exists?(self.main_user_conf_path)
+            result.add_source(Fwissr::Source.from_settings({ 'filepath' => self.main_user_conf_path }))
+          end
+
+          # setup additional sources
+          if !self.main_conf['fwissr_sources'].nil?
+            self.main_conf['fwissr_sources'].each do |source_setting|
+              result.add_source(Fwissr::Source.from_settings(source_setting))
+            end
+          end
+        end
+
+        result
+      end
+    end
+
+    # fetch main fwissr conf
+    def main_conf
+      @main_conf ||= begin
+        result = { }
+
+        if File.exists?(self.main_conf_file)
+          result = self.merge_conf!(result, self.parse_conf_file(self.main_conf_file))
+        end
+
+        if File.exists?(self.main_user_conf_file)
+          result = self.merge_conf!(result, self.parse_conf_file(self.main_user_conf_file))
+        end
+
+        result
+      end
+    end
+
+    def main_conf_file
+      @main_conf_file ||= File.join(self.main_conf_path, MAIN_CONF_FILE)
+    end
+
+    def main_user_conf_file
+      @main_user_conf_file ||= File.join(self.main_user_conf_path, MAIN_CONF_FILE)
+    end
+
+    # delegate to global registry
+    [ :[], :get ].each do |meth_name|
+      class_eval <<-EOS, __FILE__, __LINE__
+        def #{meth_name}(key)
+          self.global_registry[key]
+        end
+      EOS
+    end
+
+    [ :keys, :dump ].each do |meth_name|
+      class_eval <<-EOS, __FILE__, __LINE__
+        def #{meth_name}
+          self.global_registry.__send__('#{meth_name}')
+        end
+      EOS
+    end
+
+
+    #
+    # Utils
+    #
+
+    def parse_conf_file(conf_file_path)
+      conf_file_ext = File.extname(conf_file_path)
+
+      case conf_file_ext
+      when ".json"
+        # json file
+        if FWISSR_USE_YAJL
+          Yajl::Parser.parse(File.read(conf_file_path), :check_utf8 => false)
+        else
+          JSON.parse(File.read(conf_file_path))
+        end
+      when ".yaml", ".yml"
+        # yaml file
+        YAML.load_file(conf_file_path)
+      else
+        raise "Unsupported conf file kind: #{conf_file_path}"
+      end
+    end
+
+    # borrowed from rails
+    def merge_conf(to_hash, other_hash)
+      self.merge_conf!(to_hash.dup, other_hash)
+    end
+
+    # borrowed from rails
+    def merge_conf!(to_hash, other_hash)
+      other_hash.each_pair do |k,v|
+        tv = to_hash[k]
+        to_hash[k] = (tv.is_a?(Hash) && v.is_a?(Hash)) ? self.merge_conf(tv, v) : v
+      end
+      to_hash
+    end
+
+    # simple deep freezer
+    def deep_freeze(obj)
+      if obj.is_a?(Hash)
+        obj.each do |k, v|
+          self.deep_freeze(v)
+        end
+      elsif obj.is_a?(Array)
+        obj.each do |v|
+          self.deep_freeze(v)
+        end
+      end
+
+      obj.freeze
+    end
+  end # class << self
+
+end # module Fwissr

data/lib/fwissr/registry.rb

@@ -0,0 +1,154 @@
+require 'thread'
+
+module Fwissr
+
+  class Registry
+
+    # refresh period in seconds
+    DEFAULT_REFRESH_PERIOD = 30
+
+    #
+    # API
+    #
+
+    attr_reader :refresh_period
+
+    def initialize(options = { })
+      @refresh_period = options['refresh_period'] || DEFAULT_REFRESH_PERIOD
+
+      @registry = { }
+      @sources  = [ ]
+
+      # mutex for @registry and @sources
+      @semaphore = Mutex.new
+
+      @refresh_thread = nil
+    end
+
+    def add_source(source)
+      @semaphore.synchronize do
+        @sources << source
+      end
+
+      if @registry.frozen?
+        # already frozen, must reload everything
+        self.reload!
+      else
+        @semaphore.synchronize do
+          Fwissr.merge_conf!(@registry, source.get_conf)
+        end
+      end
+
+      self.ensure_refresh_thread
+    end
+
+    def reload!
+      self.reset!
+      self.load!
+    end
+
+    def get(key)
+      # split key
+      key_ary = key.split('/')
+
+      # remove first empty part
+      key_ary.shift if (key_ary.first == '')
+
+      cur_hash = self.registry
+      key_ary.each do |key_part|
+        cur_hash = cur_hash[key_part]
+        return nil if cur_hash.nil?
+      end
+
+      cur_hash
+    end
+
+    alias :[] :get
+
+    def keys
+      result = [ ]
+      _keys(result, [ ], self.registry)
+      result.sort
+    end
+
+    def dump
+      self.registry
+    end
+
+
+    #
+    # PRIVATE
+    #
+
+    def refresh_thread
+      @refresh_thread
+    end
+
+    def have_refreshable_source?
+      @semaphore.synchronize do
+        !@sources.find { |source| source.can_refresh? }.nil?
+      end
+    end
+
+    def ensure_refresh_thread
+      # check refresh thread state
+      if ((@refresh_period > 0) && self.have_refreshable_source?) && (!@refresh_thread || !@refresh_thread.alive?)
+        # (re)start refresh thread
+        @refresh_thread = Thread.new do
+          while(true) do
+            sleep(@refresh_period)
+            self.load!
+          end
+        end
+      end
+    end
+
+    def ensure_frozen
+      if !@registry.frozen?
+        @semaphore.synchronize do
+          Fwissr.deep_freeze(@registry)
+        end
+      end
+    end
+
+    def reset!
+      @semaphore.synchronize do
+        @registry = { }
+
+        @sources.each do |source|
+          source.reset!
+        end
+      end
+    end
+
+    def load!
+      @semaphore.synchronize do
+        @registry = { }
+
+        @sources.each do |source|
+          source_conf = source.get_conf
+          Fwissr.merge_conf!(@registry, source_conf)
+        end
+      end
+    end
+
+    def registry
+      self.ensure_refresh_thread
+      self.ensure_frozen
+
+      @registry
+    end
+
+    # helper for #keys
+    def _keys(result, key_ary, hash)
+      hash.each do |key, value|
+        key_ary << key
+        result << "/#{key_ary.join('/')}"
+        _keys(result, key_ary, value) if value.is_a?(Hash)
+        key_ary.pop
+      end
+    end
+
+  end # module Registry
+
+end # module Fwissr

data/lib/fwissr/source.rb

@@ -0,0 +1,60 @@
+class Fwissr::Source
+
+  autoload :File,    'fwissr/source/file'
+  autoload :Mongodb, 'fwissr/source/mongodb'
+
+  class << self
+    def from_settings(settings)
+      raise "Unexpected source settings class: #{settings.inspect}" unless settings.is_a?(Hash)
+
+      if settings['filepath']
+        Fwissr::Source::File.from_settings(settings)
+      elsif settings['mongodb']
+        Fwissr::Source::Mongodb.from_settings(settings)
+      else
+        raise "Unexpected source settings kind: #{settings.inspect}"
+      end
+    end
+  end # class << self
+
+
+  #
+  # API
+  #
+
+  attr_reader :options
+
+  def initialize(options = { })
+    @options = options
+
+    @conf = nil
+  end
+
+  # reset source
+  def reset!
+    @conf = nil
+  end
+
+  # source can be refreshed ?
+  def can_refresh?
+    @options && (@options['refresh'] == true)
+  end
+
+  # get conf
+  def get_conf
+    if (@conf && !self.can_refresh?)
+      # return already fetched conf if refresh is not allowed
+      @conf
+    else
+      # fetch conf
+      @conf = self.fetch_conf
+    end
+  end
+
+  # fetch conf from source
+  def fetch_conf
+    # MUST be implemented by child class
+    raise "not implemented"
+  end
+
+end # class Fwissr::Source

data/lib/fwissr/source/file.rb

@@ -0,0 +1,88 @@
+class Fwissr::Source::File < Fwissr::Source
+
+  class << self
+
+    def from_path(path, options = { })
+      if path.nil? || (path == '')
+        raise "Unexpected file source path: #{path.inspect}"
+      end
+
+      self.new(path, options)
+    end
+
+    def from_settings(settings)
+      options = settings.dup
+      options.delete('filepath')
+
+      self.from_path(settings['filepath'], options)
+    end
+
+  end # class << self
+
+
+  TOP_LEVEL_CONF_FILES = [ 'fwissr' ].freeze
+
+  attr_reader :path
+
+  #
+  # API
+  #
+
+  def initialize(path, options = { })
+    super(options)
+
+    raise "File not found: #{path}" if !::File.exists?(path)
+
+    @path = path
+  end
+
+  def fetch_conf
+    result = { }
+
+    conf_files = if ::File.directory?(@path)
+      Dir[@path + "/*.{json,yml}"].sort
+    else
+      [ @path ]
+    end
+
+    conf_files.each do |conf_file_path|
+      next unless ::File.file?(conf_file_path)
+
+      self.merge_conf_file!(result, conf_file_path)
+    end
+
+    result
+  end
+
+
+  #
+  # PRIVATE
+  #
+
+  def merge_conf_file!(result, conf_file_path)
+    # parse conf file
+    conf = Fwissr.parse_conf_file(conf_file_path)
+    if conf
+      conf_file_name = ::File.basename(conf_file_path, ::File.extname(conf_file_path))
+
+      result_part = result
+
+      unless TOP_LEVEL_CONF_FILES.include?(conf_file_name) || @options['top_level']
+        # merge conf at the correct place in registry
+        #
+        # eg: my_app.json               => /my_app
+        #     my_app.database.yml       => /my_app/database
+        #     my_app.database.slave.yml => /my_app/database/slave
+        key_ary = conf_file_name.split('.')
+        key_ary.each do |key_part|
+          result_part = (result_part[key_part] ||= { })
+        end
+      end
+
+      Fwissr.merge_conf!(result_part, conf)
+    else
+      raise "Failed to parse conf file: #{conf_file_path}"
+    end
+  end
+
+end # class Fwissr::Source::File

data/lib/fwissr/source/mongodb.rb

@@ -0,0 +1,180 @@
+require 'uri'
+
+begin
+  require 'moped'
+rescue LoadError
+  begin
+    require 'mongo'
+  rescue LoadError
+    raise "[fwissr] Can't find any suitable mongodb driver: please install 'mongo' or 'moped' gem"
+  end
+end
+
+class Fwissr::Source::Mongodb < Fwissr::Source
+
+  class Connection
+
+    attr_reader :db_name
+
+    # init
+    def initialize(uri)
+      raise "URI is missing: #{uri}" if (uri.nil? || uri == '')
+
+      @uri = uri
+      @collections = { }
+
+      @kind = if defined?(::Moped)
+        # moped driver
+        :moped
+      elsif defined?(::Mongo::MongoClient)
+        # mongo ruby driver < 2.0.0
+        :mongo
+      elsif defined?(::Mongo::Client)
+        raise "Sorry, mongo gem >= 2.0 is not supported yet"
+      else
+        raise "Can't find any suitable mongodb driver: please install 'mongo' or 'moped' gem"
+      end
+
+      # parse URI
+      parsed_uri = URI.parse(@uri)
+      @db_name = parsed_uri.path[1..-1]
+
+      if @db_name.nil? || (@db_name == '')
+        raise "Missing database in mongodb settings: #{settings['mongodb'].inspect}"
+      end
+    end
+
+    def conn
+      @conn ||= begin
+        case @kind
+        when :moped
+          ::Moped::Session.connect(@uri)
+        when :mongo
+          ::Mongo::MongoClient.from_uri(@uri)
+        end
+      end
+    end
+
+    def collection(col_name)
+      @collections[col_name] ||= begin
+        case @kind
+        when :moped
+          self.conn[col_name]
+        when :mongo
+          self.conn.db(@db_name).collection(col_name)
+        end
+      end
+    end
+
+    # returns an Enumerator for all documents from given collection
+    def fetch(col_name)
+      case @kind
+      when :moped, :mongo
+        self.collection(col_name).find()
+      end
+    end
+
+    # insert document in collection
+    def insert(col_name, doc)
+      case @kind
+      when :moped, :mongo
+        self.collection(col_name).insert(doc)
+      end
+    end
+
+    # create a collection
+    def create_collection(col_name)
+      case @kind
+      when :moped
+        # NOOP
+      when :mongo
+        self.conn.db(@db_name).create_collection(col_name)
+      end
+    end
+
+    # drop database
+    def drop_database(db_name)
+      case @kind
+      when :moped
+        self.conn.drop
+      when :mongo
+        self.conn.drop_database(db_name)
+      end
+    end
+  end # class Connection
+
+  class << self
+
+    def from_settings(settings)
+      if settings['mongodb'].nil? || (settings['mongodb'] == '') || settings['collection'].nil? || (settings['collection'] == '')
+        raise "Erroneous mongodb settings: #{settings.inspect}"
+      end
+
+      conn = self.connection_for_uri(settings['mongodb'])
+
+      options = settings.dup
+      options.delete('mongodb')
+      options.delete('collection')
+
+      self.new(conn, settings['collection'], options)
+    end
+
+    def connection_for_uri(uri)
+      @connections ||= { }
+      @connections[uri] ||= Fwissr::Source::Mongodb::Connection.new(uri)
+    end
+
+  end # class << self
+
+
+  TOP_LEVEL_COLLECTIONS = [ 'fwissr' ].freeze
+
+  attr_reader :conn, :collection_name
+
+  #
+  # API
+  #
+
+  def initialize(conn, collection_name, options = { })
+    super(options)
+
+    @conn            = conn
+    @collection_name = collection_name
+  end
+
+  def fetch_conf
+    result = { }
+    result_part = result
+
+    unless TOP_LEVEL_COLLECTIONS.include?(@collection_name) || @options['top_level']
+      # merge conf at the correct place in registry
+      #
+      # eg: m_app                 => /my_app
+      #     my_app.database       => /my_app/database
+      #     my_app.database.slave => /my_app/database/slave
+      key_ary = @collection_name.split('.')
+      key_ary.each do |key_part|
+        result_part = (result_part[key_part] ||= { })
+      end
+    end
+
+    # build conf hash from collection's documents
+    conf = { }
+    self.conn.fetch(@collection_name).each do |doc|
+      key = doc['_id']
+      value = if doc['value'].nil?
+        doc.delete('_id')
+        doc
+      else
+        doc['value']
+      end
+
+      conf[key] = value
+    end
+
+    Fwissr.merge_conf!(result_part, conf)
+
+    result
+  end
+
+end # class Fwissr::Source::Mongodb

data/lib/fwissr/version.rb

@@ -0,0 +1,3 @@
+module Fwissr
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: fwissr
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Fotonauts Team
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-12-03 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id002 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id002
+  type: :development
+  version_requirements: *id003
+description: "  A simple configuration registry tool by Fotonauts.\n"
+email: 
+- aymerick@fotonauts.com
+- oct@fotonauts.com
+executables: 
+- fwissr
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- Rakefile
+- README.md
+- bin/fwissr
+- lib/fwissr/registry.rb
+- lib/fwissr/source/file.rb
+- lib/fwissr/source/mongodb.rb
+- lib/fwissr/source.rb
+- lib/fwissr/version.rb
+- lib/fwissr.rb
+homepage: https://github.com/fotonauts/fwissr
+licenses: []
+
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id002
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id002
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Fwissr
+test_files: []
+