corl 0.4.15 → 0.4.16

data/lib/core/plugin/action.rb

@@ -1,5 +1,29 @@
 
 module CORL
+module Vagrant
+  
+  #
+  # Since we can execute CORL actions from within Vagrant on a combination of
+  # Vagrant VMs and remote server instances we need a way to tap into the 
+  # Vagrant environment and operate on CORL configured Vagrant machines.
+  # 
+  # This command is set in the CORL launcher Vagrant command plugin execute 
+  # method.  It is then accessible anywhere within CORL if we have used that
+  # Vagrant command as an execution gateway.  If not it will be nil, giving us
+  # a convienient method for checking whether we are executing through Vagrant
+  # which is used in the CORL Vagrant {Node} and {Machine} plugins.
+  #  
+  @@command = nil
+  
+  def self.command=command
+    @@command = command
+  end
+  
+  def self.command
+    @@command
+  end  
+end
+
 module Plugin
 class CloudAction < CORL.plugin_class(:action)
   
@@ -38,10 +62,11 @@ class CloudAction < CORL.plugin_class(:action)
       true
     end
     register :node_provider, :str, :local, 'corl.core.action.options.node_provider' do |value|
-      value = value.to_sym
+      value          = value.to_sym      
+      node_providers = node_plugins.keys
       
-      unless node_plugins.keys.include?(value)
-        warn('corl.core.action.errors.node_provider', { :value => value, :choices => node_plugins.keys.join(", ") })
+      unless CORL.vagrant? || node_providers.include?(value)
+        warn('corl.core.action.errors.node_provider', { :value => value, :choices => node_providers.join(", ") })
         next false
       end
       true  
@@ -94,7 +119,7 @@ class CloudAction < CORL.plugin_class(:action)
     #
     # A fork in the road...
     #
-    if network.has_nodes? && ! settings[:nodes].empty?
+    if network && network.has_nodes? && ! settings[:nodes].empty?
       # Execute action on remote nodes 
       success = network.batch(settings[:nodes], settings[:node_provider], settings[:parallel]) do |node|
         exec_config = Config.new(settings)
@@ -110,7 +135,8 @@ class CloudAction < CORL.plugin_class(:action)
       myself.status = code.batch_error unless success
     else
       # Execute statement locally
-      node = network.local_node
+      node = nil
+      node = network.local_node if network
       
       if validate(node, network)
         yield(node, network) if block_given?
@@ -149,6 +175,28 @@ class CloudAction < CORL.plugin_class(:action)
     # Implement in sub classes if needed
     data 
   end
+  
+  #---
+  
+  def ensure_network(network, &block)
+    codes :network_failure
+    
+    if network
+      block.call
+    else
+      myself.status = code.network_failure
+    end
+  end
+  
+  def ensure_node(node, &block)
+    codes :node_failure
+    
+    if node
+      block.call
+    else
+      myself.status = code.node_failure
+    end
+  end
 end
 end
 end

data/lib/core/plugin/configuration.rb

@@ -16,11 +16,13 @@ class Configuration < CORL.plugin_class(:base)
     
     logger.info("Setting source configuration project")
     @project = CORL.project(extended_config(:project, {
-      :directory => _delete(:directory, Dir.pwd),
-      :url       => _delete(:url),
-      :revision  => _delete(:revision),
-      :create    => _delete(:create, false),
-      :pull      => true
+      :directory     => _delete(:directory, Dir.pwd),
+      :url           => _delete(:url),
+      :revision      => _delete(:revision),
+      :create        => _delete(:create, false),
+      :pull          => true,
+      :internal_ip   => CORL.public_ip, # Needed for seeding Vagrant VMs
+      :manage_ignore => true
     }), _delete(:project_provider))
         
     _init(:autoload, true)
@@ -53,6 +55,18 @@ class Configuration < CORL.plugin_class(:base)
   
   #---
   
+  def cache
+    project.cache
+  end
+  
+  #---
+  
+  def ignore(files)
+    project.ignore(files)
+  end
+  
+  #---
+  
   def autoload(default = false)
     _get(:autoload, default)
   end

data/lib/core/plugin/fog_machine.rb

@@ -149,7 +149,7 @@ class Fog < CORL.plugin_class(:machine)
   
   def download(remote_path, local_path, options = {})
     super do |config, success|
-      logger.debug("Executing SCP download to #{local_path} from #{remote_path} on machine #{name}") 
+      logger.debug("Executing SCP download to #{local_path} from #{remote_path} on machine #{plugin_name}") 
       
       begin
         if init_ssh_session(server)

data/lib/core/plugin/fog_node.rb

@@ -11,15 +11,15 @@ class Fog < CORL.plugin_class(:node)
   # Node plugin interface
    
   def normalize(reload)
-    super do
-      myself.region  = region 
+    super
+    
+    myself.region  = region 
       
-      unless reload
-        machine_provider = :fog
-        machine_provider = yield if block_given?
+    unless reload
+      machine_provider = :fog
+      machine_provider = yield if block_given?
                         
-        myself.machine = create_machine(:machine, machine_provider, machine_config)
-      end
+      myself.machine = create_machine(:machine, machine_provider, machine_config)
     end
   end
        
@@ -81,8 +81,8 @@ class Fog < CORL.plugin_class(:node)
     if region = myself[:region]
       region
     else
-      first_region = regions.first
-      myself.region  = first_region
+      first_region  = regions.first
+      myself.region = first_region
       first_region
     end
   end

data/lib/core/plugin/machine.rb

@@ -7,7 +7,6 @@ class Machine < CORL.plugin_class(:base)
   # Machine plugin interface
   
   def normalize(reload)
-    myself.plugin_name = node[:id]
   end
        
   #-----------------------------------------------------------------------------
@@ -85,12 +84,6 @@ class Machine < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   # Management
   
-  def init_ssh(ssh_port)
-    # Implement in sub classes if needed
-  end
-  
-  #--- 
-
   def load
     success = true
     
@@ -158,7 +151,7 @@ class Machine < CORL.plugin_class(:base)
     results = []
     
     if running?
-      logger.debug("Executing command on #{plugin_provider} machine with: #{options.inspect}")
+      logger.debug("Executing commands on #{plugin_provider} machine with: #{options.inspect}")
       config  = Config.ensure(options)      
       results = yield(config, results) if block_given?
     else
@@ -246,12 +239,12 @@ class Machine < CORL.plugin_class(:base)
     else
       logger.debug("Starting #{plugin_provider} machine with: #{options.inspect}")
       
-      if created?
-        logger.debug("Machine #{plugin_name} has already been created") 
+      logger.debug("Machine #{plugin_name} is not running yet")
+      if block_given?
+        success = yield(config)  
       else
-        logger.debug("Machine #{plugin_name} does not yet exist")
-        success = create(options)
-      end      
+        success = create(options)  
+      end            
     end
     
     logger.warn("There was an error starting the machine #{plugin_name}") unless success

data/lib/core/plugin/network.rb

@@ -4,7 +4,6 @@ module Plugin
 class Network < CORL.plugin_class(:base)
   
   init_plugin_collection 
-  task_class TaskThread
   
   #-----------------------------------------------------------------------------
   # Cloud plugin interface
@@ -14,6 +13,8 @@ class Network < CORL.plugin_class(:base)
     
     logger.info("Initializing sub configuration from source with: #{myself._export.inspect}")
     myself.config = CORL.configuration(Config.new(myself._export).import({ :autosave => false, :create => false })) unless reload
+    
+    ignore('build')
   end
   
   #-----------------------------------------------------------------------------
@@ -49,6 +50,18 @@ class Network < CORL.plugin_class(:base)
   
   #---
   
+  def cache
+    config.cache
+  end
+  
+  #---
+  
+  def ignore(files)
+    config.ignore(files)
+  end
+  
+  #---
+  
   def remote(name)
     config.remote(name)
   end
@@ -130,7 +143,7 @@ class Network < CORL.plugin_class(:base)
   #---
   
   def local_node(require_new = false)
-    ip_address = CORL.ip_address
+    ip_address = CORL.public_ip  
     local_node = node_by_ip(ip_address, require_new)
         
     if local_node.nil?
@@ -223,15 +236,18 @@ class Network < CORL.plugin_class(:base)
         
     remote_name = config.delete(:remote, :edit)
     
-    # Set node data
-    node = set_node(provider, name, { 
-      :settings     => array(config.delete(:groups, [])), 
+    node_options = Util::Data.clean({ 
+      :settings     => array(config.delete(:groups, [])) | [ "server" ], 
       :region       => config.delete(:region, nil),
       :machine_type => config.delete(:machine_type, nil),
+      :public_ip    => config.delete(:public_ip, nil),
       :image        => config.delete(:image, nil),
       :user         => config.delete(:user, :root),
       :hostname     => name
     })
+    
+    # Set node data
+    node = set_node(provider, name, node_options)
     hook_config = { :node => node, :remote => remote_name, :config => config }
     success     = true
     
@@ -252,11 +268,11 @@ class Network < CORL.plugin_class(:base)
         if success
           seed_project = config.get(:project_reference, nil)
           save_config  = { :commit => true, :remote => remote_name, :push => true }
-               
+                         
           if seed_project && remote_name
             # Reset project remote
             seed_info = Plugin::Project.translate_reference(seed_project)
-          
+                    
             if seed_info
               seed_url    = seed_info[:url]
               seed_branch = seed_info[:revision] if seed_info[:revision]

data/lib/core/plugin/node.rb

@@ -4,8 +4,7 @@ module Plugin
 class Node < CORL.plugin_class(:base)
   
   include Celluloid
-  task_class TaskThread
- 
+  
   #-----------------------------------------------------------------------------
   # Node plugin interface
    
@@ -18,12 +17,10 @@ class Node < CORL.plugin_class(:base)
       myself[name] = value
     end
     
-    yield if block_given? # Chance to create a machine to feed hostname
-    
     ui.resource = Util::Console.colorize(hostname, @class_color)
     logger      = hostname
     
-    myself[:settings] = [ "all", plugin_provider.to_s, plugin_name.to_s ] | setting(:settings, [], :array)
+    add_groups([ "all", plugin_provider.to_s, plugin_name.to_s ])
     
     unless reload
       @cli_interface = Util::Liquid.new do |method, args, &code|
@@ -317,7 +314,7 @@ class Node < CORL.plugin_class(:base)
   
   def machine_config
     name   = myself[:id]
-    name   = myself[:hostname] if name.nil?
+    name   = myself[:hostname] if name.nil? || name.empty?
     config = Config.new({ :name => name })
     
     yield(config) if block_given?
@@ -436,6 +433,8 @@ class Node < CORL.plugin_class(:base)
     if machine
       config = Config.ensure(options)
       
+      clear_cache
+      
       if extension_check(:create, { :config => config })
         logger.info("Creating node: #{plugin_name}")
       
@@ -571,7 +570,8 @@ class Node < CORL.plugin_class(:base)
   execute_block_on_receiver :exec
   
   def exec(options = {})
-    results = nil
+    default_error = Util::Shell::Result.new(:error, 255)
+    results       = [ default_error ]
     
     if machine && machine.running?
       config = Config.ensure(options)
@@ -594,25 +594,35 @@ class Node < CORL.plugin_class(:base)
           results = active_machine.exec(commands, config.export) do |type, command, data|
             unless local?
               if type == :error
-                alert(data)
+                alert(filter_output(type, data))
               else
-                render(data)
+                render(filter_output(type, data))
               end
             end
             yield(:progress, { :type => type, :command => command, :data => data }) if block_given?   
           end
+        else
+          default_error.append_errors("No execution command")    
         end
         
-        success  = true
-        results.each do |result|
-          success = false if result.status != code.success  
-        end
-        if success
-          yield(:process, config) if block_given?
-          extension(:exec_success, { :config => config, :results => results }) 
+        if results
+          success = true
+          results.each do |result|
+            success = false if result.status != code.success  
+          end
+          if success
+            yield(:process, config) if block_given?
+            extension(:exec_success, { :config => config, :results => results }) 
+          end
+        else
+          default_error.append_errors("No execution results")
         end
+      else
+        default_error.append_errors("Execution prevented by exec hook")
       end
     else
+      default_error.append_errors("No attached machine")
+      
       logger.warn("Node #{plugin_name} does not have an attached machine or is not running so cannot execute commands")
     end
     results 
@@ -638,14 +648,14 @@ class Node < CORL.plugin_class(:base)
     
     admin_command = ''
     if as_admin
-      admin_command = 'sudo' if user.to_s == 'ubuntu'
+      admin_command = 'sudo' if user.to_s != 'root'
       admin_command = extension_set(:admin_command, admin_command, config)
     end
     
     results = exec({ :commands => [ "#{admin_command} #{command.to_s}".strip ] }) do |op, data|
       yield(op, data) if block_given?  
-    end
-    results.first
+    end    
+    results.first 
   end
   
   #---
@@ -737,6 +747,7 @@ class Node < CORL.plugin_class(:base)
     codes :local_path_not_found,
           :home_path_lookup_failure,
           :auth_upload_failure,
+          :root_auth_copy_failure,
           :bootstrap_upload_failure,
           :bootstrap_exec_failure,
           :reload_failure
@@ -748,7 +759,7 @@ class Node < CORL.plugin_class(:base)
         # Transmit authorisation / credential files
         package_files = [ '.fog', '.netrc', '.google-privatekey.p12', '.vimrc' ]
         auth_files.each do |file|
-          package_files = file.gsub(local_path + '/', '')
+          package_files << file.gsub(local_path + '/', '')
         end
         send_success = send_files(local_path, user_home, package_files, '0600') do |op, data|
           yield("send_#{op}".to_sym, data) if block_given?
@@ -757,6 +768,14 @@ class Node < CORL.plugin_class(:base)
         unless send_success
           myself.status = code.auth_upload_failure
         end
+        
+        if user.to_sym != config.get(:root_user, :root).to_sym
+          auth_files     = package_files.collect { |path| "'#{path}'"}
+          root_home_path = config.get(:root_home, '/root')
+          
+          result        = command("cp #{auth_files.join(' ')} #{root_home_path}", { :as_admin => true })
+          myself.status = code.root_auth_copy_failure unless result.status == code.success  
+        end
     
         # Send bootstrap package
         if status == code.success
@@ -809,16 +828,19 @@ class Node < CORL.plugin_class(:base)
     config = Config.ensure(options)
     
     # Record machine parameters
-    id(true)
-    public_ip(true)
-    private_ip(true)
-    state(true)
-    
-    machine_type(false)
-    image(false)
+    if block_given?
+      # Provider or external configuration preparation
+      yield(config)  
+    else
+      # Default configuration preparation
+      id(true)
+      public_ip(true)
+      private_ip(true)
+      state(true)
     
-    # Provider or external configuration preparation
-    yield(config) if block_given?
+      machine_type(false)
+      image(false)
+    end
     
     network.save(config.import({ 
       :commit      => true,
@@ -943,15 +965,19 @@ class Node < CORL.plugin_class(:base)
         
         myself.machine = nil
         
-        delete_setting(:id)
-        delete_setting(:public_ip)
-        delete_setting(:private_ip)
-        delete_setting(:ssh_port)
-        delete_setting(:build)
+        override_settings = false
+        override_settings = yield(:finalize, config) if success && block_given?
         
-        myself[:state] = :stopped
+        if success && ! override_settings
+          delete_setting(:id)
+          delete_setting(:public_ip)
+          delete_setting(:private_ip)
+          delete_setting(:ssh_port)
+          delete_setting(:build)
         
-        success = save(config) if success
+          myself[:state] = :stopped
+        end
+        success = save(config)
         
         if success && block_given?
           process_success = yield(:process, config)
@@ -1005,6 +1031,7 @@ class Node < CORL.plugin_class(:base)
         
         if success
           extension(:destroy_success, { :config => config })
+          clear_cache
         end
       end
     else
@@ -1091,6 +1118,12 @@ class Node < CORL.plugin_class(:base)
     result.status == code.success ? true : false  
   end
   
+  #---
+  
+  def filter_output(type, data)
+    data  
+  end
+   
   #-----------------------------------------------------------------------------
   # Machine type utilities
   

data/lib/core/plugin/provisioner.rb

@@ -4,8 +4,7 @@ module Plugin
 class Provisioner < CORL.plugin_class(:base)
   
   include Celluloid
-  task_class TaskThread
- 
+  
   #-----------------------------------------------------------------------------
   # Provisioner plugin interface
   

data/lib/core/vagrant/Vagrantfile

@@ -0,0 +1,7 @@
+#
+# CORL Vagrant environment (development platform)
+#-------------------------------------------------------------------------------
+#
+Vagrant.configure('2') do |config|
+  CORL.vagrant_config(File.dirname(__FILE__), config)
+end

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

@@ -0,0 +1,66 @@
+
+module VagrantPlugins
+module CORL
+module Command
+class Launcher < ::Vagrant.plugin("2", :command)
+  
+  include Celluloid
+  
+  #-----------------------------------------------------------------------------
+  
+  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 = current_actor   
+    ::CORL.executable(@argv - [ "--" ], "vagrant corl")
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def vm_machine(name, provider = nil, refresh = false)
+    machine = nil
+    
+    # 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|
+      if name == active_name
+        if provider && provider != active_provider
+          raise ::Vagrant::Errors::ActiveMachineWithDifferentProvider,
+            :name               => active_name.to_s,
+            :active_provider    => active_provider.to_s,
+            :requested_provider => provider.to_s
+        else
+          @logger.info("Active machine found with name #{active_name}. " +
+                       "Using provider: #{active_provider}")
+          provider = active_provider
+          break
+        end
+      end
+    end
+
+    provider ||= env.default_provider
+    
+    machine = env.machine(name, provider, refresh)
+    machine.ui.opts[:color] = :default # TODO: Something better??
+    
+    machine
+  end
+end
+end
+end
+end