corl 0.4.1 → 0.4.2

data/lib/core/plugin/machine.rb

@@ -6,8 +6,8 @@ class Machine < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   # Machine plugin interface
   
-  def normalize
-    myself.plugin_name = nil if plugin_name.to_s == plugin_provider.to_s      
+  def normalize(reload)
+    myself.plugin_name = node[:id]
   end
        
   #-----------------------------------------------------------------------------
@@ -83,15 +83,21 @@ class Machine < CORL.plugin_class(:base)
   end
             
   #-----------------------------------------------------------------------------
-  # Management 
+  # Management
+  
+  def init_ssh(ssh_port)
+    # Implement in sub classes if needed
+  end
+  
+  #--- 
 
   def load
     success = true
     
-    logger.debug("Loading #{plugin_provider} machine: #{name}")
+    logger.debug("Loading #{plugin_provider} machine: #{plugin_name}")
     success = yield if block_given?  
         
-    logger.warn("There was an error loading the machine #{name}") unless success
+    logger.warn("There was an error loading the machine #{plugin_name}") unless success
     success
   end
   
@@ -101,14 +107,14 @@ class Machine < CORL.plugin_class(:base)
     success = true
     
     if created?
-      logger.debug("Machine #{name} already exists")
+      logger.debug("Machine #{plugin_name} already exists")
     else
       logger.debug("Creating #{plugin_provider} machine with: #{options.inspect}")
       config  = Config.ensure(options)
       success = yield(config) if block_given?  
     end
     
-    logger.warn("There was an error creating the machine #{name}") unless success
+    logger.warn("There was an error creating the machine #{plugin_name}") unless success
     success
   end
   
@@ -122,10 +128,10 @@ class Machine < CORL.plugin_class(:base)
       config  = Config.ensure(options)      
       success = yield(config, success) if block_given?
     else
-      logger.debug("Machine #{name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")  
     end
     
-    logger.warn("There was an error downloading from the machine #{name}") unless success
+    logger.warn("There was an error downloading from the machine #{plugin_name}") unless success
     success
   end
   
@@ -139,10 +145,10 @@ class Machine < CORL.plugin_class(:base)
       config  = Config.ensure(options)      
       success = yield(config, success) if block_given?
     else
-      logger.debug("Machine #{name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")  
     end
     
-    logger.warn("There was an error uploading to the machine #{name}") unless success
+    logger.warn("There was an error uploading to the machine #{plugin_name}") unless success
     success
   end
   
@@ -156,34 +162,27 @@ class Machine < CORL.plugin_class(:base)
       config  = Config.ensure(options)      
       results = yield(config, results) if block_given?
     else
-      logger.debug("Machine #{name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")  
     end
     
-    logger.warn("There was an error executing command on the machine #{name}") unless results
+    logger.warn("There was an error executing command on the machine #{plugin_name}") unless results
     results
   end
   
   #---
   
-  def start(options = {})
-    success = true
+  def terminal(user, options = {})
+    status = code.unknown_status
     
     if running?
-      logger.debug("Machine #{name} is already running")  
+      logger.debug("Launching #{user} terminal on #{plugin_provider} machine with: #{options.inspect}")
+      config = Config.ensure(options)      
+      status = yield(config) if block_given?
     else
-      logger.debug("Starting #{plugin_provider} machine with: #{options.inspect}")
-      
-      if created?
-        config  = Config.ensure(options)
-        success = yield(config) if block_given?    
-      else
-        logger.debug("Machine #{name} does not yet exist")
-        success = create(options)
-      end      
-    end
-    
-    logger.warn("There was an error starting the machine #{name}") unless success
-    success
+      logger.debug("Machine #{plugin_name} is not running")  
+    end    
+    logger.warn("There was an error launching a #{user} terminal on the machine #{plugin_name}") unless status == code.success
+    status
   end
   
   #---
@@ -196,10 +195,10 @@ class Machine < CORL.plugin_class(:base)
       config  = Config.ensure(options)
       success = yield(config) if block_given?
     else
-      logger.debug("Machine #{name} does not yet exist")
+      logger.debug("Machine #{plugin_name} does not yet exist")
     end
     
-    logger.warn("There was an error reloading the machine #{name}") unless success
+    logger.warn("There was an error reloading the machine #{plugin_name}") unless success
     success
   end
 
@@ -213,10 +212,10 @@ class Machine < CORL.plugin_class(:base)
       config  = Config.ensure(options)      
       success = yield(config) if block_given?
     else
-      logger.debug("Machine #{name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")  
     end
     
-    logger.warn("There was an error creating an image of the machine #{name}") unless success
+    logger.warn("There was an error creating an image of the machine #{plugin_name}") unless success
     success
   end
 
@@ -230,10 +229,32 @@ class Machine < CORL.plugin_class(:base)
       config  = Config.ensure(options)      
       success = yield(config) if block_given?
     else
-      logger.debug("Machine #{name} is not running")  
+      logger.debug("Machine #{plugin_name} is not running")  
+    end
+    
+    logger.warn("There was an error stopping the machine #{plugin_name}") unless success
+    success
+  end
+  
+  #---
+  
+  def start(options = {})
+    success = true
+    
+    if running?
+      logger.debug("Machine #{plugin_name} is already running")  
+    else
+      logger.debug("Starting #{plugin_provider} machine with: #{options.inspect}")
+      
+      if created?
+        logger.debug("Machine #{plugin_name} has already been created") 
+      else
+        logger.debug("Machine #{plugin_name} does not yet exist")
+        success = create(options)
+      end      
     end
     
-    logger.warn("There was an error stopping the machine #{name}") unless success
+    logger.warn("There was an error starting the machine #{plugin_name}") unless success
     success
   end
   
@@ -247,10 +268,10 @@ class Machine < CORL.plugin_class(:base)
       config  = Config.ensure(options)
       success = yield(config) if block_given?
     else
-      logger.debug("Machine #{name} does not yet exist")
+      logger.debug("Machine #{plugin_name} does not yet exist")
     end
     
-    logger.warn("There was an error destroying the machine #{name}") unless success
+    logger.warn("There was an error destroying the machine #{plugin_name}") unless success
     success
   end
   

data/lib/core/plugin/network.rb

@@ -8,11 +8,11 @@ class Network < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   # Cloud plugin interface
   
-  def normalize
+  def normalize(reload)
     super
     
     logger.info("Initializing sub configuration from source with: #{myself._export.inspect}")
-    myself.config = CORL.configuration(Config.new(myself._export))
+    myself.config = CORL.configuration(Config.new(myself._export).import({ :autosave => false })) unless reload
   end
   
   #-----------------------------------------------------------------------------
@@ -52,9 +52,9 @@ class Network < CORL.plugin_class(:base)
       search_node(provider, name, :groups, [], :array).each do |group|
         group = group.to_sym
         groups[group] = [] unless groups.has_key?(group)
-        groups[group] << { :provider => provider, :name => node_name }
+        groups[group] << { :provider => provider, :name => name }
       end
-    end    
+    end
     groups
   end
   
@@ -106,23 +106,25 @@ class Network < CORL.plugin_class(:base)
   
   #---
   
-  def node_by_ip(public_ip)
+  def node_by_ip(public_ip, require_new = false)
     each_node_config do |provider, name, info|
-      return node(provider, name) if info[:public_ip] == public_ip  
+      return node(provider, name, require_new) if info[:public_ip] == public_ip  
     end
     nil
   end
   
   #---
   
-  def local_node
-    ip_address = lookup(:ipaddress)
-    local_node = node_by_ip(ip_address)
+  def local_node(require_new = false)
+    ip_address = CORL.ip_address
+    local_node = node_by_ip(ip_address, require_new)
         
     if local_node.nil?
       name       = Util::Data.ensure_value(lookup(:hostname), ip_address)    
       local_node = CORL.node(name, extended_config(:local_node).import({ :meta => { :parent => myself }}), :local) 
     else
+      local_node.network = myself
+      local_node.normalize(true)
       local_node.localize               
     end    
     local_node
@@ -130,12 +132,12 @@ class Network < CORL.plugin_class(:base)
   
   #---
   
-  def nodes_by_reference(references, default_provider = nil)
+  def nodes_by_reference(references, default_provider = nil, require_new = false)
     nodes = []
     
     node_info(references, default_provider).each do |provider, names|
       names.each do |name|
-        nodes << node(provider, name)
+        nodes << node(provider, name, require_new)
       end
     end
     nodes  
@@ -143,8 +145,9 @@ class Network < CORL.plugin_class(:base)
   
   #---
   
-  def test_node(provider)
-    CORL.node(:test, { :meta => { :parent => myself } }, provider)
+  def test_node(provider, options = {})
+    config = Config.ensure(options).import({ :meta => { :parent => myself } })
+    CORL.node(:test, config.export, provider)
   end
   
   #-----------------------------------------------------------------------------
@@ -183,132 +186,94 @@ class Network < CORL.plugin_class(:base)
     attached_data = nil    
     
     if data.is_a?(String)
-      attached_data = config.attach(type, name, file, attach_config)
+      attached_data = config.attach(type, name, data, attach_config)
     end  
     attached_data
   end
   
   #---
   
-  def attach_keys(node, keypair)
-    save_config = { :pull => false, :push => false }    
-    private_key = attach_data(:keys, "#{node.public_ip}-id_#{keypair.type}", keypair.encrypted_key)
-    public_key  = attach_data(:keys, "#{node.public_ip}-id_#{keypair.type}.pub", keypair.ssh_key)
-    
-    if private_key && public_key
-      save_config[:files] = [ private_key, public_key ]
-    
-      node[:private_key] = private_key
-      node[:public_key]  = public_key
-    
-      save_config[:message] = "Updating SSH keys for node #{node.plugin_name} (#{node.public_ip})"    
-      node.save(extended_config(:key_save, save_config))
-    else
-      false
-    end
+  def delete_attachments(ids, options = {})
+    config.delete_attachments(ids, options)    
   end
   
   #---
   
+  execute_block_on_receiver :add_node
+  
   def add_node(provider, name, options = {})
     config = Config.ensure(options)
     
     keypair = config.delete(:keypair, nil)
     return false unless keypair && keypair.is_a?(Util::SSH::Keypair)
         
-    remote_name  = config.delete(:remote, :edit)
-    dbg(config, 'node add configuration')
+    remote_name = config.delete(:remote, :edit)
     
     # Set node data
-    #node        = set_node(provider, name, config)
-    #hook_config = { :node => node, :remote => remote_name, :seed => seed_project, :config => config }
+    node = set_node(provider, name, { 
+      :groups       => array(config.delete(:groups, [])), 
+      :region       => config.delete(:region, nil),
+      :machine_type => config.delete(:machine_type, nil),
+      :image        => config.delete(:image, nil),
+      :user         => config.delete(:user, :root),
+      :hostname     => name
+    })
+    hook_config = { :node => node, :remote => remote_name, :config => config }
     success     = true
     
-    #yield(:preprocess, hook_config) if block_given?
+    yield(:preprocess, hook_config) if block_given?
     
-    #if ! node.local? && attach_keys(node, keypair) && extension_check(:add_node, hook_config)
-    #  # Create new node / machine
-    #  success = node.create do |op, data|
-    #    data = yield("create_#{op}".to_sym, data) if block_given?
-    #    data  
-    #  end
+    if ! node.local? && node.attach_keys(keypair) && extension_check(:add_node, hook_config)
+      # Create new node / machine
+      success = node.create do |op, data|
+        block_given? ? yield("create_#{op}".to_sym, data) : data
+      end
       
-    #  if success       
-    #    # Bootstrap new machine
-    #    success = node.bootstrap(home, extended_config(:bootstrap, config)) do |op, data|
-    #      data = yield("bootstrap_#{op}".to_sym, data) if block_given?
-    #      data
-    #    end  
+      if success && node.save({ :remote => remote_name, :message => "Created machine #{name} on #{provider}" })
+        # Bootstrap new machine
+        success = node.bootstrap(home, extended_config(:bootstrap, config)) do |op, data|
+          block_given? ? yield("bootstrap_#{op}".to_sym, data) : data
+        end  
         
-    #    if success
-    #      save_config = { :commit => true, :remote => remote_name, :push => true }
+        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_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]
-    #        else
-    #          seed_url = seed_project                
-    #        end
-    #        set_remote(:origin, seed_url) if remote_name.to_sym == :edit
-    #        set_remote(remote_name, seed_url)
-    #        save_config[:pull] = false
-    #      end
-        
-    #      # Save network changes (preliminary)
-    #      success = node.save(extended_config(:node_save, save_config))
+            if seed_info
+              seed_url    = seed_info[:url]
+              seed_branch = seed_info[:revision] if seed_info[:revision]
+            else
+              seed_url = seed_project                
+            end
+            set_remote(:origin, seed_url) if remote_name.to_sym == :edit
+            set_remote(remote_name, seed_url)
+            save_config[:pull] = false
+          end
+          
+          # Save network changes (preliminary)
+          success = node.save(extended_config(:node_save, save_config))
         
-    #      if success && seed_project
-    #        # Seed machine with remote project reference
-    #        result = node.seed({
-    #          :net_provider      => plugin_provider,
-    #          :project_reference => seed_project,
-    #          :project_branch    => seed_branch
-    #        }) do |op, data|
-    #          yield("seed_#{op}".to_sym, data)
-    #        end
-    #        success = result.status == code.success
-    #      end
+          if success && seed_project
+            # Seed machine with remote project reference
+            result = node.seed({
+              :project_reference => seed_project,
+              :project_branch    => seed_branch
+            }) do |op, data|
+              yield("seed_#{op}".to_sym, data)
+            end
+            success = result.status == code.success
+          end
         
-    #      if success
-    #        # Update local network project  
-    #      end
-    #    end
-    #  end
-    #end
-    
-    success 
-  end
-  
-  #---
-  
-  def remove_node(provider, name = nil)
-    status = CORL.code.success
-    
-    if name.nil?
-      nodes(provider).each do |node_name, node|
-        sub_status = remove_node(provider, node_name)
-        status     = sub_status unless status == sub_status 
-      end  
-    else
-      node = node(provider, name)
-      
-      unless node.local?  
-        # Stop node
-        status = node.run(:stop)
+          # Update local network project
+          success = load({ :remote => remote_name, :pull => true }) if success
+        end
       end
-      
-      if status == CORL.code.success
-        delete_node(provider, name)
-      else
-        ui.warn("Stopping #{provider} node #{name} failed")
-      end       
-    end  
-        
-    status
+    end    
+    success 
   end
   
   #-----------------------------------------------------------------------------