corl 0.4.0

data/lib/corl_core/plugin/base.rb

@@ -0,0 +1,374 @@
+
+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

data/lib/corl_core/plugin/command.rb

@@ -0,0 +1,98 @@
+
+module CORL
+module Plugin
+class Command < Base
+
+  #-----------------------------------------------------------------------------
+  # Command plugin interface
+  
+  def normalize
+    super
+  end
+  
+  #---
+   
+  def to_s
+    return build(export)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+  
+  def command(default = '')
+    return string(get(:command, default))
+  end
+  
+  #---
+  
+  def command=command
+    set(:command, string(command))
+  end
+  
+  #---
+  
+  def args(default = [])
+    return array(get(:args, default)) 
+  end
+  
+  #---
+  
+  def args=args
+    set(:args, array(args))
+  end
+  
+  #---
+  
+  def flags(default = [])
+    return array(get(:flags, default)) 
+  end
+  
+  #---
+  
+  def flags=flags
+    set(:flags, array(flags))
+  end
+  
+  #---
+  
+  def data(default = {})
+    return hash(get(:data, default)) 
+  end
+  
+  #---
+  
+  def data=data
+    set(:data, hash(data))
+  end
+  
+  #---
+  
+  def subcommand=subcommand
+    unless Util::Data.empty?(subcommand)
+      set(:subcommand, new(hash(subcommand)))
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Command operations
+  
+  def build(components = {}, overrides = nil, override_key = false)
+    logger.debug("Building command with #{components.inspect}")
+    logger.debug("Overrides: #{overrides.inspect}")
+    logger.debug("Override key: #{override_key}")
+    
+    return '' # Implement in sub classes
+  end
+  
+  #---
+  
+  def exec(options = {}, overrides = nil)
+    logger.debug("Executing command with #{options.inspect}")
+    logger.debug("Overrides: #{overrides.inspect}")
+    
+    # Implement in sub classes (don't forget the yield!)
+    return true
+  end
+end
+end
+end

data/lib/corl_core/plugin/configuration.rb

@@ -0,0 +1,177 @@
+
+module CORL
+module Plugin
+class Configuration < Base
+    
+  include Mixin::SubConfig
+
+  #-----------------------------------------------------------------------------
+  # Configuration plugin interface
+  
+  def normalize
+    super
+    
+    logger.debug("Initializing source sub configuration")
+    init_subconfig(true)
+    
+    _init(:autoload, true)
+    _init(:autosave, false)
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def can_persist?
+    false
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def autoload(default = false)
+    _get(:autoload, default)
+  end
+  
+  def autoload=autoload
+    _set(:autoload, test(autoload))
+  end
+   
+  #---
+  
+  def autosave(default = false)
+    _get(:autosave, default)
+  end
+  
+  def autosave=autosave
+    _set(:autosave, test(autosave))
+  end
+  
+  #-----------------------------------------------------------------------------
+    
+  def set(keys, value = '', options = {})
+    super(keys, value)
+    save(options) if autosave
+  end
+   
+  #---
+   
+  def delete(keys, options = {})
+    super(keys)
+    save(options) if autosave
+  end
+  
+  #---
+  
+  def clear(options = {})
+    super
+    save(options) if autosave
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def remote(name)
+    nil
+  end
+
+  #---
+  
+  def set_remote(name, location)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def import(properties, options = {})
+    super(properties, options)
+    save(options) if autosave
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Configuration loading / saving
+    
+  def load(options = {})
+    method_config = Config.ensure(options)
+    success = false
+    
+    if can_persist?
+      if extension_check(:load, { :config => method_config })
+        logger.info("Loading source configuration")
+      
+        config.clear if method_config.get(:override, false)
+      
+        properties = Config.new
+        yield(method_config, properties) if block_given?
+          
+        unless properties.export.empty?
+          logger.debug("Source configuration parsed properties: #{properties}")
+        
+          extension(:load_process, { :properties => properties, :config => method_config })               
+          config.import(properties, method_config)
+        end
+        success = true
+      end
+    else
+      logger.warn("Loading of source configuration failed")
+    end
+    success
+  end
+   
+  #---
+    
+  def save(options = {})
+    method_config = Config.ensure(options)
+    success       = false
+    
+    if can_persist?
+      if extension_check(:save, { :config => method_config })
+        logger.info("Saving source configuration")
+        logger.debug("Source configuration properties: #{config.export}") 
+      
+        success = yield(method_config) if block_given?
+      end
+    else
+      logger.warn("Can not save source configuration")
+    end
+    success
+  end
+  
+  #---
+  
+  def remove(options = {})
+    method_config = Config.ensure(options)
+    success       = false
+    
+    if can_persist?
+      if extension_check(:delete, { :config => method_config })
+        logger.info("Removing source configuration")
+      
+        config.clear
+      
+        success = yield(method_config) if block_given?
+      end
+    else
+      logger.warn("Can not remove source configuration")
+    end
+    success
+  end
+  
+  #---
+  
+  def attach(type, name, data, options = {})
+    method_config = Config.ensure(options)
+    new_location  = nil
+    
+    if can_persist?
+      if extension_check(:attach, { :config => method_config })
+        logger.info("Attaching data to source configuration")
+      
+        new_location = yield(method_config) if block_given?
+      end
+    else
+      logger.warn("Can not attach data to source configuration")
+    end
+    new_location
+  end
+end
+end
+end

data/lib/corl_core/plugin/event.rb

@@ -0,0 +1,53 @@
+
+module CORL
+module Plugin
+class Event < Base
+
+  #-----------------------------------------------------------------------------
+  # Event plugin interface
+
+  
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def render
+    return name
+  end
+  
+  #---
+ 
+  def check(source)
+    # Implement in sub classes
+    return true
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.build_info(type, data)  
+    data = data.split(/\s*,\s*/) if data.is_a?(String)
+    return super(type, data)
+  end
+  
+  #---
+   
+  def self.translate(data)
+    options = super(data)
+    
+    case data        
+    when String
+      components = data.split(':')
+      
+      options[:provider] = components.shift
+      options[:string]   = components.join(':')
+      
+      logger.debug("Translating event options: #{options.inspect}") 
+    end
+    return options  
+  end
+end
+end
+end

data/lib/corl_core/plugin/extension.rb

@@ -0,0 +1,12 @@
+
+module CORL
+module Plugin
+class Extension < Base
+
+  #-----------------------------------------------------------------------------
+  # Extension plugin interface
+
+  # This plugin type is just a system container for various plugin hooks
+end
+end
+end