coral_core 0.2.26 → 0.2.30

data/lib/coral_core/event/puppet_event.rb

@@ -0,0 +1,98 @@
+module Coral
+class PuppetEvent < Event
+
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  TYPE = :puppet
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    options[:type] = TYPE
+    
+    super(options)
+    
+    if options.has_key?(:string)
+      items = options[:string].split(':')
+      self.element = items[0]
+      self.operation = items[1]
+      self.message = items[2]
+    end
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def element
+    return property(:element, '', :string)
+  end
+  
+  #---
+ 
+  def element=element
+    set_property(:element, string(element))
+  end
+  
+  #---
+  
+  def operation
+    return property(:operation, '', :string)
+  end
+  
+  #---
+   
+  def operation=operation
+    set_property(:operation, string(operation))
+  end
+  
+  #--
+  
+  def message
+    return property(:message, '', :string)
+  end
+  
+  #---
+   
+  def message=message
+    set_property(:message, string(message))
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return "#{type}:#{element}:#{operation}:#{message}"
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Event handling
+  
+  def check(source)
+    if source.match(/notice:\s+(.+?):\s+(.+)\s*/i)
+      source_element = $1
+      source_operation = ''
+      source_message = $2
+                    
+      source_elements = source_element.split('/')
+      source_operation = source_elements.pop.strip unless source_elements.last.match(/[\[\]]/)
+                    
+      if source_operation
+        source_element = source_elements.join('/').strip
+        
+        logger.debug("#{source_element} includes: #{element} -- " + ( source_element.include?(element) ? 'true' : 'false' ))
+        logger.debug("#{source_operation} is: #{operation} -- " + ( source_operation == operation ? 'true' : 'false' ))
+        logger.debug("#{source_message} includes: #{message} -- " + ( source_message.include?(message) ? 'true' : 'false' ))
+        
+        if source_element.include?(element) && source_operation == operation && source_message.include?(message)
+            logger.debug("MATCH! -> #{element} - #{operation} - #{message}")
+            return true
+        end
+      end
+    end
+    logger.debug("nothing -> #{element} - #{operation} - #{message}")
+    return false
+  end
+end
+end

data/lib/coral_core/mixin/config_collection.rb

@@ -0,0 +1,52 @@
+
+# Should be included via extend
+#
+# extend Mixin::ConfigCollection
+#
+
+module Coral
+module Mixin
+module ConfigCollection
+  #-----------------------------------------------------------------------------
+  # Configuration collection interface
+  
+  def all_properties
+    return Config::Collection.all
+  end
+  
+  #---
+  
+  def get_property(name)
+    return Config::Collection.get(name)
+  end
+  
+  #---
+  
+  def set_property(name, value)
+    Config::Collection.set(name, value)
+    return self  
+  end
+  
+  #---
+  
+  def delete_property(name)
+    Config::Collection.delete(name)
+    return self
+  end
+  
+  #---
+  
+  def clear_properties
+    Config::Collection.clear
+    return self  
+  end
+  
+  #---
+  
+  def save_properties
+    Config::Collection.save
+    return self
+  end
+end
+end
+end

data/lib/coral_core/mixin/config_ops.rb

@@ -0,0 +1,51 @@
+
+# Should be included via extend
+#
+# extend Mixin::ConfigOps
+#
+
+module Coral
+module Mixin
+module ConfigOps
+  #-----------------------------------------------------------------------------
+  # Parsing
+      
+  def parse(statement, options = {})
+    config = Config.ensure(options)
+    
+    # statement = 'common->php::apache::memory_limit = 32M'
+    # statement = 'identity -> test -> users::user[admin][shell]'
+    # statement = 'servers->development->dev.loc->facts[server_environment]=vagrant'
+    # statement = 'cloud->settings[debug][puppet][options] = ["--debug"]'
+    
+    reference, new_value = statement.split(/\=/)
+    new_value            = new_value.join('=').strip if new_value && new_value.is_a?(Array)
+    
+    config_elements = reference.gsub(/\s+/, '').split(/\-\>/)
+    property        = config_elements.pop
+    config_file     = config_elements.pop
+    
+    if config_directory = config.get(:directory, nil)
+      config_path = File.join(repo.directory, config_directory, *config_elements)
+    else
+      config_path = File.join(repo.directory, *config_elements)
+    end
+    
+    return nil unless property && config_file
+    
+    config_file = "#{config_file}." + config.get(:ext, 'json')
+    property    = property.gsub(/\]$/, '').split(/\]?\[/)
+    data        = open(config_path, config_file, config)
+       
+    return { 
+      :path          => config_path, 
+      :file          => config_file, 
+      :property      => property,
+      :conf          => data,
+      :current_value => (data ? data.get(property) : nil), 
+      :new_value     => eval(new_value) 
+    }    
+  end
+end
+end
+end

data/lib/coral_core/mixin/config_options.rb

@@ -0,0 +1,38 @@
+
+# Should be included via extend
+#
+# extend Mixin::ConfigOptions
+#
+
+module Coral
+module Mixin
+module ConfigOptions
+  #-----------------------------------------------------------------------------
+  # Configuration options interface
+  
+  def contexts(contexts = [], hierarchy = [])
+    return Config::Options.contexts(contexts, hierarchy)  
+  end
+  
+  #---
+  
+  def get_options(contexts, force = true)
+    return Config::Options.get(contexts, force)  
+  end
+  
+  #---
+  
+  def set_options(contexts, options, force = true)
+    Config::Options.set(contexts, options, force)
+    return self  
+  end
+  
+  #---
+  
+  def clear_options(contexts)
+    Config::Options.clear(contexts)
+    return self  
+  end
+end
+end
+end

data/lib/coral_core/mixin/lookup.rb

@@ -0,0 +1,211 @@
+
+# Should be included via extend
+#
+# extend Mixin::Lookup
+#
+
+module Coral
+module Mixin
+module Lookup
+  #-----------------------------------------------------------------------------
+  # Hiera configuration
+  
+  @@hiera = nil
+  
+  #---
+  
+  def hiera_config
+    config_file = Puppet.settings[:hiera_config]
+    config      = {}
+
+    if File.exist?(config_file)
+      config = Hiera::Config.load(config_file)
+    else
+      ui.warn("Config file #{config_file} not found, using Hiera defaults")
+    end
+
+    config[:logger] = 'puppet'
+    return config
+  end
+  
+  #---
+
+  def hiera
+    @@hiera = Hiera.new(:config => hiera_config) unless @@hiera
+    return @@hiera
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Configuration lookup interface
+      
+  def initialized?(options = {})
+    config   = Config.ensure(options)
+    
+    begin
+      require 'hiera'
+      puppet_scope = config.get(:puppet_scope, scope)
+    
+      prefix_text = config.get(:prefix_text, '::')  
+      init_fact   = prefix_text + config.get(:init_fact, 'hiera_ready')
+      
+      if Puppet::Parser::Functions.function('hiera') && puppet_scope.respond_to?('[]')
+        return true if Util::Data.true?(puppet_scope[init_fact])
+      end
+      return false
+    
+    rescue Exception # Prevent abortions.
+    end    
+    return false
+  end
+  
+  #---
+    
+  def lookup(properties, default = nil, options = {})
+    config          = Config.ensure(options)
+    value           = nil
+    
+    hiera_scope     = config.get(:hiera_scope, {})
+    context         = config.get(:context, :priority)    
+    override        = config.get(:override, nil)
+    
+    puppet_scope    = config.get(:puppet_scope, scope)
+    
+    base_names      = config.get(:search, nil)
+     
+    search_name     = config.get(:search_name, true)
+    reverse_lookup  = config.get(:reverse_lookup, true)
+    
+    return_property = config.get(:return_property, false)
+    
+    unless properties.is_a?(Array)
+      properties = [ properties ].flatten
+    end
+
+    first_property = nil
+    properties.each do |property|
+      first_property = property unless first_property
+          
+      if initialized?(config)
+        unless hiera_scope.respond_to?('[]')
+          hiera_scope = Hiera::Scope.new(hiera_scope)
+        end
+        value = hiera.lookup(property, nil, hiera_scope, override, context)
+      end 
+    
+      if Util::Data.undef?(value)    
+        log_level = Puppet::Util::Log.level
+        Puppet::Util::Log.level = :err # Don't want failed parameter lookup warnings here.
+      
+        if base_names
+          if base_names.is_a?(String)
+            base_names = [ base_names ]
+          end
+          base_names = base_names.reverse if reverse_lookup
+        
+          base_names.each do |base|
+            value = puppet_scope.lookupvar("::#{base}::#{property}")
+            break unless Util::Data.undef?(value)  
+          end
+        end
+        if Util::Data.undef?(value) && search_name
+          value = puppet_scope.lookupvar("::#{property}")
+        end
+        Puppet::Util::Log.level = log_level
+      end
+    end
+    value = default if Util::Data.undef?(value)
+    value = Util::Data.value(value)
+    
+    if ! @@properties.has_key?(first_property) || ! Util::Data.undef?(value)
+      Config::Collection.set(first_property, value)
+    end
+    return value, first_property if return_property
+    return value
+  end
+    
+  #---
+  
+  def lookup_array(properties, default = [], options = {})
+    config          = Config.ensure(options) 
+    value, property = lookup(properties, nil, config.import({ :return_property => true }))
+    
+    if Util::Data.undef?(value)
+      value = default
+        
+    elsif ! Util::Data.empty?(default)
+      if config.get(:merge, false)
+        value = Util::Data.merge([default, value], config)
+      end
+    end
+    
+    unless value.is_a?(Array)
+      value = ( Util::Data.empty?(value) ? [] : [ value ] )
+    end
+    
+    Config::Collection.set(property, value)
+    return value
+  end
+    
+  #---
+  
+  def lookup_hash(properties, default = {}, options = {})
+    config          = Config.ensure(options) 
+    value, property = lookup(properties, nil, config.import({ :return_property => true }))
+    
+    if Util::Data.undef?(value)
+      value = default
+        
+    elsif ! Util::Data.empty?(default)
+      if config.get(:merge, false)
+        value = Util::Data.merge([default, value], config)
+      end
+    end
+    
+    unless value.is_a?(Hash)
+      value = ( Util::Data.empty?(value) ? {} : { :value => value } )
+    end
+    
+    Config::Collection.set(property, value)
+    return value
+  end
+  
+  #---
+
+  def normalize(data, override = nil, options = {})
+    config  = Config.ensure(options)
+    results = {}
+    
+    unless Util::Data.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 = lookup(data.to_s, {}, config)
+      
+    when Array
+      data.each do |item|
+        if item.is_a?(String) || item.is_a?(Symbol)
+          item = lookup(item.to_s, {}, config)
+        end
+        unless Util::Data.undef?(item)
+          results = Util::Data.merge([ results, item ], config)
+        end
+      end
+  
+    when Hash
+      results = data
+    end
+    
+    return results
+  end
+end
+end
+end