corl 0.4.29 → 0.5.0

data/lib/core/build.rb

@@ -0,0 +1,112 @@
+
+module CORL
+class Build < Core
+  
+  include Parallel
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / destructor
+  
+  def initialize
+    @config    = Config.new
+    @locations = Config.new
+    
+    @plurals   = {}
+    @types     = {}
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Build lock
+  
+  @@build_lock = Mutex.new
+ 
+  #---
+  
+  def build_lock
+    @@build_lock
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Type registration
+  
+  def register(type, plural = nil)
+    type = type.to_sym
+    
+    if plural
+      plural = plural.to_sym
+    else
+      plural = "#{type}s".to_sym
+    end
+    @plurals[plural] = type
+    @types[type]     = Config.new
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Package configuration
+  
+  def config
+    @config  
+  end
+  
+  def import(config)
+    @config.import(config)  
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Build locations
+  
+  def locations
+    @locations
+  end
+  
+  def set_location(provider, name, directory)
+    @locations.set([ provider, name ], directory)
+  end
+  
+  def remove_location(provider, name = nil)
+    @locations.delete([ provider, name ])
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Addon build types
+    
+  def method_missing(method, *args, &code)
+    success = false
+    result  = nil
+      
+    if method.to_s.match(/^set\_([a-z].*)$/)
+      name = $1.to_sym
+      
+      if @types.has_key?(name) && args.length > 2
+        @types[name].set([ args[0], args[1] ], args[2]) if args.length > 2
+        success = true
+      end
+      
+    elsif method.to_s.match(/^remove\_([a-z].*)$/)
+      name = $1.to_sym
+      
+      if @types.has_key?(name) && args.length > 0
+        @types[name].delete([ args[0], args[1] ])
+        success = true
+      end
+      
+    else
+      name = @plurals[method.to_sym]
+      
+      if name && @types.has_key?(name)
+        result  = @types[name]
+        success = true
+      end  
+    end
+    super unless success # Raise NoMethodError
+    result
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Builders
+  
+  def manage(plugin_type, options = {})
+    CORL.send(plugin_type, options)
+  end 
+end
+end

data/lib/core/facade.rb

@@ -1,6 +1,36 @@
 
 module CORL
 module Facade
+
+  #-----------------------------------------------------------------------------
+  # Facter lookup
+  
+  @@facts = {}
+  
+  def facts(reset = false)
+    if reset || @@facts.empty?
+      @@facts = {} if reset
+      Facter.list.each do |name|
+        @@facts[name] = Facter.value(name)
+      end
+    end
+    @@facts
+  end
+  
+  #---
+  
+  def create_fact(name, value, weight = 1000)
+    Facter.collection.add(name.to_sym, { 
+      :value  => value, 
+      :weight => weight 
+    })
+  end
+  
+  #---
+  
+  def fact(name)
+    Facter.value(name)
+  end
   
   #-----------------------------------------------------------------------------
   # Local identification
@@ -37,42 +67,52 @@ module Facade
   # Core plugin type facade
   
   def configuration(options, provider = nil)
-    plugin(:configuration, provider, options)
+    plugin(:CORL, :configuration, provider, options)
   end
   
   def configurations(data, build_hash = false, keep_array = false)
-    plugins(:configuration, data, build_hash, keep_array)
+    plugins(:CORL, :configuration, data, build_hash, keep_array)
   end
   
   #-----------------------------------------------------------------------------
   # Cluster plugin type facade
    
   def network(name, options = {}, provider = nil)
-    plugin(:network, provider, Config.ensure(options).import({ :name => name }))
+    plugin(:CORL, :network, provider, Config.ensure(options).import({ :name => name }))
   end
   
   def networks(data, build_hash = false, keep_array = false)
-    plugins(:network, data, build_hash, keep_array)
+    plugins(:CORL, :network, data, build_hash, keep_array)
   end
    
   #---
   
   def node(name, options = {}, provider = nil)
-    plugin(:node, provider, Config.ensure(options).import({ :name => name }))
+    plugin(:CORL, :node, provider, Config.ensure(options).import({ :name => name }))
   end
   
   def nodes(data, build_hash = false, keep_array = false)
-    plugins(:node, data, build_hash, keep_array)
+    plugins(:CORL, :node, data, build_hash, keep_array)
+  end
+  
+  #---
+  
+  def builder(options, provider = nil)
+    plugin(:CORL, :builder, provider, options)
+  end
+  
+  def builder(data, build_hash = false, keep_array = false)
+    plugins(:CORL, :builder, data, build_hash, keep_array)
   end
   
   #---
   
   def provisioner(options, provider = nil)
-    plugin(:provisioner, provider, options)
+    plugin(:CORL, :provisioner, provider, options)
   end
   
   def provisioners(data, build_hash = false, keep_array = false)
-    plugins(:provisioner, data, build_hash, keep_array)
+    plugins(:CORL, :provisioner, data, build_hash, keep_array)
   end
 end
 end

data/lib/core/mixin/builder.rb

@@ -0,0 +1,158 @@
+
+module CORL
+module Mixin
+module Builder
+module Global # Extend
+  
+  #-----------------------------------------------------------------------------
+  # Accessors / modifiers
+  
+  def resource_joiner
+    '::'
+  end
+  
+  #---
+  
+  def id_joiner
+    '__'
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def id(name = nil)
+    name = 'unknown' if name.nil?
+    name       = [ name ] unless name.is_a?(Array)
+    components = []
+    
+    name.flatten.each do |component|
+      components << component.to_s.gsub(resource_joiner, id_joiner)
+    end
+    components.join(id_joiner).to_sym
+  end
+  
+  #---
+  
+  def resource(name = nil, capitalize = false)
+    name = 'unknown' if name.nil?
+    concatenate(name, capitalize, resource_joiner)
+  end
+  
+  #---
+  
+  def concatenate(components, capitalize = false, joiner = nil)
+    joiner = resource_joiner unless joiner
+    
+    if components.is_a?(Array)
+      components = components.collect do |str|
+        str.to_s.split(id_joiner)  
+      end.flatten
+    else
+      components = [ components.to_s.split(id_joiner) ].flatten
+    end
+    
+    if capitalize
+      name = components.collect {|str| str.capitalize }.join(joiner)
+    else
+      name = components.join(joiner)
+    end
+    name
+  end
+  
+  #---
+  
+  def process_environment(settings, environment = nil)
+    config      = Config.new(hash(settings))
+    env_config  = config.delete(:environment)
+    environment = environment.to_sym if environment
+    
+    if env_config    
+      if environment && env_config.has_key?(environment)
+        local_env_config = env_config[environment]
+        
+        while local_env_config && local_env_config.has_key?(:use) do
+          local_env_config = env_config[local_env_config[:use].to_sym]
+        end
+         
+        config.defaults(local_env_config) if local_env_config
+      end
+      config.defaults(env_config[:default]) if env_config.has_key?(:default)
+    end
+    config.export 
+  end
+end
+
+#-------------------------------------------------------------------------------
+
+module Instance # Include
+  
+  extend Global
+    
+  #-----------------------------------------------------------------------------
+  # Accessors / modifiers
+  
+  def resource_joiner
+    self.class.resource_joiner
+  end
+  
+  #---
+  
+  def id_joiner
+    self.class.id_joiner
+  end
+  
+  #---
+  
+  def build_directory
+    network.build_directory
+  end
+  
+  #---
+  
+  def build_config
+    return network.build if network
+    nil
+  end
+ 
+  #---
+  
+  def build_lock
+    self.class.build_lock
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def id(name = nil)
+    name = plugin_name if name.nil?
+    self.class.id(name)
+  end
+  
+  #---
+  
+  def resource(name = nil, capitalize = false)
+    name = plugin_name if name.nil?
+    self.class.resource(name, capitalize)
+  end
+  
+  #---
+  
+  def concatenate(components, capitalize = false, joiner = nil)
+    self.class.concatenate(components, capitalize, joiner)
+  end
+  
+  #---
+  
+  def internal_path(directory)
+    directory.gsub(network.directory + "/", '')
+  end
+  
+  #---
+  
+  def process_environment(settings, environment = nil)
+    self.class.process_environment(settings, environment)
+  end  
+end
+end
+end
+end

data/lib/core/mixin/lookup.rb

@@ -6,20 +6,36 @@ module Lookup
   #-----------------------------------------------------------------------------
   # Facter lookup
   
-  def facts
-    fact_map = {}
-    
-    Facter.list.each do |name|
-      fact_map[name] = Facter.value(name)
-    end
-        
-    fact_map
+  @@facts = nil
+  
+  def fact_var
+    @@facts
+  end
+  
+  def fact_var=facts
+    @@facts = facts
+  end
+  
+  #---
+  
+  def facts(reset = false, clone = true) # Override if needed. (See node plugin)
+    self.fact_var = CORL.facts if reset || fact_var.nil?
+    return fact_var.clone if clone
+    fact_var
+  end
+  
+  #---
+  
+  def create_fact(name, value, reset = false)
+    facts(reset, false)
+    fact_var[name.to_sym] = value
   end
   
   #---
   
-  def fact(name)
-    Facter.value(name)
+  def fact(name, reset = false)
+    facts(reset, false)
+    fact_var[name.to_sym]
   end
   
   #-----------------------------------------------------------------------------
@@ -27,6 +43,14 @@ module Lookup
   
   @@hiera = nil
   
+  def hiera_var
+    @@hiera
+  end
+  
+  def hiera_var=hiera
+    @@hiera = hiera
+  end
+  
   #---
   
   def hiera_override_dir
@@ -35,13 +59,13 @@ module Lookup
   
   #---
   
-  def hiera_facts
-    facts # Override if needed. (See node plugin)
+  def hiera_lookup_prefix
+    '::'
   end
   
   #---
   
-  def hiera_configuration
+  def hiera_configuration(local_facts = {})
     Kernel.load File.join(File.dirname(__FILE__), '..', 'mod', 'hiera_backend.rb')
     
     backends    = CORL.value(:hiera_backends, [ "json", "yaml" ])
@@ -72,7 +96,7 @@ module Lookup
     end
     
     hiera_config = CORL.config(:hiera, config)
-    loaded_facts = Util::Data.prefix('::', hiera_facts, '')
+    loaded_facts = Util::Data.prefix(hiera_lookup_prefix, local_facts, '')
     
     if hiera_config[:hierarchy]
       hiera_config[:hierarchy].delete('common')
@@ -96,8 +120,8 @@ module Lookup
   #---
 
   def hiera(reset = false)
-    @@hiera = Hiera.new(:config => hiera_configuration) if reset || @@hiera.nil?
-    @@hiera
+    self.hiera_var = Hiera.new(:config => hiera_configuration(facts(reset))) if reset || hiera_var.nil?
+    hiera_var
   end
   
   #-----------------------------------------------------------------------------
@@ -120,9 +144,11 @@ module Lookup
   #---
     
   def lookup(properties, default = nil, options = {})
-    config      = Config.ensure(options)
+    config      = Config.new(Config.ensure(options).export)
     value       = nil
     
+    node        = config.delete(:node, nil)
+    
     provisioner = config.get(:provisioner, nil)
     
     hiera_scope = config.get(:hiera_scope, {})
@@ -132,10 +158,12 @@ module Lookup
     
     return_property = config.get(:return_property, false)
     
+    return node.lookup(properties, default, config) if node
+        
     unless properties.is_a?(Array)
       properties = [ properties ].flatten
     end
-
+    
     first_property = nil
     properties.each do |property|
       property       = property.to_sym
@@ -158,11 +186,14 @@ module Lookup
           unless hiera_scope.respond_to?('[]')
             hiera_scope = Hiera::Scope.new(hiera_scope)
           end
-          value = hiera.lookup(property.to_s, nil, hiera_scope, override, context)
+          
+          hiera_scope = string_map(hiera_scope) if hiera_scope.is_a?(Hash)
+          value       = hiera.lookup(property.to_s, nil, hiera_scope, override, context)
+          
           debug_lookup(config, property, value, "Hiera lookup")
         end 
     
-        if CORL.admin? && provisioner && value.nil?
+        if provisioner && value.nil?
           # Search the provisioner scope (only admins can provision a machine)
           value = CORL.provisioner({ :name => :lookup }, provisioner).lookup(property, default, config)
           debug_lookup(config, property, value, "Provisioner lookup")

data/lib/core/mixin/machine/ssh.rb

@@ -6,13 +6,25 @@ module SSH
   #-----------------------------------------------------------------------------
   # SSH Operations
        
-  def init_ssh_session(reset = false, tries = 5, sleep_secs = 5)
+  def init_ssh_session(reset = false, tries = 12, sleep_secs = 5)
     ssh_wait_for_ready
     
-    success = true
-        
+    success     = true
+    
+    public_ip   = node.public_ip
+    user        = node.user
+    ssh_port    = node.ssh_port
+    private_key = node.private_key
+    
+    ssh_config  = Config.new({ 
+      :keypair  => node.keypair,
+      :key_dir  => node.network.key_cache_directory,
+      :key_name => node.plugin_name 
+    })
+    
     begin
-      Util::SSH.session(node.public_ip, node.user, node.ssh_port, node.private_key, reset)
+      Util::SSH.session(public_ip, user, ssh_port, private_key, reset, ssh_config)
+      node.keypair = ssh_config[:keypair]
             
     rescue Net::SSH::HostKeyMismatch => error
       error.remember_host!

data/lib/core/plugin/builder.rb

@@ -0,0 +1,49 @@
+
+module CORL
+module Plugin
+class Builder < CORL.plugin_class(:nucleon, :base)
+  
+  include Parallel
+  
+  extend Mixin::Builder::Global
+  include Mixin::Builder::Instance
+  
+  #-----------------------------------------------------------------------------
+  # Builder plugin interface
+  
+  def normalize(reload)
+    super
+    yield if block_given?
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Checks
+
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+
+  network_settings :builder
+  
+  #-----------------------------------------------------------------------------
+  # Builder operations
+ 
+  def build(node, options = {})
+    config        = Config.ensure(options)    
+    environment   = Util::Data.ensure_value(config[:environment], node.lookup(:corl_environment))
+    configuration = process_environment(export, environment)    
+    
+    FileUtils.mkdir_p(build_directory)
+    
+    status = parallel(:build_provider, configuration, environment)
+    status.values.include?(false) ? false : true
+  end
+  
+  #---
+  
+  def build_provider(name, project_reference, environment)
+    # Implement in sub classes
+    true
+  end
+end
+end
+end

data/lib/core/plugin/{action.rb → cloud_action.rb}

@@ -23,14 +23,18 @@ module Vagrant
     @@command
   end  
 end
+end
+
+#-------------------------------------------------------------------------------
 
+module Nucleon
 module Plugin
-class CloudAction < CORL.plugin_class(:action)
+class CloudAction < CORL.plugin_class(:nucleon, :action)
   
   #-----------------------------------------------------------------------------
   # Property accessor / modifiers
   
-  def namespace
+  def self.namespace
     :corl
   end
   
@@ -38,8 +42,8 @@ class CloudAction < CORL.plugin_class(:action)
     
   def configure
     super do
-      node_config
       yield if block_given?
+      node_config
     end
   end
           
@@ -47,13 +51,13 @@ class CloudAction < CORL.plugin_class(:action)
   # Settings
   
   def node_config
-    node_plugins = CORL.loaded_plugins(:node)
+    node_plugins = CORL.loaded_plugins(:CORL, :node)
     
     register :parallel, :bool, true, 'corl.core.action.options.parallel'
     register :net_remote, :str, :edit, 'corl.core.action.options.net_remote'
-    register :net_provider, :str, :default, 'corl.core.action.options.net_provider' do |value|
+    register :net_provider, :str, :corl, 'corl.core.action.options.net_provider' do |value|
       value           = value.to_sym
-      network_plugins = CORL.loaded_plugins(:network)
+      network_plugins = CORL.loaded_plugins(:CORL, :network)
       
       unless network_plugins.keys.include?(value)
         warn('corl.core.action.errors.network_provider', { :value => value, :choices => network_plugins.keys.join(", ") })
@@ -74,7 +78,7 @@ class CloudAction < CORL.plugin_class(:action)
     register :nodes, :array, [], 'corl.core.action.options.nodes' do |values|
       success = true
       values.each do |value|
-        if info = CORL.plugin_class(:node).translate_reference(value)
+        if info = CORL.plugin_class(:CORL, :node).translate_reference(value)
           if ! node_plugins.keys.include?(info[:provider].to_sym) || info[:name].empty?
             warn('corl.core.action.errors.nodes', { :value => value, :provider => info[:provider],  :name => info[:name] })
             success = false
@@ -94,20 +98,24 @@ class CloudAction < CORL.plugin_class(:action)
   #-----------------------------------------------------------------------------
   # Operations
   
-  def validate(node, network)
+  def validate(node = nil, network = nil)
     super(node, network)
   end
   
   #---
    
-  def execute
-    super(true, true) do
-      node_exec do |node, network|
-        hook_config = { :node => node, :network => network }
+  def execute(use_network = true, &code)
+    if use_network
+      super(true, true) do
+        node_exec do |node, network|
+          hook_config = { :node => node, :network => network }
         
-        yield(node, network) if block_given? && extension_check(:exec_init, hook_config)
-        myself.status = extension_set(:exec_exit, status, hook_config)
+          code.call(node, network) if code && extension_check(:exec_init, hook_config)
+          myself.status = extension_set(:exec_exit, status, hook_config)
+        end
       end
+    else
+      super(false, false, &code)
     end
   end
   
@@ -123,9 +131,7 @@ class CloudAction < CORL.plugin_class(:action)
       # Execute action on remote nodes 
       success = network.batch(settings[:nodes], settings[:node_provider], settings[:parallel]) do |node|
         exec_config = Config.new(settings)
-        exec_config.delete(:parallel)
         exec_config.delete(:nodes)
-        exec_config.delete(:node_provider)
               
         result = node.action(plugin_provider, exec_config) do |op, data|
           execute_remote(node, network, op, data)