nucleon 0.1.0 → 0.1.1

data/lib/core/plugin/action.rb

@@ -0,0 +1,371 @@
+
+module Nucleon
+module Plugin
+class Action < Base
+  
+  #-----------------------------------------------------------------------------
+  # 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? ? "nucleon.actions.#{provider}.options.#{name}" : locale
+      @validator = validator if validator
+    end
+    
+    #---
+    
+    attr_reader :provider, :name, :type
+    attr_accessor :default, :locale, :validator
+    
+    #---
+    
+    def validate(value, *args)
+      success = true
+      if @validator
+        success = @validator.call(value, *args)
+      end
+      success
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  # Action plugin interface
+  
+  def self.exec_safe(provider, options)
+    action_result = nil
+    
+    begin
+      logger = Nucleon.logger
+      
+      logger.debug("Running nucleon action #{provider} with #{options.inspect}")
+      action        = Nucleon.action(provider, options)
+      exit_status   = action.execute
+      action_result = action.result
+      
+    rescue Exception => error
+      logger.error("Nucleon action #{provider} experienced an error:")
+      logger.error(error.inspect)
+      logger.error(error.message)
+      logger.error(Nucleon::Util::Data.to_yaml(error.backtrace))
+
+      Nucleon.ui.error(error.message, { :prefix => false }) if error.message
+  
+      exit_status = error.status_code if error.respond_to?(:status_code)
+    end
+    
+    Nucleon.remove_plugin(action) if action
+
+    exit_status = Nucleon.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)))
+      
+      Nucleon.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(executable_name = 'nucleon')
+    yield if block_given?
+    
+    usage = "#{executable_name} #{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('nucleon.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
+    # 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])
+    end
+    if success
+      # Check for missing arguments (in case of internal execution mode)
+      arguments.each do |name|        
+        if settings[name.to_sym].nil?
+          warn('nucleon.core.exec.errors.missing_argument', { :name => name })
+          success = false
+        end
+      end
+    end
+    success
+  end
+  
+  #---
+   
+  def execute
+    logger.info("Executing action #{plugin_provider}")
+    
+    myself.status = code.success
+    myself.result = nil
+    
+    if processed?      
+      begin
+        yield if block_given? && extension_check(:exec_init)
+        myself.status = extension_set(:exec_exit)
+      ensure
+        cleanup
+      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/core/plugin/base.rb

@@ -0,0 +1,313 @@
+
+module Nucleon
+module Plugin
+class Base < Core
+  
+  # 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("Normalizing #{plugin_type} plugin #{plugin_name} with meta data: #{meta.inspect}")
+    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_namespace
+    return meta.get(:namespace)
+  end
+  
+  #---
+  
+  def plugin_type
+    return meta.get(:type)
+  end
+  
+  #---
+  
+  def plugin_provider
+    return meta.get(:provider)
+  end
+  
+  #---
+  
+  def plugin_name
+    return meta.get(:name)
+  end
+  
+  def plugin_name=plugin_name
+    meta.set(:name, string(plugin_name))
+  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?(Nucleon::Plugin::Base)
+  end
+  
+  def plugin_parent
+    return meta.get(:parent)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Status codes
+    
+  def code
+    Nucleon.code
+  end
+  
+  def codes(*codes)
+    Nucleon.codes(*codes)
+  end
+
+  #---
+  
+  def status=status
+    meta.set(:status, status)
+  end
+  
+  def status
+    meta.get(:status, code.unknown_status)
+  end
+
+  #-----------------------------------------------------------------------------
+  # Plugin operations
+    
+  def normalize
+    # Implement in sub classes
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Extensions
+  
+  def hook_method(hook)
+    "#{plugin_type}_#{plugin_provider}_#{hook}"  
+  end
+  
+  #---
+  
+  def extension(hook, options = {}, &code)
+    Nucleon.exec(hook_method(hook), Config.ensure(options).import({ :plugin => myself }), &code)
+  end
+  
+  #---
+  
+  def extended_config(type, options = {})
+    Nucleon.config(type, Config.ensure(options).import({ :plugin => myself }))
+  end
+  
+  #---
+  
+  def extension_check(hook, options = {})
+    Nucleon.check(hook_method(hook), Config.ensure(options).import({ :plugin => myself }))
+  end
+  
+  #---
+  
+  def extension_set(hook, value, options = {})
+    Nucleon.set(hook_method(hook), value, Config.ensure(options).import({ :plugin => myself }))
+  end
+  
+  #---
+  
+  def extension_collect(hook, options = {})
+    Nucleon.collect(hook_method(hook), Config.ensure(options).import({ :plugin => myself }))
+  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] = Nucleon.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, &code)
+    begin
+      result = code.call
+      return result if return_result
+      return true
+      
+    rescue Exception => error
+      logger.error(error.inspect)
+      logger.error(error.message)
+      
+      ui.error(error.message, { :prefix => false }) if error.message
+    end
+    return false
+  end
+  
+  #---
+  
+  def admin_exec(return_result = true, &code)
+    if Nucleon.admin?
+      safe_exec(return_result, &code) 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