hiera-redis 0.2.2 → 1.0.0

data/lib/hiera/backend/redis_backend.rb

@@ -2,79 +2,66 @@ class Hiera
   module Backend
     class Redis_backend
 
-      VERSION="0.2.2"
+      VERSION="1.0.0"
 
-      attr_reader :redis
+      attr_reader :redis, :options
 
       def initialize
-
-        require 'redis'
-        Hiera.debug("Hiera Redis backend #{VERSION} starting")
-
-        # default values
-        options = {:host => 'localhost', :port => 6379, :db => 0, :password => nil, :timeout => 3, :path => nil}
-        
-        # config overrides default values
-        options.each_key do |k|
-          options[k] = Config[:redis][k] if Config[:redis].is_a?(Hash) && Config[:redis].has_key?(k)
-        end
-
-        @redis = Redis.new(options)
-
-        @soft_connection_failure = false  # Thus we are preventing the current behaviour
-        @soft_connection_failure = Config[:redis][:soft_connection_failure] if Config[:redis].is_a?(Hash) && Config[:redis].has_key?(:soft_connection_failure)
+        Hiera.debug("Hiera Redis backend %s starting" % VERSION)
+        @redis = connect
       end
 
-      def redis_query(args = {})
-
-        # convert our seperator in order to maintain yaml compatibility
-        redis_key = args[:source].gsub('/', ':')
-
-        begin
-          if redis.type(redis_key) == "hash"
-            redis.hget(redis_key, args[:key])
-          else
-            redis_key << ":#{args[:key]}"
-            case redis.type(redis_key)
-            when "set"
-              redis.smembers(redis_key)
-            when "hash"
-              redis.hgetall(redis_key)
-            when "list"
-              redis.lrange(redis_key, 0, -1)
-            when "string"
-              redis.get(redis_key)
-            when "zset"
-              redis.zrange(redis_key, 0, -1)
-            else
-              Hiera.debug("No such key: #{redis_key}")
-              nil
-            end
-          end
-        rescue Redis::CannotConnectError => e
-          raise e unless @soft_connection_failure
-          Hiera.warn("Cannot connect to Redis server")
-          nil
+      def deserialize(args = {})
+        return nil if args[:string].nil?
+
+        Hiera.debug("Found %s key in %s source" % [args[:key], args[:source]])
+        return args[:string] unless options.include? :deserialize
+
+        case options[:deserialize]
+        when :json
+          Hiera.debug("Deserializing JSON")
+          require 'json'
+
+          JSON.parse(args[:string])
+        when :yaml
+          Hiera.debug("Deserializing YAML")
+          require 'yaml'
+          YAML::load(args[:string])
+        else
+          Hiera.warn("Invalid configuration for :deserialize; found %s" % options[:deserialize])
+          args[:string]
         end
+      # when we try to deserialize a string
+      rescue JSON::ParserError
+        args[:string]
+      rescue => e
+        Hiera.warn("Exception raised: %s: %s" % [e.class, e.message])
       end
 
       def lookup(key, scope, order_override, resolution_type)
+        answer = nil
 
-        answer = Backend.empty_answer(resolution_type)
+        Hiera.debug("Looking up %s in Redis backend" % key)
 
         Backend.datasources(scope, order_override) do |source|
+          Hiera.debug("Looking for data source %s" % source)
 
-          data = redis_query(:source => source, :key => key)
+          data = deserialize(:string => redis_query(:source => source, :key => key),
+                             :source => source,
+                             :key => key)
 
           next unless data
+
           new_answer = Backend.parse_answer(data, scope)
 
           case resolution_type
           when :array
-            raise Exception, "Hiera type mismatch: expected Array and got #{new_answer.class}" unless new_answer.is_a?(Array) or new_answer.is_a?(String)
+            raise Exception, "Hiera type mismatch: expected Array and got #{new_answer.class}" unless new_answer.is_a? Array or new_answer.is_a? String
+            answer ||= []
             answer << new_answer
           when :hash
-            raise Exception, "Hiera type mismatch: expected Hash and got #{new_answer.class}" unless new_answer.is_a?(Hash)
+            raise Exception, "Hiera type mismatch: expected Hash and got #{new_answer.class}" unless new_answer.is_a? Hash
+            answer ||= {}
             answer = new_answer.merge answer
           else
             answer = new_answer
@@ -84,6 +71,56 @@ class Hiera
 
         answer
       end
+
+      private
+
+      def connect
+
+        # override default options
+        @options = {
+          :host => 'localhost',
+          :port => 6379,
+          :db => 0,
+          :password => nil,
+          :timeout => 3,
+          :path => nil,
+          :soft_connection_failure => false,
+          :separator => ':',
+          :json => false
+        }.merge Config[:redis] || {}
+
+        require 'redis'
+
+        Redis.new(options)
+      rescue LoadError
+        retry if require 'rubygems'
+      end
+
+      def redis_query(args = {})
+
+        # convert our seperator in order to maintain yaml compatibility
+        redis_key = "%s" % [args[:source].split('/'), args[:key]].join(options[:separator])
+
+        case redis.type(redis_key)
+        when 'set'
+          redis.smembers(redis_key)
+        when 'hash'
+          redis.hgetall(redis_key)
+        when 'list'
+          redis.lrange(redis_key, 0, -1)
+        when 'string'
+          redis.get(redis_key)
+        when 'zset'
+          redis.zrange(redis_key, 0, -1)
+        else
+          Hiera.debug("No such key: %s" % redis_key)
+          nil
+        end
+      rescue Redis::CannotConnectError => e
+        Hiera.warn('Cannot connect to Redis server')
+        raise e unless options.has_key?(:soft_connection_failure)
+        nil
+      end
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hiera-redis
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 23
   prerelease: 
   segments: 
+  - 1
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Adam Kosmin c/o Reliant Security, Inc.
@@ -15,9 +15,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-23 00:00:00 Z
-dependencies: []
-
+date: 2012-09-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hiera
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
 description: Allows hiera functions to pull data from a Redis database.
 email: heira-redis@reliantsecurity.com
 executables: []
@@ -55,8 +69,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       segments: 
       - 0
       version: "0"
-requirements: 
-- hiera
+requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.15
 signing_key: