corl 0.4.0

data/lib/corl/machine/fog.rb

@@ -0,0 +1,310 @@
+
+module CORL
+module Machine
+class Fog < Plugin::Machine
+ 
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def created?
+    server && ! server.state != 'DELETED'
+  end
+  
+  #---
+  
+  def running?
+    created? && server.ready?
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def set_connection
+    logger.info("Initializing Fog Compute connection to cloud hosting provider")
+    logger.debug("Compute settings: #{export.inspect}")
+    
+    ENV['DEBUG'] = 'true' if CORL.log_level == :debug
+    
+    require 'fog' 
+        
+    myself.compute = ::Fog::Compute.new(export)
+  end
+  protected :set_connection
+  
+  #---
+  
+  def compute=compute
+    @compute = compute
+  end
+  
+  def compute
+    set_connection unless @compute
+    @compute
+  end
+  
+  #---
+  
+  def server=id
+    if id.is_a?(String)
+      @server = compute.servers.get(id)
+    else
+      @server = id
+    end
+    
+    unless @server.nil?
+      myself.name = @server.id
+      
+      node[:id]         = 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
+  
+  def server
+    compute
+    load unless @server
+    @server
+  end
+   
+  #---
+  
+  def state
+    return translate_state(server.state) if server
+    nil
+  end
+  
+  #---
+  
+  def hostname
+    return server.name if server
+    nil
+  end
+  
+  #---
+  
+  def public_ip
+    return server.public_ip_address if server
+    nil
+  end
+  
+  #---
+  
+  def private_ip
+    return server.private_ip_address if server
+    nil
+  end
+  
+  #---
+    
+  def machine_types
+    return compute.flavors if compute
+    []
+  end
+  
+  #---
+  
+  def machine_type
+    return server.flavor.id if server
+    nil
+  end
+  
+  #---
+  
+  def images
+    return compute.images if compute
+    []
+  end
+  
+  #---
+  
+  def image
+    return server.image.id if server
+    nil
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Management
+  
+  def load
+    super do
+      myself.server = name if compute && ! name.empty?
+      server.nil? ? false : true
+    end    
+  end
+  
+  #---
+  
+  def create(options = {})
+    super do
+      myself.server = compute.servers.bootstrap(Config.ensure(options).export) if compute
+      myself.server ? true : false
+    end
+  end
+  
+  #---
+  
+  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}") 
+      
+      begin
+        if init_ssh_session
+          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
+          true
+        else
+          false
+        end
+      rescue Exception => error
+        ui.error(error.message)
+        false
+      end
+    end  
+  end
+  
+  #---
+  
+  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}") 
+      
+      begin
+        if init_ssh_session
+          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
+          true
+        else
+          false
+        end
+      rescue Exception => error
+        ui.error(error.message)
+        false
+      end
+    end  
+  end
+  
+  #---
+  
+  def exec(commands, options = {})
+    super do |config, results|
+      if commands
+        logger.debug("Executing SSH commands ( #{commands.inspect} ) on machine #{name}")
+        
+        if init_ssh_session
+          results = Util::SSH.exec(node.public_ip, node.user, commands) do |type, command, data|
+            yield(type, command, data) if block_given?  
+          end
+        else
+          results = nil
+        end
+      end
+      results
+    end
+  end
+  
+  #---
+  
+  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      
+    end
+  end
+  
+  #---
+  
+  def reload(options = {})
+    super do
+      if server
+        logger.debug("Rebooting machine #{name}")
+        server.reboot(options)
+      else
+        false
+      end  
+    end
+  end
+
+  #---
+ 
+  def create_image(name, options = {})
+    super do
+      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
+      end
+    end
+  end
+  
+  #---
+  
+  def stop(options = {})
+    super do
+      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        
+      end
+      success
+    end
+  end
+  
+  #---
+
+  def destroy(options = {})
+    super do
+      if server
+        logger.debug("Destroying machine #{name}")
+        server.destroy(options)
+      else
+        false  
+      end  
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def init_ssh_session
+    Util::SSH.session(node.public_ip, node.user, node.ssh_port, node.private_key)
+  end
+end
+end
+end

data/lib/corl/machine/physical.rb

@@ -0,0 +1,161 @@
+
+module CORL
+module Machine
+class Physical < Plugin::Machine
+  
+  #-----------------------------------------------------------------------------
+  # Machine plugin interface
+  
+  def normalize
+    super
+    myself.plugin_name = hostname
+  end
+     
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def created?
+    true
+  end
+  
+  #---
+  
+  def running?
+    true
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def state
+    translate_state('RUNNING')
+  end
+  
+  #---
+  
+  def hostname
+    fact(:hostname)
+  end
+  
+  #---
+  
+  def public_ip
+    fact(:ipaddress)
+  end
+  
+  #---
+  
+  def private_ip
+    nil
+  end
+  
+  #---
+  
+  def machine_type
+    'physical'
+  end
+  
+  #---
+  
+  def image
+    nil
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Management
+
+  def load
+    super do
+      true
+    end    
+  end
+  
+  #---
+  
+  def create(options = {})
+    super do
+      logger.warn("Damn!  We can't create new instances of physical machines")
+      true
+    end
+  end
+  
+  #---
+  
+  def download(remote_path, local_path, options = {})
+    super do |config, success|
+      logger.debug("Executing SCP downloads not yet supported on physical machines")
+      true
+    end
+  end
+  
+  #---
+  
+  def upload(local_path, remote_path, options = {})
+    super do |config, success|
+      logger.debug("Executing SCP uploads not yet supported on physical machines")
+      true
+    end
+  end
+  
+  #---
+  
+  def exec(commands, options = {})
+    super do |config, results|
+      logger.debug("Executing shell commands ( #{commands.inspect} ) on machine #{name}")
+      
+      commands.each do |command|
+        result = Util::Shell.connection.exec(command, config) do |op, command_str, data|
+          block_given? ? yield(op, command_str, data) : true
+        end        
+        results << result
+      end
+      results
+    end
+  end
+ 
+  #---
+  
+  def start(options = {})
+    super do
+      logger.warn("This machine is already running so can not be started")
+      true
+    end
+  end
+  
+  #---
+  
+  def reload(options = {})
+    return super do
+      logger.warn("Reloading not currently supported on physical machines")
+      true
+    end
+  end
+ 
+  #---
+ 
+  def create_image(name, options = {})
+    super do
+      logger.warn("Creating images of local machines not supported yet")
+      true
+    end
+  end
+  #---
+  
+  def stop(options = {})
+    super do
+      logger.warn("Stopping the machine we are operating is not supported right now")
+      true
+    end
+  end
+  
+  #---
+
+  def destroy(options = {})
+    super do
+      logger.warn("If you want to destroy your physical machine, grab a hammer")
+      true  
+    end
+  end
+end
+end
+end

data/lib/corl/network/default.rb

@@ -0,0 +1,26 @@
+
+module CORL
+module Network
+class Default < Plugin::Network
+ 
+  #-----------------------------------------------------------------------------
+  # Cloud plugin interface
+   
+  def normalize
+    super
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Checks
+    
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+
+
+  #-----------------------------------------------------------------------------
+  # Operations
+     
+end
+end
+end

data/lib/corl/node/aws.rb

@@ -0,0 +1,90 @@
+
+corl_require(File.dirname(__FILE__), :fog)
+
+#---
+
+module CORL
+module Node
+class Aws < Node::Fog
+ 
+  #-----------------------------------------------------------------------------
+  # Node plugin interface
+      
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def usable_image?(image)
+    image.state == 'available' && image.name
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def regions
+    [
+      'us-west-2a',
+      'us-west-2b',
+      'us-west-2c'
+    ]
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Settings groups
+    
+  def machine_config
+    super do |config|
+      config.import({ 
+        :provider => 'AWS'
+      })
+    
+      config[:aws_access_key_id]     = api_user if api_user
+      config[:aws_secret_access_key] = api_key if api_key
+    end
+  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
+        })
+      end
+    end
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def render_machine_type(machine_type)
+    sprintf("[  %20s  ][ VCPUS: %5.1f ] %-40s ( RAM: %6iMB | DISK: %8iGB )  ( BITS: %2i )", 
+      machine_type_id(machine_type), 
+      machine_type.cores, 
+      machine_type.name, 
+      machine_type.ram, 
+      machine_type.disk, 
+      machine_type.bits
+    )
+  end
+  
+  #---
+  
+  def render_image(image)
+    sprintf("[  %20s  ][ %10s ] %10s - %s", image_id(image), image.state, image.architecture, image.name)
+  end
+  
+  #---
+  
+  def image_search_text(image)
+    sprintf("%s %s %s %s %s", image_id(image), image.name, image.description, image.state, image.architecture)
+  end
+end
+end
+end