coral_core 0.2.30 → 0.4.0

data/lib/coral_core/mod/hash.rb

@@ -1,29 +0,0 @@
-
-#-------------------------------------------------------------------------------
-# Hash 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/mod/hiera_backend.rb

@@ -1,63 +0,0 @@
-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

data/lib/coral_core/plugin/command.rb

@@ -1,95 +0,0 @@
-
-module Coral
-module Plugin
-class Command < Base
-
-  #-----------------------------------------------------------------------------
-  # Command plugin interface
-  
-  def to_s
-    return build(export)
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
-  
-  def command(default = '')
-    return string(get(:command, default))
-  end
-  
-  #---
-  
-  def command=command
-    set(:command, string(command))
-  end
-  
-  #---
-  
-  def args(default = [])
-    return array(get(:args, default)) 
-  end
-  
-  #---
-  
-  def args=args
-    set(:args, array(args))
-  end
-  
-  #---
-  
-  def flags(default = [])
-    return array(get(:flags, default)) 
-  end
-  
-  #---
-  
-  def flags=flags
-    set(:flags, array(flags))
-  end
-  
-  #---
-  
-  def data(default = {})
-    return hash(get(:data, default)) 
-  end
-  
-  #---
-  
-  def data=data
-    set(:data, hash(data))
-  end
-  
-  #---
-  
-  def subcommand=subcommand
-    unless Util::Data.empty?(subcommand)
-      set(:subcommand, new(hash(subcommand)))
-    end
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Plugin operations
-
-
-  #-----------------------------------------------------------------------------
-  # Command operations
-  
-  def build(components = {}, overrides = nil, override_key = false)
-    return '' # Implement in sub classes
-  end
-  
-  #---
-  
-  def exec!(options = {}, overrides = nil)
-    # Implement in sub classes (don't forget the yield!)
-    return true
-  end
-    
-  #---
-  
-  def exec(options = {}, overrides = nil)
-    return exec!(options, overrides)
-  end
-end
-end
-end

data/lib/coral_core/plugin/machine.rb

@@ -1,152 +0,0 @@
-
-module Coral
-module Plugin
-class Machine < Base
-
-  #-----------------------------------------------------------------------------
-  # Machine plugin interface
- 
-      
-  #-----------------------------------------------------------------------------
-  # Checks
-  
-  def created?
-    return false
-  end
-  
-  #---
-  
-  def running?
-    return ( created? && false )
-  end
-   
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  def hostname
-    return get(:hostname, '')
-  end
-  
-  #---
-  
-  def state
-    return get(:state, nil)
-  end
-  
-  #---
-  
-  def public_ip
-    return get(:public_ip, nil)
-  end
-  
-  #---
-  
-  def private_ip
-    return get(:private_ip, nil)
-  end
-            
-  #-----------------------------------------------------------------------------
-  # Management 
-
-  def create(options = {})
-    unless created?
-      
-    end
-    return true
-  end
-  
-  #---
-  
-  def start(options = {})
-    unless running?
-      
-    end
-    return true
-  end
-  
-  #---
-  
-  def stop(options = {})
-    if running?
-      
-    end
-    return true
-  end
-  
-  #---
-  
-  def reload(options = {})
-    if created?
-      
-    end
-    return true
-  end
-
-  #---
-
-  def destroy(options = {})   
-    if created?
-        
-    end
-    return true
-  end
-  
-  #---
-  
-  def exec(options = {})
-    if running?
-      config = Config.ensure(options)
-      if commands = config.delete(:commands)
-        commands.each do |command|
-          Util::Shell.exec!(command, config) do |line|
-            yield(line) if block_given?
-          end
-        end
-      end  
-    end
-    return true
-  end
-    
-  #---
-  
-  def provision(options = {})
-    if running?
-      config = Config.ensure(options)
-      
-      # TODO: Abstract this out so it does not depend on Puppet functionality.
-      
-      puppet  = config.delete(:puppet, :puppet) # puppet (community) or puppetlabs (enterprise)     
-      command = Coral.command({
-        :command    => :puppet,
-        :flags      => config.delete(:puppet_flags, ''),
-        :subcommand => {
-          :command => config.delete(:puppet_op, :apply),
-          :flags   => config.delete(:puppet_op_flags, ''),
-          :data    => config.delete(:puppet_op_data, {}).merge({
-            'modulepath=' => array(config.delete(:puppet_modules, "/etc/#{puppet}/modules")).join(':')
-          }),
-          :args => config.delete(:puppet_manifest, "/etc/#{puppet}/manifests/site.pp")
-        }
-      }, config.get(:provider, :shell))
-      
-      config[:commands] = [ command.to_s ]
-      return exec(config)
-    end
-    return true
-  end
-  
-  #---
-  
-  def create_image(options = {})
-    if created?
-      
-    end
-    return true
-  end
-
-  #-----------------------------------------------------------------------------
-  # Utilities
-
-end
-end
-end

data/lib/coral_core/plugin/network.rb

@@ -1,24 +0,0 @@
-
-module Coral
-module Plugin
-class Network < Base
-  
-  ensure_plugin_collection 
-  
-  #-----------------------------------------------------------------------------
-  # Cloud plugin interface
-  
-  def normalize
-    @config = Config::Project.new(self._export)
-    super
-    
-    init_nodes
-  end
-       
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  plugin_collection :node
-end
-end
-end

data/lib/coral_core/plugin/node.rb

@@ -1,184 +0,0 @@
-
-module Coral
-module Plugin
-class Node < Base
- 
-  #-----------------------------------------------------------------------------
-  # Node plugin interface
-   
-  def normalize
-    super
-  end
-       
-  #-----------------------------------------------------------------------------
-  # Checks
-    
-   
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  def network
-    return plugin_parent
-  end
- 
-  #---
-  
-  def network=network
-    self.plugin_parent = network
-  end
-  
-  #---
-  
-  def setting(property, default = nil, format = false)
-    return network.node_setting(plugin_provider, name, property, default, format)
-  end
-  
-  #---
-  
-  def search(property, default = nil, format = false)
-    return network.search_node(plugin_provider, name, property, default, format)
-  end
-  
-  #---
-  
-  def set_setting(property, value = nil)
-    network.set_node_setting(plugin_provider, name, property, value)
-    return self
-  end
-  
-  #---
-  
-  def delete_setting(property)
-    network.delete_node_setting(plugin_provider, name, property)
-    return self
-  end
-  
-  #-----------------------------------------------------------------------------
-  
-  def machine
-    return get(:machine, nil)
-  end
-  
-  #---
-  
-  def machine=machine
-    set(:machine, machine)  
-  end
-  
-  #---
- 
-  def create_machine(provider, options = {})
-    if provider.is_a?(String) || provider.is_a?(Symbol)
-      set(:machine, Coral.machine(options, provider))
-    end
-    return self
-  end
- 
-  #---
-  
-  def public_ip # Must be set at machine level
-    return machine.public_ip if machine
-    return nil
-  end
-
-  #---
-  
-  def private_ip # Must be set at machine level
-    return machine.private_ip if machine
-    return nil
-  end
-
-  #---
- 
-  def hostname # Must be set at machine level
-    return machine.hostname if machine
-    return ''
-  end
- 
-  #---
- 
-  def state # Must be set at machine level
-    return machine.state if machine
-    return nil
-  end
- 
-  #-----------------------------------------------------------------------------
-  # Machine operations
-    
-  def start(options = {})
-    return true unless machine
-    return machine.start(options)
-  end
-  
-  #---
-    
-  def stop(options = {})
-    return true unless machine && machine.running?    
-    return machine.stop(options)
-  end
-
-  #---
-    
-  def reload(options = {})
-    return true unless machine && machine.created?    
-    return machine.reload(options)
-  end
-    
-  #---
-
-  def destroy(options = {})    
-    return true unless machine
-    
-    config = Config.ensure(options)
-    
-    if machine.created?
-      run = false
-
-      if config[:force]
-        run = true
-      else
-        choice = nil
-        begin
-          choice = ui.ask("Are you sure you want to remove: #{name}?")
-          run    = choice.upcase == "Y"
-        rescue Errors::UIExpectsTTY
-          run = false
-        end        
-      end
-
-      if run
-        return machine.destroy(config)
-      end
-    end
-    return true    
-  end
-
-  #---
-  
-  def exec(commands, options = {})
-    return true unless machine && machine.running?
-    
-    config = Config.ensure(options)        
-    return machine.exec(config.import({ :commands => commands }))  
-  end
-   
-  #---
-  
-  def provision(options = {})
-    return true unless machine && machine.running?    
-    return machine.provision(options)  
-  end
- 
-  #---
-  
-  def create_image(options = {})
-    return true unless machine && machine.running?    
-    return machine.create_image(options)  
-  end
- 
-  #-----------------------------------------------------------------------------
-  # Utilities
-               
-end
-end
-end