corl 0.5.2 → 0.5.3

data/lib/core/vagrant/commands/launcher.rb

@@ -3,38 +3,38 @@ module VagrantPlugins
 module CORL
 module Command
 class Launcher < ::Vagrant.plugin("2", :command)
-  
+
   include ::CORL::Parallel # Mainly for auto locking of resources
-  
+
   #-----------------------------------------------------------------------------
-  
+
   def self.synopsis
     "execute CORL actions within the defined network"
   end
- 
+
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
-  
+
   def env
     @env
   end
-  
+
   #-----------------------------------------------------------------------------
   # Execution
 
   def execute
     # Set the base command so we can access in any actions executed
     ::CORL::Vagrant.command = ::CORL.handle(self)
-    ::CORL.executable(ARGV - [ 'corl', '--' ], "[ vagrant ] corl")
+    ::CORL.executable(ARGV - [ 'corl', '--' ], "vagrant corl")
   end
-  
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def vm_machine(name, provider = nil, refresh = false)
     machine = nil
-    
-    # Mostly derived from Vagrant base command with_target_vms() method 
+
+    # Mostly derived from Vagrant base command with_target_vms() method
     provider = provider.to_sym if provider
 
     env.active_machines.each do |active_name, active_provider|
@@ -54,10 +54,10 @@ class Launcher < ::Vagrant.plugin("2", :command)
     end
 
     provider ||= env.default_provider
-    
+
     machine = env.machine(name, provider, refresh)
     machine.ui.opts[:color] = :default # TODO: Something better??
-    
+
     machine
   end
 end

data/lib/core/vagrant/provisioner/config.rb

@@ -29,7 +29,7 @@ class CORL < ::Vagrant.plugin("2", :config)
     @project_reference = UNSET_VALUE
     @project_branch    = UNSET_VALUE
     
-    @provision         = UNSET_VALUE
+    @provision         = false
     @dry_run           = false
   end
   
@@ -52,8 +52,6 @@ class CORL < ::Vagrant.plugin("2", :config)
     @seed              = nil if @seed == UNSET_VALUE
     @project_reference = nil if @project_reference == UNSET_VALUE
     @project_branch    = nil if @project_branch == UNSET_VALUE
-    
-    @provision         = nil if @provision == UNSET_VALUE
   end
   
   #-----------------------------------------------------------------------------

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

@@ -3,37 +3,42 @@ module Nucleon
 module Action
 module Node
 class Bootstrap < Nucleon.plugin_class(:nucleon, :cloud_action)
-  
+
   #-----------------------------------------------------------------------------
   # Info
-  
+
   def self.describe
     super(:node, :bootstrap, 630)
   end
 
   #-----------------------------------------------------------------------------
   # Settings
-  
+
   def configure
     super do
       register_directory :bootstrap_path, File.join(CORL.lib_path, '..', 'bootstrap')
       register_files :auth_files
-      
+
+      register_bool :reboot, false
+      register_bool :dev_build, false
+
       register_str :home_env_var, 'HOME'
-      register_str :home, nil    
-            
+      register_str :home, nil
+
       register_str :bootstrap_glob, '**/*.sh'
       register_str :bootstrap_init, 'bootstrap.sh'
-      
+
+      register_array :bootstrap_scripts
+
       register_array :bootstrap_nodes, nil do |values|
         if values.nil?
           warn('bootstrap_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?
@@ -46,28 +51,28 @@ class Bootstrap < Nucleon.plugin_class(:nucleon, :cloud_action)
       end
     end
   end
-  
+
   #---
-  
+
   def ignore
     [ :nodes ]
   end
-  
+
   def arguments
     [ :bootstrap_nodes ]
   end
 
   #-----------------------------------------------------------------------------
   # Operations
-    
+
   def execute
     super do |local_node|
       ensure_network do
         batch_success = network.batch(settings[:bootstrap_nodes], settings[:node_provider], settings[:parallel]) do |node|
           render_options = { :id => node.id, :hostname => node.hostname }
-          
+
           info('start', render_options)
-          success = node.bootstrap(network.home, extended_config(:bootstrap, settings.clone))
+          success = node.bootstrap(network.home, extended_config(:bootstrap, Util::Data.clone(settings)))
           if success
             success('complete', render_options)
           else

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

@@ -3,38 +3,38 @@ module Nucleon
 module Action
 module Node
 class Destroy < Nucleon.plugin_class(:nucleon, :cloud_action)
-  
+
   #-----------------------------------------------------------------------------
   # Info
-  
+
   def self.describe
     super(:node, :destroy, 580)
   end
- 
+
   #-----------------------------------------------------------------------------
   # Settings
-  
+
   def configure
     super do
       register_bool :force, false
-      
+
       register_nodes :destroy_nodes
     end
   end
-  
+
   #---
-  
+
   def ignore
     [ :nodes ]
   end
-  
+
   def arguments
     [ :destroy_nodes ]
   end
 
   #-----------------------------------------------------------------------------
   # Operations
-   
+
   def execute
     super do |local_node|
       ensure_network do
@@ -42,17 +42,17 @@ class Destroy < Nucleon.plugin_class(:nucleon, :cloud_action)
           answer = 'YES'
         else
           message = render_message('prompt', { :operation => :ask }) + "\n\n"
-        
+
           array(settings[:destroy_nodes]).each do |hostname|
             message << "  #{hostname}\n"
           end
-        
+
           message << "\n" + render_message('yes_query', { :operation => :ask, :yes => 'YES' }) + ' '
           answer = ask(message)
         end
-        
+
         if answer.upcase == 'YES'
-          batch_success = network.batch(settings[:destroy_nodes], settings[:node_provider], settings[:parallel]) do |node|
+          batch_success = network.batch(settings[:destroy_nodes], settings[:node_provider], settings[:parallel], false) do |node|
             info('start', { :provider => node.plugin_provider, :name => node.plugin_name })
             node.destroy
           end

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

@@ -3,17 +3,17 @@ module Nucleon
 module Action
 module Node
 class Seed < Nucleon.plugin_class(:nucleon, :cloud_action)
-  
+
   #-----------------------------------------------------------------------------
   # Info
-  
+
   def self.describe
     super(:node, :seed, 625)
   end
-  
+
   #-----------------------------------------------------------------------------
   # Settings
-  
+
   def configure
     super do
       codes :key_store_failure,
@@ -22,84 +22,82 @@ class Seed < Nucleon.plugin_class(:nucleon, :cloud_action)
             :node_load_failure,
             :node_save_failure
       #---
-      
+
       register_project :project_reference
-      register_str :project_branch, 'master'      
+      register_str :project_branch, 'master'
     end
   end
-  
+
   #---
-  
+
   def arguments
     [ :project_reference ]
   end
 
   #-----------------------------------------------------------------------------
   # Operations
-   
+
   def execute
     super do |node|
       info('start')
-      
-      ensure_node(node) do
-        admin_exec do
-          network_path = lookup(:corl_network)
-          backup_path  = File.join(Dir.tmpdir(), 'corl')
-          
-          info('deploy_keys')
-          
-          project_class = CORL.plugin_class(:nucleon, :project)
-          
-          if keys = Util::SSH.generate.store
-            if @project_info = project_class.translate_reference(settings[:project_reference], true)
-              project_info = Config.new(@project_info)
-            else
-              project_info = Config.new({ :provider => :git })
-            end
-            
-            project_class.clear_provider(network_path)
-            
-            info('backup')
+
+      admin_exec do
+        network_path = lookup(:corl_network)
+        backup_path  = File.join(Dir.tmpdir(), 'corl')
+
+        info('deploy_keys')
+
+        project_class = CORL.plugin_class(:nucleon, :project)
+
+        if keys = Util::SSH.generate.store
+          if @project_info = project_class.translate_reference(settings[:project_reference], true)
+            project_info = Config.new(@project_info)
+          else
+            project_info = Config.new({ :provider => :git })
+          end
+
+          project_class.clear_provider(network_path)
+
+          info('backup')
+          FileUtils.rm_rf(backup_path)
+          FileUtils.mv(network_path, backup_path)
+
+          info('seeding')
+          project = CORL.project(extended_config(:project, {
+            :directory   => network_path,
+            :reference   => project_info.get(:reference, nil),
+            :url         => project_info.get(:url, settings[:project_reference]),
+            :revision    => project_info.get(:revision, settings[:project_branch]),
+            :create      => true,
+            :pull        => true,
+            :keys        => keys,
+            :internal_ip => CORL.public_ip, # Needed for seeding Vagrant VMs,
+            :new         => true
+          }), project_info[:provider])
+
+          if project
+            info('finalizing')
+            FileUtils.chmod_R(0600, network_path)
             FileUtils.rm_rf(backup_path)
-            FileUtils.mv(network_path, backup_path)
-            
-            info('seeding')
-            project = CORL.project(extended_config(:project, {
-              :directory   => network_path,
-              :reference   => project_info.get(:reference, nil),
-              :url         => project_info.get(:url, settings[:project_reference]),
-              :revision    => project_info.get(:revision, settings[:project_branch]),
-              :create      => true,
-              :pull        => true,
-              :keys        => keys,
-              :internal_ip => CORL.public_ip, # Needed for seeding Vagrant VMs,
-              :new         => true
-            }), project_info[:provider])
-            
-            if project
-              info('finalizing')
-              FileUtils.chmod_R(0600, network_path)
-              FileUtils.rm_rf(backup_path)
-              
-              info('reinitializing')
-              init_network
-              
-              if network.load
-                if node = network.local_node(true)
-                  info('updating')
-                  myself.status = code.node_save_failure unless node.save  
-                else
-                  myself.status = code.node_load_failure
-                end                  
+
+            info('reinitializing')
+            init_network
+
+            if network.load
+              if node = network.local_node(true)
+                info('updating')
+                myself.status = code.node_save_failure unless node.save
               else
-                myself.status = code.network_load_failure    
-              end     
+                myself.status = code.node_load_failure
+              end
             else
-              myself.status = code.project_failure  
-            end            
+              myself.status = code.network_load_failure
+            end
           else
-            myself.status = code.key_store_failure
+            myself.status = code.project_failure
           end
+        else
+          myself.status = code.key_store_failure
         end
       end
     end

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

@@ -3,70 +3,77 @@ module Nucleon
 module Action
 module Node
 class Status < Nucleon.plugin_class(:nucleon, :cloud_action)
-  
+
   #-----------------------------------------------------------------------------
   # Info
-  
+
   def self.describe
     super(:node, :status, 800)
   end
- 
+
   #-----------------------------------------------------------------------------
   # Settings
-  
+
   def configure
     super do
+      codes :network_save_failed
+
       register_nodes :status_nodes, []
-      
       register_bool :basic
     end
   end
-  
+
   #---
-  
+
   def ignore
     [ :nodes ]
   end
-  
+
   def arguments
     [ :status_nodes ]
   end
-  
+
   #-----------------------------------------------------------------------------
   # Operations
-   
+
   def execute
     super do |local_node|
       ensure_network do
         settings[:status_nodes] = [ 'all' ] if settings[:status_nodes].empty?
-        
+
         batch_success = network.batch(settings[:status_nodes], settings[:node_provider], settings[:parallel]) do |node|
-          state       = node.state(true)
-          state       = state.nil? ? :aborted : state.to_sym
-          ssh_enabled = ''
-          
-          case state
-          when :running, :active
-            state = green(state.to_s)
-            
-            unless settings[:basic]
-              result = node.cli.test :true
-            
-              if result.status == code.success
-                ssh_enabled = '[ ' + green('connected') + ' ]'
-              else
-                ssh_enabled = '[ ' + red('connection failed') + ' ]'      
+          unless node.is_a?(Nucleon.provider_class(:CORL, :node, :local))
+            state       = node.state(true)
+            state       = state.nil? ? :aborted : state.to_sym
+            ssh_enabled = ''
+
+            case state
+            when :running, :active
+              state = green(state.to_s)
+
+              unless settings[:basic]
+                result = node.cli.test :true
+
+                if result.status == code.success
+                  ssh_enabled = '[ ' + green('SSH connected') + ' ]'
+                else
+                  ssh_enabled = '[ ' + red('SSH connection failed') + ' ]'
+                end
               end
+
+            when :stopped, :aborted
+              state = red(state.to_s)
             end
-            
-          when :stopped, :aborted
-            state = red(state.to_s)
+            info(state.to_s + " #{ssh_enabled}".rstrip, { :i18n => false, :prefix_text => yellow(node.plugin_provider) + ' ' + purple(node.plugin_name) })
           end
-          info(state.to_s + " #{ssh_enabled}".rstrip, { :i18n => false, :prefix_text => yellow(node.plugin_provider) + ' ' + purple(node.plugin_name) })
           true
         end
-        success = network.save({ :push => true, :remote => :edit, :message => "Updating node status information.", :allow_empty => true })
-        myself.status = code.batch_error unless batch_success && success
+        if batch_success
+          success = network.save({ :push => true, :remote => :edit, :message => "Updating node status information.", :allow_empty => true })
+          myself.status = code.network_save_failed unless success
+        else
+          myself.status = code.batch_error
+        end
       end
     end
   end