coral_core 0.1.10 → 0.2.0

data/lib/coral_core/template.rb

@@ -0,0 +1,82 @@
+
+module Coral
+module Template
+  
+  #-----------------------------------------------------------------------------
+  # General template utilities
+  
+  def self.instance(class_name, options = {}, defaults = {}, force = true)
+    return Template::const_get(class_name).new(options, defaults, force)
+  end
+  
+  #---
+  
+  def self.process(value)
+    case value
+    when String
+      return ''         if Util::Data.undef?(value)
+      return 'false'    if value == false
+      return 'true'     if value == true      
+      return value.to_s if value.is_a?(Symbol)
+      
+    when Hash
+      value.each do |key, item|
+        value[key] = process(item)
+      end
+      
+    when Array
+      value.each_with_index do |item, index|
+        value[index] = process(item)
+      end
+    end
+    return value
+  end
+  
+  #---
+  
+  def self.render(class_name, data, options = {})
+    config = Config.ensure(options)
+    
+    normalize   = config.get(:normalize_template, true)
+    interpolate = config.get(:interpolate_template, true)
+    
+    #dbg(class_name, 'template engine name')
+    #dbg(data, 'template data -> init')
+    
+    if normalize
+      data = Util::Data.normalize(data, config)
+      #dbg(data, 'template data -> post normalization')
+    end
+    
+    if normalize && interpolate
+      data = Util::Data.interpolate(data, data, config)
+      #dbg(data, 'template data -> post interpolation')
+    end
+    
+    engine = instance(class_name, config, {}, config.get(:force, true))
+    #dbg(engine, 'template engine')
+    
+    output = engine.render(process(data))
+    #dbg(output, 'template output')
+    
+    return output
+  end
+
+  #-----------------------------------------------------------------------------
+  # Base template
+  
+class Base < Config
+  # All template classes should extend Base
+  
+  def intialize(options = {}, defaults = {}, force = true)
+    super(options, defaults, force)
+  end
+  
+  #---
+  
+  def render(input)
+    return ''  # Implement in sub classes!! 
+  end
+end
+end
+end

data/lib/coral_core/util/data.rb

@@ -2,58 +2,253 @@
 module Coral
 module Util
 class Data < Core
+  
+  #-----------------------------------------------------------------------------
+  # Type checking
+  
+  def self.undef?(value)
+    if value.nil? || 
+      (value.is_a?(Symbol) && value == :undef || value == :undefined) || 
+      (value.is_a?(String) && value.match(/^\s*(undef|UNDEF|Undef|nil|NIL|Nil)\s*$/))
+      return true
+    end
+    return false  
+  end
+  
+  #---
+  
+  def self.true?(value)
+    if value == true || 
+      (value.is_a?(String) && value.match(/^\s*(true|TRUE|True)\s*$/))
+      return true
+    end
+    return false  
+  end
+  
+  #---
+  
+  def self.false?(value)
+    if value == false || 
+      (value.is_a?(String) && value.match(/^\s*(false|FALSE|False)\s*$/))
+      return true
+    end
+    return false  
+  end
+  
+  #---
+  
+  def self.empty?(value)
+    if undef?(value) || false?(value) || (value.respond_to?('empty?') && value.empty?)
+      return false
+    end
+    return true
+  end
    
   #-----------------------------------------------------------------------------
-  # Utilities
+  # Translation
+  
+  def self.to_json(data)
+    output = ''
+    begin
+      require 'json'
+      output = data.to_json
+    rescue LoadError
+    end
+    return output
+  end
+  
+  #---
+  
+  def self.to_yaml(data)
+    output = ''
+    begin
+      require 'yaml'
+      output = YAML.dump(data)
+    rescue LoadError
+    end
+    return output
+  end
+  
+  #---
+  
+  def self.value(value)
+    case value
+    when String
+      if undef?(value)
+        value = nil
+      elsif true?(value)
+        value = true
+      elsif false?(value)
+        value = false
+      end
     
-  def self.merge(objects, merge_arrays = false)
-    value = nil
-    return value unless objects
+    when Array
+      value.each_with_index do |item, index|
+        value[index] = value(item)
+      end
     
-    unless objects.is_a?(Array)
-      objects = [ objects ]
+    when Hash
+      value.each do |key, data|
+        value[key] = value(data)
+      end
     end
-            
-    objects.each do |object|
-      value = recursive_merge(value, object, merge_arrays)  
+    return value  
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def self.merge(data, force = true)
+    value = data
+    
+    # Special case because this method is called from within Config.new so we 
+    # can not use Config.ensure, as that would cause an infinite loop.
+    force = force.is_a?(Coral::Config) ? force.get(:force, force) : force
+    
+    #dbg(data, 'data')
+    
+    if data.is_a?(Array)
+      value = data.shift
+      data.each do |item|
+        #dbg(item, 'item')
+        case value
+        when Hash
+          begin
+            require 'deep_merge'
+            value = force ? value.deep_merge!(item) : value.deep_merge(item)
+          rescue LoadError
+            if item.is_a?(Hash) # Non recursive top level by default.
+              value = value.merge(item)                
+            elsif force
+              value = item
+            end
+          end  
+        when Array
+          if item.is_a?(Array)
+            value = value.concat(item).uniq
+          elsif force
+            value = item
+          end
+        end
+      end  
     end
+    
+    #dbg(value, 'value')            
     return value
   end
+  
+  #---
+
+  def self.normalize(data, override = nil, options = {})
+    config  = Config.ensure(options)
+    results = {}
+    
+    unless undef?(override)
+      case data
+      when String, Symbol
+        data = [ data, override ] if data != override
+      when Array
+        data << override unless data.include?(override)
+      when Hash
+        data = [ data, override ]
+      end
+    end
     
+    case data
+    when String, Symbol
+      results = Config.lookup(data.to_s, {}, config)
+      
+    when Array
+      data.each do |item|
+        if item.is_a?(String) || item.is_a?(Symbol)
+          item = Config.lookup(item.to_s, {}, config)
+        end
+        unless undef?(item)
+          results = merge([ results, item ], config)
+        end
+      end
+  
+    when Hash
+      results = data
+    end
+    
+    return results
+  end
+  
   #---
+  
+  def self.interpolate(value, scope, options = {})    
+    config  = Config.ensure(options)
+  
+    pattern = config.get(:pattern, '\$(\{)?([a-zA-Z0-9\_\-]+)(\})?')
+    group   = config.get(:var_group, 2)
+    flags   = config.get(:flags, '')
     
-  def self.recursive_merge(overrides, data, merge_arrays = false)
-    return data unless overrides
-    return overrides unless data
-            
-    if overrides.is_a?(Hash)
-      overrides.each do |name, override|
-        if data.is_a?(Hash)
-          if data[name]
-            data[name] = recursive_merge(override, data[name])
-          else
-            begin
-              item = override.dup
-            rescue TypeError
-              item = override
-            end
-            data[name] = recursive_merge(override, item)
-          end
-        else
-          data = overrides
+    if scope.is_a?(Hash)
+      regexp = Regexp.new(pattern, flags.split(''))
+    
+      replace = lambda do |item|
+        matches = item.match(regexp)
+        result  = nil
+        
+        #dbg(item, 'item')
+        #dbg(matches, 'matches')
+        
+        unless matches.nil?
+          replacement = scope.search(matches[group], config)
+          result      = item.gsub(matches[0], replacement) unless replacement.nil?
         end
+        return result
       end
-    elsif merge_arrays && overrides.is_a?(Array)
-      if data.is_a?(Array)
-        data = data | overrides
-      else
-        data = overrides
+      
+      case value
+      when String
+        #dbg(value, 'interpolate (string) -> init')
+        while (temp = replace.call(value))
+          #dbg(temp, 'interpolate (string) -> replacement')
+          value = temp
+        end
+        
+      when Hash
+        #dbg(value, 'interpolate (hash) -> init')
+        value.each do |key, data|
+          #dbg(data, "interpolate (#{key}) -> data")
+          value[key] = interpolate(data, scope, config)
+        end
       end
-    else
-      data = overrides
     end
-    return data   
+    #dbg(value, 'interpolate -> result')
+    return value  
   end
 end
 end
-end
+end
+
+#-------------------------------------------------------------------------------
+# Data type alterations
+
+class Hash
+  def search(search_key, options = {})
+    config = Coral::Config.ensure(options)
+    value  = nil
+    
+    recurse       = config.get(:recurse, false)
+    recurse_level = config.get(:recurse_level, -1)
+        
+    self.each do |key, data|
+      if key == search_key
+        value = data
+        
+      elsif data.is_a?(Hash) && 
+        recurse && (recurse_level == -1 || recurse_level > 0)
+        
+        recurse_level -= 1 unless recurse_level == -1
+        value = value.search(search_key, 
+          Coral::Config.new(config).set(:recurse_level, recurse_level)
+        )
+      end
+      break unless value.nil?
+    end
+    return value
+  end
+end

data/lib/coral_core/util/shell.rb

@@ -27,30 +27,30 @@ class Shell < Core
       ui.info(">> running: #{command}")
       
       begin
-        t1, output_new, output_orig = pipe_exec_stream!($stdout, conditions, { 
+        t1, output_new, output_orig, output_reader = pipe_exec_stream!($stdout, conditions, { 
           :prefix => info_prefix, 
           :suffix => info_suffix, 
-        }) do |line|
+        }, 'output') do |line|
           block_given? ? yield(line) : true
         end
       
-        t2, error_new, error_orig = pipe_exec_stream!($stderr, conditions, { 
+        t2, error_new, error_orig, error_reader = pipe_exec_stream!($stderr, conditions, { 
           :prefix => error_prefix, 
           :suffix => error_suffix, 
-        }) do |line|
+        }, 'error') do |line|
           block_given? ? yield(line) : true
         end
       
         system_success = system(command)
       
       ensure
-        output_success = close_exec_pipe(t1, $stdout, output_orig, output_new)
-        error_success  = close_exec_pipe(t2, $stderr, error_orig, error_new)
+        output_success = close_exec_pipe(t1, $stdout, output_orig, output_new, 'output')
+        error_success  = close_exec_pipe(t2, $stderr, error_orig, error_new, 'error')
       end
       ui.info('')
       
       success = ( system_success && output_success && error_success )
-      
+                  
       min -= 1
       break if success && min <= 0 && conditions.empty?
     end
@@ -69,13 +69,13 @@ class Shell < Core
   
   #---
   
-  def self.pipe_exec_stream!(output, conditions, options)
+  def self.pipe_exec_stream!(output, conditions, options, label)
     original     = output.dup
     read, write  = IO.pipe
     
     match_prefix = ( options[:match_prefix] ? options[:match_prefix] : 'EXIT' )
             
-    thread = process_stream!(read, original, options) do |line|
+    thread = process_stream!(read, original, options, label) do |line|
       check_conditions!(line, conditions, match_prefix) do
         block_given? ? yield(line) : true
       end
@@ -84,17 +84,16 @@ class Shell < Core
     thread.abort_on_exception = false
     
     output.reopen(write)    
-    return thread, write, original
+    return thread, write, original, read
   end
   
   #---
   
-  def self.close_exec_pipe(thread, output, original, write)
+  def self.close_exec_pipe(thread, output, original, write, label)
     output.reopen(original)
-    
+     
     write.close
     success = thread.value
-    Thread.kill(thread) # Die bastard, die!
     
     original.close
     return success
@@ -132,7 +131,7 @@ class Shell < Core
   
   #---
   
-  def self.process_stream!(input, output, options)
+  def self.process_stream!(input, output, options, label)
     return Thread.new do
       success        = true      
       default_prefix = ( options[:prefix] ? options[:prefix] : '' )
@@ -149,29 +148,31 @@ class Shell < Core
               prefix  = default_prefix
               suffix  = default_suffix
               
-              if block_given?
-                result = yield(line)
+              unless line.empty?
+                if block_given?
+                  result = yield(line)
                                           
-                if result && result.is_a?(Hash)
-                  prefix = result[:prefix]
-                  suffix = result[:suffix]
-                  result = result[:success]                 
+                  if result && result.is_a?(Hash)
+                    prefix = result[:prefix]
+                    suffix = result[:suffix]
+                    result = result[:success]                 
+                  end
+                  success = result if success
                 end
-                success = result if success
-              end
             
-              prefix = ( prefix && ! prefix.empty? ? "#{prefix}: " : '' )
-              suffix = ( suffix && ! suffix.empty? ? suffix : '' )            
-              eol    = ( index < lines.length - 1 || newline ? "\n" : ' ' )
+                prefix = ( prefix && ! prefix.empty? ? "#{prefix}: " : '' )
+                suffix = ( suffix && ! suffix.empty? ? suffix : '' )            
+                eol    = ( index < lines.length - 1 || newline ? "\n" : ' ' )
             
-              output.write(prefix.lstrip + line + suffix.rstrip + eol)
+                output.write(prefix.lstrip + line + suffix.rstrip + eol)
+              end
             end
           end
         end
       rescue EOFError
       end
       
-      input.close
+      input.close()
       success
     end
   end

data/lib/coral_core.rb

@@ -7,6 +7,7 @@ $:.unshift(home) unless
 #-------------------------------------------------------------------------------
   
 require 'rubygems'
+require 'hiera_backend.rb'
 
 #---
 
@@ -45,5 +46,74 @@ end
 module Coral
   
   VERSION = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
- 
-end
+  
+  #---
+  
+  @@ui = Coral::Core.ui
+  
+  #-----------------------------------------------------------------------------
+  # Initialization
+  
+  def self.load(base_path)
+    if File.exists?(base_path)
+      Dir.glob(File.join(base_path, '*.rb')).each do |file|
+        require file
+      end
+      Dir.glob(File.join(base_path, 'event', '*.rb')).each do |file|
+        require file
+      end
+      Dir.glob(File.join(base_path, 'template', '*.rb')).each do |file|
+        require file
+      end  
+    end  
+  end
+  
+  #---
+  
+  @@initialized = false
+  
+  def self.initialize
+    unless @@initialized
+      Config.set_property('time', Time.now.to_i)
+      
+      # Include Coral extensions
+      Puppet::Node::Environment.new.modules.each do |mod|
+        load(File.join(mod.path, 'lib', 'coral'))
+      end      
+            
+      @@initialized = true
+    end    
+  end
+  
+  #-----------------------------------------------------------------------------
+  # External execution
+   
+  def self.run
+    begin
+      initialize
+      yield
+      
+    rescue Exception => error
+      ui.warning(error.inspect)
+      ui.warning(Util::Data.to_yaml(error.backtrace))
+      raise
+    end
+  end 
+end
+
+#-------------------------------------------------------------------------------
+# Global namespace
+
+module Kernel
+  def dbg(data, label = '')
+    require 'pp'
+    
+    puts '>>----------------------'
+    unless label.empty?
+      puts label
+      puts '---'
+    end
+    pp data
+    puts '<<'
+  end
+end

data/lib/hiera_backend.rb

@@ -0,0 +1,63 @@
+begin
+  require 'hiera/backend'
+
+  class Hiera
+    module Backend
+      #
+      # NOTE: This function is overridden so we can collect accumulated hiera
+      # parameters and their values on a particular puppet run for reporting 
+      # purposes.
+      #
+      # Calls out to all configured backends in the order they
+      # were specified.  The first one to answer will win.
+      #
+      # This lets you declare multiple backends, a possible
+      # use case might be in Puppet where a Puppet module declares
+      # default data using in-module data while users can override
+      # using JSON/YAML etc.  By layering the backends and putting
+      # the Puppet one last you can override module author data
+      # easily.
+      #
+      # Backend instances are cached so if you need to connect to any
+      # databases then do so in your constructor, future calls to your
+      # backend will not create new instances
+      def lookup(key, default, scope, order_override, resolution_type)
+        @backends ||= {}
+        answer = nil
+
+        Config[:backends].each do |backend|
+          if constants.include?("#{backend.capitalize}_backend") || constants.include?("#{backend.capitalize}_backend".to_sym)
+            @backends[backend] ||= Backend.const_get("#{backend.capitalize}_backend").new
+            new_answer = @backends[backend].lookup(key, scope, order_override, resolution_type)
+
+            if not new_answer.nil?
+              case resolution_type
+              when :array
+                raise Exception, "Hiera type mismatch: expected Array and got #{new_answer.class}" unless new_answer.kind_of? Array or new_answer.kind_of? String
+                answer ||= []
+                answer << new_answer
+              when :hash
+                raise Exception, "Hiera type mismatch: expected Hash and got #{new_answer.class}" unless new_answer.kind_of? Hash
+                answer ||= {}
+                answer = merge_answer(new_answer,answer)
+              else
+              answer = new_answer
+              break
+              end
+            end
+          end
+        end
+
+        answer = resolve_answer(answer, resolution_type) unless answer.nil?
+        answer = parse_string(default, scope) if answer.nil? and default.is_a?(String)
+
+        answer = default if answer.nil?
+        
+        Coral::Config.set_property(key, answer) # This is why we override this function!!
+        return answer
+      end
+    end
+  end
+
+rescue LoadError
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: coral_core
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 10
-  version: 0.1.10
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Adrian Webb
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-03-15 00:00:00 Z
+date: 2013-05-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: git
@@ -191,12 +191,19 @@ files:
 - coral_core.gemspec
 - lib/coral_core.rb
 - lib/coral_core/command.rb
+- lib/coral_core/config.rb
 - lib/coral_core/core.rb
 - lib/coral_core/event.rb
 - lib/coral_core/event/regexp_event.rb
 - lib/coral_core/interface.rb
 - lib/coral_core/memory.rb
 - lib/coral_core/repository.rb
+- lib/coral_core/resource.rb
+- lib/coral_core/template.rb
+- lib/coral_core/template/environment.rb
+- lib/coral_core/template/json.rb
+- lib/coral_core/template/wrapper.rb
+- lib/coral_core/template/yaml.rb
 - lib/coral_core/util/data.rb
 - lib/coral_core/util/disk.rb
 - lib/coral_core/util/git.rb
@@ -204,6 +211,7 @@ files:
 - lib/coral_core/util/git/lib.rb
 - lib/coral_core/util/git/remote.rb
 - lib/coral_core/util/shell.rb
+- lib/hiera_backend.rb
 - spec/coral_core/interface_spec.rb
 - spec/coral_mock_input.rb
 - spec/coral_test_kernel.rb