corl 0.4.0

data/lib/corl_core/plugin/machine.rb

@@ -0,0 +1,266 @@
+
+module CORL
+module Plugin
+class Machine < Base
+
+  #-----------------------------------------------------------------------------
+  # Machine plugin interface
+  
+  def normalize
+    myself.plugin_name = nil if plugin_name.to_s == plugin_provider.to_s      
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def created?
+    false
+  end
+  
+  #---
+  
+  def running?
+    ( created? && false )
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def node
+    plugin_parent
+  end
+ 
+  def node=node
+    myself.plugin_parent = node
+  end
+  
+  #---
+  
+  def state
+    nil
+  end
+  
+  #---
+  
+  def hostname
+    nil
+  end
+  
+  #---
+  
+  def public_ip
+    nil
+  end
+  
+  #---
+  
+  def private_ip
+    nil
+  end
+  
+  #---
+    
+  def machine_types
+    []
+  end
+  
+  #---
+  
+  def machine_type
+    nil
+  end
+  
+  #---
+  
+  def images
+    []
+  end
+  
+  #---
+  
+  def image
+    nil
+  end
+            
+  #-----------------------------------------------------------------------------
+  # Management 
+
+  def load
+    success = true
+    
+    logger.debug("Loading #{plugin_provider} machine: #{name}")
+    success = yield if block_given?  
+        
+    logger.warn("There was an error loading the machine #{name}") unless success
+    success
+  end
+  
+  #---
+  
+  def create(options = {})
+    success = true
+    
+    if created?
+      logger.debug("Machine #{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
+    success
+  end
+  
+  #---
+  
+  def download(remote_path, local_path, options = {})
+    success = true
+    
+    if running?
+      logger.debug("Downloading #{local_path} from #{remote_path} on #{plugin_provider} machine with: #{options.inspect}")
+      config  = Config.ensure(options)      
+      success = yield(config, success) if block_given?
+    else
+      logger.debug("Machine #{name} is not running")  
+    end
+    
+    logger.warn("There was an error downloading from the machine #{name}") unless success
+    success
+  end
+  
+  #---
+  
+  def upload(local_path, remote_path, options = {})
+    success = true
+    
+    if running?
+      logger.debug("Uploading #{local_path} to #{remote_path} on #{plugin_provider} machine with: #{options.inspect}")
+      config  = Config.ensure(options)      
+      success = yield(config, success) if block_given?
+    else
+      logger.debug("Machine #{name} is not running")  
+    end
+    
+    logger.warn("There was an error uploading to the machine #{name}") unless success
+    success
+  end
+  
+  #---
+  
+  def exec(commands, options = {})
+    results = []
+    
+    if running?
+      logger.debug("Executing command on #{plugin_provider} machine with: #{options.inspect}")
+      config  = Config.ensure(options)      
+      results = yield(config, results) if block_given?
+    else
+      logger.debug("Machine #{name} is not running")  
+    end
+    
+    logger.warn("There was an error executing command on the machine #{name}") unless results
+    results
+  end
+  
+  #---
+  
+  def start(options = {})
+    success = true
+    
+    if running?
+      logger.debug("Machine #{name} is already running")  
+    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
+  end
+  
+  #---
+  
+  def reload(options = {})
+    success = true
+    
+    if created?
+      logger.debug("Reloading #{plugin_provider} machine with: #{options.inspect}")
+      config  = Config.ensure(options)
+      success = yield(config) if block_given?
+    else
+      logger.debug("Machine #{name} does not yet exist")
+    end
+    
+    logger.warn("There was an error reloading the machine #{name}") unless success
+    success
+  end
+
+  #---
+  
+  def create_image(options = {})
+    success = true
+    
+    if running?
+      logger.debug("Creating image of #{plugin_provider} machine with: #{options.inspect}")
+      config  = Config.ensure(options)      
+      success = yield(config) if block_given?
+    else
+      logger.debug("Machine #{name} is not running")  
+    end
+    
+    logger.warn("There was an error creating an image of the machine #{name}") unless success
+    success
+  end
+
+  #---
+  
+  def stop(options = {})
+    success = true
+    
+    if running?
+      logger.debug("Stopping #{plugin_provider} machine with: #{options.inspect}")
+      config  = Config.ensure(options)      
+      success = yield(config) if block_given?
+    else
+      logger.debug("Machine #{name} is not running")  
+    end
+    
+    logger.warn("There was an error stopping the machine #{name}") unless success
+    success
+  end
+  
+  #---
+
+  def destroy(options = {})   
+    success = true
+    
+    if created?
+      logger.debug("Destroying #{plugin_provider} machine with: #{options.inspect}")
+      config  = Config.ensure(options)
+      success = yield(config) if block_given?
+    else
+      logger.debug("Machine #{name} does not yet exist")
+    end
+    
+    logger.warn("There was an error destroying the machine #{name}") unless success
+    success
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def translate_state(state)
+    return string(state).downcase.to_sym if status
+    :unknown
+  end
+end
+end
+end

data/lib/corl_core/plugin/network.rb

@@ -0,0 +1,359 @@
+
+module CORL
+module Plugin
+class Network < Base
+  
+  init_plugin_collection 
+  
+  #-----------------------------------------------------------------------------
+  # Cloud plugin interface
+  
+  def normalize
+    super
+    
+    logger.info("Initializing sub configuration from source with: #{myself._export.inspect}")
+    myself.config = CORL.configuration(Config.new(myself._export))
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def has_nodes?(provider = nil)   
+    node_config(provider).export.empty? ? false : true
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  plugin_collection :node
+  
+  #---
+  
+  def home
+    extension_set(:home, ( ENV['USER'] == 'root' ? '/root' : ENV['HOME'] )) 
+  end
+  
+  #---
+  
+  def remote(name)
+    config.remote(name)
+  end
+  
+  def set_remote(name, location)
+    config.set_remote(name, location)
+  end
+  
+  #---
+  
+  def node_groups
+    groups = {}
+    
+    each_node_config! do |provider, name, info|
+      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 }
+      end
+    end    
+    groups
+  end
+  
+  #---
+  
+  def node_info(references, default_provider = nil)
+    groups    = node_groups
+    node_info = {}
+    
+    default_provider = Manager.connection.type_default(:node) if default_provider.nil?
+        
+    references.each do |reference|
+      info = Plugin::Node.translate_reference(reference)
+      info = { :provider => default_provider, :name => reference } unless info
+      name = info[:name].to_sym     
+      
+      # Check for group membership
+      if groups.has_key?(name)
+        groups[name].each do |member_info|
+          provider = member_info[:provider].to_sym
+          
+          node_info[provider] = [] unless node_info.has_key?(provider)        
+          node_info[provider] << member_info[:name]
+        end
+      else
+        # Not a group
+        provider = info[:provider].to_sym
+        
+        if node_config.export.has_key?(provider)
+          node_found = false
+          
+          each_node_config(provider) do |node_provider, node_name, node|
+            if node_name == name
+              node_info[node_provider] = [] unless node_info.has_key?(node_provider)        
+              node_info[node_provider] << node_name
+              node_found = true
+              break
+            end
+          end
+          
+          unless node_found
+            # TODO:  Error or something?
+          end
+        end 
+      end     
+    end    
+    node_info  
+  end
+  
+  #---
+  
+  def node_by_ip(public_ip)
+    each_node_config! do |provider, name, info|
+      return node(provider, name) if info[:public_ip] == public_ip  
+    end
+    nil
+  end
+  
+  #---
+  
+  def local_node
+    ip_address = lookup(:ipaddress)
+    local_node = node_by_ip(ip_address)
+        
+    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.localize               
+    end    
+    local_node
+  end
+  
+  #---
+  
+  def nodes_by_reference(references, default_provider = nil)
+    nodes = []
+    
+    node_info(references, default_provider).each do |provider, names|
+      names.each do |name|
+        nodes << node(provider, name)
+      end
+    end
+    nodes  
+  end
+  
+  #---
+  
+  def test_node(provider)
+    CORL.node(:test, { :meta => { :parent => myself } }, provider)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def load(options = {})
+    config.load(options)
+  end
+  
+  #---
+  
+  def save(options = {})
+    config.save(options)
+  end
+  
+  #---
+  
+  def attach_files(type, name, files, options = {})
+    attach_config  = Config.ensure(options).import({ :type => :file })
+    included_files = []    
+    files          = [ files ] unless files.is_a?(Array)
+    
+    files.each do |file|
+      if file
+        attached_file = config.attach(type, name, file, attach_config)
+        included_files << attached_file unless attached_file.nil?
+      end  
+    end    
+    included_files
+  end
+  
+  #---
+  
+  def attach_data(type, name, data, options = {})
+    attach_config = Config.ensure(options).import({ :type => :source })
+    attached_data = nil    
+    
+    if data.is_a?(String)
+      attached_data = config.attach(type, name, file, 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
+  end
+  
+  #---
+  
+  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')
+    
+    # Set node data
+    #node        = set_node(provider, name, config)
+    #hook_config = { :node => node, :remote => remote_name, :seed => seed_project, :config => config }
+    success     = true
+    
+    #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 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
+    #      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_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
+    #        # 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)
+      end
+      
+      if status == CORL.code.success
+        delete_node(provider, name)
+      else
+        ui.warn("Stopping #{provider} node #{name} failed")
+      end       
+    end  
+        
+    status
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def each_node_config(provider = nil)
+    node_config.export.each do |node_provider, nodes|
+      if provider.nil? || provider == node_provider
+        nodes.each do |name, info|
+          yield(node_provider, name, info)
+        end
+      end
+    end
+  end
+  
+  #---
+  
+  execute_block_on_receiver :batch
+  
+  def batch(node_references, default_provider = nil, parallel = true, &code)
+    success = true
+    
+    if has_nodes? && ! node_references.empty?
+      # Execute action on selected nodes      
+      nodes = nodes_by_reference(node_references, default_provider)
+      
+      if parallel
+        values = []
+        nodes.each do |node|
+          values << Celluloid::Future.new(node, &code)
+        end
+        values  = values.map { |future| future.value }
+        success = false if values.include?(false)
+      else
+        nodes.each do |node|
+          proc_success = code.call(node)
+          if proc_success == false
+            success = false
+            break
+          end
+        end  
+      end
+    end
+    success
+  end
+end
+end
+end