corl 0.4.0

data/lib/corl_core/facade.rb

@@ -0,0 +1,126 @@
+
+module CORL
+    
+  #-----------------------------------------------------------------------------
+  # Core plugin type facade
+  
+  def self.extension(provider)
+    plugin(:extension, provider, {})
+  end
+  
+  #---
+  
+  def self.configuration(options, provider = nil)
+    plugin(:configuration, provider, options)
+  end
+  
+  def self.configurations(data, build_hash = false, keep_array = false)
+    plugins(:configuration, data, build_hash, keep_array)
+  end
+  
+  #---
+  
+  def self.action(provider, options)
+    plugin(:action, provider, options)
+  end
+  
+  def self.action_config(provider)
+    action(provider, { :settings => {}, :quiet => true }).configure
+  end
+  
+  def self.actions(data, build_hash = false, keep_array = false)
+    plugins(:action, data, build_hash, keep_array)  
+  end
+  
+  def self.action_run(provider, options = {}, quiet = true)
+    Plugin::Action.exec(provider, options, quiet)
+  end
+  
+  def self.action_cli(provider, args = [], quiet = false)
+    Plugin::Action.exec_cli(provider, args, quiet)
+  end
+  
+  #---
+  
+  def self.project(options, provider = nil)
+    plugin(:project, provider, options)
+  end
+  
+  def self.projects(data, build_hash = false, keep_array = false)
+    plugins(:project, data, build_hash, keep_array)
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Cluster plugin type facade
+   
+  def self.network(name, options = {}, provider = nil)
+    plugin(:network, provider, Config.ensure(options).import({ :name => name }))
+  end
+  
+  def self.networks(data, build_hash = false, keep_array = false)
+    plugins(:network, data, build_hash, keep_array)
+  end
+   
+  #---
+  
+  def self.node(name, options = {}, provider = nil)
+    plugin(:node, provider, Config.ensure(options).import({ :name => name }))
+  end
+  
+  def self.nodes(data, build_hash = false, keep_array = false)
+    plugins(:node, data, build_hash, keep_array)
+  end
+  
+  #---
+  
+  def self.provisioner(options, provider = nil)
+    plugin(:provisioner, provider, options)
+  end
+  
+  #---
+  
+  def self.provisioners(data, build_hash = false, keep_array = false)
+    plugins(:provisioner, data, build_hash, keep_array)
+  end
+  
+  #---
+  
+  def self.command(options, provider = nil)
+    plugin(:command, provider, options)
+  end
+  
+  def self.commands(data, build_hash = false, keep_array = false)
+    plugins(:command, data, build_hash, keep_array)
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Utility plugin type facade
+  
+  def self.event(options, provider = nil)
+    plugin(:event, provider, options)
+  end
+  
+  def self.events(data, build_hash = false, keep_array = false)
+    plugins(:event, data, build_hash, keep_array)
+  end
+  
+  #---
+  
+  def self.template(options, provider = nil)
+    plugin(:template, provider, options)
+  end
+  
+  def self.templates(data, build_hash = false, keep_array = false)
+    plugins(:template, data, build_hash, keep_array)
+  end
+   
+  #---
+  
+  def self.translator(options, provider = nil)
+    plugin(:translator, provider, options)
+  end
+  
+  def self.translators(data, build_hash = false, keep_array = false)
+    plugins(:translator, data, build_hash, keep_array)
+  end
+end

data/lib/corl_core/gems.rb

@@ -0,0 +1,72 @@
+
+module CORL
+module Gems
+  
+  #-----------------------------------------------------------------------------
+  
+  @@core = nil
+  @@gems = {}
+  
+  #-----------------------------------------------------------------------------
+  # Gem interface
+  
+  def self.logger
+    Core.logger
+  end
+  
+  #---
+    
+  def self.core
+    @@core
+  end
+  
+  #---
+  
+  def self.registered
+    @@gems
+  end
+  
+  #---
+  
+  def self.register(reset = false)
+    if reset || Util::Data.empty?(@@gems)
+      logger.info("Registering external gem defined CORL plugins at #{Time.now}")
+      
+      if defined?(Gem) 
+        if ! defined?(Bundler) && Gem::Specification.respond_to?(:latest_specs)
+          logger.debug("Not using bundler")
+          Gem::Specification.latest_specs(true).each do |spec|
+            register_gem(spec)
+          end
+        else
+          logger.debug("Using bundler or Gem specification without latest_specs")
+          Gem.loaded_specs.each do |name, spec|
+            register_gem(spec)
+          end     
+        end
+      end
+    end
+    @@gems
+  end
+  
+  #---
+  
+  def self.register_gem(spec)
+    plugin_path = File.join(spec.full_gem_path, 'lib', 'corl')
+    if File.directory?(plugin_path)
+      logger.info("Registering gem #{spec.name} at #{plugin_path} at #{Time.now}")
+      
+      @@gems[spec.name] = {
+        :lib_dir => plugin_path,
+        :spec    => spec
+      }
+      if spec.name == 'corl_core'
+        logger.debug("Setting CORL core gemspec")
+        @@core = spec
+      else
+        Manager.connection.register(plugin_path) # Autoload plugins and related files  
+      end      
+    end  
+  end
+end
+end

data/lib/corl_core/manager.rb

@@ -0,0 +1,425 @@
+
+module CORL
+class Manager
+  
+  include Celluloid
+  
+  #-----------------------------------------------------------------------------
+  
+  @@supervisors = {}
+  
+  #-----------------------------------------------------------------------------
+  # Plugin manager interface
+  
+  def self.init_manager(name)
+    name = name.to_sym
+    
+    Manager.supervise_as name
+    @@supervisors[name] = Celluloid::Actor[name]  
+  end
+  
+  #---
+  
+  def self.connection(name = :core)
+    name = name.to_sym
+    
+    init_manager(name) unless @@supervisors.has_key?(name)
+    
+    begin
+      @@supervisors[name].test_connection
+    rescue Celluloid::DeadActorError
+      retry
+    end
+    @@supervisors[name]
+  end
+  
+  #---
+  
+  def initialize
+    @logger = CORL.logger
+    
+    @types     = {}
+    @load_info = {}    
+    @plugins   = {}
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+  
+  attr_reader :logger
+  
+  #---
+  
+  def types
+    @types.keys
+  end
+  
+  #---
+  
+  def type_default(type)
+    @types[type.to_sym]
+  end
+  
+  #---
+  
+  def loaded_plugins(type = nil, provider = nil)
+    results  = {}
+    type     = type.to_sym if type
+    provider = provider.to_sym if provider
+    
+    if type && @load_info.has_key?(type)
+      if provider && @load_info.has_key?(provider)
+        results = @load_info[type][provider]  
+      else
+        results = @load_info[type]
+      end
+    elsif ! type
+      results = @load_info      
+    end
+    results
+  end
+ 
+  #---
+  
+  def plugins(type = nil, provider = nil)
+    results  = {}
+    type     = type.to_sym if type
+    provider = provider.to_sym if provider
+    
+    if type && @plugins.has_key?(type)
+      if provider && ! @plugins[type].keys.empty?
+        @plugins[type].each do |instance_name, plugin|
+          plugin                 = @plugins[type][instance_name]
+          results[instance_name] = plugin if plugin.plugin_provider == provider
+        end
+      else
+        results = @plugins[type]
+      end
+    elsif ! type
+      results = @plugins
+    end    
+    results
+  end 
+  
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def test_connection
+    true
+  end
+  
+  #---
+  
+  def define_type(type_info)
+    if type_info.is_a?(Hash)
+      logger.info("Defining plugin types at #{Time.now}")
+      
+      type_info.each do |type, default_provider|
+        logger.debug("Mapping plugin type #{type} to default provider #{default_provider}")
+        @types[type.to_sym] = default_provider
+      end
+    else
+      logger.warn("Defined types must be specified as a hash to be registered properly")      
+    end
+  end
+  
+  #---
+  
+  def load_plugins(reset_gems = false)    
+    # Register core plugins
+    unless @core_loaded
+      logger.info("Initializing core plugins at #{Time.now}")
+      register(File.join(File.dirname(__FILE__), '..', 'corl'))
+      @core_loaded = true
+    end
+      
+    # Register external Gem defined plugins
+    Gems.register(reset_gems)
+    
+    # Register any other extension plugins
+    exec(:register_plugins)
+        
+    # Autoload all registered plugins
+    autoload
+  end
+  
+  #---
+  
+  def register(base_path)
+    if File.directory?(base_path)
+      logger.info("Loading files from #{base_path} at #{Time.now}")
+      
+      Dir.glob(File.join(base_path, '*.rb')).each do |file|
+        logger.debug("Loading file: #{file}")
+        require file
+      end
+      
+      logger.info("Loading directories from #{base_path} at #{Time.now}")
+      Dir.entries(base_path).each do |path|
+        unless path.match(/^\.\.?$/)
+          register_type(base_path, path)          
+        end
+      end
+    end  
+  end
+  
+  #---
+  
+  def register_type(base_path, plugin_type)
+    base_directory = File.join(base_path, plugin_type.to_s)
+    
+    if File.directory?(base_directory)
+      logger.info("Registering #{base_directory} at #{Time.now}")
+      
+      Dir.glob(File.join(base_directory, '*.rb')).each do |file|
+        add_build_info(plugin_type, file)
+      end
+    end
+  end
+  protected :register_type
+  
+  #---
+ 
+  def add_build_info(type, file)
+    type = type.to_sym
+    
+    @load_info[type] = {} unless @load_info.has_key?(type)
+    
+    components = file.split(File::SEPARATOR)
+    provider   = components.pop.sub(/\.rb/, '').to_sym
+    directory  = components.join(File::SEPARATOR) 
+    
+    logger.info("Loading corl #{type} plugin #{provider} at #{Time.now}")
+        
+    unless @load_info[type].has_key?(provider)
+      data = {
+        :type      => type,
+        :provider  => provider,        
+        :directory => directory,
+        :file      => file
+      }
+      
+      logger.debug("Plugin #{type} loaded: #{data.inspect}")
+      @load_info[type][provider] = data
+    end
+  end
+  protected :add_build_info
+  
+  #---
+  
+  def autoload
+    logger.info("Autoloading registered plugins at #{Time.now}")
+    
+    @load_info.keys.each do |type|
+      logger.debug("Autoloading type: #{type}")
+      
+      @load_info[type].each do |provider, plugin|
+        logger.debug("Autoloading provider #{provider} at #{plugin[:directory]}")
+        
+        corl_require(plugin[:directory], provider)
+        
+        @load_info[type][provider][:class] = CORL.class_const([ 'CORL', type, provider ])
+        logger.debug("Updated #{type} #{provider} load info: #{@load_info[type][provider].inspect}")
+        
+        # Make sure extensions are listening from the time they are loaded
+        create(:extension, provider) if type == :extension # Create a persistent instance
+      end
+    end
+  end    
+ 
+  #---
+  
+  def create(type, provider, options = {})
+    type     = type.to_sym
+    provider = provider.to_sym
+       
+    unless @types.has_key?(type)
+      logger.warn("Plugin type #{type} creation requested but it has not been registered yet")
+      return nil
+    end
+    
+    options = translate_type(type, options)
+    info    = @load_info[type][provider] if Util::Data.exists?(@load_info, [ type, provider ])
+        
+    if info
+      logger.debug("Plugin information for #{provider} #{type} found.  Data: #{info.inspect}")
+      
+      instance_name = "#{provider}_" + CORL.sha1(options)
+      options       = translate(type, provider, options)      
+              
+      @plugins[type] = {} unless @plugins.has_key?(type)
+      
+      unless instance_name && @plugins[type].has_key?(instance_name)
+        info[:instance_name] = instance_name
+        options[:meta]       = Config.new(info).import(Util::Data.hash(options[:meta]))
+        
+        logger.info("Creating new plugin #{provider} #{type} with #{options.inspect}")
+       
+        plugin = CORL.class_const([ 'CORL', type, provider ]).new(type, provider, options)
+        
+        @plugins[type][instance_name] = plugin 
+      end
+      return @plugins[type][instance_name]
+    end
+    
+    logger.warn("Plugin information cannot be found for plugin #{type} #{provider}")      
+    nil  
+  end
+  
+  #---
+  
+  def get(type, name)
+    logger.info("Fetching plugin #{type} #{name}")
+    
+    if @plugins.has_key?(type)
+      @plugins[type].each do |instance_name, plugin|
+        if plugin.plugin_name.to_s == name.to_s
+          logger.debug("Plugin #{type} #{name} found")
+          return plugin
+        end
+      end
+    end
+    logger.debug("Plugin #{type} #{name} not found")
+    nil  
+  end
+  
+  #---
+  
+  def remove(plugin)
+    if plugin && plugin.respond_to?(:plugin_type) && @plugins.has_key?(plugin.plugin_type)
+      logger.debug("Removing #{plugin.plugin_type} #{plugin.plugin_name}")
+      @plugins[plugin.plugin_type].delete(plugin.plugin_instance_name)
+      plugin.terminate if plugin.respond_to?(:terminate)
+    else
+      logger.warn("Cannot remove plugin: #{plugin.inspect}")    
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Extension hook execution
+ 
+  def exec(method, options = {})
+    results = nil
+    
+    if CORL.log_level == :hook # To save processing on rendering
+      logger.hook("Executing extension hook { #{method} } at #{Time.now} with:\n#{PP.pp(options, '')}\n")
+    end
+    
+    extensions = plugins(:extension)
+    
+    extensions.each do |name, plugin|
+      provider = plugin.plugin_provider
+      result   = nil      
+      
+      logger.debug("Checking extension #{provider}")
+      
+      if plugin.respond_to?(method)
+        results = {} if results.nil?       
+                
+        result = plugin.send(method, options)
+        logger.info("Completed hook #{method} at #{Time.now} with: #{result.inspect}")
+                    
+        if block_given?
+          results[provider] = yield(:process, result)
+          logger.debug("Processed extension result into: #{results[provider].inspect}")  
+        end
+        
+        if results[provider].nil?
+          logger.debug("Setting extension result to: #{result.inspect}") 
+          results[provider] = result
+        end
+      end
+    end
+    
+    if ! results.nil? && block_given? 
+      results = yield(:reduce, results)
+      logger.debug("Reducing extension results to: #{results.inspect}")
+    else
+      logger.debug("Final extension results: #{results.inspect}")     
+    end        
+    results    
+  end
+  
+  #---
+  
+  def config(type, options = {})
+    config = Config.ensure(options)
+    
+    logger.debug("Generating #{type} extended configuration from: #{config.export.inspect}")
+      
+    exec("#{type}_config", Config.new(config.export)) do |op, data|
+      if op == :reduce
+        data.each do |provider, result|
+          config.defaults(result)
+        end
+        nil
+      else
+        hash(data)
+      end
+    end    
+    config.delete(:extension_type)
+     
+    logger.debug("Final extended configuration: #{config.export.inspect}")   
+    config 
+  end
+  
+  #---
+  
+  def check(method, options = {})
+    config = Config.ensure(options)
+    
+    logger.debug("Checking extension #{method} given: #{config.export.inspect}")
+    
+    success = exec(method, config.import({ :extension_type => :check })) do |op, data|
+      if op == :reduce
+        ! data.values.include?(false)
+      else
+        data ? true : false
+      end
+    end
+    
+    success = success.nil? || success ? true : false
+    
+    logger.debug("Extension #{method} check result: #{success.inspect}")      
+    success
+  end
+  
+  #---
+  
+  def value(method, value, options = {})
+    config = Config.ensure(options)
+    
+    logger.debug("Setting extension #{method} value given: #{value.inspect}")
+    
+    exec(method, config.import({ :value => value, :extension_type => :value })) do |op, data|
+      if op == :process
+        value = data unless data.nil?  
+      end
+    end
+    
+    logger.debug("Extension #{method} retrieved value: #{value.inspect}")
+    value
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def translate_type(type, info, method = :translate)
+    klass = CORL.class_const([ 'CORL', :plugin, type ])
+    logger.debug("Executing option translation for: #{klass.inspect}")          
+    
+    info = klass.send(method, info) if klass.respond_to?(method)
+    info  
+  end
+  
+  #---
+  
+  def translate(type, provider, info, method = :translate)
+    klass = CORL.class_const([ 'CORL', type, provider ])
+    logger.debug("Executing option translation for: #{klass.inspect}")
+              
+    info = klass.send(method, info) if klass.respond_to?(method)
+    info  
+  end  
+end
+end

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

@@ -0,0 +1,58 @@
+
+module CORL
+module Mixin
+module Action
+module Commit
+        
+  #-----------------------------------------------------------------------------
+  # Options
+        
+  def commit_options(parser, optional = true)
+    if optional
+      parser.option_bool(:commit, false, 
+        '--commit', 
+        'corl.core.mixins.commit.options.commit'
+      )
+    else
+      parser.options[:commit] = true
+    end
+         
+    parser.option_bool(:allow_empty, false,
+      '--empty', 
+      'corl.core.mixins.commit.options.empty'
+    )
+    parser.option_bool(:propogate, false,
+      '--propogate', 
+      'corl.core.mixins.commit.options.propogate'
+    )          
+    parser.option_str(:message, '',
+      '--message COMMIT_MESSAGE',  
+      'corl.core.mixins.commit.options.message'
+    )
+    parser.option_str(:author, nil,
+      '--author COMMIT_AUTHOR',  
+      'corl.core.mixins.commit.options.author'
+    )         
+  end
+        
+  #-----------------------------------------------------------------------------
+  # Operations
+        
+  def commit(project, files = '.')
+    success = true
+          
+    if project && settings[:commit]
+      success = project.commit(files, extended_config(:commit, {
+        :allow_empty => settings[:allow_empty],
+        :message     => settings[:message],
+        :author      => settings[:author],
+        :propogate   => settings[:propogate]
+      }))
+    end
+    success
+  end
+end
+end
+end
+end
+