coral_core 0.2.23 → 0.2.24

data/lib/coral_core/command.rb

@@ -0,0 +1,244 @@
+
+module Coral
+class Command < Core
+
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  attr_accessor :name
+  attr_reader :subcommand
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+
+  def initialize(options = {})
+      
+    if options.is_a?(String) || options.is_a?(Symbol)
+      options = string(options)
+      options = { :name => options, :command => options }
+    end
+    
+    config = Config.ensure(options)
+  
+    super(config)
+    
+    @properties           = {}
+    
+    self.subcommand       = config.get(:subcommand, nil)
+    
+    @name                 = config.get(:name, '')
+    
+    @properties           = config.options
+    @properties[:command] = executable(config)   
+  end
+     
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+ 
+  def command_base
+    return @properties[:command]
+  end
+  
+  #---
+  
+  def command=command
+    @properties[:command] = executable({ :command => command })
+  end
+  
+  #---
+  
+  def vagrant=command
+    @properties[:command] = executable({ :vagrant => command })
+  end
+  
+  #---
+  
+  def coral=command
+    @properties[:command] = executable({ :coral => command })
+  end
+  
+  #---
+  
+  def args
+    return array(@properties[:args]) 
+  end
+  
+  #---
+  
+  def args=args
+    @properties[:args] = array(args)
+  end
+  
+  #---
+  
+  def flags
+    return array(@properties[:flags]) 
+  end
+  
+  #---
+  
+  def flags=flags
+    @properties[:flags] = array(flags)
+  end
+  
+  #---
+  
+  def data
+    return hash(@properties[:data]) 
+  end
+  
+  #---
+  
+  def data=data
+    @properties[:data] = hash(data)
+  end
+  
+  #---
+  
+  def subcommand=subcommand
+    unless Util::Data.empty?(subcommand)
+      @properties[:subcommand] = hash(subcommand)
+      @subcommand = self.class.new(@properties[:subcommand])
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return symbol_map(@properties)
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Command functions
+  
+  def build(components = {}, overrides = nil, override_key = false)    
+    
+    command            = string(components[:command])
+    flags              = array( components.has_key?(:flags) ? components[:flags] : [] )
+    data               = string_map(hash( components.has_key?(:data) ? components[:data] : {} ))
+    args               = array( components.has_key?(:args) ? components[:args] : [] )
+    subcommand         = hash( components.has_key?(:subcommand) ? components[:subcommand] : {} )
+    
+    override_key       = command unless override_key
+    override_key       = override_key.to_sym
+    
+    command_string     = command.dup
+    subcommand_string  = ''
+    
+    escape_characters  = /[\'\"]+/
+    escape_replacement = '\"'
+    
+    dash_pattern       = /^([\-]+)/
+    assignment_pattern = /\=$/
+    
+    # Flags
+    if overrides && overrides.has_key?(:flags)
+      if overrides[:flags].is_a?(Hash)
+        if overrides[:flags].has_key?(override_key)
+          flags = array(overrides[:flags][override_key])
+        end
+      else
+        flags = array(overrides[:flags])
+      end
+    end
+    flags.each do |flag|
+      flag = string(flag)
+      if ! flag.empty?        
+        if flag.match(dash_pattern)
+          dashes = $1
+        else
+          dashes = ( flag.size == 1 ? '-' : '--' )  
+        end
+        command_string << " #{dashes}#{flag}"
+      end
+    end
+    
+    # Data
+    if overrides && overrides.has_key?(:data)
+      if overrides[:data].has_key?(override_key)
+        data = hash(overrides[:data][override_key])
+      else
+        override = true
+        overrides[:data].each do |key, value|
+          if ! value.is_a?(String)
+            override = false
+          end
+        end
+        data = hash(overrides[:data]) if override
+      end
+    end
+    data.each do |key, value|
+      key   = string(key)
+      value = string(value).strip.sub(escape_characters, escape_replacement)
+      
+      if key.match(dash_pattern)
+        dashes = $1
+      else
+        dashes = ( key.size == 1 ? '-' : '--' )  
+      end      
+      space = ( key.match(assignment_pattern) ? '' : ' ' )  
+      
+      command_string << " #{dashes}#{key}#{space}'#{value}'"
+    end
+    
+    # Arguments
+    if overrides && overrides.has_key?(:args)
+      if overrides[:args].is_a?(Hash)
+        if overrides[:args].has_key?(override_key)
+          args = array(overrides[:args][override_key])
+        end
+      else
+        args = array(overrides[:args])
+      end
+    end
+    args.each do |arg|
+      arg = string(arg).sub(escape_characters, escape_replacement)
+      command_string << " '#{arg}'"
+    end
+    
+    # Subcommand
+    subcommand_overrides = ( overrides ? overrides[:subcommand] : nil )
+    if subcommand && subcommand.is_a?(Hash) && ! subcommand.empty?
+      subcommand_string = build(subcommand, subcommand_overrides)
+    end
+    
+    return (command_string + ' ' + subcommand_string).strip
+  end
+  
+  #-----------------------------------------------------------------------------
+    
+  def exec!(options = {}, overrides = nil)
+    config = Config.ensure(options)
+    
+    config[:ui] = @ui
+    success = Coral::Util::Shell.exec!(build(export, overrides), config) do |line|
+      block_given? ? yield(line) : true
+    end    
+    return success
+  end
+  
+  #---
+  
+  def exec(options = {}, overrides = nil)
+    return exec!(options, overrides)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def executable(options)
+    config = Config.ensure(options)
+    
+    if config.get(:coral, false)
+      return 'vagrant coral ' + config[:coral]
+        
+    elsif config.get(:vagrant, false)
+      return 'vagrant ' + config[:vagrant]
+        
+    elsif config.get(:command, false)
+      return config[:command]
+    end
+  end
+end
+end

data/lib/coral_core/config.rb

@@ -0,0 +1,360 @@
+
+module Coral
+class Config
+  
+  #-----------------------------------------------------------------------------
+  # Global configuration
+  
+  @@options = {}
+  
+  #---
+  
+  def self.options(contexts, force = true)
+    options = {}
+    
+    unless contexts.is_a?(Array)
+      contexts = [ contexts ]
+    end
+    contexts.each do |name|
+      if @@options.has_key?(name)
+        options = Util::Data.merge([ options, @@options[name] ], force)
+      end
+    end
+    return options
+  end
+  
+  #---
+  
+  def self.set_options(context, options, force = true)    
+    current_options = ( @@options.has_key?(context) ? @@options[context] : {} )
+    @@options[context] = Util::Data.merge([ current_options, options ], force)  
+  end
+  
+  #---
+  
+  def self.clear_options(contexts)
+    unless contexts.is_a?(Array)
+      contexts = [ contexts ]
+    end
+    contexts.each do |name|
+      @@options.delete(name)
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+
+  @@properties = {}
+  
+  #---
+  
+  def self.properties
+    return @@properties
+  end
+  
+  #---
+  
+  def self.set_property(name, value)
+    #dbg(value, "result -> #{name}")
+    @@properties[name] = value
+    save_properties  
+  end
+  
+  #---
+  
+  def self.clear_property(name)
+    @@properties.delete(name)
+    save_properties
+  end
+  
+  #---
+  
+  def self.save_properties
+    log_options = options('coral_log')
+    
+    unless Util::Data.empty?(log_options['config_log'])
+      config_log = log_options['config_log']
+      
+      Util::Disk.write(config_log, JSON.pretty_generate(@@properties))
+      Util::Disk.close(config_log)
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Hiera configuration
+  
+  @@hiera = nil
+  
+  #---
+  
+  def self.hiera_config
+    config_file = Puppet.settings[:hiera_config]
+    config      = {}
+
+    if File.exist?(config_file)
+      config = Hiera::Config.load(config_file)
+    else
+      Coral.ui.warn("Config file #{config_file} not found, using Hiera defaults")
+    end
+
+    config[:logger] = 'puppet'
+    return config
+  end
+  
+  #---
+
+  def self.hiera
+    @@hiera = Hiera.new(:config => hiera_config) unless @@hiera
+    return @@hiera
+  end
+  
+  #---
+
+  def hiera
+    return self.class.hiera
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Configuration lookup
+      
+  def self.initialized?(options = {})
+    config = Config.ensure(options)
+    begin
+      require 'hiera_puppet'
+      
+      scope       = config.get(:scope, {})
+      
+      sep         = config.get(:sep, '::')
+      prefix      = config.get(:prefix, true)    
+      prefix_text = prefix ? sep : ''
+      
+      init_fact   = prefix_text + config.get(:init_fact, 'hiera_ready')
+      coral_fact  = prefix_text + config.get(:coral_fact, 'coral_exists') 
+      
+      if Puppet::Parser::Functions.function('hiera')
+        if scope.respond_to?('[]')
+          return true if Util::Data.true?(scope[init_fact]) && Util::Data.true?(scope[coral_fact])
+        else
+          return true
+        end
+      end
+    
+    rescue Exception # Prevent abortions.
+    end    
+    return false
+  end
+  
+  #---
+    
+  def self.lookup(name, default = nil, options = {})
+    config = Config.ensure(options)
+    value  = nil
+    
+    context     = config.get(:context, :priority)
+    scope       = config.get(:scope, {})
+    override    = config.get(:override, nil)
+    
+    base_names  = config.get(:search, nil)
+    sep         = config.get(:sep, '::')
+    prefix      = config.get(:prefix, true)    
+    prefix_text = prefix ? sep : ''
+    
+    search_name    = config.get(:search_name, true)
+    reverse_lookup = config.get(:reverse_lookup, true)
+    
+    #dbg(default, "lookup -> #{name}")
+    
+    if Config.initialized?(options)
+      unless scope.respond_to?("[]")
+        scope = Hiera::Scope.new(scope)
+      end
+      value = hiera.lookup(name, default, scope, override, context)
+      #dbg(value, "hiera -> #{name}")
+    end 
+    
+    if Util::Data.undef?(value) && ( scope.respond_to?("[]") || scope.respond_to?("lookupvar") )
+      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
+        
+        #bg(base_names, 'search path')        
+        base_names.each do |item|
+          if scope.respond_to?("lookupvar")
+            value = scope.lookupvar("#{prefix_text}#{item}#{sep}#{name}")  
+          else
+            value = scope["#{prefix_text}#{item}#{sep}#{name}"]
+          end
+          #dbg(value, "#{prefix_text}#{item}#{sep}#{name}")
+          break unless Util::Data.undef?(value)  
+        end
+      end
+      if Util::Data.undef?(value) && search_name
+        if scope.respond_to?("lookupvar")
+          value = scope.lookupvar("#{prefix_text}#{name}")
+        else
+          value = scope["#{prefix_text}#{name}"]
+        end
+        #dbg(value, "#{prefix_text}#{name}")
+      end
+      Puppet::Util::Log.level = log_level
+    end    
+    value = default if Util::Data.undef?(value)
+    value = Util::Data.value(value)
+    
+    if ! @@properties.has_key?(name) || ! Util::Data.undef?(value)
+      set_property(name, value)
+    end
+    
+    #dbg(value, "result -> #{name}")    
+    return value  
+  end
+  
+  #---
+
+  def self.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 = 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 Util::Data.undef?(item)
+          results = Util::Data.merge([ results, item ], config)
+        end
+      end
+  
+    when Hash
+      results = data
+    end
+    
+    return results
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Instance generators
+  
+  def self.ensure(config)
+    case config
+    when Coral::Config
+      return config
+    when Hash
+      return Config.new(config) 
+    end
+    return Config.new
+  end
+  
+  #---
+  
+  def self.init(options, contexts = [], defaults = {})
+    config = Coral::Config.new(Coral::Config.options(contexts), defaults)
+    config.import(options) unless Coral::Util::Data.empty?(options)
+    return config
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Configuration instance
+    
+  def initialize(data = {}, defaults = {}, force = true)
+    @force   = force
+    @options = {}
+    
+    if defaults.is_a?(Hash) && ! defaults.empty?
+      symbolized = {}
+      defaults.each do |key, value|
+        symbolized[key.to_sym] = value
+      end
+      defaults = symbolized
+    end
+    
+    case data
+    when Coral::Config
+      @options = Util::Data.merge([ defaults, data.options ], force)
+    when Hash
+      @options = {}
+      if data.is_a?(Hash)
+        symbolized = {}
+        data.each do |key, value|
+          symbolized[key.to_sym] = value
+        end
+        @options = Util::Data.merge([ defaults, symbolized ], force)
+      end  
+    end
+  end
+  
+  #---
+  
+  def import(data, options = {})
+    config = Config.new(options, { :force => @force }).set(:context, :hash)
+    
+    case data
+    when Hash
+      symbolized = {}
+      data.each do |key, value|
+        symbolized[key.to_sym] = value
+      end
+      @options = Util::Data.merge([ @options, symbolized ], config)
+    
+    when String      
+      data = Util::Data.lookup(data, {}, config)
+      Util::Data.merge([ @options, data ], config)
+     
+    when Array
+      data.each do |item|
+        import(item, config)
+      end
+    end
+    
+    return self
+  end
+  
+  #---
+  
+  def set(name, value)
+    @options[name.to_sym] = value
+    return self
+  end
+  
+  def []=(name, value)
+    set(name, value)
+  end
+  
+  #---
+    
+  def get(name, default = nil)
+    name = name.to_sym
+    return @options[name] if @options.has_key?(name)
+    return default
+  end
+  
+  def [](name, default = nil)
+    get(name, default)
+  end
+  
+  #---
+  
+  def options
+    return @options
+  end
+end
+end