corl 0.4.0 → 0.4.1

data/lib/corl_core/mod/hash.rb

@@ -1,29 +0,0 @@
-
-#-------------------------------------------------------------------------------
-# Hash data type alterations
-
-class Hash
-  def search(search_key, options = {})
-    config = CORL::Config.ensure(options)
-    value  = nil
-    
-    recurse       = config.get(:recurse, false)
-    recurse_level = config.get(:recurse_level, -1)
-        
-    self.each do |key, data|
-      if key == search_key
-        value = data
-        
-      elsif data.is_a?(Hash) && 
-        recurse && (recurse_level == -1 || recurse_level > 0)
-        
-        recurse_level -= 1 unless recurse_level == -1
-        value = value.search(search_key, 
-          CORL::Config.new(config).set(:recurse_level, recurse_level)
-        )
-      end
-      break unless value.nil?
-    end
-    return value
-  end
-end

data/lib/corl_core/plugin/action.rb

@@ -1,381 +0,0 @@
-
-module CORL
-module Plugin
-class Action < Base
-  
-  include Mixin::Action::Node
-  
-  #-----------------------------------------------------------------------------
-  # Default option interface
-  
-  class Option
-    def initialize(provider, name, type, default, locale = nil, &validator)
-      @provider  = provider
-      @name      = name
-      @type      = type
-      @default   = default
-      @locale    = locale.nil? ? "corl.actions.#{provider}.options.#{name}" : locale
-      @validator = validator if validator
-    end
-    
-    #---
-    
-    attr_reader :provider, :name, :type
-    attr_accessor :default, :locale, :validator
-    
-    #---
-    
-    def validate(value, node, network)
-      success = true
-      if @validator
-        success = @validator.call(value, node, network)
-      end
-      success
-    end
-  end
-
-  #-----------------------------------------------------------------------------
-  # Action plugin interface
-  
-  def self.exec_safe(provider, options)
-    action_result = nil
-    
-    begin
-      logger = CORL.logger
-      
-      logger.debug("Running corl action #{provider} with #{options.inspect}")
-      action        = CORL.action(provider, options)
-      exit_status   = action.execute
-      action_result = action.result
-      
-    rescue Exception => error
-      logger.error("Corl action #{provider} experienced an error:")
-      logger.error(error.inspect)
-      logger.error(error.message)
-      logger.error(CORL::Util::Data.to_yaml(error.backtrace))
-
-      CORL.ui.error(error.message, { :prefix => false }) if error.message
-  
-      exit_status = error.status_code if error.respond_to?(:status_code)
-    end
-    
-    CORL.remove_plugin(action) if action
-
-    exit_status = CORL.code.unknown_status unless exit_status.is_a?(Integer)
-    { :status => exit_status, :result => action_result }  
-  end
-  
-  def self.exec(provider, options, quiet = true)
-    exec_safe(provider, { :settings => Config.ensure(options), :quiet => quiet })
-  end
-  
-  def self.exec_cli(provider, args, quiet = false)
-    results = exec_safe(provider, { :args => args, :quiet => quiet })
-    results[:status]
-  end
-  
-  #---
-  
-  def normalize
-    args = array(delete(:args, []))
-       
-    @action_interface = Util::Liquid.new do |method, method_args|
-      options = {}
-      options = method_args[0] if method_args.length > 0
-      
-      quiet   = true
-      quiet   = method_args[1] if method_args.length > 1
-      
-      myself.class.exec(method, options, quiet)
-    end
-    
-    set(:config, Config.new)
-        
-    if get(:settings, nil)
-      # Internal processing
-      configure
-      set(:processed, true)
-      set(:settings, Config.ensure(get(:settings)))
-      
-      CORL.log_level = settings[:log_level] if settings.has_key?(:log_level)
-    else
-      # External processing
-      set(:settings, Config.new)
-      configure
-      parse_base(args)
-    end   
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Checks
-  
-  def processed?
-    get(:processed, false)
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
-  
-  def config
-    get(:config)
-  end
-  
-  #---
-  
-  def config_subset(names)
-    Util::Data.subset(config, names)
-  end
-  
-  #---
-   
-  def settings
-    get(:settings)
-  end
-  
-  #---
-  
-  def register(name, type, default, locale = nil)
-    name = name.to_sym
-        
-    if block_given?
-      option = Option.new(plugin_provider, name, type, default, locale) do |value, success|
-        yield(value, success)
-      end
-    else
-      option = Option.new(plugin_provider, name, type, default, locale)
-    end
-    
-    config[name]   = option
-    settings[name] = option.default if settings[name].nil?
-  end
-  
-  #---
-  
-  def remove(names)
-    Util::Data.rm_keys(config, names)
-    Util::Data.rm_keys(settings, names)
-  end
-  
-  #---
-  
-  def ignore
-    []
-  end
-    
-  def options
-    config.keys - arguments - ignore
-  end
-    
-  def arguments
-    []
-  end
-  
-  #---
-    
-  def configure
-    node_config
-    yield if block_given?
-    
-    usage = "corl #{plugin_provider} "    
-    arguments.each do |arg|
-      arg_config = config[arg.to_sym]
-      
-      if arg_config.type == :array
-        usage << "<#{arg}> ..."
-      else
-        usage << "<#{arg}> "  
-      end      
-    end
-    myself.usage = usage
-    myself
-  end
-  
-  #---
-  
-  def usage=usage
-    set(:usage, usage)
-  end
-  
-  def usage
-    get(:usage, '')
-  end
-  
-  #---
-  
-  def help
-    return @parser.help if @parser
-    usage
-  end
-  
-  #---
-  
-  def result=result
-    set(:result, result)
-  end
-  
-  def result
-    get(:result, nil)
-  end
-
-  #-----------------------------------------------------------------------------
-  # Operations
- 
-  def parse_base(args)    
-    logger.info("Parsing action #{plugin_provider} with: #{args.inspect}")
-    
-    @parser = Util::CLI::Parser.new(args, usage) do |parser|
-      parse(parser)      
-      extension(:parse, { :parser => parser, :config => config })
-    end
-    
-    if @parser 
-      if @parser.processed
-        set(:processed, true)
-        settings.import(Util::Data.merge([ @parser.options, @parser.arguments ], true))
-        logger.debug("Parse successful: #{export.inspect}")
-        
-      elsif @parser.options[:help] && ! quiet?
-        puts I18n.t('corl.core.exec.help.usage') + ': ' + help + "\n"
-        
-      else
-        if @parser.options[:help]
-          logger.debug("Help wanted but running in silent mode")
-        else
-          logger.warn("Parse failed for unknown reasons")
-        end
-      end
-    end
-  end
-  
-  #---
-  
-  def parse(parser)
-        
-    generate = lambda do |format, name|
-      formats = [ :option, :arg ]
-      types   = [ :bool, :int, :float, :str, :array ]
-      name    = name.to_sym
-          
-      if config.export.has_key?(name) && formats.include?(format.to_sym)
-        option_config = config[name]
-        type          = option_config.type
-        default       = option_config.default
-        locale        = option_config.locale        
-        
-        if types.include?(type.to_sym)
-          value_label = "#{type.to_s.upcase}"
-      
-          if type == :bool
-            parser.send("option_#{type}", name, default, "--[no-]#{name}", locale)        
-          elsif format == :arg
-            parser.send("#{format}_#{type}", name, default, locale)  
-          else
-            if type == :array
-              parser.send("option_#{type}", name, default, "--#{name} #{value_label},...", locale)  
-            else
-              parser.send("option_#{type}", name, default, "--#{name} #{value_label}", locale)
-            end
-          end
-        end           
-      end
-    end
-     
-    #---
-    
-    options.each do |name|
-      generate.call(:option, name)  
-    end
-    
-    arguments.each do |name|
-      generate.call(:arg, name)
-    end 
-  end
-  
-  #---
-  
-  def validate(node, network)
-    # TODO: Add extension hooks and logging
-    
-    # Validate all of the configurations
-    success = true
-    config.export.each do |name, option|
-      success = false unless option.validate(settings[name], node, network)
-    end
-    if success
-      # Check for missing arguments (in case of internal execution mode)
-      arguments.each do |name|        
-        if settings[name.to_sym].nil?
-          warn('corl.core.exec.errors.missing_argument', { :name => name })
-          success = false
-        end
-      end
-    end
-    if ignore.include?(:nodes)
-      settings[:nodes] = []
-    end
-    success
-  end
-  
-  #---
-   
-  def execute
-    logger.info("Executing action #{plugin_provider}")
-    
-    myself.status = code.success
-    myself.result = nil
-    
-    if processed?      
-      node_exec do |node, network|
-        hook_config = { :node => node, :network => network }
-        
-        begin
-          yield(node, network) if block_given? && extension_check(:exec_init, hook_config)
-          myself.status = extension_set(:exec_exit, status, hook_config)
-        ensure
-          cleanup
-        end
-      end
-    else
-      if @parser.options[:help]
-        myself.status = code.help_wanted
-      else
-        myself.status = code.action_unprocessed
-      end
-    end
-    
-    myself.status = code.unknown_status unless status.is_a?(Integer)
-    
-    if processed? && status != code.success
-      logger.warn("Execution failed for #{plugin_provider} with status #{status}: #{export.inspect}")
-      alert(Codes.render_index(status))
-    end  
-    
-    status
-  end
-  
-  #---
-  
-  def run
-    @action_interface
-  end
-  
-  #---
-  
-  def cleanup
-    logger.info("Running cleanup for action #{plugin_provider}")
-    
-    yield if block_given?
-    
-    # Nothing to do right now
-    extension(:cleanup)
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Output
-  
-  def render_options
-    settings
-  end
-end
-end
-end

data/lib/corl_core/plugin/base.rb

@@ -1,374 +0,0 @@
-
-module CORL
-module Plugin
-class Base < Core
-  
-  include Mixin::Lookup
-     
-  #---
-  
-  # All Plugin classes should directly or indirectly extend Base
-  
-  def initialize(type, provider, options)
-    config = Util::Data.clean(Config.ensure(options))
-    name   = Util::Data.ensure_value(config.delete(:plugin_name), config.delete(:name, provider))
-    @quiet = config.delete(:quiet, false)
-       
-    set_meta(config.delete(:meta, Config.new))
-    
-    # No logging statements aove this line!!
-    super(config.import({ :logger => "#{plugin_type}->#{plugin_provider}" }))
-    myself.plugin_name = name
-    
-    logger.debug("Set #{plugin_type} plugin #{plugin_name} meta data: #{meta.inspect}")    
-    logger.debug("Normalizing #{plugin_type} plugin #{plugin_name}")
-    normalize
-  end
-  
-  #---
-  
-  def method_missing(method, *args, &block)  
-    return nil  
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Checks
-  
-  def initialized?(options = {})
-    return true  
-  end
-  
-  #---
-  
-  def quiet?
-    @quiet
-  end
-   
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
-  
-  def myself
-    return current_actor if respond_to?(:current_actor) # Celluloid enhanced plugin
-    self
-  end
-  alias_method :me, :myself
-  
-  #---
-  
-  def quiet=quiet
-    @quiet = quiet
-  end
-  
-  #---
-  
-  def meta
-    return @meta
-  end
-  
-  #---
-  
-  def set_meta(meta)
-    @meta = Config.ensure(meta)
-  end
-  
-  #---
-  
-  def plugin_name
-    return meta.get(:name)
-  end
-  alias_method :name, :plugin_name
-  
-  def plugin_name=plugin_name
-    meta.set(:name, string(plugin_name))
-  end
-  alias_method :name=, :plugin_name=
-  
-  #---
-  
-  def plugin_type
-    return meta.get(:type)
-  end
-  
-  #---
-  
-  def plugin_provider
-    return meta.get(:provider)
-  end
-  
-  #---
-  
-  def plugin_directory
-    return meta.get(:directory)
-  end
-  
-  #---
-  
-  def plugin_file
-    return meta.get(:file)
-  end
-  
-  #---
-  
-  def plugin_instance_name
-    return meta.get(:instance_name)
-  end
-  
-  #---
-  
-  def plugin_parent=parent
-    meta.set(:parent, parent) if parent.is_a?(CORL::Plugin::Base)
-  end
-  
-  def plugin_parent
-    return meta.get(:parent)
-  end
-
-  #-----------------------------------------------------------------------------
-  # Status codes
-    
-  def code
-    CORL.code
-  end
-  
-  def codes(*codes)
-    CORL.codes(*codes)
-  end
-
-  #---
-  
-  def status=status
-    meta.set(:status, status)
-  end
-  
-  def status
-    meta.get(:status, code.unknown_status)
-  end
-
-  #-----------------------------------------------------------------------------
-  # Plugin operations
-    
-  def normalize
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Extensions
-  
-  def hook_method(hook)
-    "#{plugin_type}_#{plugin_provider}_#{hook}"  
-  end
-  
-  #---
-  
-  def extension(hook, options = {})
-    method = hook_method(hook)
-    
-    logger.debug("Executing plugin hook #{hook} (#{method})")
-    
-    return Manager.connection.exec(method, Config.ensure(options).defaults({ :extension_type => :base }).import({ :plugin => myself })) do |op, results|
-      results = yield(op, results) if block_given?
-      results
-    end
-  end
-  
-  #---
-  
-  def extended_config(type, options = {})
-    config = Config.ensure(options)
-    
-    logger.debug("Generating #{type} extended configuration from: #{config.export.inspect}")
-      
-    extension("#{type}_config", Config.new(config.export).import({ :extension_type => :config })) do |op, results|
-      if op == :reduce
-        results.each do |provider, result|
-          config.defaults(result)
-        end
-        nil
-      else
-        hash(results)
-      end
-    end    
-    config.delete(:extension_type)
-     
-    logger.debug("Final extended configuration: #{config.export.inspect}")   
-    config 
-  end
-  
-  #---
-  
-  def extension_check(hook, options = {})
-    config = Config.ensure(options)
-    
-    logger.debug("Checking extension #{plugin_provider} #{hook} given: #{config.export.inspect}")
-    
-    success = extension(hook, config.import({ :extension_type => :check })) do |op, results|
-      if op == :reduce
-        ! results.values.include?(false)
-      else
-        results ? true : false
-      end
-    end
-    
-    success = success.nil? || success ? true : false
-    
-    logger.debug("Extension #{plugin_provider} #{hook} check result: #{success.inspect}")  
-    success
-  end
-  
-  #---
-  
-  def extension_set(hook, value, options = {})
-    config = Config.ensure(options)
-    
-    logger.debug("Setting extension #{plugin_provider} #{hook} value given: #{value.inspect}")
-    
-    extension(hook, config.import({ :value => value, :extension_type => :set })) do |op, results|
-      if op == :process
-        value = results unless results.nil?  
-      end
-    end
-    
-    logger.debug("Extension #{plugin_provider} #{hook} set value to: #{value.inspect}")  
-    value
-  end
-  
-  #---
-  
-  def extension_collect(hook, options = {})
-    config = Config.ensure(options)
-    values = []
-    
-    logger.debug("Collecting extension #{plugin_provider} #{hook} values")
-    
-    extension(hook, config.import({ :extension_type => :add })) do |op, results|
-      if op == :process
-        values << results unless results.nil?  
-      end
-    end
-    
-    logger.debug("Extension #{plugin_provider} #{hook} collected values: #{values.inspect}")  
-    values
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Output
-  
-  def render_options
-    export  
-  end
-  protected :render_options
-  
-  #---
-  
-  def render(display, options = {})
-    ui.info(display.strip, options) unless quiet? || display.strip.empty?
-  end
-  
-  #---
-        
-  def info(name, options = {})
-    ui.info(I18n.t(name, Util::Data.merge([ Config.ensure(render_options).export, options ], true))) unless quiet?
-  end
-  
-  #---
-   
-  def alert(display, options = {})
-    ui.warn(display.strip, options) unless quiet? || display.strip.empty?
-  end
-        
-  #---
-       
-  def warn(name, options = {})
-    ui.warn(I18n.t(name, Util::Data.merge([ Config.ensure(render_options).export, options ], true))) unless quiet?  
-  end
-        
-  #---
-        
-  def error(name, options = {})
-    ui.error(I18n.t(name, Util::Data.merge([ Config.ensure(render_options).export, options ], true))) unless quiet?  
-  end
-        
-  #---
-        
-  def success(name, options = {})
-    ui.success(I18n.t(name, Util::Data.merge([ Config.ensure(render_options).export, options ], true))) unless quiet?  
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.build_info(type, data)  
-    plugins = []
-        
-    if data.is_a?(Hash)
-      data = [ data ]
-    end
-    
-    logger.debug("Building plugin list of #{type} from data: #{data.inspect}")
-    
-    if data.is_a?(Array)
-      data.each do |info|
-        unless Util::Data.empty?(info)
-          info = translate(info)
-          
-          if Util::Data.empty?(info[:provider])
-            info[:provider] = Manager.connection.type_default(type)
-          end
-          
-          logger.debug("Translated plugin info: #{info.inspect}")
-          
-          plugins << info
-        end
-      end
-    end
-    return plugins
-  end
-  
-  #---
-
-  def self.translate(data)
-    logger.debug("Translating data to internal plugin structure: #{data.inspect}")
-    return ( data.is_a?(Hash) ? symbol_map(data) : {} )
-  end
-  
-  #---
-  
-  def self.init_plugin_collection
-    logger.debug("Initializing plugin collection interface at #{Time.now}")
-    
-    include Celluloid
-    include Mixin::Settings
-    include Mixin::SubConfig
-    
-    extend Mixin::Macro::PluginInterface
-  end
-  
-  #---
-  
-  def safe_exec(return_result = true)
-    begin
-      result = yield
-      return result if return_result
-      return true
-      
-    rescue Exception => e
-      logger.error(e.inspect)
-      logger.error(e.message)
-      
-      ui.error(e.message, { :prefix => false }) if e.message
-    end
-    return false
-  end
-  
-  #---
-  
-  def admin_exec
-    if CORL.admin?
-      yield if block_given?
-    else
-      ui.warn("The #{plugin_provider} action must be run as a machine administrator")
-      myself.status = code.access_denied    
-    end
-  end
-end
-end
-end