corl 0.5.2 → 0.5.3

data/lib/CORL/configuration/file.rb

@@ -5,107 +5,107 @@ class File < Nucleon.plugin_class(:CORL, :configuration)
 
   #-----------------------------------------------------------------------------
   # Configuration plugin interface
-  
+
   def normalize(reload)
-    super do        
+    super do
       _set(:search, Config.new)
       _set(:router, Config.new)
     end
   end
-    
+
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
-  
+
   def search
     _get(:search)
   end
-  
+
   #---
-  
+
   def router
     _get(:router)
   end
 
   #-----------------------------------------------------------------------------
-  
+
   def set_location(directory)
     super
     search_files if directory
   end
-  
+
   #-----------------------------------------------------------------------------
   # Configuration loading / saving
-    
+
   def load(options = {})
-    super do |method_config, properties|      
+    super do |method_config, properties|
       success = true
-      
+
       myself.status = code.success
-      
+
       generate_routes = lambda do |config_name, file_properties, parents = []|
         file_properties.each do |name, value|
           keys = [ parents, name ].flatten
-          
+
           if value.is_a?(Hash) && ! value.empty?
             generate_routes.call(config_name, value, keys)
           else
-            router.set(keys, config_name)  
+            router.set(keys, config_name)
           end
         end
       end
-      
+
       if fetch_project(method_config)
         search.export.each do |config_name, info|
           provider = info[:provider]
           file     = info[:file]
-        
+
           logger.info("Loading #{provider} translated source configuration from #{file}")
-          
+
           parser = CORL.translator(method_config, provider)
           raw    = Util::Disk.read(file)
-          
+
           if parser && raw && ! raw.empty?
             logger.debug("Source configuration file contents: #{raw}")
-            
-            begin            
+
+            begin
               parse_properties = parser.parse(raw)
-              
+
               generate_routes.call(config_name, parse_properties)
               properties.import(parse_properties)
-            
+
             rescue => error
               ui_group(file) do
                 error(error.message.sub(/^[^\:]+\:\s+/, ''), { :i18n => false })
               end
               myself.status = 255
               success       = false
-            end            
+            end
           end
-          CORL.remove_plugin(parser) if parser         
+          CORL.remove_plugin(parser) if parser
         end
       end
       success
     end
   end
-   
+
   #---
-  
+
   # properties[key...] = values
   #
   # to
-  # 
+  #
   # file_data[config_name][key...] = config
-  
-  def separate    
+
+  def separate
     file_data        = Config.new
     default_provider = CORL.type_default(:nucleon, :translator)
-    
+
     split_config = lambda do |properties, local_router, parents = []|
       properties.each do |name, value|
         next if name.to_sym == :nodes
-        
+
         keys = [ parents, name ].flatten
-        
+
         if value.is_a?(Hash) && ! value.empty?
           # Nested configurations
           if local_router.is_a?(Hash) && local_router.has_key?(name)
@@ -119,35 +119,35 @@ class File < Nucleon.plugin_class(:CORL, :configuration)
             else
               # Never encountered before
               config_name = nil
-              
+
               config_name = select_largest(router.get(parents)) unless parents.empty?
-              split_config.call(value, config_name, keys)  
-            end  
+              split_config.call(value, config_name, keys)
+            end
           end
         else
           if local_router.is_a?(String)
             # Router is a config_name string
             file_data.set([ local_router, keys ].flatten, value)
-                     
+
           elsif local_router.is_a?(Hash)
             # Router is a hash with sub options we have to pick from
             config_name = select_largest(local_router)
-            file_data.set([ config_name, keys ].flatten, value)  
+            file_data.set([ config_name, keys ].flatten, value)
           else
             # Router is non existent.  Resort to easily found default
             config_name = "corl.#{default_provider}"
-            file_data.set([ config_name, keys ].flatten, value)      
+            file_data.set([ config_name, keys ].flatten, value)
           end
-        end        
+        end
       end
     end
-    
+
     if config.get(:nodes, false)
       config[:nodes].each do |provider, data|
         data.each do |name, info|
           config_name = ::File.join('nodes', provider.to_s, "#{name}.#{default_provider}")
           file_data.set([ config_name, :nodes, provider, name ], info)
-          
+
           unless search[config_name]
             search[config_name] = {
               :provider => default_provider,
@@ -156,34 +156,34 @@ class File < Nucleon.plugin_class(:CORL, :configuration)
           end
         end
       end
-    end    
-    
+    end
+
     # Whew!  Glad that's over...
     split_config.call(Util::Data.subset(config.export, config.keys - [ :nodes ]), router.export)
-    file_data     
+    file_data
   end
   protected :separate
-  
+
   #---
-    
+
   def save(options = {})
     super do |method_config|
       config_files = []
-      success      = true      
+      success      = true
       deleted_keys = search.export.keys
-      
+
       separate.export.each do |config_name, router_data|
         info         = search[config_name]
         provider     = info[:provider]
         file         = info[:file]
-        file_dir     = ::File.dirname(file)       
+        file_dir     = ::File.dirname(file)
         deleted_keys = deleted_keys - [ config_name ]
-        
+
         FileUtils.mkdir_p(file_dir) unless Dir.exists?(file_dir)
-        
+
         if renderer = CORL.translator(method_config, provider)
           rendering = renderer.generate(router_data)
-          
+
           if Util::Disk.write(file, rendering)
             config_files << config_name
           else
@@ -193,36 +193,36 @@ class File < Nucleon.plugin_class(:CORL, :configuration)
         else
           success = false
         end
-        break unless success        
+        break unless success
       end
       if success
         # Check for removals
         deleted_keys.each do |config_name|
           info = search[config_name]
-          
+
           search.delete(config_name)
           FileUtils.rm_f(info[:file])
-          
+
           config_files << config_name
         end
       end
       if success && ! config_files.empty?
         # Commit changes
         commit_files = [ config_files, method_config.get_array(:files) ].flatten
-        
-        logger.debug("Source configuration rendering: #{rendering}")        
+
+        logger.debug("Source configuration rendering: #{rendering}")
         success = update_project(commit_files, method_config)
       end
       success
     end
   end
-  
+
   #---
-  
+
   def remove(options = {})
     super do |method_config|
       success      = true
-      config_files = [] 
+      config_files = []
       search.each do |config_name, info|
         config_files << info[:file]
         success = false unless Util::Disk.delete(info[:file])
@@ -231,45 +231,45 @@ class File < Nucleon.plugin_class(:CORL, :configuration)
       success
     end
   end
-  
+
   #---
-  
+
   def attach(type, name, data, options = {})
     super do |method_config|
       attach_path = Util::Disk.filename([ project.directory, type.to_s ])
       success     = true
-      
+
       begin
         FileUtils.mkdir_p(attach_path) unless Dir.exists?(attach_path)
-      
+
       rescue => error
         warn(error.message, { :i18n => false })
         success = false
       end
-      
+
       if success
         case method_config.get(:type, :source)
         when :source
           new_file = project.local_path(Util::Disk.filename([ attach_path, name ]))
-          
-          logger.debug("Attaching source data (length: #{data.length}) to configuration at #{attach_path}")        
+
+          logger.debug("Attaching source data (length: #{data.length}) to configuration at #{attach_path}")
           success = Util::Disk.write(new_file, data)
-          
-        when :file  
+
+        when :file
           file       = ::File.expand_path(data)
           attach_ext = ::File.basename(file)
-          new_file   = project.local_path(Util::Disk.filename([ attach_path, "#{name}-#{attach_ext}" ])) 
-              
-          logger.debug("Attaching file #{file} to configuration at #{attach_path}")       
-      
+          new_file   = project.local_path(Util::Disk.filename([ attach_path, "#{name}-#{attach_ext}" ]))
+
+          logger.debug("Attaching file #{file} to configuration at #{attach_path}")
+
           begin
             FileUtils.mkdir_p(attach_path) unless Dir.exists?(attach_path)
             FileUtils.cp(file, new_file)
-          
+
           rescue => error
             warn(error.message, { :i18n => false })
             success = false
-          end  
+          end
         end
       end
       if success && autosave
@@ -279,24 +279,24 @@ class File < Nucleon.plugin_class(:CORL, :configuration)
       success ? new_file : nil
     end
   end
-  
+
   #---
-  
+
   def delete_attachments(ids, options = {})
     super do |method_config|
       success = true
       files   = []
-      
+
       array(ids).each do |id|
         file = ::File.join(project.directory, id.to_s)
-        
+
         if Util::Disk.delete(file)
           files << file
         else
           success = false
         end
       end
-      
+
       if success && autosave
         logger.debug("Removing attached data from project as #{files.join(', ')}")
         success = update_project(files, method_config)
@@ -304,97 +304,97 @@ class File < Nucleon.plugin_class(:CORL, :configuration)
       success ? files : nil
     end
   end
-  
+
   #-----------------------------------------------------------------------------
   # Utilities
-   
+
   def search_files
-    
+
     add_search_file = lambda do |config_name, file, provider, info|
-      if Util::Disk.exists?(file)            
+      if Util::Disk.exists?(file)
         search[config_name] = {
           :provider => provider,
           :info     => info,
           :file     => file
         }
       else
-        logger.info("Configuration file #{file} does not exist")   
-      end  
+        logger.info("Configuration file #{file} does not exist")
+      end
     end
-    
+
     if Util::Data.empty?(project.directory)
-      logger.debug("Clearing configuration file information")      
+      logger.debug("Clearing configuration file information")
       search.clear
     else
       translators = CORL.loaded_plugins(:nucleon, :translator)
       file_bases  = [ :corl, extension_set(:base, []) ].flatten.uniq
-      
+
       project.localize do
         translators.each do |provider, info|
           Dir.glob(::File.join('nodes', '**', "*.#{provider}")).each do |file|
             config_name = file
             file        = ::File.join(project.directory, file)
-            
-            add_search_file.call(config_name, file, provider, info)  
+
+            add_search_file.call(config_name, file, provider, info)
           end
         end
       end
-      
+
       translators.each do |provider, info|
         file_bases.each do |file_base|
           config_name = "#{file_base}.#{provider}"
           file        = Util::Disk.filename([ project.directory, config_name ])
-         
+
           add_search_file.call(config_name, file, provider, info)
         end
-      end     
+      end
       logger.debug("Setting configuration file information to #{search.inspect}")
     end
     load(_export) if autoload
   end
   protected :search_files
-  
+
   #---
-  
+
   def fetch_project(options = {})
     config  = Config.ensure(options)
     success = true
     if remote = config.get(:remote, nil)
       logger.info("Pulling configuration updates from remote #{remote}")
-      success = project.pull(remote, config) if config.get(:pull, true)   
+      success = project.pull(remote, config) if config.get(:pull, true)
     end
     success
   end
   protected :fetch_project
-  
+
   #---
-  
+
   def update_project(files = [], options = {})
     config  = Config.ensure(options)
     success = true
-    
+
     commit_files = '.'
     commit_files = array(files).flatten unless files.empty?
-          
-    logger.info("Committing changes to configuration files")        
+
+    logger.info("Committing changes to configuration files")
     success = project.commit(commit_files, config)
-          
+
     if success && remote = config.get(:remote, nil)
       logger.info("Pushing configuration updates to remote #{remote}")
-      success = project.pull(remote, config) if config.get(:pull, true)
-      success = project.push(remote, config) if success && config.get(:push, true)      
+      success = project.pull(remote, config) if config.get(:pull, true) && ! config.get(:push, false)
+      success = project.push(remote, config) if success && config.get(:push, true)
     end
     success
   end
   protected :update_project
-  
+
   #---
-  
+
   def select_largest(router)
     return router unless router.is_a?(Hash)
-    
+
     config_map = {}
-    
+
     count_config_names = lambda do |data|
       data = data.export if data.is_a?(CORL::Config)
       data.each do |name, value|
@@ -406,16 +406,16 @@ class File < Nucleon.plugin_class(:CORL, :configuration)
         end
       end
     end
-    
+
     config_name   = nil
     config_weight = nil
-    
+
     count_config_names.call(router)
     config_map.each do |name, weight|
       if config_name.nil? || weight > config_weight
         config_name   = name
         config_weight = weight
-      end  
+      end
     end
     config_name
   end

data/lib/CORL/machine/rackspace.rb

@@ -2,55 +2,56 @@
 module CORL
 module Machine
 class Rackspace < Fog
- 
+
   #-----------------------------------------------------------------------------
   # Checks
-   
+
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
-  
+
   def set_connection
+    require 'fog-rackspace'
     super
-    Kernel.load File.join(File.dirname(__FILE__), '..', '..', 'core', 'mod', 'fog_rackspace_server.rb')
+    #Kernel.load File.join(File.dirname(__FILE__), '..', '..', 'core', 'mod', 'fog_rackspace_server.rb')
   end
- 
+
   #-----------------------------------------------------------------------------
   # Management
 
   def init_server
     super do
       myself.plugin_name = @server.id
-      
+
       node[:id]           = plugin_name
       node[:public_ip]    = @server.public_ip_address
-      node[:private_ip]   = @server.private_ip_address    
+      node[:private_ip]   = @server.private_ip_address
       node[:machine_type] = @server.flavor.id
-      node[:image]        = @server.image.id    
+      node[:image]        = @server.image.id if @server.image
       node.user           = @server.username unless node.user
-      
+
       @server.private_key_path = node.private_key if node.private_key
       @server.public_key_path  = node.public_key if node.public_key
-    end  
+    end
   end
-  
+
   #---
-  
+
   def reload(options = {})
     super do |config|
       success = server.reboot(config.get(:type, 'SOFT'))
-      
+
       server.wait_for { ready? } if success
       success
     end
   end
-  
+
   #---
- 
+
   def create_image(options = {})
     super do |image_name, config, success|
-      image = server.create_image(image_name)        
+      image = server.create_image(image_name)
       image.wait_for { ready? }
-      
+
       if image
         node[:image] = image.id
         success      = true

data/lib/core/facade.rb

@@ -105,7 +105,7 @@ module Facade
     plugin(:CORL, :builder, provider, options)
   end
   
-  def builder(data, build_hash = false, keep_array = false)
+  def builders(data, build_hash = false, keep_array = false)
     plugins(:CORL, :builder, data, build_hash, keep_array)
   end