corl 0.4.1 → 0.4.2

data/lib/core/plugin/node.rb

@@ -8,27 +8,38 @@ class Node < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   # Node plugin interface
    
-  def normalize
+  def normalize(reload)
     super
     
+    export.each do |name, value|
+      myself[name] = value
+    end
+    
+    yield if block_given? # Chance to create a machine to feed hostname
+    
     ui.resource = hostname
     logger      = hostname
     
-    @cli_interface = Util::Liquid.new do |method, args, &code|
-      result = exec({ :commands => [ [ method, args ].flatten.join(' ') ] }) do |op, data|
-        code.call(op, data) if code
+    myself[:groups] = [ "all", plugin_provider.to_s, plugin_name.to_s ] | groups 
+    
+    unless reload
+      @cli_interface = Util::Liquid.new do |method, args, &code|
+        result = exec({ :commands => [ [ method, args ].flatten.join(' ') ] }) do |op, data|
+          code.call(op, data) if code
+        end
+        if result
+          result = result.first
+          alert(result.errors) unless result.errors.empty?
+        end
+        result
       end
-      result = result.first
-      
-      alert(result.errors) unless result.errors.empty?
-      result
-    end
     
-    @action_interface = Util::Liquid.new do |method, args, &code|
-      action(method, *args) do |op, data|
-        code.call(op, data) if code
+      @action_interface = Util::Liquid.new do |method, args, &code|
+        action(method, *args) do |op, data|
+          code.call(op, data) if code
+        end
       end
-    end    
+    end
   end
   
   #---
@@ -103,7 +114,7 @@ class Node < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   
   def groups
-    array(self[:groups])
+    array(myself[:groups])
   end
   
   #-----------------------------------------------------------------------------
@@ -129,33 +140,38 @@ class Node < CORL.plugin_class(:base)
   #---
   
   def id(reset = false)
-    myself[:id] = machine.plugin_name if reset || myself[:id].nil?
+    myself[:id] = machine.plugin_name if machine && ( reset || myself[:id].nil? )
     myself[:id]
   end
- 
+  
   #---
   
   def public_ip(reset = false)
-    myself[:public_ip] = machine.public_ip if reset || myself[:public_ip].nil?
+    myself[:public_ip] = machine.public_ip if machine && ( reset || myself[:public_ip].nil? )
     myself[:public_ip]
   end
   
   def private_ip(reset = false)
-    myself[:private_ip] = machine.private_ip if reset || myself[:private_ip].nil?
+    myself[:private_ip] = machine.private_ip if machine && ( reset || myself[:private_ip].nil? )
     myself[:private_ip]
   end
   
   #---
   
-  def hostname(reset = false)
-    myself[:hostname] = machine.hostname if reset || myself[:hostname].nil?
-    myself[:hostname]
+  def hostname
+    hostname = myself[:hostname]
+    
+    if hostname.to_s != ui.resource.to_s 
+      ui.resource = hostname
+      logger      = hostname
+    end
+    hostname
   end
   
   #---
   
   def state(reset = false)
-    myself[:state] = machine.state if reset || myself[:state].nil?
+    myself[:state] = machine.state if machine && ( reset || myself[:state].nil? )
     myself[:state]
   end
   
@@ -173,6 +189,7 @@ class Node < CORL.plugin_class(:base)
   
   def ssh_port=ssh_port
     myself[:ssh_port] = ssh_port
+    machine.init_ssh(ssh_port) if machine
   end
   
   def ssh_port
@@ -191,6 +208,13 @@ class Node < CORL.plugin_class(:base)
   
   #---
   
+  def ssh_path(home_env_var = 'HOME', reset = false)
+    home = home(home_env_var, reset)
+    home ? File.join(home, '.ssh') : nil
+  end
+  
+  #---
+  
   def private_key=private_key
     myself[:private_key] = private_key
   end
@@ -208,7 +232,7 @@ class Node < CORL.plugin_class(:base)
   end
   
   def public_key
-    config_key = myself[:private_key]
+    config_key = myself[:public_key]
     return File.expand_path(config_key) if config_key
   end
   
@@ -217,20 +241,16 @@ class Node < CORL.plugin_class(:base)
   def machine_types # Must be set at machine level (queried)
     machine.machine_types if machine
   end
-    
-  def machine_type=machine_type
-    myself[:machine_type] = machine_type
-  end
   
   def machine_type(reset = false)
-    myself[:machine_type] = machine.machine_type if reset || myself[:machine_type].nil?
-    machine_type        = myself[:machine_type]
+    myself[:machine_type] = machine.machine_type if machine && ( reset || myself[:machine_type].nil? )
+    machine_type          = myself[:machine_type]
     
     if machine_type.nil? && machine
       if types = machine_types
         unless types.empty?
-          machine_type      = machine_type_id(types.first)
-          myself.machine_type = machine_type
+          machine_type          = machine_type_id(types.first)
+          myself[:machine_type] = machine_type
         end
       end
     end
@@ -284,7 +304,7 @@ class Node < CORL.plugin_class(:base)
   end
   
   def image(reset = false)
-    myself[:image] = machine.image if reset || myself[:image].nil?
+    myself[:image] = machine.image if machine && ( reset || myself[:image].nil? )
     myself[:image]
   end
   
@@ -303,6 +323,71 @@ class Node < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   # Machine operations
   
+  def attach_keys(keypair)
+    base_name   = "#{plugin_provider}-#{plugin_name}"
+    save_config = { 
+      :pull    => false, 
+      :push    => false,
+      :message => "Updating SSH keys for node #{plugin_provider} (#{plugin_name})" 
+    }
+    
+    active  = machine && machine.running?
+    result  = run.authorize({ :public_key => keypair.ssh_key }) if active
+    success = false
+    
+    if ! active || result.status == code.success        
+      private_key = network.attach_data(:keys, "#{base_name}-id_#{keypair.type}", keypair.encrypted_key)
+      public_key  = network.attach_data(:keys, "#{base_name}-id_#{keypair.type}.pub", keypair.ssh_key)
+    
+      if private_key && public_key
+        FileUtils.chmod(0600, private_key)
+        FileUtils.chmod(0644, public_key)
+      
+        save_config[:files] = [ private_key, public_key ]
+    
+        myself.private_key = private_key
+        myself.public_key  = public_key
+    
+        success = save(extended_config(:key_save, save_config))
+      end
+    end
+    success
+  end
+  
+  #---
+  
+  def delete_keys
+    private_key = myself[:private_key]
+    public_key  = myself[:public_key]
+    
+    keys = []
+    keys << private_key if private_key
+    keys << public_key if public_key
+    
+    success = true
+    
+    unless keys.empty?
+      files = network.delete_attachments(keys)
+      
+      if files && ! files.empty?
+        delete_setting(:private_key)
+        delete_setting(:public_key)
+        
+        success = save(extended_config(:key_delete, {
+          :files   => [ private_key, public_key ], 
+          :pull    => false, 
+          :push    => false,
+          :message => "Removing SSH keys for node #{plugin_provider} (#{plugin_name})"  
+        }))
+      else
+        success = false
+      end
+    end
+    success
+  end
+  
+  #---
+  
   def create_machine(name, provider, options = {})
     CORL.create_plugin(:machine, provider, extended_config(name, options).import({ :meta => { :parent => myself }}))
   end
@@ -447,6 +532,8 @@ class Node < CORL.plugin_class(:base)
   
   #---
   
+  execute_block_on_receiver :exec
+  
   def exec(options = {})
     results = nil
     
@@ -458,26 +545,33 @@ class Node < CORL.plugin_class(:base)
               
         yield(:config, config) if block_given?
         
-        active_machine = local? ? local_machine : machine
+        if local? && local_machine
+          active_machine = local_machine
+          
+          config[:info_prefix]  = "[#{hostname}] "
+          config[:error_prefix] = "[#{hostname}] "
+        else
+          active_machine = machine
+        end
         
         if commands = config.get(:commands, nil)
-          render("Starting command execution: #{commands.join('; ')}")
           results = active_machine.exec(commands, config.export) do |type, command, data|
-            if type == :error
-              alert(data)
-            else
-              render(data)
+            unless local?
+              if type == :error
+                alert(data.gsub(/^\[[^\]]+\]\s*/, ''))
+              else
+                render(data.gsub(/^\[[^\]]+\]\s*/, ''))
+              end
             end
-            yield(:progress, { :type => type, :command => command, :data => data })    
+            yield(:progress, { :type => type, :command => command, :data => data }) if block_given?   
           end
         end
         
         success  = true
         results.each do |result|
-          success = false if result.status != CORL.code.success  
+          success = false if result.status != code.success  
         end
         if success
-          render("Successfully finished execution")
           yield(:process, config) if block_given?
           extension(:exec_success, { :config => config, :results => results }) 
         end
@@ -496,11 +590,23 @@ class Node < CORL.plugin_class(:base)
   
   #---
   
+  execute_block_on_receiver :command
+  
   def command(command, options = {})
+    config   = Config.ensure(options)
+    as_admin = config.delete(:as_admin, false)
+    
     unless command.is_a?(CORL::Plugin::Command)
-      command = CORL.command(Config.new({ :command => command }).import(options), :bash)
+      command = CORL.command(Config.new({ :command => command }).import(config), :bash)
     end
-    results = exec({ :commands => [ command.to_s ] }) do |op, data|
+    
+    admin_command = ''
+    if as_admin
+      admin_command = 'sudo' if user.to_s == 'ubuntu'
+      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
@@ -508,19 +614,34 @@ class Node < CORL.plugin_class(:base)
   
   #---
   
+  execute_block_on_receiver :action
+  
   def action(provider, options = {})
-    config         = Config.ensure(options).defaults({ :net_provider => network.plugin_provider })
-    encoded_config = Util::CLI.encode(config.export)
+    codes :network_load_error
+    
+    config = Config.ensure(options).defaults({
+      :log_level    => Nucleon.log_level,
+      :net_remote   => :edit, 
+      :net_provider => network.plugin_provider 
+    })
     
     logger.info("Executing remote action #{provider} with encoded arguments: #{config.export.inspect}")
     
-    action_config = extended_config(:action, {
+    encoded_config = Util::CLI.encode(Util::Data.clean(config.export))
+    action_config  = extended_config(:action, {
       :command => provider, 
       :data    => { :encoded => encoded_config }
     })
-    command(:corl, { :subcommand => action_config }) do |op, data|
+    
+    result = command(:corl, { :subcommand => action_config, :as_admin => true }) do |op, data|
       yield(op, data) if block_given?  
-    end  
+    end
+    
+    # Update local network configuration so we capture any updates
+    if result.status == code.success && ! network.load({ :remote => config[:net_remote], :pull => true })
+      result.status = code.network_load_error
+    end
+    result
   end
   
   #---
@@ -529,6 +650,40 @@ class Node < CORL.plugin_class(:base)
     @action_interface
   end
   
+  #---
+  
+  def terminal(options = {})
+    myself.status = code.unknown_status
+    
+    if machine && machine.running?
+      config = Config.ensure(options)
+      
+      if extension_check(:terminal, { :config => config })
+        logger.info("Launching terminal for node: #{plugin_name}")
+        
+        if local? && local_machine
+          active_machine = local_machine
+          
+          config[:info_prefix]  = "[#{hostname}] "
+          config[:error_prefix] = "[#{hostname}] "
+        else
+          active_machine = machine
+        end
+        
+        config[:private_keys] = private_key
+        
+        myself.status = active_machine.terminal(user, config.export)
+        
+        if status == code.success
+          extension(:exec_success, { :config => config }) 
+        end
+      end
+    else
+      logger.warn("Node #{plugin_name} does not have an attached machine or is not running so cannot launch terminal")
+    end
+    status == code.success
+  end
+  
   #---
    
   def bootstrap(local_path, options = {})
@@ -547,14 +702,15 @@ class Node < CORL.plugin_class(:base)
           :home_path_lookup_failure,
           :auth_upload_failure,
           :bootstrap_upload_failure,
-          :bootstrap_exec_failure
+          :bootstrap_exec_failure,
+          :reload_failure
     
     if File.directory?(local_path)      
       if user_home || user_home = home(config.get(:home_env_var, 'HOME'), config.get(:force, false))
         myself.status = code.success
         
         # Transmit authorisation / credential files
-        package_files = [ '.fog', '.netrc', '.google-privatekey.p12' ]
+        package_files = [ '.fog', '.netrc', '.google-privatekey.p12', '.vimrc' ]
         auth_files.each do |file|
           package_files = file.gsub(local_path + '/', '')
         end
@@ -581,16 +737,24 @@ class Node < CORL.plugin_class(:base)
           
           # Execute bootstrap process
           if status == code.success
-            remote_script = File.join(remote_bootstrap_path, bootstrap_init) 
+            remote_script = File.join(remote_bootstrap_path, bootstrap_init)
+            
+            myself[:bootstrap] = remote_script
             
-            result = command(remote_script) do |op, data|
+            result = command("HOSTNAME='#{hostname}' #{remote_script}", { :as_admin => true }) do |op, data|
               yield("exec_#{op}".to_sym, data) if block_given?
               data
             end
             
-            if result.status != code.success
+            if result.status == code.success
+              # Reboot the machine
+              unless reload
+                warn('corl.core.node.bootstrap.reload')
+                myself.status = code.reload_failure 
+              end
+            else
               warn('corl.core.node.bootstrap.status', { :script => remote_script, :status => result.status })
-              myself.status = code.bootstrap_exec_failure  
+              myself.status = code.bootstrap_exec_failure
             end
           end
         end
@@ -612,10 +776,10 @@ class Node < CORL.plugin_class(:base)
     id(true)
     public_ip(true)
     private_ip(true)
-    hostname(true)
     state(true)
-    machine_type(true)
-    image(true)
+    
+    machine_type(false)
+    image(false)
     
     # Provider or external configuration preparation
     yield(config) if block_given?
@@ -641,6 +805,17 @@ class Node < CORL.plugin_class(:base)
       
         yield(:config, config) if block_given?      
         success = machine.start(config.export)
+        success = save(config) if success
+        
+        if success
+          if bootstrap_script = myself[:bootstrap]
+            result = command("HOSTNAME='#{hostname}' #{bootstrap_script}", { :as_admin => true }) do |op, data|
+              yield("bootstrap_#{op}".to_sym, data) if block_given?
+              data
+            end
+            success = false unless result.status == code.success && reload
+          end
+        end
         
         if success && block_given?
           process_success = yield(:process, config)
@@ -699,6 +874,7 @@ class Node < CORL.plugin_class(:base)
       
         yield(:config, config) if block_given?      
         success = machine.create_image(config.export)
+        success = save(config) if success
         
         if success && block_given?
           process_success = yield(:process, config)
@@ -729,6 +905,17 @@ class Node < CORL.plugin_class(:base)
         yield(:config, config) if block_given?      
         success = machine.stop(config.export)
         
+        myself.machine = nil
+        
+        delete_setting(:id)
+        delete_setting(:public_ip)
+        delete_setting(:private_ip)
+        delete_setting(:ssh_port)
+        
+        myself[:state] = :stopped
+        
+        success = save(config) if success
+        
         if success && block_given?
           process_success = yield(:process, config)
           success         = process_success if process_success == false        
@@ -752,42 +939,39 @@ class Node < CORL.plugin_class(:base)
     if machine && machine.created?
       config = Config.ensure(options)
       
-      run = false
-
-      if config[:force]
-        run = true
-      else
-        choice = nil
-        begin
-          choice = ui.ask("Are you sure you want to permanently destroy (Y|N): #{plugin_name}?")
-          run    = choice.upcase == "Y"
-          
-        rescue Errors::UIExpectsTTY
-          run = false
-        end        
-      end
-
-      if run
-        if extension_check(:destroy, { :config => config })
-          logger.info("Destroying node: #{plugin_name}")
+      if extension_check(:destroy, { :config => config })
+        logger.info("Destroying node: #{plugin_name}")
       
-          yield(:config, config) if block_given?      
-          success = machine.destroy(config.export)
+        yield(:config, config) if block_given?
         
-          if success && block_given?
-            process_success = yield(:process, config)
-            success         = process_success if process_success == false        
-          end
+        # Shut down machine      
+        success = machine.destroy(config.export)
         
-          if success
-            extension(:destroy_success, { :config => config })
-          end
+        myself.machine = nil
+        
+        # Remove SSH keys
+        if success && delete_keys
+          # Remove node information
+          network.delete_node(plugin_provider, plugin_name, false)
+          
+          network.save({
+            :commit => true, 
+            :remote => config.get(:remote, :edit), 
+            :push   => true 
+          })
+        end      
+        
+        if success && block_given?
+          process_success = yield(:process, config)
+          success         = process_success if process_success == false        
+        end
+        
+        if success
+          extension(:destroy_success, { :config => config })
         end
-      else
-        logger.warn("Node #{plugin_name} does not have an attached machine or is not created so cannot be destroyed")
       end
     else
-      logger.info("Node #{plugin_name} not destroyed due to user cancellation")  
+      logger.warn("Node #{plugin_name} does not have an attached machine or is not created so cannot be destroyed")
     end
     success    
   end

data/lib/core/plugin/provisioner.rb

@@ -6,7 +6,7 @@ class Provisioner < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   # Provisioner plugin interface
   
-  def normalize
+  def normalize(reload)
     super
   end
   

data/lib/corl.rb

@@ -32,9 +32,6 @@ require 'rubygems'
 require 'nucleon_base'
 CORL = Nucleon
 
-require 'tmpdir'
-require 'sshkey'
-
 require 'hiera'
 require 'facter'
 
@@ -47,13 +44,6 @@ I18n.load_path << File.expand_path(File.join('..', 'locales', 'en.yml'), lib_dir
 
 #---
 
-# Object modifications (100% pure monkey patches)
-Dir.glob(File.join(mod_dir, '*.rb')).each do |file|
-  require file
-end
-
-#---
-
 # Mixins for classes
 Dir.glob(File.join(mixin_dir, '*.rb')).each do |file|
   require file
@@ -65,10 +55,12 @@ end
 #---
 
 # Include CORL utilities
-[ :ssh 
-].each do |name| 
-  nucleon_require(util_dir, name)
-end
+#[].each do |name| 
+#  nucleon_require(util_dir, name)
+#end
+
+# Special errors
+nucleon_require(core_dir, :errors)
 
 # Include facade
 nucleon_require(core_dir, :facade)

data/locales/en.yml

@@ -90,7 +90,20 @@ en:
           hostnames: |-
             Hostnames of machines to create on provider infrastructure
         start: |-
-          Spawning new machines on %{provider}
+          Spawning new machines on %{node_provider}
+      ssh:
+        options:
+        errors:
+          ssh_nodes_empty: |-
+            Nodes must be specified in order to launch a SSH terminal
+          ssh_nodes: |-
+            Provider %{node_provider} node %{name} is not a valid node to launch terminal (%{value} given)
+        start: |-
+          Launching terminal for machine %{hostname} (%{id})
+        success: |-
+          Machine %{hostname} (%{id}) successfully ended terminal session
+        failure: |-
+          Machine %{hostname} (%{id}) terminal session failed with status %{status}
       bootstrap:
         options:
           bootstrap_path: |-
@@ -112,6 +125,8 @@ en:
             Bootstrap path must be an existing directory
           auth_files: |-
             Authorization file %{value} does not exist on the local system
+          bootstrap_nodes_empty: |-
+            Nodes must be specified in order to run the bootstrap action
           bootstrap_nodes: |-
             Provider %{node_provider} node %{name} is not a valid node to bootstrap (%{value} given)
         start: |-
@@ -133,6 +148,8 @@ en:
         errors:
           project_reference: |-
             Project reference %{value} failed to parse or provider %{provider} isn't loaded >> Possible providers: %{choices}
+        start: |-
+          Now seeding CORL node
       provision:
         options:
           provider: |-