corl 0.4.2 → 0.4.3

data/lib/core/mixin/macro/network_settings.rb

@@ -0,0 +1,52 @@
+
+module CORL
+module Mixin
+module Macro
+module NetworkSettings
+  
+  def network_settings(_type)
+    
+    # Networks are inherited unless explicitely set
+     
+    define_method :network do
+      plugin_parent
+    end
+ 
+    define_method :network= do |network|
+      myself.plugin_parent = network
+    end
+  
+    #---
+  
+    define_method :setting do |property, default = nil, format = false|
+      network.send("#{_type}_setting", plugin_provider, plugin_name, property, default, format)
+    end
+  
+    define_method :search do |property, default = nil, format = false|
+      network.send("search_#{_type}", plugin_provider, plugin_name, property, default, format)
+    end
+  
+    define_method :set_setting do |property, value = nil|
+      network.send("set_#{_type}_setting", plugin_provider, plugin_name, property, value)
+    end
+  
+    define_method :delete_setting do |property|
+      network.send("delete_#{_type}_setting", plugin_provider, plugin_name, property)
+    end
+  
+    #---
+ 
+    define_method :[] do |name, default = nil, format = false|
+      search(name, default, format)
+    end
+  
+    #---
+  
+    define_method :[]= do |name, value|
+      set_setting(name, value)
+    end   
+  end
+end
+end
+end
+end

data/lib/core/plugin/action.rb

@@ -133,7 +133,7 @@ class CloudAction < CORL.plugin_class(:action)
     end
     
     # Load network if it exists
-    network_config = extended_config(:network, { :directory => network_path })
+    network_config = extended_config(:network, { :directory => network_path, :name => network_path })
     
     network = CORL.network(
       CORL.sha1(network_config), 

data/lib/core/plugin/configuration.rb

@@ -14,19 +14,44 @@ class Configuration < CORL.plugin_class(:base)
     logger.debug("Initializing source sub configuration")
     init_subconfig(true) unless reload
     
+    logger.info("Setting source configuration project")
+    @project = CORL.project(extended_config(:project, {
+      :directory => _delete(:directory, Dir.pwd),
+      :url       => _delete(:url),
+      :revision  => _delete(:revision),
+      :create    => _delete(:create, false),
+      :pull      => true
+    }), _delete(:project_provider))
+        
     _init(:autoload, true)
     _init(:autosave, false)
+    
+    yield if block_given?
+    
+    set_location(@project)
   end
    
   #-----------------------------------------------------------------------------
   # Checks
   
   def can_persist?
-    false
+    project.can_persist?
   end
       
   #-----------------------------------------------------------------------------
   # Property accessors / modifiers
+
+  def project
+    @project
+  end
+  
+  #---
+  
+  def directory
+    project.directory  
+  end
+  
+  #---
   
   def autoload(default = false)
     _get(:autoload, default)
@@ -45,6 +70,19 @@ class Configuration < CORL.plugin_class(:base)
   def autosave=autosave
     _set(:autosave, test(autosave))
   end
+
+  #-----------------------------------------------------------------------------
+  
+  def set_location(directory)
+    if directory && directory.is_a?(CORL::Plugin::Project)
+      logger.debug("Setting source project directory from other project at #{directory.directory}")
+      project.set_location(directory.directory)
+      
+    elsif directory && directory.is_a?(String) || directory.is_a?(Symbol)
+      logger.debug("Setting source project directory to #{directory}")
+      project.set_location(directory.to_s)
+    end
+  end
   
   #-----------------------------------------------------------------------------
     
@@ -70,14 +108,15 @@ class Configuration < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   
   def remote(name)
-    nil
+    project.remote(name)
   end
-
+  
   #---
   
   def set_remote(name, location)
+    project.set_remote(name, location)
   end
-  
+ 
   #-----------------------------------------------------------------------------
   # Import / Export
   

data/lib/core/plugin/network.rb

@@ -12,7 +12,7 @@ class Network < CORL.plugin_class(:base)
     super
     
     logger.info("Initializing sub configuration from source with: #{myself._export.inspect}")
-    myself.config = CORL.configuration(Config.new(myself._export).import({ :autosave => false })) unless reload
+    myself.config = CORL.configuration(Config.new(myself._export).import({ :autosave => false, :create => false })) unless reload
   end
   
   #-----------------------------------------------------------------------------
@@ -26,6 +26,7 @@ class Network < CORL.plugin_class(:base)
   # Property accessors / modifiers
   
   plugin_collection :node
+  plugin_collection :provisioner
   
   #---
   
@@ -35,6 +36,18 @@ class Network < CORL.plugin_class(:base)
   
   #---
   
+  def directory
+    config.directory
+  end
+  
+  #---
+  
+  def build_directory
+    File.join(directory, 'build')
+  end
+  
+  #---
+  
   def remote(name)
     config.remote(name)
   end
@@ -49,7 +62,7 @@ class Network < CORL.plugin_class(:base)
     groups = {}
     
     each_node_config do |provider, name, info|
-      search_node(provider, name, :groups, [], :array).each do |group|
+      search_node(provider, name, :settings, [], :array).each do |group|
         group = group.to_sym
         groups[group] = [] unless groups.has_key?(group)
         groups[group] << { :provider => provider, :name => name }
@@ -211,7 +224,7 @@ class Network < CORL.plugin_class(:base)
     
     # Set node data
     node = set_node(provider, name, { 
-      :groups       => array(config.delete(:groups, [])), 
+      :settings     => array(config.delete(:groups, [])), 
       :region       => config.delete(:region, nil),
       :machine_type => config.delete(:machine_type, nil),
       :image        => config.delete(:image, nil),

data/lib/core/plugin/node.rb

@@ -20,7 +20,7 @@ class Node < CORL.plugin_class(:base)
     ui.resource = hostname
     logger      = hostname
     
-    myself[:groups] = [ "all", plugin_provider.to_s, plugin_name.to_s ] | groups 
+    myself[:settings] = [ "all", plugin_provider.to_s, plugin_name.to_s ] | setting(:settings, [], :array)
     
     unless reload
       @cli_interface = Util::Liquid.new do |method, args, &code|
@@ -114,7 +114,7 @@ class Node < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   
   def groups
-    array(myself[:groups])
+    array(myself[:settings])
   end
   
   #-----------------------------------------------------------------------------
@@ -308,6 +308,49 @@ class Node < CORL.plugin_class(:base)
     myself[:image]
   end
   
+  #---
+  
+  def profiles=profiles
+    myself[:profiles] = array(profiles)
+  end
+  
+  def profiles
+    array(myself[:profiles])
+  end
+  
+  #---
+  
+  def provisioner_info
+    provisioner_info = {}
+        
+    # Compose needed provisioners and profiles
+    profiles.each do |profile|        
+      if info = Plugin::Provisioner.translate_reference(profile)
+        provider = info[:provider]
+            
+        provisioner_info[provider] = { :profiles => [] } unless provisioner_info.has_key?(provider)
+        provisioner_info[provider][:profiles] += info[:profiles]
+      end
+    end
+    provisioner_info
+  end
+  
+  #---
+  
+  def provisioners
+    provisioners = {}        
+    provisioner_info.each do |provider, node_profiles|
+      provisioners[provider] = network.provisioners(provider)
+    end    
+    provisioners
+  end
+  
+  #---
+  
+  def build_time
+    myself[:build]
+  end
+  
   #-----------------------------------------------------------------------------
   # Settings groups
   
@@ -323,6 +366,29 @@ class Node < CORL.plugin_class(:base)
   #-----------------------------------------------------------------------------
   # Machine operations
   
+  def build(options = {})
+    config = Config.ensure(options)
+    info   = provisioner_info
+    
+    provisioners.each do |provider, collection|
+      provider_info = info[provider]
+      profiles      = provider_info[:profiles]
+          
+      collection.each do |name, provisioner|
+        provisioner.build(options)
+      end
+    end
+    
+    myself[:build] = Time.now.to_s
+    
+    save(extended_config(:build, {
+      :message => config.get(:message, "Built #{plugin_provider} node: #{plugin_name}"),
+      :remote  => config.get(:remote, :edit)  
+    }))
+  end
+  
+  #---
+  
   def attach_keys(keypair)
     base_name   = "#{plugin_provider}-#{plugin_name}"
     save_config = { 
@@ -911,6 +977,7 @@ class Node < CORL.plugin_class(:base)
         delete_setting(:public_ip)
         delete_setting(:private_ip)
         delete_setting(:ssh_port)
+        delete_setting(:build)
         
         myself[:state] = :stopped
         

data/lib/core/plugin/provisioner.rb

@@ -2,49 +2,324 @@
 module Nucleon
 module Plugin
 class Provisioner < CORL.plugin_class(:base)
-
+  
+  include Celluloid
+ 
   #-----------------------------------------------------------------------------
   # Provisioner plugin interface
   
   def normalize(reload)
     super
+    yield if block_given?
   end
   
-  #---
+  #-----------------------------------------------------------------------------
+  # Checks
 
   def initialized?(options = {})
   end
   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+
+  network_settings :provisioner
+
   #---
   
-  def register
+  def id(name = nil)
+    name = plugin_name if name.nil?
+    name.to_s.gsub('::', '_').to_sym
   end
   
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
- 
-  def hiera_config
+  #---
+  
+  def directory=directory
+    myself[:directory] = directory
+  end
+  
+  def directory
+    myself[:directory]
+  end
+  
+  #---
+  
+  def build_directory
+    File.join(network.build_directory, plugin_provider.to_s)
+  end
+  
+  #---
+  
+  def gateway=gateway
+    myself[:gateway] = gateway
+  end
+  
+  def gateway
+    myself[:gateway]
+  end
+  
+  #---
+  
+  def packages
+    hash(myself[:packages])
+  end
+  
+  #---
+  
+  def profiles
+    hash(myself[:profiles])
+  end
+  
+  def find_profiles(reset = false)
+    allowed_profiles = []  
+    build_info(reset).each do |package_name, package_info|
+      hash(package_info[:profiles]).each do |profile_name, profile_info|
+        allowed_profiles << concatenate([ package_name, 'profile', profile_name ])
+      end
+    end
+    profiles.each do |profile_name, profile_info|
+      allowed_profiles << concatenate([ plugin_name, 'profile', profile_name ])
+    end
+    allowed_profiles  
+  end
+  protected :find_profiles
+  
+  #---
+  
+  def supported_profiles(profile_names = nil)
+    found    = []    
+    profiles = build_profiles
+    
+    if profile_names.nil?
+      found = profiles  
+    else
+      profile_names.each do |name|
+        name = name.to_s
+        if profiles.include?(name)
+          found << name
+        end
+      end
+    end
+    found.empty? ? false : found
+  end
+     
+  #---
+  
+  def build_locations(reset = false)
+    locations = hash(myself[:build_locations])
+    build if reset || locations.empty?
+    myself[:build_locations]
+  end
+  
+  #---
+  
+  def build_info(reset = false)
+    info = hash(myself[:build_info])
+    build if reset || info.empty?
+    myself[:build_info]
+  end
+  
+  #---
+  
+  def build_profiles(reset = false)
+    profiles = array(myself[:build_profiles])
+    build if reset || profiles.empty?
+    myself[:build_profiles]
   end
   
   #-----------------------------------------------------------------------------
   # Provisioner operations
-   
+ 
+  def register(options = {})
+    # Implement in providers
+  end
+  
+  #---
+  
+  def build(options = {})
+    config = Config.ensure(options)
+    
+    locations    = Config.new({ :package => {} })
+    package_info = Config.new
+    
+    init_location = lambda do |name, ext = '', base_directory = nil|
+      name           = name.to_sym      
+      base_directory = directory if base_directory.nil?
+      build_base     = build_directory
+          
+      # Create directory
+      locations[name] = File.join(locations[:build], name.to_s)        
+      FileUtils.mkdir_p(File.join(build_base, locations[name]))
+     
+      # Copy directory contents
+      unless ext.nil?
+        ext             = ! ext.to_s.empty? ? ".#{ext}" : ''
+        local_directory = File.join(base_directory, name.to_s)
+        
+        if File.directory?(local_directory)  
+          unless Dir.glob(File.join(local_directory, "*#{ext}")).empty?            
+            FileUtils.cp_r(local_directory, File.join(build_base, locations[:build]))
+          end
+        end
+        
+        # Copy gateway file
+        gateway_file = File.join(base_directory, "#{name}#{ext}")
+      
+        if File.exists?(gateway_file)
+          FileUtils.cp(gateway_file, File.join(build_base, locations[:build]))
+        end
+      end  
+    end
+    
+    init_package = lambda do |name, reference|
+      package_directory = File.join(locations[:packages], id(name).to_s)
+        
+      project = CORL.configuration(extended_config(:package, {
+        :directory => File.join(build_directory, package_directory),
+        :url       => reference,
+        :create    => true
+      }))
+      raise unless project
+      
+      package_info.import(project.export)
+      locations[:package][name] = package_directory
+      
+      if project.get([ :provisioners, plugin_provider ], false)
+        project.get_hash([ :provisioners, plugin_provider ]).each do |prov_name, info|
+          if info.has_key?(:packages)
+            info[:packages].each do |sub_name, sub_reference|
+              init_package.call(sub_name, sub_reference)
+            end
+          end
+        end
+      end
+    end
+    
+    locations[:build]     = id.to_s
+    local_build_directory = File.join(build_directory, locations[:build])   
+    
+    FileUtils.rm_rf(local_build_directory)
+    FileUtils.mkdir_p(local_build_directory)
+    
+    init_location.call(:packages, nil)
+    
+    # Build packages
+    packages.each do |name, reference|
+      init_package.call(name, reference)
+    end
+     
+    yield(locations, package_info, init_location) if block_given?
+    
+    myself[:build_locations] = locations.export
+    myself[:build_info]      = package_info.get([ :provisioners, plugin_provider ])
+    myself[:build_profiles]  = find_profiles
+    
+    network.save(config.import({
+      :commit      => true,
+      :allow_empty => true, 
+      :message     => config.get(:message, "Built #{plugin_provider} provisioner #{plugin_name}"),
+      :remote      => config.get(:remote, :edit)
+    }))
+  end
+  
+  #---
+  
   def lookup(property, default = nil, options = {})
+    # Implement in providers
   end
   
   #--
   
-  def import(files)
+  def import(files, options = {})
+    # Implement in providers
+  end
+  
+  #---
+  
+  def include(resource_name, properties = {}, options = {})
+    # Implement in providers
+  end
+  
+  #---
+  
+  def provision(profiles, options = {})
+    # Implement in providers
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.build_info(type, data)  
+    data = data.split(/\s*,\s*/) if data.is_a?(String)
+    super(type, data)
+  end
+  
+  #---
+   
+  def self.translate(data)
+    options = super(data)
+    
+    case data        
+    when String
+      options = { :profiles => array(data) }
+    when Hash
+      options = data
+    end
+    
+    if options.has_key?(:profiles)
+      if matches = translate_reference(options[:profiles])
+        options[:provider] = matches[:provider]
+        options[:profiles] = matches[:profiles]
+        
+        logger.debug("Translating provisioner options: #{options.inspect}")  
+      end
+    end
+    options
+  end
+  
+  #---
+  
+  def self.translate_reference(reference)
+    # ex: puppetnode:::profile::something,profile::somethingelse
+    if reference && reference.match(/^\s*([a-zA-Z0-9_-]+):::([^\s]+)\s*$/)
+      provider = $1
+      profiles = $2
+      
+      logger.debug("Translating provisioner reference: #{provider} #{profiles}")
+      
+      info = {
+        :provider => provider,
+        :profiles => profiles.split(/\s*,\s*/)
+      }
+      
+      logger.debug("Project reference info: #{info.inspect}")
+      return info
+    end
+    nil
   end
   
   #---
   
-  def include(resource_name, properties, options = {})
+  def translate_reference(reference)
+    myself.class.translate_reference(reference)
   end
   
   #---
   
-  def provision(options = {})
+  def concatenate(components, capitalize = false, joiner = '::')
+    if components.is_a?(Array)
+      components = components.collect do |str|
+        str.to_s.split('__')  
+      end.flatten
+    else
+      components = [ components.to_s ]
+    end
+    
+    if capitalize
+      name = components.collect {|str| str.capitalize }.join(joiner)
+    else
+      name = components.join(joiner)
+    end
+    name
   end
 end
 end