corl 0.4.0 → 0.4.1

data/lib/{corl → CORL}/provisioner/puppetnode.rb

@@ -1,7 +1,7 @@
 
 module CORL
 module Provisioner
-class Puppetnode < Plugin::Provisioner
+class Puppetnode < CORL.plugin_class(:provisioner)
   
   #-----------------------------------------------------------------------------
   # Provisioner plugin interface
@@ -25,19 +25,6 @@ class Puppetnode < Plugin::Provisioner
     register
   end
   
-  #---
-  
-  def register
-    # Register Puppet CORL extensions
-    env.modules.each do |mod|
-      lib_dir = File.join(mod.path, 'lib', 'corl')
-      if File.directory?(lib_dir)
-        logger.debug("Registering Puppet module at #{lib_dir}")
-        Manager.connection.register(lib_dir)
-      end
-    end
-  end
-  
   #-----------------------------------------------------------------------------
   # Property accessor / modifiers
  

data/lib/{corl → CORL}/template/environment.rb

@@ -1,7 +1,7 @@
 
 module CORL
 module Template
-class Environment < Plugin::Template
+class Environment < CORL.plugin_class(:template)
   
   #-----------------------------------------------------------------------------
   # Renderers  

data/lib/core/facade.rb

@@ -0,0 +1,49 @@
+
+module CORL
+module Facade
+    
+  #-----------------------------------------------------------------------------
+  # Core plugin type facade
+  
+  def configuration(options, provider = nil)
+    plugin(:configuration, provider, options)
+  end
+  
+  def configurations(data, build_hash = false, keep_array = false)
+    plugins(:configuration, data, build_hash, keep_array)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Cluster plugin type facade
+   
+  def network(name, options = {}, provider = nil)
+    plugin(:network, provider, Config.ensure(options).import({ :name => name }))
+  end
+  
+  def networks(data, build_hash = false, keep_array = false)
+    plugins(:network, data, build_hash, keep_array)
+  end
+   
+  #---
+  
+  def node(name, options = {}, provider = nil)
+    plugin(:node, provider, Config.ensure(options).import({ :name => name }))
+  end
+  
+  def nodes(data, build_hash = false, keep_array = false)
+    plugins(:node, data, build_hash, keep_array)
+  end
+  
+  #---
+  
+  def provisioner(options, provider = nil)
+    plugin(:provisioner, provider, options)
+  end
+  
+  #---
+  
+  def provisioners(data, build_hash = false, keep_array = false)
+    plugins(:provisioner, data, build_hash, keep_array)
+  end
+end
+end

data/lib/{corl_core → core}/mixin/action/keypair.rb

@@ -8,41 +8,41 @@ module Keypair
   # Options
         
   def keypair_config
-    register :private_key, :str, nil, 'corl.core.mixins.keypair.options.private_key' do |value|
+    register :private_key, :str, nil, 'corl.core.mixin.action.keypair.options.private_key' do |value|
       success = true
       if value
         file = File.expand_path(value)
         if File.exists?(file)
           unless Util::SSH.generate({ :private_key => file })
-            warn('corl.core.mixins.keypair.errors.private_key_parse_error', { :value => file })
+            warn('corl.core.mixin.action.keypair.errors.private_key_parse_error', { :value => file })
             success = false
           end
         else
-          warn('corl.core.mixins.keypair.errors.private_key_not_found', { :value => file })
+          warn('corl.core.mixin.action.keypair.errors.private_key_not_found', { :value => file })
           success = false  
         end
       end
       success  
     end
     
-    register :require_password, :bool, false, 'corl.core.mixins.keypair.options.require_password'
+    register :require_password, :bool, false, 'corl.core.mixin.action.keypair.options.require_password'
     
-    register :key_type, :str, 'RSA', 'corl.core.mixins.keypair.options.key_type' do |value|
+    register :key_type, :str, 'RSA', 'corl.core.mixin.action.keypair.options.key_type' do |value|
       key_type_choices = [ 'RSA', 'DSA' ]
       unless key_type_choices.include?(value.to_s.upcase)
-        warn('corl.core.mixins.keypair.errors.key_type', { :value => value, :choices => key_type_choices })
+        warn('corl.core.mixin.action.keypair.errors.key_type', { :value => value, :choices => key_type_choices })
         next false    
       end
       true
     end
-    register :key_bits, :int, 2048, 'corl.core.mixins.keypair.options.key_bits' do |value|
+    register :key_bits, :int, 2048, 'corl.core.mixin.action.keypair.options.key_bits' do |value|
       unless value >= 2048
-        warn('corl.core.mixins.keypair.errors.key_bits', { :value => value, :required => 2048 })
+        warn('corl.core.mixin.action.keypair.errors.key_bits', { :value => value, :required => 2048 })
         next false 
       end
       true     
     end
-    register :key_comment, :str, '', 'corl.core.mixins.keypair.options.key_comment'
+    register :key_comment, :str, '', 'corl.core.mixin.action.keypair.options.key_comment'
     
     config_subset(keypair_ignore)
   end
@@ -89,7 +89,7 @@ module Keypair
           if password
             key_options[:passphrase] = password
           else
-            warn('corl.core.mixins.keypair.errors.no_password')
+            warn('corl.core.mixin.action.keypair.errors.no_password')
             return nil
           end
         end

data/lib/{corl_core/mixin/action/node.rb → core/plugin/action.rb}

@@ -1,41 +1,56 @@
 
 module CORL
-module Mixin
-module Action
-module Node
-        
+module Plugin
+class CloudAction < CORL.plugin_class(:action)
+  
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+  
+  def namespace
+    :corl
+  end
+  
+  #---
+    
+  def configure
+    super do
+      node_config
+      yield if block_given?
+    end
+  end
+          
   #-----------------------------------------------------------------------------
   # Settings
   
   def node_config
-    node_plugins = Manager.connection.loaded_plugins(:node)
+    node_plugins = CORL.loaded_plugins(:node)
     
-    register :parallel, :bool, true, 'corl.core.mixins.node.options.parallel'
-    register :net_provider, :str, :default, 'corl.core.mixins.node.options.net_provider' do |value|
+    register :parallel, :bool, true, 'corl.core.action.options.parallel'
+    register :net_provider, :str, :default, 'corl.core.action.options.net_provider' do |value|
       value           = value.to_sym
-      network_plugins = Manager.connection.loaded_plugins(:network)
+      network_plugins = CORL.loaded_plugins(:network)
       
       unless network_plugins.keys.include?(value)
-        warn('corl.core.mixins.node.errors.network_provider', { :value => value, :choices => network_plugins.keys.join(", ") })
+        warn('corl.core.action.errors.network_provider', { :value => value, :choices => network_plugins.keys.join(", ") })
         next false 
       end
       true
     end
-    register :node_provider, :str, :local, 'corl.core.mixins.node.options.node_provider' do |value|
+    register :node_provider, :str, :local, 'corl.core.action.options.node_provider' do |value|
       value = value.to_sym
       
       unless node_plugins.keys.include?(value)
-        warn('corl.core.mixins.node.errors.node_provider', { :value => value, :choices => node_plugins.keys.join(", ") })
+        warn('corl.core.action.errors.node_provider', { :value => value, :choices => node_plugins.keys.join(", ") })
         next false
       end
       true  
     end
-    register :nodes, :array, [], 'corl.core.mixins.node.options.nodes' do |values|
+    register :nodes, :array, [], 'corl.core.action.options.nodes' do |values|
       success = true
       values.each do |value|
-        if info = Plugin::Node.translate_reference(value)
+        if info = CORL.plugin_class(:node).translate_reference(value)
           if ! node_plugins.keys.include?(info[:provider].to_sym) || info[:name].empty?
-            warn('corl.core.mixins.node.errors.nodes', { :value => value, :provider => info[:provider],  :name => info[:name] })
+            warn('corl.core.action.errors.nodes', { :value => value, :provider => info[:provider],  :name => info[:name] })
             success = false
           end
         end
@@ -49,28 +64,25 @@ module Node
   def node_ignore
     [ :parallel, :net_provider, :node_provider, :nodes ]
   end
-     
+  
   #-----------------------------------------------------------------------------
   # Operations
   
-  def init_network(path = nil)
-    # Get network configuration path
-    if CORL.admin?
-      network_path = lookup(:corl_network)
-      Dir.mkdir(network_path) unless File.directory?(network_path)
-    else
-      network_path = ( path.nil? ? Dir.pwd : File.expand_path(path) )
+  def validate(node, network)
+    super(node, network)
+  end
+  
+  #---
+   
+  def execute
+    super(true, true) do
+      node_exec do |node, network|
+        hook_config = { :node => node, :network => network }
+        
+        yield(node, network) if block_given? && extension_check(:exec_init, hook_config)
+        myself.status = extension_set(:exec_exit, status, hook_config)
+      end
     end
-    
-    # Load network if it exists
-    network_config = extended_config(:network, { :directory => network_path })
-    
-    network = CORL.network(
-      CORL.sha1(network_config), 
-      network_config, 
-      settings[:net_provider]
-    )
-    network  
   end
   
   #---
@@ -119,6 +131,28 @@ module Node
   
   #---
   
+  def init_network(path = nil)
+    # Get network configuration path
+    if CORL.admin?
+      network_path = lookup(:corl_network)
+      Dir.mkdir(network_path) unless File.directory?(network_path)
+    else
+      network_path = ( path.nil? ? Dir.pwd : File.expand_path(path) )
+    end
+    
+    # Load network if it exists
+    network_config = extended_config(:network, { :directory => network_path })
+    
+    network = CORL.network(
+      CORL.sha1(network_config), 
+      network_config, 
+      settings[:net_provider]
+    )
+    network  
+  end
+  
+  #---
+  
   def execute_remote(node, network, op, data)
     # Implement in sub classes if needed
     data 
@@ -126,4 +160,3 @@ module Node
 end
 end
 end
-end

data/lib/{corl_core → core}/plugin/configuration.rb

@@ -1,7 +1,7 @@
 
-module CORL
+module Nucleon
 module Plugin
-class Configuration < Base
+class Configuration < CORL.plugin_class(:base)
     
   include Mixin::SubConfig
 

data/lib/{corl/node → core/plugin}/fog.rb

@@ -1,7 +1,11 @@
 
+nucleon_require(File.dirname(__FILE__), :node)
+
+#---
+
 module CORL
 module Node
-class Fog < Plugin::Node
+class Fog < CORL.plugin_class(:node)
  
   #-----------------------------------------------------------------------------
   # Node plugin interface

data/lib/{corl_core → core}/plugin/machine.rb

@@ -1,7 +1,7 @@
 
-module CORL
+module Nucleon
 module Plugin
-class Machine < Base
+class Machine < CORL.plugin_class(:base)
 
   #-----------------------------------------------------------------------------
   # Machine plugin interface

data/lib/{corl_core → core}/plugin/network.rb

@@ -1,7 +1,7 @@
 
-module CORL
+module Nucleon
 module Plugin
-class Network < Base
+class Network < CORL.plugin_class(:base)
   
   init_plugin_collection 
   
@@ -48,7 +48,7 @@ class Network < Base
   def node_groups
     groups = {}
     
-    each_node_config! do |provider, name, info|
+    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)
@@ -107,7 +107,7 @@ class Network < Base
   #---
   
   def node_by_ip(public_ip)
-    each_node_config! do |provider, name, info|
+    each_node_config do |provider, name, info|
       return node(provider, name) if info[:public_ip] == public_ip  
     end
     nil

data/lib/{corl_core → core}/plugin/node.rb

@@ -1,7 +1,7 @@
 
-module CORL
+module Nucleon
 module Plugin
-class Node < Base
+class Node < CORL.plugin_class(:base)
   
   include Celluloid
  
@@ -12,7 +12,7 @@ class Node < Base
     super
     
     ui.resource = hostname
-    ui.logger   = hostname
+    logger      = hostname
     
     @cli_interface = Util::Liquid.new do |method, args, &code|
       result = exec({ :commands => [ [ method, args ].flatten.join(' ') ] }) do |op, data|
@@ -28,7 +28,7 @@ class Node < Base
       action(method, *args) do |op, data|
         code.call(op, data) if code
       end
-    end
+    end    
   end
   
   #---
@@ -304,7 +304,7 @@ class Node < Base
   # Machine operations
   
   def create_machine(name, provider, options = {})
-    CORL.plugin_load(:machine, provider, extended_config(name, options).import({ :meta => { :parent => myself }}))
+    CORL.create_plugin(:machine, provider, extended_config(name, options).import({ :meta => { :parent => myself }}))
   end
   
   #---
@@ -461,7 +461,7 @@ class Node < Base
         active_machine = local? ? local_machine : machine
         
         if commands = config.get(:commands, nil)
-          logger.info("Starting command execution: #{commands.join('; ')}")
+          render("Starting command execution: #{commands.join('; ')}")
           results = active_machine.exec(commands, config.export) do |type, command, data|
             if type == :error
               alert(data)
@@ -498,7 +498,7 @@ class Node < Base
   
   def command(command, options = {})
     unless command.is_a?(CORL::Plugin::Command)
-      command = CORL.command(Config.new({ :command => command }).import(options), :shell)
+      command = CORL.command(Config.new({ :command => command }).import(options), :bash)
     end
     results = exec({ :commands => [ command.to_s ] }) do |op, data|
       yield(op, data) if block_given?  
@@ -536,7 +536,7 @@ class Node < Base
     myself.status = code.unknown_status
     
     bootstrap_name = 'bootstrap'    
-    bootstrap_path = config.get(:bootstrap_path, File.join(Gems.core.full_gem_path, bootstrap_name))
+    bootstrap_path = config.get(:bootstrap_path, File.join(CORL.lib_path, '..', bootstrap_name))
     bootstrap_glob = config.get(:bootstrap_glob, '**/*.sh')
     bootstrap_init = config.get(:bootstrap_init, 'bootstrap.sh')
     
@@ -581,13 +581,15 @@ class Node < Base
           
           # Execute bootstrap process
           if status == code.success
-            remote_script = File.join(remote_bootstrap_path, bootstrap_init)                  
+            remote_script = File.join(remote_bootstrap_path, bootstrap_init) 
+            
             result = command(remote_script) do |op, data|
               yield("exec_#{op}".to_sym, data) if block_given?
               data
             end
             
             if result.status != code.success
+              warn('corl.core.node.bootstrap.status', { :script => remote_script, :status => result.status })
               myself.status = code.bootstrap_exec_failure  
             end
           end