corl 0.4.1 → 0.4.2

data/lib/CORL/node/rackspace.rb

@@ -1,10 +1,16 @@
 
 module CORL
 module Node
-class Rackspace < Node::Fog
+class Rackspace < Fog
  
   #-----------------------------------------------------------------------------
   # Node plugin interface
+  
+  def normalize(reload)
+    super do
+      :rackspace
+    end
+  end
       
   #-----------------------------------------------------------------------------
   # Checks
@@ -41,21 +47,33 @@ class Rackspace < Node::Fog
     end
   end
   
+  #---
+  
+  def create_config
+    { :name => hostname, :flavor_id => machine_type, :image_id => image }  
+  end
+  
   #-----------------------------------------------------------------------------
   # Node operations
   
   def create(options = {})
     super do |op, config|
       if op == :config
-        config.defaults({
-          :name      => hostname,
-          :flavor_id => machine_type,
-          :image_id  => image
-        })
+        config.defaults(create_config)
       end
     end
   end
- 
+  
+  #---
+  
+  def start(options = {})
+    super do |op, config|
+      if op == :config
+        config.defaults(create_config)
+      end
+    end
+  end
+  
   #-----------------------------------------------------------------------------
   # Utilities
   

data/lib/CORL/provisioner/puppetnode.rb

@@ -6,20 +6,22 @@ class Puppetnode < CORL.plugin_class(:provisioner)
   #-----------------------------------------------------------------------------
   # Provisioner plugin interface
    
-  def normalize
+  def normalize(reload)
     super
     
-    require 'puppet'
+    unless reload
+      require 'puppet'
     
-    if CORL.log_level == :debug
-      Puppet.debug = true
-    end
-    Puppet.initialize_settings
+      if CORL.log_level == :debug
+        Puppet.debug = true
+      end
+      Puppet.initialize_settings
     
-    myself.plugin_name = :default if plugin_name.to_sym == :puppetnode
+      myself.plugin_name = :default if plugin_name.to_sym == :puppetnode
        
-    @env      = Puppet::Node::Environment.new
-    @compiler = Puppet::Parser::Compiler.new(node)
+      @env      = Puppet::Node::Environment.new
+      @compiler = Puppet::Parser::Compiler.new(node)
+    end
     
     init_scope
     register

data/lib/core/errors.rb

@@ -0,0 +1,6 @@
+
+module CORL
+module Errors
+   
+end
+end

data/lib/core/mod/fog_aws_server.rb

@@ -0,0 +1,38 @@
+module Fog
+module Compute
+class AWS
+class Server
+  
+  def setup(credentials = {})
+    requires :ssh_ip_address, :username
+    
+    commands = [
+      %{mkdir .ssh},
+      %{passwd -l #{username}},
+      %{echo "#{Fog::JSON.encode(Fog::JSON.sanitize(attributes))}" >> ~/attributes.json}
+    ]
+    if public_key
+      commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
+    end
+
+    tries      = 5
+    sleep_secs = 5
+    
+    begin      
+      Nucleon::Util::SSH.session(ssh_ip_address, username, ssh_port, private_key_path, true)
+      results = Nucleon::Util::SSH.exec(ssh_ip_address, username, commands)
+            
+    rescue Exception => error
+      if tries > 1
+        sleep(sleep_secs)        
+        tries -= 1
+        retry
+      else
+        raise error
+      end
+    end
+  end
+end
+end
+end
+end

data/lib/core/plugin/action.rb

@@ -26,6 +26,7 @@ class CloudAction < CORL.plugin_class(:action)
     node_plugins = CORL.loaded_plugins(:node)
     
     register :parallel, :bool, true, 'corl.core.action.options.parallel'
+    register :net_remote, :str, :edit, 'corl.core.action.options.net_remote'
     register :net_provider, :str, :default, 'corl.core.action.options.net_provider' do |value|
       value           = value.to_sym
       network_plugins = CORL.loaded_plugins(:network)
@@ -62,7 +63,7 @@ class CloudAction < CORL.plugin_class(:action)
   #---
          
   def node_ignore
-    [ :parallel, :net_provider, :node_provider, :nodes ]
+    [ :parallel, :net_remote, :net_provider, :node_provider, :nodes ]
   end
   
   #-----------------------------------------------------------------------------
@@ -102,16 +103,7 @@ class CloudAction < CORL.plugin_class(:action)
         exec_config.delete(:node_provider)
               
         result = node.action(plugin_provider, exec_config) do |op, data|
-          ui_group(node.plugin_name) do
-            case op
-            when :config # Modify seed execution configurations
-              render("Starting remote execution of #{plugin_provider} action")  
-            when :process # Process final result
-              render("Successfully finished remote execution of #{plugin_provider} action")     
-            end
-            data = execute_remote(node, network, op, data)
-          end
-          data
+          execute_remote(node, network, op, data)
         end
         result.status == code.success 
       end

data/lib/core/plugin/configuration.rb

@@ -8,11 +8,11 @@ class Configuration < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   # Configuration plugin interface
   
-  def normalize
+  def normalize(reload)
     super
     
     logger.debug("Initializing source sub configuration")
-    init_subconfig(true)
+    init_subconfig(true) unless reload
     
     _init(:autoload, true)
     _init(:autosave, false)
@@ -172,6 +172,24 @@ class Configuration < CORL.plugin_class(:base)
     end
     new_location
   end
+  
+  #---
+  
+  def delete_attachments(type, ids, options = {})
+    method_config = Config.ensure(options)
+    locations     = []
+    
+    if can_persist?
+      if extension_check(:remove_attachments, { :config => method_config })
+        logger.info("Removing attached data from source configuration")
+      
+        locations = yield(method_config) if block_given?
+      end
+    else
+      logger.warn("Can not remove attached data from source configuration")
+    end
+    locations  
+  end
 end
 end
 end

data/lib/{CORL/machine/fog.rb → core/plugin/fog_machine.rb}

@@ -1,4 +1,8 @@
 
+nucleon_require(File.dirname(__FILE__), :machine)
+
+#---
+
 module CORL
 module Machine
 class Fog < CORL.plugin_class(:machine)
@@ -25,8 +29,8 @@ class Fog < CORL.plugin_class(:machine)
     
     ENV['DEBUG'] = 'true' if CORL.log_level == :debug
     
-    require 'fog' 
-        
+    require 'fog'
+            
     myself.compute = ::Fog::Compute.new(export)
   end
   protected :set_connection
@@ -45,28 +49,14 @@ class Fog < CORL.plugin_class(:machine)
   #---
   
   def server=id
+    @server = nil
+    
     if id.is_a?(String)
-      @server = compute.servers.get(id)
-    else
+      @server = compute.servers.get(id) unless id.empty?
+    elsif ! id.nil?
       @server = id
-    end
-    
-    unless @server.nil?
-      myself.name = @server.id
-      
-      node[:id]         = plugin_name
-      node[:hostname]   = @server.name
-      node[:public_ip]  = @server.public_ip_address
-      node[:private_ip] = @server.private_ip_address
-    
-      node.machine_type = @server.flavor.id
-      node.image        = @server.image.id      
-    
-      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    
+    init_server
   end
   
   def server
@@ -81,14 +71,7 @@ class Fog < CORL.plugin_class(:machine)
     return translate_state(server.state) if server
     nil
   end
-  
-  #---
-  
-  def hostname
-    return server.name if server
-    nil
-  end
-  
+   
   #---
   
   def public_ip
@@ -134,18 +117,30 @@ class Fog < CORL.plugin_class(:machine)
   #-----------------------------------------------------------------------------
   # Management
   
+  def init_server
+    unless @server.nil?
+      yield # Implement in fog machine providers
+    end  
+  end
+  protected :init_server
+  
+  #---
+  
   def load
     super do
-      myself.server = plugin_name if compute && ! plugin_name.empty?
-      server.nil? ? false : true
+      myself.server = plugin_name if compute && plugin_name
+      ! plugin_name && @server.nil? ? false : true
     end    
   end
   
   #---
   
   def create(options = {})
-    super do
-      myself.server = compute.servers.bootstrap(Config.ensure(options).export) if compute
+    super do |config|
+      if compute
+        yield(config) if block_given?
+        myself.server = compute.servers.bootstrap(config.export)
+      end
       myself.server ? true : false
     end
   end
@@ -157,7 +152,7 @@ class Fog < CORL.plugin_class(:machine)
       logger.debug("Executing SCP download to #{local_path} from #{remote_path} on machine #{name}") 
       
       begin
-        if init_ssh_session
+        if init_ssh_session(server)
           Util::SSH.download(node.public_ip, node.user, remote_path, local_path, config.export) do |name, received, total|
             yield(name, received, total) if block_given?
           end
@@ -176,10 +171,10 @@ class Fog < CORL.plugin_class(:machine)
   
   def upload(local_path, remote_path, options = {})
     super do |config, success|
-      logger.debug("Executing SCP upload from #{local_path} to #{remote_path} on machine #{name}") 
+      logger.debug("Executing SCP upload from #{local_path} to #{remote_path} on machine #{plugin_name}") 
       
       begin
-        if init_ssh_session
+        if init_ssh_session(server)
           Util::SSH.upload(node.public_ip, node.user, local_path, remote_path, config.export) do |name, sent, total|
             yield(name, sent, total) if block_given?
           end
@@ -199,9 +194,9 @@ class Fog < CORL.plugin_class(:machine)
   def exec(commands, options = {})
     super do |config, results|
       if commands
-        logger.debug("Executing SSH commands ( #{commands.inspect} ) on machine #{name}")
+        logger.debug("Executing SSH commands ( #{commands.inspect} ) on machine #{plugin_name}")
         
-        if init_ssh_session
+        if init_ssh_session(server)
           results = Util::SSH.exec(node.public_ip, node.user, commands) do |type, command, data|
             yield(type, command, data) if block_given?  
           end
@@ -215,72 +210,51 @@ class Fog < CORL.plugin_class(:machine)
   
   #---
   
-  def start(options = {})
-    super do
-      if compute
-        server_info = compute.servers.create(options)
-      
-        logger.info("Waiting for #{plugin_provider} machine to start")
-        ::Fog.wait_for do
-          compute.servers.get(server_info.id).ready? ? true : false
-        end
-      
-        logger.debug("Setting machine #{server_info.id}")
-            
-        myself.server = compute.servers.get(server_info.id)
-        myself.server ? true : false
-      else
-        false
-      end      
+  def terminal(user, options = {})
+    super do |config|
+      Util::SSH.terminal(node.public_ip, user, config.export)
     end
   end
   
   #---
   
   def reload(options = {})
-    super do
+    super do |config|
+      success = false
       if server
-        logger.debug("Rebooting machine #{name}")
-        server.reboot(options)
-      else
-        false
-      end  
+        success = block_given? ? yield(config) : true            
+        success = init_ssh_session(server, true, config.get(:tries, 5), config.get(:sleep_time, 5)) if success
+      end
+      success
     end
   end
 
   #---
  
-  def create_image(name, options = {})
-    super do
+  def create_image(options = {})
+    super do |config|
+      success = false
       if server
-        logger.debug("Imaging machine #{self.name}")
-        image = server.create_image(name, options)
-      
-        if image
-          node.image = image.id
-          true
-        else
-          false
-        end
-      else
-        false
+        logger.debug("Imaging machine #{plugin_name}")
+        
+        image_name = sprintf("%s (%s)", node.plugin_name, Time.now.to_s)
+        success    = yield(image_name, config, success) if block_given? # Implement in sub classes
+        success    = init_ssh_session(server, true, config.get(:tries, 5), config.get(:sleep_time, 5)) if success
       end
+      success
     end
   end
   
   #---
   
   def stop(options = {})
-    super do
+    super do |config|
       success = true
-      if image_id = create_image(name)      
-        logger.info("Waiting for #{plugin_provider} machine to finish creating image: #{image_id}")
-        ::Fog.wait_for do
-          compute.images.get(image_id).ready? ? true : false
-        end
-              
-        logger.debug("Detroying machine #{name}")
-        success = server.destroy        
+      if server && create_image(config)      
+        logger.debug("Stopping machine #{plugin_name}")
+        success = destroy(config.import({ :stop => true }))
+      else
+        success = false            
       end
       success
     end
@@ -289,21 +263,47 @@ class Fog < CORL.plugin_class(:machine)
   #---
 
   def destroy(options = {})
-    super do
+    super do |config|
+      success = false
       if server
-        logger.debug("Destroying machine #{name}")
-        server.destroy(options)
-      else
-        false  
-      end  
+        logger.debug("Destroying machine #{plugin_name}")
+        success = server.destroy
+        success = yield(config) if success && block_given?
+      end
+      close_ssh_session if success
+      success
     end
   end
   
   #-----------------------------------------------------------------------------
   # Utilities
   
-  def init_ssh_session
-    Util::SSH.session(node.public_ip, node.user, node.ssh_port, node.private_key)
+  def init_ssh_session(server, reset = false, tries = 5, sleep_secs = 5)
+    server.wait_for { ready? }
+    
+    success = true
+        
+    begin
+      Util::SSH.session(node.public_ip, node.user, node.ssh_port, node.private_key, reset)
+            
+    rescue Exception => error
+      if tries > 1
+        sleep(sleep_secs)
+        
+        tries -= 1
+        reset  = true
+        retry
+      else
+        success = false
+      end
+    end
+    success
+  end
+  
+  #---
+  
+  def close_ssh_session
+    Util::SSH.close_session(node.public_ip, node.user)
   end
 end
 end

data/lib/core/plugin/{fog.rb → fog_node.rb}

@@ -10,12 +10,17 @@ class Fog < CORL.plugin_class(:node)
   #-----------------------------------------------------------------------------
   # Node plugin interface
    
-  def normalize
-    super
-    myself.region = region
-    
-    yield if block_given?    
-    myself.machine = create_machine(:machine, :fog, machine_config)
+  def normalize(reload)
+    super do
+      myself.region  = region 
+      
+      unless reload
+        machine_provider = :fog
+        machine_provider = yield if block_given?
+                        
+        myself.machine = create_machine(:machine, machine_provider, machine_config)
+      end
+    end
   end
        
   #-----------------------------------------------------------------------------
@@ -94,6 +99,12 @@ class Fog < CORL.plugin_class(:node)
   
   #---
   
+  def key_config
+    { :private_key_path => private_key, :public_key_path  => public_key }
+  end
+  
+  #---
+  
   def exec_options(name, options = {})
     extended_config(name, options).export
   end
@@ -105,8 +116,9 @@ class Fog < CORL.plugin_class(:node)
     super do |op, config|
       if op == :config
         config.import(exec_options(:create))
+        config.defaults(key_config)
       end
-      yield(op, config) if block_given?
+      yield(op, config) if block_given?      
     end
   end
   
@@ -149,6 +161,7 @@ class Fog < CORL.plugin_class(:node)
     super do |op, config|
       if op == :config
         config.import(exec_options(:start))
+        config.defaults(key_config)
       end
       yield(op, config) if block_given?
     end