corl 0.4.0

data/lib/corl_core/mixin/action/keypair.rb

@@ -0,0 +1,105 @@
+
+module CORL
+module Mixin
+module Action
+module Keypair
+        
+  #-----------------------------------------------------------------------------
+  # Options
+        
+  def keypair_config
+    register :private_key, :str, nil, 'corl.core.mixins.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 })
+            success = false
+          end
+        else
+          warn('corl.core.mixins.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 :key_type, :str, 'RSA', 'corl.core.mixins.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 })
+        next false    
+      end
+      true
+    end
+    register :key_bits, :int, 2048, 'corl.core.mixins.keypair.options.key_bits' do |value|
+      unless value >= 2048
+        warn('corl.core.mixins.keypair.errors.key_bits', { :value => value, :required => 2048 })
+        next false 
+      end
+      true     
+    end
+    register :key_comment, :str, '', 'corl.core.mixins.keypair.options.key_comment'
+    
+    config_subset(keypair_ignore)
+  end
+  
+  #---
+         
+  def keypair_ignore
+    [ :require_password, :key_type, :key_bits, :key_comment ]
+  end
+  
+  #---
+  
+  def keypair_clean
+    remove(keypair_ignore)  
+  end
+         
+  #-----------------------------------------------------------------------------
+  # Properties
+  
+  @keypair = nil
+  
+  #---
+  
+  def keypair=options
+    config = Config.ensure(options).defaults({
+      :type    => settings[:key_type].to_s.upcase,
+      :bits    => settings[:key_bits],
+      :comment => settings[:key_comment]
+    })
+    @keypair = Util::SSH.generate(options)
+    settings.import({ :keypair => @keypair })
+  end
+  
+  #---
+  
+  def keypair(reset = false)
+    if reset || ! @keypair
+      if settings[:private_key]
+        key_options = { :private_key => private_key } 
+      else
+        key_options = {}
+        if settings[:require_password]
+          password = ui.password('SSH')
+          if password
+            key_options[:passphrase] = password
+          else
+            warn('corl.core.mixins.keypair.errors.no_password')
+            return nil
+          end
+        end
+      end
+      myself.keypair = key_options
+    end
+    @keypair
+  end
+end
+end
+end
+end
+

data/lib/corl_core/mixin/action/node.rb

@@ -0,0 +1,129 @@
+
+module CORL
+module Mixin
+module Action
+module Node
+        
+  #-----------------------------------------------------------------------------
+  # Settings
+  
+  def node_config
+    node_plugins = Manager.connection.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|
+      value           = value.to_sym
+      network_plugins = Manager.connection.loaded_plugins(:network)
+      
+      unless network_plugins.keys.include?(value)
+        warn('corl.core.mixins.node.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|
+      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(", ") })
+        next false
+      end
+      true  
+    end
+    register :nodes, :array, [], 'corl.core.mixins.node.options.nodes' do |values|
+      success = true
+      values.each do |value|
+        if info = Plugin::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] })
+            success = false
+          end
+        end
+      end
+      success
+    end
+  end
+  
+  #---
+         
+  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) )
+    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 node_exec
+    network = init_network
+    
+    #
+    # A fork in the road...
+    #
+    if network.has_nodes? && ! settings[:nodes].empty?
+      # Execute action on remote nodes 
+      success = network.batch(settings[:nodes], settings[:node_provider], settings[:parallel]) do |node|
+        exec_config = Config.new(settings)
+        exec_config.delete(:parallel)
+        exec_config.delete(:nodes)
+        exec_config.delete(:node_provider)
+              
+        result = node.action(plugin_provider, exec_config) do |op, data|
+          ui_group(node.plugin_name) do
+            case op
+            when :config # Modify seed execution configurations
+              render("Starting remote execution of #{plugin_provider} action")  
+            when :process # Process final result
+              render("Successfully finished remote execution of #{plugin_provider} action")     
+            end
+            data = execute_remote(node, network, op, data)
+          end
+          data
+        end
+        result.status == code.success 
+      end
+      myself.status = code.batch_error unless success
+    else
+      # Execute statement locally
+      node = network.local_node
+      
+      if validate(node, network)
+        yield(node, network) if block_given?
+      else
+        puts "\n" + I18n.t('corl.core.exec.help.usage') + ': ' + help + "\n" unless quiet?
+        myself.status = code.validation_failed 
+      end
+    end
+  end
+  
+  #---
+  
+  def execute_remote(node, network, op, data)
+    # Implement in sub classes if needed
+    data 
+  end
+end
+end
+end
+end

data/lib/corl_core/mixin/action/project.rb

@@ -0,0 +1,53 @@
+
+module CORL
+module Mixin
+module Action
+module Project
+        
+  #-----------------------------------------------------------------------------
+  # Options
+        
+  def project_options(parser, ref_override = false, rev_override = false)
+    parser.option_str(:project_provider, 'git', 
+      '--proj-provider PROVIDER', 
+      'corl.core.mixins.project.options.provider'
+    )
+    if ref_override
+      parser.option_str(:reference, nil,
+        '--reference PROJECT_REF', 
+        'corl.core.mixins.project.options.reference'
+      )
+    end
+    if rev_override
+      parser.option_str(:revision, nil,
+        '--revision PROJECT_REV',  
+        'corl.core.mixins.project.options.revision'
+      )
+    end
+  end
+        
+  #-----------------------------------------------------------------------------
+  # Operations
+        
+  def project_load(root_dir, update = false)
+        
+    # 1. Set a default project provider (reference can override)
+    # 2. Get project from root directory
+    # 3. Initialize project if not yet initialized
+    # 4. Set remote if needed
+    # 5. Checkout revision if needed
+    # 6. Pull down updates if requested
+          
+    return CORL.project(extended_config(:project, {
+      :provider  => settings[:project_provider],
+      :directory => root_dir,
+      :url       => settings[:reference],
+      :revision  => settings[:revision],
+      :pull      => update
+    }))
+  end       
+end
+end
+end
+end
+

data/lib/corl_core/mixin/action/push.rb

@@ -0,0 +1,52 @@
+
+module CORL
+module Mixin
+module Action
+module Push
+        
+  #-----------------------------------------------------------------------------
+  # Options
+        
+  def push_options(parser, optional = true)
+    if optional
+      parser.option_bool(:push, false, 
+        '--push', 
+        'corl.core.mixins.push.options.push'
+      )
+    else
+      parser.options[:push] = true
+    end
+          
+    parser.option_bool(:propogate, false,
+      '--propogate', 
+      'corl.core.mixins.push.options.propogate'
+    )          
+    parser.option_str(:remote, :edit,
+      '--remote PROJECT_REMOTE',  
+      'corl.core.mixins.push.options.remote'
+    )
+    parser.option_str(:revision, :master,
+      '--revision PROJECT_REVISION',  
+      'corl.core.mixins.push.options.revision'
+    )         
+  end
+        
+  #-----------------------------------------------------------------------------
+  # Operations
+        
+  def push(project, remote = :edit)
+    success = true
+          
+    if project && settings[:push]
+      success = project.push(settings[:remote], extended_config(:push, {
+        :revision  => settings[:revision],
+        :propogate => settings[:propogate]
+      }))
+    end
+    success
+  end
+end
+end
+end
+end
+

data/lib/corl_core/mixin/config/collection.rb

@@ -0,0 +1,53 @@
+
+# Should be included via extend
+#
+# extend Mixin::ConfigCollection
+#
+
+module CORL
+module Mixin
+module ConfigCollection
+
+  #-----------------------------------------------------------------------------
+  # Configuration collection interface
+  
+  def all_properties
+    return Config::Collection.all
+  end
+  
+  #---
+  
+  def get_property(name)
+    return Config::Collection.get(name)
+  end
+  
+  #---
+  
+  def set_property(name, value)
+    Config::Collection.set(name, value)
+    return self  
+  end
+  
+  #---
+  
+  def delete_property(name)
+    Config::Collection.delete(name)
+    return self
+  end
+  
+  #---
+  
+  def clear_properties
+    Config::Collection.clear
+    return self  
+  end
+  
+  #---
+  
+  def save_properties
+    Config::Collection.save
+    return self
+  end
+end
+end
+end

data/lib/corl_core/mixin/config/ops.rb

@@ -0,0 +1,53 @@
+
+# Should be included via extend
+#
+# extend Mixin::ConfigOps
+#
+
+module CORL
+module Mixin
+module ConfigOps
+
+  #-----------------------------------------------------------------------------
+  # Parsing
+      
+  def parse(statement, options = {})
+    config = Config.ensure(options)
+    
+    # statement =  common->php::apache::memory_limit = 32M
+    # statement =  identity -> test -> users::user[admin][shell]
+    # statement =  nodes->development->dev.loc->facts[server_location]
+    # statement =  corl->nodes[vagrant][dev.loc][vm][private_network]=172.5.5.10
+    # statement =  corl->settings[debug][puppet][options] = ["--debug"]
+    
+    reference, new_value = statement.split(/\=/)
+    new_value            = new_value.join('=').strip if new_value && new_value.is_a?(Array)
+    
+    config_elements = reference.gsub(/\s+/, '').split(/\-\>/)
+    property        = config_elements.pop
+    config_file     = config_elements.pop
+    
+    if config_directory = config.get(:directory, nil)
+      config_path = File.join(project.directory, config_directory, *config_elements)
+    else
+      config_path = File.join(project.directory, *config_elements)
+    end
+    
+    return nil unless property && config_file
+    
+    config_file = "#{config_file}." + config.get(:ext, 'json')
+    property    = property.gsub(/\]$/, '').split(/\]?\[/)
+    data        = open(config_path, config_file, config)
+       
+    return { 
+      :path          => config_path, 
+      :file          => config_file, 
+      :property      => property,
+      :conf          => data,
+      :current_value => (data ? data.get(property) : nil), 
+      :new_value     => eval(new_value) 
+    }    
+  end
+end
+end
+end

data/lib/corl_core/mixin/config/options.rb

@@ -0,0 +1,39 @@
+
+# Should be included via extend
+#
+# extend Mixin::ConfigOptions
+#
+
+module CORL
+module Mixin
+module ConfigOptions
+  
+  #-----------------------------------------------------------------------------
+  # Configuration options interface
+  
+  def contexts(contexts = [], hierarchy = [])
+    return Config::Options.contexts(contexts, hierarchy)  
+  end
+  
+  #---
+  
+  def get_options(contexts, force = true)
+    return Config::Options.get(contexts, force)  
+  end
+  
+  #---
+  
+  def set_options(contexts, options, force = true)
+    Config::Options.set(contexts, options, force)
+    return self  
+  end
+  
+  #---
+  
+  def clear_options(contexts)
+    Config::Options.clear(contexts)
+    return self  
+  end
+end
+end
+end

data/lib/corl_core/mixin/lookup.rb

@@ -0,0 +1,196 @@
+
+module CORL
+module Mixin
+module Lookup
+
+  #-----------------------------------------------------------------------------
+  # Facter lookup
+  
+  def facts
+    fact_map = {}
+    Facter.list.each do |name|
+      fact_map[name] = Facter.value(name)
+    end
+    fact_map
+  end
+  
+  def fact(name)
+    Facter.value(name)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Hiera configuration
+  
+  @@hiera = nil
+  
+  #---
+  
+  def hiera_config
+    config_file = CORL.value(:hiera_config_file, nil)
+    config      = {}
+
+    if config_file && File.exist?(config_file)
+      config = Hiera::Config.load(config_file)
+    end
+    config[:logger] = :corl
+    
+    results = CORL.config(:hiera_config, { :config => config })
+    results[:config]
+  end
+  
+  #---
+
+  def hiera
+    @@hiera = Hiera.new(:config => hiera_config) if @@hiera.nil?
+    @@hiera
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Configuration lookup interface
+      
+  def config_initialized?
+    ready = false
+    if CORL.admin? && hiera && network_path = fact(:corl_network)
+      ready = File.directory?(network_path) && File.directory?(File.join(network_path, 'config')) ? true : false
+    end
+    ready
+  end
+  
+  #---
+    
+  def lookup(properties, default = nil, options = {})
+    config      = Config.ensure(options)
+    value       = nil
+    
+    provisioner = config.get(:provisioner, nil)
+    
+    hiera_scope = config.get(:hiera_scope, {})
+    override    = config.get(:override, nil)
+    context     = config.get(:context, :priority)    
+    
+    
+    return_property = config.get(:return_property, false)
+    
+    unless properties.is_a?(Array)
+      properties = [ properties ].flatten
+    end
+
+    first_property = nil
+    properties.each do |property|
+      property       = property.to_sym
+      first_property = property unless first_property
+      
+      # Try to load facts first (these can not be overridden)
+      unless value = fact(property)
+        if CORL.admin? 
+          if config_initialized?
+            # Try to find in Hiera data store (these might be security sensitive)
+            unless hiera_scope.respond_to?('[]')
+              hiera_scope = Hiera::Scope.new(hiera_scope)
+            end
+            value = hiera.lookup(property, nil, hiera_scope, override, context)
+          end 
+    
+          if provisioner && Util::Data.undef?(value)
+            # Search the provisioner scope (only admins can provision a machine)
+            value = CORL.provisioner(provisioner).lookup(property, default, config)
+          end
+        end
+      end
+    end
+    value = default if Util::Data.undef?(value) # Resort to default
+    value = Util::Data.value(value)
+    
+    if ! Config.get_property(first_property) || ! Util::Data.undef?(value)
+      Config.set_property(first_property, value)
+    end
+    return value, first_property if return_property
+    value
+  end
+    
+  #---
+  
+  def lookup_array(properties, default = [], options = {})
+    config          = Config.ensure(options) 
+    value, property = lookup(properties, nil, config.import({ :return_property => true }))
+    
+    if Util::Data.undef?(value)
+      value = default
+        
+    elsif ! Util::Data.empty?(default)
+      if config.get(:merge, false)
+        value = Util::Data.merge([default, value], config)
+      end
+    end
+    
+    unless value.is_a?(Array)
+      value = ( Util::Data.empty?(value) ? [] : [ value ] )
+    end
+    
+    Config.set_property(property, value)
+    value
+  end
+    
+  #---
+  
+  def lookup_hash(properties, default = {}, options = {})
+    config          = Config.ensure(options) 
+    value, property = lookup(properties, nil, config.import({ :return_property => true }))
+    
+    if Util::Data.undef?(value)
+      value = default
+        
+    elsif ! Util::Data.empty?(default)
+      if config.get(:merge, false)
+        value = Util::Data.merge([default, value], config)
+      end
+    end
+    
+    unless value.is_a?(Hash)
+      value = ( Util::Data.empty?(value) ? {} : { :value => value } )
+    end
+    
+    Config.set_property(property, value)
+    value
+  end
+  
+  #---
+
+  def normalize(data, override = nil, options = {})
+    config  = Config.ensure(options)
+    results = {}
+    
+    unless Util::Data.undef?(override)
+      case data
+      when String, Symbol
+        data = [ data, override ] if data != override
+      when Array
+        data << override unless data.include?(override)
+      when Hash
+        data = [ data, override ]
+      end
+    end
+    
+    case data
+    when String, Symbol
+      results = lookup(data.to_s, {}, config)
+      
+    when Array
+      data.each do |item|
+        if item.is_a?(String) || item.is_a?(Symbol)
+          item = lookup(item.to_s, {}, config)
+        end
+        unless Util::Data.undef?(item)
+          results = Util::Data.merge([ results, item ], config)
+        end
+      end
+  
+    when Hash
+      results = data
+    end
+    
+    results
+  end
+end
+end
+end