corl 0.4.1 → 0.4.2

data/lib/CORL/action/ssh.rb

@@ -0,0 +1,74 @@
+
+module CORL
+module Action
+class Ssh < Plugin::CloudAction
+
+  #-----------------------------------------------------------------------------
+  # Settings
+  
+  def configure
+    super do
+      codes :network_failure
+      
+      register :ssh_nodes, :array, nil do |values|
+        if values.nil?
+          warn('corl.actions.bootstrap.errors.ssh_nodes_empty')
+          next false 
+        end
+        
+        node_plugins = CORL.loaded_plugins(:node)
+        success      = true
+        
+        values.each do |value|
+          if info = CORL.plugin_class(:node).translate_reference(value)
+            if ! node_plugins.keys.include?(info[:provider].to_sym) || info[:name].empty?
+              warn('corl.actions.bootstrap.errors.ssh_nodes', { :value => value, :node_provider => info[:provider],  :name => info[:name] })
+              success = false
+            end
+          end
+        end
+        success
+      end
+      
+      config[:node_provider].default = :rackspace
+    end
+  end
+  
+  #---
+  
+  def ignore
+    node_ignore - [ :net_provider, :node_provider ]
+  end
+  
+  def arguments
+    [ :ssh_nodes ]
+  end
+
+  #-----------------------------------------------------------------------------
+  # Operations
+    
+  def execute
+    super do |local_node, network|
+      if network
+        batch_success = network.batch(settings[:ssh_nodes], settings[:node_provider], false) do |node|
+          render_options = { :id => node.id, :hostname => node.hostname }
+          
+          info('corl.actions.ssh.start', render_options)
+          success = node.terminal(extended_config(:ssh, {}))
+          if success
+            info('corl.actions.ssh.success', render_options)
+          else
+            render_options[:status] = node.status
+            error('corl.actions.ssh.failure', render_options)
+          end
+          success
+        end
+        myself.status = code.batch_error unless batch_success
+      else
+        myself.status = code.network_failure
+      end
+    end
+  end
+end
+end
+end

data/lib/CORL/action/start.rb

@@ -9,18 +9,50 @@ class Start < Plugin::CloudAction
   def configure
     super do
       codes :network_failure
+      
+      register :start_nodes, :array, nil do |values|
+        if values.nil?
+          warn('corl.actions.start.errors.start_nodes_empty')
+          next false 
+        end
+        
+        node_plugins = CORL.loaded_plugins(:node)
+        success      = true
+        
+        values.each do |value|
+          if info = CORL.plugin_class(:node).translate_reference(value)
+            if ! node_plugins.keys.include?(info[:provider].to_sym) || info[:name].empty?
+              warn('corl.actions.start.errors.start_nodes', { :value => value, :node_provider => info[:provider],  :name => info[:name] })
+              success = false
+            end
+          end
+        end
+        success
+      end
     end
   end
 
+  #---
+  
+  def ignore
+    [ :nodes ]
+  end
+  
+  def arguments
+    [ :start_nodes ]
+  end
+
   #-----------------------------------------------------------------------------
   # Operations
    
   def execute
-    super do |node, network|
-      info('corl.actions.start.start')
-      
-      if network && node
-        
+    super do |local_node, network|
+      if network
+        batch_success = network.batch(settings[:start_nodes], settings[:node_provider], settings[:parallel]) do |node|
+          info('corl.actions.start.start', { :provider => node.plugin_provider, :name => node.plugin_name })
+          node.start 
+        end
+        myself.status = code.batch_error unless batch_success
       else
         myself.status = code.network_failure
       end

data/lib/CORL/action/stop.rb

@@ -9,18 +9,50 @@ class Stop < Plugin::CloudAction
   def configure
     super do
       codes :network_failure
+            
+      register :stop_nodes, :array, nil do |values|
+        if values.nil?
+          warn('corl.actions.stop.errors.stop_nodes_empty')
+          next false 
+        end
+        
+        node_plugins = CORL.loaded_plugins(:node)
+        success      = true
+        
+        values.each do |value|
+          if info = CORL.plugin_class(:node).translate_reference(value)
+            if ! node_plugins.keys.include?(info[:provider].to_sym) || info[:name].empty?
+              warn('corl.actions.stop.errors.stop_nodes', { :value => value, :node_provider => info[:provider],  :name => info[:name] })
+              success = false
+            end
+          end
+        end
+        success
+      end
     end
   end
 
+  #---
+  
+  def ignore
+    [ :nodes ]
+  end
+  
+  def arguments
+    [ :stop_nodes ]
+  end
+
   #-----------------------------------------------------------------------------
   # Operations
    
   def execute
-    super do |node, network|
-      info('corl.actions.stop.start')
-      
-      if network && node
-        
+    super do |local_node, network|
+      if network
+        batch_success = network.batch(settings[:stop_nodes], settings[:node_provider], settings[:parallel]) do |node|
+          info('corl.actions.stop.start', { :provider => node.plugin_provider, :name => node.plugin_name })
+          node.stop  
+        end
+        myself.status = code.batch_error unless batch_success
       else
         myself.status = code.network_failure
       end

data/lib/CORL/configuration/file.rb

@@ -6,7 +6,7 @@ class File < CORL.plugin_class(:configuration)
   #-----------------------------------------------------------------------------
   # Configuration plugin interface
   
-  def normalize
+  def normalize(reload)
     super
     
     logger.info("Setting source configuration project")
@@ -151,6 +151,7 @@ class File < CORL.plugin_class(:configuration)
             else
               # Never encountered before
               config_name = nil
+              
               config_name = select_largest(router.get(parents)) unless parents.empty?
               split_config.call(value, config_name, keys)  
             end  
@@ -165,12 +166,12 @@ class File < CORL.plugin_class(:configuration)
             file_data.set([ config_name, keys ].flatten, value)  
           else
             # Router is non existent
-            if config_name = select_largest(router)
+            if config_name = select_largest(router.export)
               # Pick largest router from top level
               file_data.set([ config_name, keys ].flatten, value)
             else
               # Resort to sane defaults
-              default_provider = Manager.connection.type_default(:translator)
+              default_provider = CORL.type_default(:translator)
               config_name      = "corl.#{default_provider}"
               file_data.set([ config_name, keys ].flatten, value)
             end      
@@ -180,7 +181,6 @@ class File < CORL.plugin_class(:configuration)
     end
     
     # Whew!  Glad that's over...
-    
     split_config.call(config.export, router.export)
     file_data     
   end
@@ -254,8 +254,8 @@ class File < CORL.plugin_class(:configuration)
       if success
         case method_config.get(:type, :source)
         when :source
-          new_file = project.local_path(Util::Disk.filename([ attach_path, name ])) 
-        
+          new_file = project.local_path(Util::Disk.filename([ attach_path, name ]))
+          
           logger.debug("Attaching source data (length: #{data.length}) to configuration at #{attach_path}")        
           success = Util::Disk.write(new_file, data)
           
@@ -276,7 +276,7 @@ class File < CORL.plugin_class(:configuration)
           end  
         end
       end
-      if success
+      if success && autosave
         logger.debug("Attaching data to project as #{new_file}")
         success = update_project(new_file, method_config)
       end
@@ -284,6 +284,31 @@ class File < CORL.plugin_class(:configuration)
     end
   end
   
+  #---
+  
+  def delete_attachments(ids, options = {})
+    super do |method_config|
+      success = true
+      files   = []
+      
+      array(ids).each do |id|
+        file = ::File.join(project.directory, id.to_s)
+        
+        if Util::Disk.delete(file)
+          files << file
+        else
+          success = false
+        end
+      end
+      
+      if success && autosave
+        logger.debug("Removing attached data from project as #{files.join(', ')}")
+        success = update_project(files, method_config)
+      end
+      success ? files : nil
+    end
+  end
+  
   #-----------------------------------------------------------------------------
   # Utilities
    
@@ -354,6 +379,8 @@ class File < CORL.plugin_class(:configuration)
   #---
   
   def select_largest(router)
+    return router unless router.is_a?(Hash)
+    
     config_map = {}
     
     count_config_names = lambda do |data|

data/lib/CORL/event/puppet.rb

@@ -6,7 +6,7 @@ class Puppet < CORL.plugin_class(:event)
   #-----------------------------------------------------------------------------
   # Puppet event interface
   
-  def normalize
+  def normalize(reload)
     super
     
     if get(:string)

data/lib/CORL/machine/aws.rb

@@ -0,0 +1,153 @@
+
+module CORL
+module Machine
+class Aws < Fog
+ 
+  #-----------------------------------------------------------------------------
+  # Checks
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def set_connection
+    require 'unf'
+    super
+    Kernel.load File.join(File.dirname(__FILE__), '..', '..', 'core', 'mod', 'fog_aws_server.rb')
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Management
+
+  def init_server
+    super do
+      myself.plugin_name = @server.id
+      
+      node[:id]           = plugin_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
+  
+  #---
+ 
+  def init_ssh(ssh_port)
+    # Security group initialization
+    if compute && ssh_port != 22
+      ensure_security_group("CORL_SSH_#{ssh_port}", ssh_port)
+    end
+  end
+  
+  #--- 
+
+  def create(options = {})
+    super do |config|
+      # Keypair initialization
+      if key_pair = compute.key_pairs.get(keypair_name)
+        key_pair.destroy
+      end
+      compute.key_pairs.create(
+        :name       => keypair_name,
+        :public_key => Util::Disk.read(node.public_key)
+      )      
+      config[:key_name] = keypair_name
+    end
+  end
+  
+  #---
+  
+  def reload(options = {})
+    super do |config|
+      success = server.reboot
+      
+      server.wait_for { ready? } if success
+      success
+    end
+  end
+  
+  #---
+ 
+  def create_image(options = {})
+    super do |image_name, config, success|
+      image_name        = image_name.gsub(/[^A-Za-z0-9\(\)\.\-\_\/]+/, '_')
+      image_description = config.get(:description, "CORL backup image")
+      
+      data     = compute.create_image(server.identity, image_name, image_description)
+      image_id = data.body['imageId']
+      
+      ::Fog.wait_for do
+        compute.describe_images('ImageId' => image_id).body['imagesSet'].first['imageState'] == 'available'
+      end
+      
+      if image_id
+        node[:image] = image_id
+        success      = true
+      end
+      success
+    end
+  end
+  
+  #---
+
+  def destroy(options = {})
+    super do |config|
+      unless config.get(:stop, false)
+        # Keypair destruction
+        if key_pair = compute.key_pairs.get(keypair_name)
+          key_pair.destroy
+        end
+      end
+      true  
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def keypair_name
+    "CORL_#{node.plugin_name}"  
+  end
+  
+  #---
+  
+  def ensure_security_group(group_name, from_port, to_port = nil, options = {})
+    config         = Config.ensure(options)
+    security_group = compute.security_groups.get(group_name)
+    cidrip         = config.get(:cidrip, '0.0.0.0/0')
+    protocol       = config.get(:protocol, 'tcp')
+    to_port        = from_port if to_port.nil?
+    
+    if security_group.nil?
+      security_group = compute.security_groups.create(
+        :name        => group_name,
+        :description => config.get(:description, "Opening port range: #{from_port} to #{to_port}")  
+      )          
+      raise unless security_group # TODO: Better error class       
+    end
+        
+    authorized = false
+    if security_group.ip_permissions  
+      authorized = security_group.ip_permissions.detect do |ip_permission|
+        ip_permission['ipRanges'].first && ip_permission['ipRanges'].first['cidrIp'] == cidrip &&
+        ip_permission['fromPort'] == from_port &&
+        ip_permission['ipProtocol'] == protocol &&
+        ip_permission['toPort'] == to_port
+      end
+    end
+    unless authorized
+      security_group.authorize_port_range(Range.new(from_port, to_port))
+    end
+      
+    if server
+      server.groups = [ group_name ] | server.groups
+      server.save
+    end
+  end
+end
+end
+end

data/lib/CORL/machine/physical.rb

@@ -6,7 +6,7 @@ class Physical < CORL.plugin_class(:machine)
   #-----------------------------------------------------------------------------
   # Machine plugin interface
   
-  def normalize
+  def normalize(reload)
     super
     myself.plugin_name = hostname
   end
@@ -40,7 +40,7 @@ class Physical < CORL.plugin_class(:machine)
   #---
   
   def public_ip
-    fact(:ipaddress)
+    CORL.ip_address
   end
   
   #---
@@ -99,13 +99,13 @@ class Physical < CORL.plugin_class(:machine)
   
   #---
   
-  def exec(commands, options = {})
+  def exec(commands, options = {}, &code)
     super do |config, results|
-      logger.debug("Executing shell commands ( #{commands.inspect} ) on machine #{name}")
+      logger.debug("Executing shell commands ( #{commands.inspect} ) on machine #{plugin_name}")
       
       commands.each do |command|
         result = CORL.cli_run(command, config) do |op, command_str, data|
-          block_given? ? yield(op, command_str, data) : true
+          code ? code.call(op, command_str, data) : true
         end        
         results << result
       end
@@ -115,6 +115,15 @@ class Physical < CORL.plugin_class(:machine)
  
   #---
   
+  def terminal(user, options = {})
+    super do |config|
+      logger.debug("Launching terminals on the local machine is not currently supported")
+      1
+    end
+  end
+  
+  #---
+  
   def start(options = {})
     super do
       logger.warn("This machine is already running so can not be started")

data/lib/CORL/machine/rackspace.rb

@@ -0,0 +1,58 @@
+
+module CORL
+module Machine
+class Rackspace < Fog
+ 
+  #-----------------------------------------------------------------------------
+  # Checks
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+ 
+  #-----------------------------------------------------------------------------
+  # Management
+
+  def init_server
+    super do
+      myself.plugin_name = @server.id
+      
+      node[:id]           = plugin_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
+  
+  #---
+  
+  def reload(options = {})
+    super do |config|
+      success = server.reboot(config.get(:type, 'SOFT'))
+      
+      server.wait_for { ready? } if success
+      success
+    end
+  end
+  
+  #---
+ 
+  def create_image(options = {})
+    super do |image_name, config, success|
+      image = server.create_image(image_name)        
+      image.wait_for { ready? }
+      
+      if image
+        node[:image] = image.id
+        success      = true
+      end
+      success
+    end
+  end
+end
+end
+end

data/lib/CORL/network/default.rb

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

data/lib/CORL/node/aws.rb

@@ -1,11 +1,17 @@
 
 module CORL
 module Node
-class Aws < Node::Fog
+class Aws < Fog
  
   #-----------------------------------------------------------------------------
   # Node plugin interface
-      
+  
+  def normalize(reload)
+    super do
+      :aws
+    end
+  end
+       
   #-----------------------------------------------------------------------------
   # Checks
   
@@ -18,9 +24,14 @@ class Aws < Node::Fog
   
   def regions
     [
-      'us-west-2a',
-      'us-west-2b',
-      'us-west-2c'
+      'us-east-1', 
+      'us-west-1', 
+      'us-west-2',
+      'eu-west-1',
+      'ap-northeast-1', 
+      'ap-southeast-1', 
+      'ap-southeast-2',       
+      'sa-east-1'
     ]
   end
   
@@ -30,7 +41,8 @@ class Aws < Node::Fog
   def machine_config
     super do |config|
       config.import({ 
-        :provider => 'AWS'
+        :provider => 'AWS',
+        :region   => region
       })
     
       config[:aws_access_key_id]     = api_user if api_user
@@ -38,24 +50,33 @@ class Aws < Node::Fog
     end
   end
   
+  #---
+  
+  def create_config
+    { :flavor_id => machine_type, :image_id => image, :username => user }  
+  end
+  
   #-----------------------------------------------------------------------------
   # Node operations
   
   def create(options = {})
     super do |op, config|
       if op == :config
-        config[:private_key] = private_key if private_key
-        config[:public_key]  = public_key if public_key
-        
-        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
   
@@ -73,13 +94,16 @@ class Aws < Node::Fog
   #---
   
   def render_image(image)
-    sprintf("[  %20s  ][ %10s ] %10s - %s", image_id(image), image.state, image.architecture, image.name)
+    location = image.location.split('/').first
+    sprintf("[  %20s  ][ %10s ] %10s - %s (%s)", image_id(image), image.state, image.architecture, image.name, location)
   end
   
   #---
   
   def image_search_text(image)
-    sprintf("%s %s %s %s %s", image_id(image), image.name, image.description, image.state, image.architecture)
+    location = image.location.split('/').first
+    location = location.match(/^\d+$/) ? '' : location
+    sprintf("%s %s %s %s %s %s %s", image_id(image), image.name, image.description, image.state, image.architecture, image.owner_id, location)
   end
 end
 end

data/lib/CORL/node/local.rb

@@ -6,9 +6,10 @@ class Local < CORL.plugin_class(:node)
   #-----------------------------------------------------------------------------
   # Node plugin interface
    
-  def normalize
-    super
-    myself.machine = create_machine(:machine, :physical, machine_config)
+  def normalize(reload)
+    super do
+      myself.machine = create_machine(:machine, :physical, machine_config)
+    end
   end
        
   #-----------------------------------------------------------------------------