corl 0.5.5 → 0.5.6

data/lib/core/plugin/node.rb

@@ -896,7 +896,7 @@ class Node < Nucleon.plugin_class(:nucleon, :base)
 
     admin_command = ''
     if as_admin
-      admin_command = config.delete(:admin_command, 'sudo -i') if user.to_s != 'root'
+      admin_command = config.delete(:admin_command, 'sudo -i')
       admin_command = extension_set(:admin_command, admin_command, config)
     else
       config.delete(:admin_command)

data/lib/core/util/puppet/resource.rb

@@ -3,101 +3,102 @@ module CORL
 module Util
 module Puppet
 class Resource < Core
-  
+
   include Mixin::SubConfig
-   
+
   #-----------------------------------------------------------------------------
   # Constructor / Destructor
-  
+
   def initialize(group, info, title, properties = {})
     super({
       :group => group,
       :title => string(title),
       :info  => symbol_map(hash(info)),
       :ready => false
-    })
-    import(properties) 
+    }, {}, true, true, false)
+
+    import(properties)
   end
-      
+
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
-  
+
   def group
     return _get(:group)
   end
-  
+
   #---
-  
+
   def info(default = {})
     return hash(_get(:info, default))
   end
-  
+
   #---
-  
+
   def info=info
     _set(:info, hash(info))
   end
-  
+
   #---
-  
+
   def title(default = '')
     return string(_get(:title, default))
   end
-  
+
   #---
-  
+
   def title=info
     _set(:title, string(info))
   end
-  
+
   #---
-  
+
   def ready(default = false)
     return test(_get(:ready, default))
   end
- 
+
   #---
-  
+
   def defaults(defaults, options = {})
     super(defaults, options)
-    
+
     _set(:ready, false)
-    return self 
+    return self
   end
 
   #---
-  
+
   def import(properties, options = {})
     super(properties, options)
-    
+
     _set(:ready, false)
-    return self  
+    return self
   end
-      
+
   #-----------------------------------------------------------------------------
   # Resource operations
-  
+
   def ensure_ready(options = {})
     unless ready
       process(options)
     end
   end
-  
+
   #---
-  
+
   def process(options = {})
     config = Config.ensure(options)
-    
+
     tag(config[:tag])
     render(config)
     translate(config)
-    
+
     _set(:ready, true) # Ready for resource creation
     return self
   end
-  
+
   #---
-  
+
   def tag(tags, append = true)
     unless Data.empty?(tags)
       if tags.is_a?(String)
@@ -106,145 +107,145 @@ class Resource < Core
         tags = tags.flatten
       end
       resource_tags = get(:tag)
-      
+
       if ! resource_tags || ! append
         set(:tag, tags)
       else
         tags.each do |tag|
-          resource_tags << tag unless resource_tags.include?(tag)  
+          resource_tags << tag unless resource_tags.include?(tag)
         end
         set(:tag, resource_tags)
       end
     end
     return self
   end
-  
+
   #---
-  
+
   def self.render(resource_info, options = {})
     resource = string_map(resource_info)
     config   = Config.ensure(options)
-    
+
     resource.keys.each do |name|
       if match = name.to_s.match(/^(.+)_template$/)
         target = match.captures[0]
-        
+
         config.set(:normalize_template, config.get("normalize_#{target}", true))
         config.set(:interpolate_template, config.get("interpolate_#{target}", true))
-        
+
         input_data       = resource[target]
         resource[target] = CORL.template(config, resource[name]).render(input_data)
-        
+
         if config.get(:debug, false)
           CORL.ui.info("\n", { :prefix => false })
           CORL.ui_group("#{resource[name]} template", :cyan) do |ui|
             ui.info("-----------------------------------------------------")
-        
+
             source_dump  = Console.blue(Data.to_json(input_data, true))
-            value_render = Console.green(resource[target])       
-        
+            value_render = Console.green(resource[target])
+
             ui.info("Data:\n#{source_dump}")
             ui.info("Rendered:\n#{value_render}")
-            ui.info("\n", { :prefix => false }) 
+            ui.info("\n", { :prefix => false })
           end
         end
-        resource.delete(name)         
+        resource.delete(name)
       end
     end
-    return resource 
+    return resource
   end
-  
+
   #---
 
   def render(options = {})
     resource = self.class.render(export, options)
     clear
-    import(Config.ensure(resource).export, options)    
+    import(Config.ensure(resource).export, options)
     return self
   end
-  
+
   #---
-  
+
   def translate(options = {})
     config = Config.ensure(options)
-    
+
     set(:before, translate_resource_refs(get(:before), config)) if get(:before)
     set(:notify, translate_resource_refs(get(:notify), config)) if get(:notify)
-    set(:require, translate_resource_refs(get(:require), config)) if get(:require)       
+    set(:require, translate_resource_refs(get(:require), config)) if get(:require)
     set(:subscribe, translate_resource_refs(get(:subscribe), config)) if get(:subscribe)
-    
+
     return self
   end
 
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def translate_resource_refs(resource_refs, options = {})
     return :undef if Data.undef?(resource_refs)
-    
+
     config         = Config.ensure(options)
     resource_names = config.get(:resource_names, {})
     title_prefix   = config.get(:title_prefix, '')
-    
+
     title_pattern  = config.get(:title_pattern, '^\s*([^\[\]]+)\s*$')
     title_group    = config.get(:title_var_group, 1)
     title_flags    = config.get(:title_flags, '')
     title_regexp   = Regexp.new(title_pattern, title_flags.split(''))
-    
-    allow_single   = config.get(:allow_single_return, true)    
-    
+
+    allow_single   = config.get(:allow_single_return, true)
+
     type_name      = info[:name].sub(/^\@?\@/, '')
     values         = []
-    
+
     composite_resources = group.composite_resources
-        
+
     case resource_refs
     when String
       if resource_refs.empty?
-        return :undef 
+        return :undef
       else
         resource_refs = resource_refs.split(/\s*,\s*/)
       end
-        
+
     when ::Puppet::Resource
-      resource_refs = [ resource_refs ]  
+      resource_refs = [ resource_refs ]
     end
-    
+
     resource_refs.collect! do |value|
       if value.is_a?(::Puppet::Resource) || ! value.to_s.match(title_regexp)
         value.to_s
-          
-      elsif resource_names.has_key?(value.to_s)
+
+      elsif resource_names.has_key?(value.to_sym)
         if ! title_prefix.empty?
           "#{title_prefix}_#{value}"
         else
           value.to_s
         end
-        
+
       elsif composite_resources.has_key?(value.to_sym) && ! composite_resources[value.to_sym].empty?
         results = []
         composite_resources[value.to_sym].each do |resource_name|
           unless title_prefix.empty?
             resource_name = "#{title_prefix}_#{resource_name}"
           end
-          results << resource_name        
+          results << resource_name
         end
         results
-        
+
       else
         nil
-      end           
+      end
     end
-    
+
     resource_refs.flatten.each do |ref|
-      unless ref.nil?        
+      unless ref.nil?
         unless ref.is_a?(::Puppet::Resource)
           ref = ref.match(title_regexp) ? ::Puppet::Resource.new(type_name, ref) : ::Puppet::Resource.new(ref)
         end
         values << ref unless ref.nil?
       end
     end
-    
+
     return values[0] if allow_single && values.length == 1
     return values
   end

data/lib/core/util/puppet/resource_group.rb

@@ -3,81 +3,82 @@ module CORL
 module Util
 module Puppet
 class ResourceGroup < Core
-  
+
   include Mixin::SubConfig
-   
+
   #-----------------------------------------------------------------------------
   # Constructor / Destructor
-  
+
   def initialize(type_info, default = {})
     super({
       :info    => hash(type_info),
       :default => symbol_map(hash(default))
-    })
+    }, {}, true, true, false)
+
     self.resources = {}
   end
-  
+
   #---
-  
+
   def inspect
     "#{self.class}#{info.to_s}[#{composite_resources.keys.length}]"
   end
-     
+
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
-  
+
   def info(default = {})
     return hash(_get(:info, default))
   end
-  
+
   #---
-  
+
   def info=info
     _set(:info, hash(info))
   end
-  
+
   #---
-  
+
   def default(default = {})
     return hash(_get(:default, default))
   end
-  
+
   #---
-  
+
   def default=default
     _set(:default, symbol_map(hash(default)))
   end
- 
+
   #---
-  
+
   def resources(default = {})
     return hash(_get(:resources, default))
   end
-  
+
   #---
-  
+
   def resources=resources
     _set(:resources, symbol_map(hash(resources)))
   end
- 
+
   #---
-  
+
   def composite_resources(default = {})
     return hash(_get(:composite_resources, default))
   end
-  
+
   #---
-  
+
   def composite_resources=resources
     _set(:composite_resources, symbol_map(hash(resources)))
   end
-  
+
   #---
-  
+
   def add(resources, options = {})
-    config    = Config.ensure(options)    
-    resources = normalize(info[:name], resources.dup, config)
-     
+    config    = Config.ensure(options)
+    resources = normalize(info[:name], Data.clone(resources), config)
+
     unless Data.empty?(resources)
       collection = self.resources
       resources.each do |title, resource|
@@ -88,21 +89,21 @@ class ResourceGroup < Core
     end
     return self
   end
-  
+
   #---
-  
+
   def add_composite_resource(name, resource_names)
     name            = name.to_sym
-    composite       = self.composite_resources    
+    composite       = self.composite_resources
     composite[name] = [] unless composite[name].is_a?(Array)
-    
+
     unless resource_names.is_a?(Array)
       resource_names = [ resource_names ]
     end
-    
+
     resource_names.each do |r_name|
       r_name = r_name.to_sym
-      
+
       unless composite[name].include?(r_name)
         composite[name] << r_name
       end
@@ -113,44 +114,45 @@ class ResourceGroup < Core
 
   #-----------------------------------------------------------------------------
   # Resource operations
-  
+
   def normalize(type_name, resources, options = {})
     self.composite_resources = {}
-    
+
     config    = Config.ensure(options)
     resources = Data.value(resources)
-    
+
     unless Data.empty?(resources)
       resource_names = {}
-      
+
       resources.keys.each do |name|
         if ! resources[name] || resources[name].empty? || ! resources[name].is_a?(Hash)
           resources.delete(name)
         else
           normalize = true
-          
+
           namevar = Puppet.namevar(type_name, name)
+
           if resources[name].has_key?(namevar)
             value = resources[name][namevar]
             if Data.empty?(value)
               resources.delete(name)
               normalize = false
-              
+
             elsif value.is_a?(Array)
               value.each do |item|
                 item_name = "#{name}_#{item}".gsub(/\-/, '_')
-                
+
                 new_resource = resources[name].clone
                 new_resource[namevar] = item
-                
-                resources[item_name] = Resource.new(self, info, item_name, new_resource).defaults(default, config)               
+
+                resources[item_name] = Resource.new(self, info, item_name, new_resource).defaults(default, config)
                 add_composite_resource(name, item_name)
               end
               resources.delete(name)
               normalize = false
-            end  
+            end
           end
-          
+
           if normalize
             resource = Resource.new(self, info, name, resources[name]).defaults(default, config)
             resource_names[name] = true
@@ -158,7 +160,7 @@ class ResourceGroup < Core
           end
         end
       end
-      
+
       config[:resource_names] = resource_names
       resources.each do |name, resource|
         resource.process(config)
@@ -167,14 +169,14 @@ class ResourceGroup < Core
     return translate(resources, config)
   end
   protected :normalize
-  
+
   #---
-  
+
   def translate(resources, options = {})
     config  = Config.ensure(options)
     results = {}
-    prefix  = config.get(:resource_prefix, '')    
-    
+    prefix  = config.get(:resource_prefix, '')
+
     resources.each do |name, resource|
       unless prefix.empty?
         name = "#{prefix}_#{name}"

data/lib/core/util/puppet.rb

@@ -115,20 +115,25 @@ module Puppet
     end
 
     display_name = puppet_scope.parent_module_name ? puppet_scope.parent_module_name : 'toplevel'
+    display      = [ :debug, :info, :warn, :error ].include? CORL.log_level
 
     case type[:type]
     when :type, :define
-      CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
-        rendered_title    = Util::Console.blue(title)
-        rendered_resource = Util::Console.green("#{type_name(type[:name])}[#{rendered_title}]")
-        ui.info("Adding #{rendered_resource}")
+      if display
+        CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
+          rendered_title    = Util::Console.blue(title)
+          rendered_resource = Util::Console.green("#{type_name(type[:name])}[#{rendered_title}]")
+          ui.info("Adding #{type[:type]} #{rendered_resource}")
+        end
       end
       add_definition(type, title, properties, config)
     when :class
-      CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
-        rendered_title    = Util::Console.blue(title)
-        rendered_resource = Util::Console.green("Class[#{rendered_title}]")
-        ui.info("Adding #{rendered_resource}")
+      if display
+        CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
+          rendered_title    = Util::Console.blue(title)
+          rendered_resource = Util::Console.green("Class[#{rendered_title}]")
+          ui.info("Adding class #{rendered_resource}")
+        end
       end
       add_class(title, properties, config)
     end
@@ -204,6 +209,7 @@ module Puppet
     return false unless puppet_scope
 
     display_name = puppet_scope.parent_module_name ? puppet_scope.parent_module_name : 'toplevel'
+    display      = [ :debug, :info, :warn, :error ].include? CORL.log_level
 
     if resource_name.is_a?(Array)
       resource_name = resource_name.flatten
@@ -215,10 +221,12 @@ module Puppet
       classes = Config.lookup(name, nil, config)
       if classes.is_a?(Array)
         classes.each do |klass|
-          CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
-            rendered_klass    = Util::Console.blue(klass)
-            rendered_resource = Util::Console.green("Class[#{rendered_klass}]")
-            ui.info("Including #{rendered_resource}")
+          if display
+            CORL.ui_group(Util::Console.cyan(display_name)) do |ui|
+              rendered_klass    = Util::Console.blue(klass)
+              rendered_resource = Util::Console.green("Class[#{rendered_klass}]")
+              ui.info("Including #{rendered_resource}")
+            end
           end
           class_data[klass] = properties
         end

data/lib/nucleon/action/node/image.rb

@@ -3,28 +3,28 @@ module Nucleon
 module Action
 module Node
 class Image < Nucleon.plugin_class(:nucleon, :cloud_action)
-  
+
   #-----------------------------------------------------------------------------
   # Info
-  
+
   def self.describe
     super(:node, :image, 610)
   end
- 
+
   #-----------------------------------------------------------------------------
   # Settings
-  
+
   def configure
     super do
       register :image_nodes, :array, nil do |values|
         if values.nil?
           warn('corl.actions.image.errors.image_nodes_empty')
-          next false 
+          next false
         end
-        
+
         node_plugins = CORL.loaded_plugins(:CORL, :node)
         success      = true
-        
+
         values.each do |value|
           if info = CORL.plugin_class(:CORL, :node).translate_reference(value)
             if ! node_plugins.keys.include?(info[:provider].to_sym) || info[:name].empty?
@@ -34,32 +34,34 @@ class Image < Nucleon.plugin_class(:nucleon, :cloud_action)
           end
         end
         success
-      end  
+      end
     end
   end
-  
+
   #---
-  
+
   def ignore
     [ :nodes ]
   end
-  
+
   def arguments
     [ :image_nodes ]
   end
 
   #-----------------------------------------------------------------------------
   # Operations
-   
+
   def execute
     super do |local_node|
       ensure_network do
         batch_success = network.batch(settings[:image_nodes], settings[:node_provider], settings[:parallel]) do |node|
-          info('corl.actions.image.start', { :provider => node.plugin_provider, :name => node.plugin_name })
-          node.create_image
+          info('start', { :provider => node.plugin_provider, :name => node.plugin_name })
+          success = node.create_image
+          success('complete', { :provider => node.plugin_provider, :name => node.plugin_name }) if success
+          success
         end
-        myself.status = code.batch_error unless batch_success  
-      end    
+        myself.status = code.batch_error unless batch_success
+      end
     end
   end
 end