visor-common 0.0.1

data/bin/visor-config

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+# VISoR configuration command line interface script.
+# Run <visor-config -h> to get more usage help.
+
+require File.expand_path('../../lib/visor-common', __FILE__)
+
+unless ARGV.empty?
+  puts %q[Usage: visor-config
+
+This script will generate the following VISOR configuration and logging directories and files:
+
+- ~/.visor                        The VISOR default configuration directory
+- ~/.visor/visor-config.yml       The VISOR configuration file template
+- ~/.visor/logs                   The VISOR default logging directory
+
+Run it without any arguments to generate the above directories and files.
+
+]
+  exit
+end
+
+dir = "#{ENV['HOME']}/.visor"
+
+if Dir.exists? dir
+  puts "Directory #{dir} already exists, do you want to override it and its files? (y/n)"
+  if gets.chomp.downcase == "n"
+    puts "Aborting configurations override."
+    exit
+  end
+end
+
+puts "\nGenerating VISOR configuration directories and files:\n\n"
+sleep (0.5)
+print "creating #{dir}..."
+system "mkdir #{dir}"
+puts " [DONE]"
+print "creating #{dir}/logs..."
+system "mkdir #{dir}/logs"
+puts " [DONE]"
+print "creating #{dir}/visor-config.yml..."
+system "echo '#{Visor::Common::Config::CONFIG_TEMPLATE}' > #{dir}/visor-config.yml"
+puts " [DONE]"
+puts "\nAll configurations were successful. Now open and customize the VISOR configuration file at #{dir}/visor-config.yml\n\n"

data/lib/common/config.rb

@@ -0,0 +1,257 @@
+require 'yaml'
+require 'logger'
+
+module Visor
+  module Common
+
+    # The Config module provides a set of utility functions to manipulate configuration
+    # files and Logging.
+    #
+    module Config
+
+      include Visor::Common::Exception
+
+      # Default possible configuration file directories
+      DEFAULT_CONFIG_DIRS = %w{. ~/.visor /etc/visor}
+      # Default configuration file name
+      DEFAULT_CONFIG_FILE = 'visor-config.yml'
+      # Default logs path
+      DEFAULT_LOG_PATH = '~/.visor/logs'
+      # Default log datetime format
+      DEFAULT_LOG_DATETIME = "%Y-%m-%d %H:%M:%S"
+      # Default log level
+      DEFAULT_LOG_LEVEL = Logger::INFO
+      # Configuration file template
+      CONFIG_TEMPLATE = %q[
+# ========== Default always loaded configuration throughout VISOR sub-systems =====
+#
+default: &default
+    # Set the default log date time format
+    log_datetime_format: "%Y-%m-%d %H:%M:%S"
+    # Set the default log path
+    log_path: ~/.visor/logs
+    # VISoR access and secret key credentials, grab yours from $ visor-admin
+    access_key: XXXXXX
+    secret_key: XXXXXX
+
+# ================================ VISoR Auth ==================================
+#
+visor_auth:
+    # Merge default configuration
+    <<: *default
+    # Address to bind the meta server
+    bind_host: 0.0.0.0
+    # Port to bind the meta server
+    bind_port: 4566
+    # Backend connection string (syntax: name://user:pass@host:port/database)
+    backend: mongodb://:@127.0.0.1:27017/visor
+    # backend: mysql://visor:passwd@127.0.0.1:3306/visor
+    # Log file name (available: filename or empty for STDOUT)
+    log_file: visor-auth-server.log
+    # Log level to start logging above events (available: DEBUG, INFO)
+    log_level: INFO
+
+# ================================ VISoR Meta =====================================
+#
+visor_meta:
+    # Merge default configuration
+    <<: *default
+    # Address to bind the meta server
+    bind_host: 0.0.0.0
+    # Port to bind the meta server
+    bind_port: 4567
+    # Backend connection string (syntax: name://user:pass@host:port/database)
+    backend: mongodb://:@127.0.0.1:27017/visor
+    # backend: mysql://visor:passwd@127.0.0.1:3306/visor
+    # Log file name (available: filename or empty for STDOUT)
+    log_file: visor-meta-server.log
+    # Log level to start logging above events (available: DEBUG, INFO)
+    log_level: INFO
+
+# ================================ VISoR Image ====================================
+#
+visor_image:
+    # Merge default configuration
+    <<: *default
+    # Address to bind the meta server
+    bind_host: 0.0.0.0
+    # Port to bind the meta server
+    bind_port: 4568
+    # Log file name (available: filename or empty for STDOUT)
+    log_file: visor-api-server.log
+    # Log level to start logging equal and above events (available: DEBUG, INFO)
+    log_level: INFO
+
+# ============================== VISoR Image Backends =============================
+#
+visor_store:
+    # Default store backend (available: s3, cumulus, walrus, lunacloud, hdfs, file)
+    default: file
+    #
+    # FileSystem store backend settings
+    #
+    file:
+        # Default directory to store image files in
+        directory: ~/VMs/
+    #
+    # Amazon Simple Storage (S3) store backend settings
+    #
+    s3:
+        # The bucket to store images in, make sure you provide an already existing bucket
+        bucket: XXXXXX
+        # Access and secret key credentials, grab yours on your AWS account settings page
+        access_key: XXXXXX
+        secret_key: XXXXXX
+    #
+    # Nimbus Cumulus (Cumulus) store backend settings
+    #
+    cumulus:
+        # The Cumulus host address
+        host: XXXXXX
+        # The Cumulus port number
+        port: XXXXXX
+        # The bucket to store images in, make sure you provide an already existing bucket
+        bucket: XXXXXX
+        # Access and secret key credentials, grab yours with Nimbus cloud
+        access_key: XXXXXX
+        secret_key: XXXXXX
+    #
+    # Eucalyptus Walrus (Walrus) store backend settings
+    #
+    walrus:
+        # The Walrus host address
+        host: XXXXXX
+        # The Walrus port number
+        port: XXXXXX
+        # A
+        # The bucket to store images in, make sure you provide an already existing bucket
+        bucket: XXXXXX
+        # Access and secret key credentials, grab yours with Eucalyptus cloud
+        access_key: XXXXXX
+        secret_key: XXXXXX
+    #
+    # Lunacloud (Lunacloud) store backend settings
+    #
+    lunacloud:
+        # The Lunacloud host address
+        host: betalcs.lunacloud.com
+        # The Lunacloud port number
+        port: 80
+        # The bucket to store images in, make sure you provide an already existing bucket
+        bucket: XXXXXX
+        # Access and secret key credentials, grab yours with Lunacloud cloud
+        access_key: XXXXXX
+        secret_key: XXXXXX
+    #
+    # Apache Hadoop HDFS (HDFS) store backend settings
+    #
+    hdfs:
+        # The HDFS host address
+        host: XXXXXX
+        # The HDFS port number
+        port: XXXXXX
+        # The bucket to store images in
+        bucket: XXXXXX
+        # Access credentials
+        username: XXXXXX
+]
+
+      # Ordered search for a VISoR configuration file on default locations and return the first matched.
+      #
+      # @param other_file [String] Other file to use instead of default config files.
+      #
+      # @return [nil, String] Returns nil if no valid config file was found or a string with the
+      #   absolute path to the found configuration file.
+      #
+      def self.find_config_file(other_file = nil)
+        if other_file
+          file = File.expand_path(other_file)
+          File.exists?(file) ? file : nil
+        else
+          DEFAULT_CONFIG_DIRS.each do |dir|
+            file = File.join(File.expand_path(dir), DEFAULT_CONFIG_FILE)
+            return file if File.exists?(file)
+          end
+        end
+      end
+
+      # Looks for a VISoR configuration file througth {#self.find_config_file} and returns a hash with
+      # all configuration settings or just a sub-system scoped settings.
+      #
+      # @param scope [String] Used to return just the settings about a specific sub-system.
+      # @param other_file [String] Other file to use instead of default config files.
+      #
+      # @return [Hash] Global or scoped settings.
+      #
+      # @raise [RuntimeError] If there is no configuration files or if errors occur during parsing.
+      #
+      #TODO: YAML.load_openstruct(File.read(file))
+      def self.load_config(scope = nil, other_file = nil)
+        file = find_config_file(other_file)
+        raise ConfigError, "Could not found any configuration file." unless file
+        begin
+          content = YAML.load_file(file).symbolize_keys
+        rescue => e
+          raise ConfigError, "Error while parsing the configuration file: #{e.message}."
+        end
+        config = scope ? content[scope] : content
+        config.merge(file: file)
+      end
+
+      # Build and return a Logger instance for a given VISoR sub-system, based on configuration
+      # file options, which are validated througth {#self.validate_logger}.
+      #
+      # @param app_name [Symbol] The VISoR sub-system app name to build a log for.
+      # @option configs [Hash] Optional configuration options to override config file ones.
+      #
+      # @return [Logger] A logger instance already properly configured.
+      #
+      def self.build_logger(app_name, configs = nil)
+        conf = configs || load_config
+
+        raise ConfigError, "Cannot locate 'default' configuration group." unless conf[:default]
+        raise ConfigError, "Cannot locate '#{app_name}' configuration group." unless conf[app_name]
+
+        log_path = File.expand_path(conf[:default][:log_path] || DEFAULT_LOG_PATH)
+        log_datetime = conf[:default][:log_datetime_format] || DEFAULT_LOG_DATETIME
+        log_file = conf[app_name][:log_file] || STDOUT
+        log_level = conf[app_name][:log_level] || DEFAULT_LOG_LEVEL
+
+        begin
+          Dir.mkdir(log_path) unless Dir.exists?(log_path)
+        rescue => e
+          raise ConfigError, "Cannot create the 'default/log_path' directory: #{e.message}."
+        end
+
+        begin
+          output = log_file==STDOUT ? log_file : File.join(log_path, log_file)
+          log = Logger.new(output, 5, 1024*1024)
+        rescue => e
+          raise ConfigError, "Error while create the logger for #{output}: #{e.message}."
+        end
+
+        begin
+          log.datetime_format = log_datetime
+          log.level = get_log_level(log_level)
+        rescue => e
+          raise ConfigError, "Error while setting logger properties: #{e.message}."
+        end
+        log
+      end
+
+      private
+
+      def self.get_log_level(level)
+        case level
+          when 'DEBUG' then
+            Logger::DEBUG
+          when 'INFO' then
+            Logger::INFO
+          else
+            DEFAULT_LOG_LEVEL
+        end
+      end
+
+    end
+  end
+end

data/lib/common/exception.rb

@@ -0,0 +1,34 @@
+module Visor
+  module Common
+
+    # The Exceptions module introduces a set of custom exceptions used along
+    # all VISoR sub-systems.
+    #
+    module Exception
+
+      # Raise if invalid data is provided within new metadata
+      class Invalid < ArgumentError; end
+
+      # Raise if no image meta or file path is not found
+      class NotFound < StandardError; end
+
+      # Raise on a configuration error
+      class ConfigError < RuntimeError; end
+
+      # Raise if provided store backend is not supported
+      class UnsupportedStore < RuntimeError; end
+
+      # Raise if a record or file is already stored
+      class Duplicated < RuntimeError; end
+
+      # Raise on an internal server error
+      class InternalError < RuntimeError; end
+
+      # Raise on error trying to manipulate image files
+      class Forbidden < RuntimeError; end
+
+      # Raise on error trying to update image files/meta
+      class ConflictError < RuntimeError; end
+    end
+  end
+end

data/lib/common/extensions/array.rb

@@ -0,0 +1,27 @@
+module Visor
+  module Common
+
+    # The Module Extensions provides a set of functions to extend the Standard Core Libraries
+    # with custom usefull methods used allong all VISoR sub-systems.
+    #
+    module Extensions
+      #
+      # Extending Array class
+      #
+      module Array
+
+        # Convert each array element to an OpenStruct.
+        # Used for Hash.to_openstruct
+        #
+        # @return [Array] The array with elements converted to OpenStruct.
+        #
+        def to_openstruct
+          map { |el| el.to_openstruct }
+        end
+
+      end
+    end
+  end
+end
+
+Array.send :include, Visor::Common::Extensions::Array

data/lib/common/extensions/hash.rb

@@ -0,0 +1,121 @@
+require 'ostruct'
+
+module Visor
+  module Common
+
+    # The Module Extensions provides a set of functions to extend the Standard Core Libraries
+    # with custom usefull methods used allong all VISoR sub-systems.
+    #
+    module Extensions
+      #
+      # Extending Hash class
+      #
+      module Hash
+
+        # Return a new hash with all keys converted to strings.
+        #
+        def stringify_keys
+          inject({}) do |acc, (k, v)|
+            key = Symbol === k ? k.to_s : k
+            value = Hash === v ? v.stringify_keys : v
+            acc[key] = value
+            acc
+          end
+        end
+
+        # Destructively convert all keys to strings.
+        #
+        def stringify_keys!
+          self.replace(self.stringify_keys)
+        end
+
+        # Return a new hash with all keys converted to symbols.
+        #
+        def symbolize_keys
+          inject({}) do |acc, (k, v)|
+            key = String === k ? k.to_sym : k
+            value = Hash === v ? v.symbolize_keys : v
+            acc[key] = value
+            acc
+          end
+        end
+
+        # Destructively convert all keys to symbols.
+        #
+        def symbolize_keys!
+          self.replace(self.symbolize_keys)
+        end
+
+        # Validate all keys in a hash match *valid keys.
+        #
+        # @param [Array] valid_keys Valid keys.
+        #
+        # @raise [ArgumentError] On a mismatch.
+        #
+        def assert_valid_keys(*valid_keys)
+          unknown_keys = keys - valid_keys.flatten
+          raise ArgumentError, "Unknown fields: #{unknown_keys.join(", ")}" unless unknown_keys.empty?
+        end
+
+        # Validate inclusions of some keys in a hash.
+        #
+        # @param [Array] inclusion_keys Keys that must be included in the hash.
+        #
+        # @raise [ArgumentError] If some key is not included.
+        #
+        def assert_inclusion_keys(*inclusion_keys)
+          inc = inclusion_keys.flatten - keys
+          raise ArgumentError, "These fields are required: #{inc.join(', ')}" unless inc.empty?
+        end
+
+        # Validate non-inclusion of some keys in a hash.
+        #
+        # @param [Array] exclude_keys Keys that must be not be included in the hash.
+        #
+        # @raise [ArgumentError] If some key is included.
+        #
+        def assert_exclusion_keys(*exclude_keys)
+          exc = exclude_keys.flatten & keys
+          raise ArgumentError, "These fields are read-only: #{exc.join(', ')}" unless exc.empty?
+        end
+
+        # Validate value of some key in a hash.
+        #
+        # @param [Array] valid_values Values to assert against the given key.
+        # @param [Array] key The key to assert its value.
+        #
+        # @raise [ArgumentError] If some key is included.
+        #
+        def assert_valid_values_for(key, *valid_values)
+          unless valid_values.flatten.include?(self[key.to_sym]) || self[key].nil?
+            raise ArgumentError, "Invalid #{key.to_s} '#{self[key]}', available options: #{valid_values.join(', ')}"
+          end
+        end
+
+        # Set some keys in a hash to a given value, possibly ignoring some keys.
+        #
+        # @param [Array] keys_to_set Keys to set its value.
+        # @param [Array] keys_to_ignore Keys to be ignored.
+        # @param [Array] to_value Value to set the wanted keys.
+        #
+        # @raise [ArgumentError] If some key is included.
+        #
+        def set_blank_keys_value_to(keys_to_set, keys_to_ignore, to_value)
+          keys_to_set.each { |k| self.merge!(k => to_value) unless self[k] || keys_to_ignore.include?(k) }
+        end
+
+        # Convert a Hash to a OpenStruct, so it can be accessed as options like: h[key] => h.key
+        #
+        # @return [OpenStruct] The resulting OpenStruct object.
+        #
+        def to_openstruct
+          mapped = {}
+          each { |key, value| mapped[key] = value.to_openstruct }
+          OpenStruct.new(mapped)
+        end
+      end
+    end
+  end
+end
+
+Hash.send :include, Visor::Common::Extensions::Hash

data/lib/common/extensions/logger.rb

@@ -0,0 +1,9 @@
+#
+# Extends the Logger Class
+#
+# Make Rack::CommonLogger accept a Logger instance
+# without raising undefined method `write' for #<Logger:0x007fc12db61778>
+#
+class Logger
+  alias write <<
+end

data/lib/common/extensions/object.rb

@@ -0,0 +1,27 @@
+module Visor
+  module Common
+
+    # The Module Extensions provides a set of functions to extend the Standard Core Libraries
+    # with custom usefull methods used allong all VISoR sub-systems.
+    #
+    module Extensions
+      #
+      # Extending Object class
+      #
+      module Object
+
+        # Pass from Hash.to_openstruct
+        #
+        # @return [self] The object itself.
+        #
+        def to_openstruct
+          self
+        end
+
+      end
+    end
+  end
+end
+
+Object.send :include, Visor::Common::Extensions::Object
+

data/lib/common/extensions/yaml.rb

@@ -0,0 +1,29 @@
+module Visor
+  module Common
+
+    # The Module Extensions provides a set of functions to extend the Standard Core Libraries
+    # with custom usefull methods used allong all VISoR sub-systems.
+    #
+    module Extensions
+      #
+      # Extending YAML library
+      #
+      module YAML
+
+        # Load a YAML source to to an OpenStruct object.
+        # Used for Hash.to_openstruct
+        #
+        # @param source [YAML] A file or a parsed YAML object.
+        #
+        # @return [OpenStruct] YAML file parsed to an OpenStruct object.
+        #
+        def self.load_openstruct(source)
+          self.load(source).to_openstruct
+        end
+
+      end
+    end
+  end
+end
+
+YAML.send :include, Visor::Common::Extensions::YAML

data/lib/common/util.rb

@@ -0,0 +1,103 @@
+require 'time'
+require 'openssl'
+require 'base64'
+
+module Visor
+  module Common
+
+    # The Util module provides a set of utility functions used along all VISoR sub-systems.
+    #
+    module Util
+      extend self
+
+      # Push a hash containing image metadata into an HTTP header.
+      # Each key value pair is pushed as a string of the form 'x-image-meta-<key>'.
+      #
+      # @param meta [Hash] The image metadata
+      # @param header [Hash] (nil) The HTTP headers hash
+      #
+      # @return [Hash] The header containing the metadata headers
+      #
+      def push_meta_into_headers(meta, headers = {})
+        meta.each { |k, v| headers["x-image-meta-#{k.to_s.downcase}"] = v.to_s }
+        headers
+      end
+
+      def pull_meta_from_headers(headers)
+        meta = {}
+        headers.each do |k, v|
+          if key = k.split(/x[_-]image[_-]meta[_-]/i)[1]
+            value                     = parse_value v
+            meta[key.downcase.to_sym] = value
+          end
+        end
+        meta
+      end
+
+      def parse_value(string)
+        if is_integer?(string) then
+          Integer(string)
+        elsif is_float?(string) then
+          Float(object)
+        elsif is_date?(string) then
+          Time.parse(string)
+        else
+          string
+        end
+      end
+
+      def is_integer?(object)
+        true if Integer(object) rescue false
+      end
+
+      def is_float?(object)
+        true if Float(object) rescue false
+      end
+
+      def is_date?(object)
+        regexp = /\d{4}[-\/]\d{1,2}[-\/]\d{1,2}\s\d{2}:\d{2}:\d{2}\s\W\d{4}/
+        object.match(regexp) ? true : false
+      end
+
+      def sign_request(access_key, secret_key, method, path, headers={})
+        headers['Date'] ||= Time.now.utc.httpdate
+        desc            = canonical_description(method, path, headers)
+        signature       = Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha1'), secret_key, desc)).strip
+
+        headers['Authorization'] = "VISOR #{access_key}:#{signature}"
+      end
+
+      def canonical_description(method, path, headers={})
+        attributes = {}
+        headers.each do |key, value|
+          key = key.downcase
+          attributes[key] = value.to_s.strip if key.match(/^x-image-meta-|^content-md5$|^content-type$|^date$/o)
+        end
+
+        attributes['content-type'] ||= ''
+        attributes['content-md5']  ||= ''
+
+        desc = "#{method}\n"
+        attributes.sort { |a, b| a[0] <=> b[0] }.each do |key, value|
+          desc << (key.match(/^x-image-meta-/o) ? "#{key}:#{value}\n" : "#{value}\n")
+        end
+        desc << path.gsub(/\?.*$/, '')
+      end
+
+      def authorize(env, vas)
+        auth = env['headers']['Authorization']
+        raise Visor::Common::Exception::Forbidden, "Authorization not provided." unless auth
+        access_key = auth.scan(/\ (\w+):/).flatten.first
+        raise Visor::Common::Exception::Forbidden, "No access key found in Authorization." unless access_key
+        user = vas.get_user(access_key) rescue nil
+        raise Visor::Common::Exception::Forbidden, "No user found with access key '#{access_key}'." unless user
+        sign = sign_request(user[:access_key], user[:secret_key], env['REQUEST_METHOD'], env['REQUEST_PATH'], env['headers'])
+        raise Visor::Common::Exception::Forbidden, "Invalid authorization, signatures do not match." unless auth == sign
+        access_key
+      end
+
+    end
+  end
+end
+
+#sign_request('key', 'secret', 'GET', '/users/joaodrp', {'x-image-meta-name' => 'hi'})

data/lib/common/version.rb

@@ -0,0 +1,5 @@
+module Visor
+  module Common
+    VERSION = "0.0.1"
+  end
+end

data/lib/visor-common.rb

@@ -0,0 +1,9 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'common/exception'
+require 'common/config'
+require 'common/util'
+require 'common/extensions/object'
+require 'common/extensions/array'
+require 'common/extensions/yaml'
+require 'common/extensions/hash'
+require 'common/extensions/logger'

data/spec/lib/config_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module Visor::Common
+  describe Config do
+
+    let(:file) { File.join(File.expand_path('~/.visor'), Config::DEFAULT_CONFIG_FILE) }
+    let(:some_file) { File.expand_path('~/some_file') }
+    let(:invalid_file) { '~/some_invalid_file' }
+
+    let(:sample_conf) { {default:
+                             {log_datetime_format: "%Y-%m-%d %H:%M:%S",
+                              log_path: "~/.visor/logs"},
+                         visor_meta:
+                             {bind_host: "0.0.0.0", bind_port: 4567,
+                              backend: "mongodb://:@127.0.0.1:27017/visor",
+                              log: {file: "visor-meta.log", level: "DEBUG"}}} }
+
+    before(:all) do
+      unless File.exists?(file)
+        File.open(file, 'w') do |f|
+          f.write(sample_conf.stringify_keys.to_yaml)
+        end
+      end
+
+      File.open(some_file, 'w') do |f|
+          f.write(sample_conf.stringify_keys.to_yaml)
+      end
+
+      File.open(File.expand_path(invalid_file), 'w') do |f|
+        f.write('this will break YAML parsing')
+      end
+    end
+
+    after(:all) do
+      #File.delete(some_file, File.expand_path(invalid_file))
+    end
+
+    describe "#find_config_file" do
+      it "should find a configuration file in default dirs if it exists" do
+        Config.find_config_file.should == file
+      end
+
+      it "should get an existing config file as option" do
+        Config.find_config_file(some_file).should == some_file
+      end
+
+      it "should return nil if no configuration file found" do
+        Config.find_config_file('fake_file').should be_nil
+      end
+    end
+
+    describe "#load_config" do
+      it "should raise if there is no configuration files" do
+        lambda { Config.load_config(nil, invalid_file) }.should raise_exception
+      end
+
+      it "should return a valid non-empty hash" do
+        conf = Config.load_config
+        conf.should be_a Hash
+        conf.should_not be_empty
+      end
+
+      it "should append the configuration file full path to hash" do
+        conf = Config.load_config
+        conf[:file].should_not be_nil
+        File.exists?(conf[:file]).should be_true
+      end
+
+      it "should return scoped configuration" do
+        conf = Config.load_config :default
+        conf.keys.should == sample_conf[:default].keys << :file
+      end
+
+      it "should raise an exception if an error occurs during parsing" do
+        lambda { Config.load_config(nil, invalid_file) }.should raise_exception
+      end
+    end
+
+    describe "#build_logger" do
+      it "should return a Logger for a specific app" do
+        log = Config.build_logger :visor_meta
+        log.should be_a Logger
+      end
+
+      it "should raise an exception if an error occurs loading the config file" do
+        lambda { Config.build_logger :fake_scope }.should raise_exception
+      end
+      
+      it "should set the log level if provided" do
+        log = Config.build_logger :visor_meta, sample_conf
+        log.level.should == Logger::DEBUG
+      end
+
+      it "should set the log level to the default if not provided" do
+        sample_conf[:visor_meta][:log].delete(:level)
+        log = Config.build_logger :visor_meta, sample_conf
+        log.level.should == Config::DEFAULT_LOG_LEVEL
+      end
+    end
+
+  end
+end

data/spec/lib/extensions/hash_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+module Visor::Common::Extensions
+  describe Hash do
+
+    let(:h_symbols) { {a: 1, b: 2, c: {d: 4, e: 5}} }
+    let(:h_strings) { {'a' => 1, 'b' => 2, 'c' => {'d' => 4, 'e' => 5}} }
+
+    let(:simple_hash) { {a: 1, b: 2, c: 3, d: 4, e: 5} }
+    let(:valid_keys) { [:a, :b, :c, :d, :e] }
+    let(:inclusion_keys) { [:a, :b, :c, :d, :e] }
+    let(:exclusion_keys) { [:f, :g] }
+
+    describe "#stringify_keys" do
+      it "should return a new hash" do
+        h_symbols.stringify_keys.should be_a Hash
+      end
+
+      it "should return the hash with all keys stringified" do
+        h_symbols.stringify_keys.keys.each { |k| k.should be_a String }
+      end
+
+      it "should succed at any hash depth" do
+        new = h_symbols.stringify_keys
+        new['c'].keys.each { |k| k.should be_a String }
+      end
+    end
+
+    describe "#stringify_keys!" do
+      it "should replace the hash with all keys stringified" do
+        h_symbols.stringify_keys!
+        h_symbols.keys.each { |k| k.should be_a String }
+      end
+
+      it "should succed at any hash depth" do
+        h_symbols.stringify_keys!
+        h_symbols['c'].keys.each { |k| k.should be_a String }
+      end
+    end
+
+    describe "#symbolize_keys" do
+      it "should return a new hash" do
+        h_strings.symbolize_keys.should be_a Hash
+      end
+
+      it "should return the hash with all keys symbolized" do
+        h_strings.symbolize_keys.keys.each { |k| k.should be_a Symbol }
+      end
+
+      it "should succed at any hash depth" do
+        new = h_strings.symbolize_keys
+        new[:c].keys.each { |k| k.should be_a Symbol }
+      end
+    end
+
+    describe "#symbolize_keys!" do
+      it "should replace the hash with all keys symbolized" do
+        h_strings.symbolize_keys!
+        h_strings.keys.each { |k| k.should be_a Symbol }
+      end
+
+      it "should succed at any hash depth" do
+        h_strings.symbolize_keys!
+        h_strings[:c].keys.each { |k| k.should be_a Symbol }
+      end
+    end
+
+    describe "#assert_valid_keys" do
+      it "should validate that all keys are valid" do
+        l = lambda { simple_hash.assert_valid_keys(simple_hash.keys) }
+        l.should_not raise_exception
+      end
+      
+      it "should raise if any key is not valid" do
+        l = lambda { simple_hash.assert_valid_keys([:x, :y, :z]) }
+        l.should raise_exception ArgumentError
+      end
+    end
+
+    describe "#assert_inclusion_keys" do
+      it "should validate that all mandatory keys are present" do
+        l = lambda { simple_hash.assert_inclusion_keys(inclusion_keys) }
+        l.should_not raise_exception
+      end
+
+      it "should raise if any mandatory keys are not present" do
+        l = lambda { simple_hash.assert_inclusion_keys(inclusion_keys << :new_one) }
+        l.should raise_exception ArgumentError
+      end
+    end
+
+    describe "#assert_exclusion_keys" do
+      it "should validate that all exclusion keys are not present" do
+        l = lambda { simple_hash.assert_exclusion_keys(exclusion_keys) }
+        l.should_not raise_exception
+      end
+
+      it "should raise if any exclusion keys are present" do
+        l = lambda { simple_hash.assert_exclusion_keys(exclusion_keys << :a) }
+        l.should raise_exception ArgumentError
+      end
+    end
+
+    describe "#assert_valid_values_for" do
+      it "should validate that a given key has a given possible value" do
+        l = lambda { simple_hash.assert_valid_values_for(:a, [1, 2, 3]) }
+        l.should_not raise_exception
+      end
+
+      it "should raise if any exclusion keys are present" do
+        l = lambda { simple_hash.assert_valid_values_for(:a, [4, 5, 6]) }
+        l.should raise_exception ArgumentError
+      end
+    end
+
+    describe "#set_blank_keys_value_to" do
+      it "should fill blank/non existing keys to a given value" do
+        simple_hash.set_blank_keys_value_to([:x, :y, :z], [], 1)
+        [:x, :y, :z].each { |el| simple_hash[el].should == 1 }
+      end
+
+      it "should ignore some fields if asked to" do
+        simple_hash.set_blank_keys_value_to([:x, :y, :z], [:z], 1)
+        [:x, :y].each { |el| simple_hash[el].should == 1 }
+        simple_hash[:z].should be_nil
+      end
+    end
+
+    describe "#to_openstruct" do
+      it "should return an OpenStruct object from a hash one" do
+        os = simple_hash.to_openstruct
+        os.should be_a OpenStruct
+        os.a.should == simple_hash[:a]
+      end
+    end
+
+  end
+end

data/spec/lib/util_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Visor::Common
+  describe Util do
+
+    let(:date) { Time.now }
+    let(:meta) { {name: 'util_spec', architecture: 'i386', access: 'public', created_at: date} }
+
+    let(:headers) { {'X_IMAGE_META_NAME'         => 'util_spec',
+                     'X_IMAGE_META_ARCHITECTURE' => 'i386',
+                     'X_IMAGE_META_ACCESS'       => 'public',
+                     'X_IMAGE_META_CREATED_AT'   => date.to_s} }
+
+    describe "#push_meta_into_headers" do
+      it "should receive an hash and push it into another as HTTP headers" do
+        headers = Visor::Common::Util.push_meta_into_headers(meta)
+        headers.should be_a Hash
+        i = 0
+        headers.each do |k, v|
+          orig_key = meta.keys[i]
+          k.should == "x-image-meta-#{orig_key}"
+          v.should == meta[orig_key.to_sym].to_s
+          i+=1
+        end
+      end
+    end
+
+    describe "#push_meta_into_headers" do
+      it "should receive an hash and pull HTTP headers to a new hash" do
+        hash = Visor::Common::Util.pull_meta_from_headers(headers)
+        hash.should be_a Hash
+        hash.keys.should == meta.keys
+      end
+
+      it "should ignore non image meta headers" do
+        hash = Visor::Common::Util.pull_meta_from_headers(headers.merge('X_EXTRA' => 'value'))
+        hash.should_not include(:X_EXTRA)
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: visor-common
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- João Pereira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The VISOR Common System, a set of utility methods.
+email: joaodrp@gmail.com
+executables:
+- visor-config
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/common/config.rb
+- lib/common/exception.rb
+- lib/common/extensions/array.rb
+- lib/common/extensions/hash.rb
+- lib/common/extensions/logger.rb
+- lib/common/extensions/object.rb
+- lib/common/extensions/yaml.rb
+- lib/common/util.rb
+- lib/common/version.rb
+- lib/visor-common.rb
+- spec/lib/config_spec.rb
+- spec/lib/extensions/hash_spec.rb
+- spec/lib/util_spec.rb
+- bin/visor-config
+homepage: http://cvisor.org
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: ! 'VISOR: Virtual Images Management Service for Cloud Infrastructures'
+test_files:
+- spec/lib/config_spec.rb
+- spec/lib/extensions/hash_spec.rb
+- spec/lib/util_spec.rb
+has_rdoc: