nucleon 0.1.19 → 0.2.0

data/lib/core/facade.rb

@@ -7,8 +7,9 @@ module Parallel
   
   def self.included(klass)
     if Nucleon.parallel?
-      klass.send :include, Celluloid      
-    end
+      klass.send :include, Celluloid
+      klass.finalizer :parallel_finalize      
+    end    
     klass.send :include, InstanceMethods
     klass.extend ClassMethods
   end
@@ -16,22 +17,62 @@ module Parallel
   #---
   
   module InstanceMethods
-    def parallel(method, split_args, *shared_args)
+    def parallel_finalize
+      # Override if needed  
+    end
+    
+    #---
+    
+    def parallel(method, args, *shared_args)
+      results = nil
+      
+      case args
+      when Hash
+        results = parallel_hash(method, args, *shared_args)
+      when Array, String, Symbol
+        results = parallel_array(method, args, *shared_args)   
+      end
+      results
+    end
+    
+    #---
+    
+    def parallel_array(method, array_args, *shared_args)
       results    = []
-      split_args = [ split_args ] unless split_args.is_a?(Array)
+      array_args = [ array_args ] unless array_args.is_a?(Array)
   
       if Nucleon.parallel?
-        split_args.each do |arg|
+        array_args.each do |arg|
           results << future.send(method, arg, *shared_args)
         end
         results.map { |future| future.value } # Wait for all to finish.
       else
-        split_args.each do |arg|
+        array_args.each do |arg|
           results << send(method, arg, *shared_args)
         end  
       end
       results
     end
+    
+    #---
+    
+    def parallel_hash(method, hash_args, *shared_args)
+      results = {}
+      
+      if Nucleon.parallel?
+        hash_args.each do |key, value|
+          results[key] = future.send(method, key, value, *shared_args)
+        end
+        results.keys.each do |key| # Wait for all to finish.
+          results[key] = results[key].value
+        end
+      else
+        hash_args.each do |key, value|
+          results[key] = send(method, key, value, *shared_args)
+        end  
+      end
+      results
+    end
   end
   
   #---
@@ -95,33 +136,35 @@ module Facade
   
   #---
   
-  def manager(collection, name, klass)
-    name = name.to_sym
-    
-    if collection.has_key?(name)
-      manager = collection[name]
+  def manager(collection, name, klass, reset = false)
+    name     = name.to_sym
+    actor_id = "#{klass}::#{name}".to_sym
+        
+    if collection.has_key?(actor_id)
+      manager = parallel? ? Celluloid::Actor[actor_id] : collection[actor_id]
     else
       if parallel?
-        klass.supervise_as name
-        manager = Celluloid::Actor[name]
+        klass.supervise_as(actor_id, actor_id, reset)
+        manager = Celluloid::Actor[actor_id]
       else
-        manager = klass.new # Managers should not have initialization parameters
+        manager = klass.new(actor_id, reset) # Managers should have standardized initialization parameters
       end
-      collection[name] = manager
+      collection[actor_id] = manager
     end
-    test_connection(manager)
-    manager
+    test_connection(actor_id, manager)
   end
   
-  def test_connection(manager)
+  def test_connection(actor_id, manager)
     if parallel?
       begin
         # Raise error if no test method found but retry for dead actors
         manager.test_connection
+        
       rescue Celluloid::DeadActorError
         retry
       end
     end
+    manager
   end
   
   #-----------------------------------------------------------------------------
@@ -203,98 +246,110 @@ module Facade
     Manager.connection.namespaces
   end
   
-  def define_namespace(*namespaces)
-    Manager.connection.namespace(*namespaces) 
-  end
-  
   #---
   
-  def types
-    Manager.connection.types
+  def types(namespace)
+    Manager.connection.types(namespace)
   end
   
-  def define_type(type_info)
-    Manager.connection.define_type(type_info)
+  def define_types(namespace, type_info)
+    Manager.connection.define_types(namespace, type_info)
   end
    
-  def type_default(type)
-    Manager.connection.type_default(type)
+  def type_default(namespace, plugin_type)
+    Manager.connection.type_default(namespace, plugin_type)
   end
   
   #---
   
+  def load_plugins(base_dir = nil)
+    base_dir = base_dir.nil? ? Dir.pwd : base_dir
+    
+    search_plugins = lambda do |search_dir|
+      lib_dir = File.join(search_dir, 'lib')
+      
+      if File.directory?(lib_dir)
+        logger.debug("Registering plugins at #{lib_dir}")
+        register(lib_dir)
+      end
+      
+      parent_search_dir = search_dir.sub(/#{File::SEPARATOR}[^#{File::SEPARATOR}]+$/, '')
+      search_plugins.call(parent_search_dir) unless parent_search_dir.split(File::SEPARATOR).empty?
+    end
+    
+    search_plugins.call(base_dir)
+  end
+  
   def register(base_path, &code)
     Manager.connection.register(base_path, &code)
     Manager.connection.autoload
   end
   
-  def loaded_plugins(type = nil, provider = nil)
-    Manager.connection.loaded_plugins(type, provider)    
+  def loaded_plugins(namespace = nil, plugin_type = nil, provider = nil)
+    Manager.connection.loaded_plugins(namespace, plugin_type, provider)    
   end
   
   #---
   
-  def active_plugins(type = nil, provider = nil)
-    Manager.connection.plugins(type, provider)    
+  def active_plugins(namespace = nil, plugin_type = nil, provider = nil)
+    Manager.connection.active_plugins(namespace, plugin_type, provider)    
   end
   
   #---
   
-  def plugin(type, provider, options = {})
-    Manager.connection.load(type, provider, options)
+  def plugin(namespace, plugin_type, provider, options = {})
+    Manager.connection.load(namespace, plugin_type, provider, options)
   end
   
   #---
   
-  def plugins(type, data, build_hash = false, keep_array = false)
-    Manager.connection.load_multiple(type, data, build_hash, keep_array)
+  def plugins(namespace, plugin_type, data, build_hash = false, keep_array = false)
+    Manager.connection.load_multiple(namespace, plugin_type, data, build_hash, keep_array)
   end
   
   #---
   
-  def create_plugin(type, provider, options = {})
-    Manager.connection.create(type, provider, options)
+  def create_plugin(namespace, plugin_type, provider, options = {})
+    Manager.connection.create(namespace, plugin_type, provider, options)
   end
   
   #---
   
-  def get_plugin(type, name)
-    Manager.connection.get(type, name)
+  def get_plugin(namespace, plugin_type, plugin_name)
+    Manager.connection.get(namespace, plugin_type, plugin_name)
   end
   
   #---
   
-  def remove_plugin(plugin)
-    Manager.connection.remove(plugin)
+  def remove_plugin_by_name(namespace, plugin_type, plugin_instance_name)
+    Manager.connection.remove_by_name(namespace, plugin_type, plugin_instance_name)  
   end
   
-  #---
-  
-  def plugin_class(type)
-    Manager.connection.plugin_class(type)
+  def remove_plugin(plugin)
+    Manager.connection.remove(plugin)
   end
   
   #---
   
-  def provider_class(namespace, type, provider)
-    Manager.connection.provider_class(namespace, type, provider)  
+  def plugin_class(namespace, plugin_type)
+    Manager.connection.plugin_class(namespace, plugin_type)
   end
     
   #-----------------------------------------------------------------------------
   # Core plugin type facade
   
   def extension(provider)
-    plugin(:extension, provider, {})
+    plugin(:nucleon, :extension, provider, {})
   end
   
   #---
   
   def action(provider, options)
-    plugin(:action, provider, options)
+    plugin(:nucleon, :action, provider, options)
   end
   
   def actions(data, build_hash = false, keep_array = false)
-    plugins(:action, data, build_hash, keep_array)  
+    plugins(:nucleon, :action, data, build_hash, keep_array)  
   end
   
   def action_config(provider)
@@ -313,55 +368,72 @@ module Facade
     Plugin::Action.exec_cli(provider, args, quiet, name)
   end
   
+  def search_actions(args)
+    action_info = Plugin::Action.search_actions(args)
+    
+    action_components = action_info[:components]
+    action            = action_info[:actions]
+      
+    action_components.each do |component|
+      args.shift
+    end
+    
+    [ action, action_components, args ]
+  end
+  
+  def action_help(action = nil, extended_help = false)
+    Plugin::Action.action_help(action, extended_help)
+  end
+  
   #---
   
   def project(options, provider = nil)
-    plugin(:project, provider, options)
+    plugin(:nucleon, :project, provider, options)
   end
   
   def projects(data, build_hash = false, keep_array = false)
-    plugins(:project, data, build_hash, keep_array)
+    plugins(:nucleon, :project, data, build_hash, keep_array)
   end
    
   #-----------------------------------------------------------------------------
   # Utility plugin type facade
   
   def command(options, provider = nil)
-    plugin(:command, provider, options)
+    plugin(:nucleon, :command, provider, options)
   end
   
   def commands(data, build_hash = false, keep_array = false)
-    plugins(:command, data, build_hash, keep_array)
+    plugins(:nucleon, :command, data, build_hash, keep_array)
   end
    
   #---
   
   def event(options, provider = nil)
-    plugin(:event, provider, options)
+    plugin(:nucleon, :event, provider, options)
   end
   
   def events(data, build_hash = false, keep_array = false)
-    plugins(:event, data, build_hash, keep_array)
+    plugins(:nucleon, :event, data, build_hash, keep_array)
   end
   
   #---
   
   def template(options, provider = nil)
-    plugin(:template, provider, options)
+    plugin(:nucleon, :template, provider, options)
   end
   
   def templates(data, build_hash = false, keep_array = false)
-    plugins(:template, data, build_hash, keep_array)
+    plugins(:nucleon, :template, data, build_hash, keep_array)
   end
    
   #---
   
   def translator(options, provider = nil)
-    plugin(:translator, provider, options)
+    plugin(:nucleon, :translator, provider, options)
   end
   
   def translators(data, build_hash = false, keep_array = false)
-    plugins(:translator, data, build_hash, keep_array)
+    plugins(:nucleon, :translator, data, build_hash, keep_array)
   end
   
   #-----------------------------------------------------------------------------
@@ -433,62 +505,41 @@ module Facade
   #---
   
   def executable(args, name = 'nucleon') #ARGV
-    Signal.trap("INT") { exit 1 }
-
     logger.info("`#{name}` invoked: #{args.inspect}")
 
     $stdout.sync = true
     $stderr.sync = true
     
     exit_status = nil
+    
+    # We need to catch this early.
+    Util::Console.use_colors = ! args.include?("--no-color")
+    args = args - [ "--no-color", "--color" ]
 
     begin
       logger.debug("Beginning execution run")
       
-      arg_components = Util::CLI::Parser.split(args, "#{name} <action> [ <arg> ... ]")
+      load_plugins
+      
+      arg_components = Util::CLI::Parser.split(args, cyan(name) + yellow(" <action components> [<arg> ...]"))
       main_command   = arg_components.shift
-      sub_command    = arg_components.shift
-      sub_args       = arg_components
       
-      lib_dir = File.join(Dir.pwd, 'lib')
-      if File.directory?(lib_dir)
-        logger.debug("Registering plugins at #{lib_dir}")
-        Nucleon.register(lib_dir)
-      end
-            
-      if main_command.processed && sub_command
-        exit_status = action_cli(sub_command, sub_args, false, name)
+      action, action_components, args = search_actions(args)
+      
+      if main_command.processed && action.is_a?(Hash)
+        exit_status = action_cli(action[:provider], args, false, name)
       else
         puts I18n.t('nucleon.core.exec.help.usage') + ': ' + main_command.help + "\n"
-        puts I18n.t('nucleon.core.exec.help.header') + ":\n\n"
+        puts I18n.t('nucleon.core.exec.help.header') + ":\n"
         
-        help_data     = {}
-        extended_help = main_command.options[:extended_help]
-        
-        loaded_plugins(:action).each do |provider, data|
-          namespace = data[:namespace]
-          
-          help_data[namespace]           = {} unless help_data.has_key?(namespace)
-          help_data[namespace][provider] = data
-        end
+        action = main_command.processed ? action : nil
+        puts action_help(action, args.include?("--help"))
         
-        help_data.each do |namespace, actions|
-          actions.each do |provider, data|
-            if extended_help
-              help_text = action(provider, { :args => [ '-h' ], :quiet => true }).help  
-            else
-              help_text = action(provider, { :settings => {}, :quiet => true }).help   
-            end
-            puts sprintf("   %-15s : %s\n", namespace, help_text)  
-          end
-          puts "\n"
-        end
-    
-        puts "\n" + I18n.t('nucleon.core.exec.help.footer', { :name => name }) + "\n\n"   
+        puts "\n" + I18n.t('nucleon.core.exec.help.footer', { :command => cyan(name) + yellow(" <action> -h") }) + "\n\n"   
         exit_status = code.help_wanted  
       end 
   
-    rescue Exception => error
+    rescue => error
       logger.error("Nucleon executable experienced an error:")
       logger.error(error.inspect)
       logger.error(error.message)
@@ -499,6 +550,7 @@ module Facade
       exit_status = error.status_code if error.respond_to?(:status_code)
       exit_status = code.unknown_status if exit_status.nil?
     end
+    
     exit_status
   end
   

data/lib/core/manager.rb

@@ -6,28 +6,40 @@ class Manager
     
   #-----------------------------------------------------------------------------
   
-  @@supervisors = {}
+  @@supervisors  = {}
+  @@environments = {}
   
   #-----------------------------------------------------------------------------
   # Plugin manager interface
   
-  def self.connection(name = :core)
-    Nucleon.manager(@@supervisors, name, self)
+  def self.connection(name = :core, reset = false)
+    Nucleon.manager(@@supervisors, name, self, reset)
   end
   
   #---
   
-  def initialize
-    @logger = Nucleon.logger
+  def initialize(actor_id, reset)
+    @logger   = Nucleon.logger
+    @actor_id = actor_id
     
-    @namespaces = {}
-    @types      = {}
-    @load_info  = {}    
-    @plugins    = {}
+    if reset || ! @@environments[@actor_id]
+      @@environments[@actor_id] = Environment.new  
+    end
   end
   
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
+  #---
+  
+  def parallel_finalize
+    active_plugins.each do |namespace, namespace_plugins|
+      namespace_plugins.each do |plugin_type, type_plugins|
+        type_plugins.each do |instance_name, plugin|
+          remove(plugin)
+        end
+      end
+    end
+  end
+  
+  #---
   
   attr_reader :logger
   
@@ -39,93 +51,81 @@ class Manager
   
   #---
   
-  def namespaces
-    @namespaces.keys
+  def test_connection
+    true
   end
   
-  def define_namespace(*names)
-    names.each do |namespace|
-      @namespaces[namespace.to_sym] = true
-    end  
+  #-----------------------------------------------------------------------------
+  # Plugin model accessors / modifiers
+  
+  def namespaces
+    @@environments[@actor_id].namespaces
   end
   
   #---
   
-  def types
-    @types.keys
+  def types(namespace)
+    @@environments[@actor_id].plugin_types(namespace)
   end
   
-  #---
+  def define_type(namespace, plugin_type, default_provider)
+    @@environments[@actor_id].define_plugin_type(namespace, plugin_type, default_provider)  
+  end
   
-  def type_default(type)
-    @types[type.to_sym]
+  def define_types(namespace, type_info)
+    @@environments[@actor_id].define_plugin_types(namespace, type_info) 
   end
   
-  #---
+  def type_defined?(namespace, plugin_type)
+    @@environments[@actor_id].plugin_type_defined?(namespace, plugin_type)  
+  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
+  def type_default(namespace, plugin_type)
+    @@environments[@actor_id].plugin_type_default(namespace, plugin_type)
   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 
+  def loaded_plugin(namespace, plugin_type, provider)
+    @@environments[@actor_id].loaded_plugin(namespace, plugin_type, provider)  
+  end
   
-  #-----------------------------------------------------------------------------
-  # Operations
+  def loaded_plugins(namespace = nil, plugin_type = nil, provider = nil)
+    @@environments[@actor_id].loaded_plugins(namespace, plugin_type, provider)
+  end
   
-  def test_connection
-    true
+  def define_plugin(namespace, plugin_type, base_path, file, &code)
+    @@environments[@actor_id].define_plugin(namespace, plugin_type, base_path, file, &code)  
+  end
+  
+  def plugin_has_provider?(namespace, plugin_type, provider)
+    @@environments[@actor_id].plugin_has_provider?(namespace, plugin_type, provider)  
   end
   
   #---
   
+  def active_plugins(namespace = nil, plugin_type = nil, provider = nil)
+    @@environments[@actor_id].active_plugins(namespace, plugin_type, provider)
+  end 
+  
+  #-----------------------------------------------------------------------------
+  # Plugin registration / initialization
+  
   def reload(core = false, &code)
     logger.info("Loading Nucleon plugins at #{Time.now}")
     
     if core
       Celluloid.logger = logger if Nucleon.parallel?   
     
-      define_namespace :nucleon
-    
-      define_type :extension     => nil,     # Core
-                  :action        => :update, # Core
-                  :project       => :git,    # Core
-                  :command       => :bash,   # Core
-                  :event         => :regex,  # Utility
-                  :template      => :json,   # Utility
-                  :translator    => :json    # Utility
+      define_types :nucleon, {
+        :extension  => nil,     # Core
+        :action     => :update, # Core
+        :project    => :git,    # Core
+        :command    => :bash,   # Core
+        :event      => :regex,  # Utility
+        :template   => :json,   # Utility
+        :translator => :json    # Utility
+      }
     end
     
     # Allow block level namespace and type registration
@@ -137,21 +137,6 @@ class Manager
   
   #---
   
-  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(core = false, &code)
     if core    
       # Register core plugins
@@ -196,7 +181,7 @@ class Manager
       logger.info("Loading directories from #{base_path} at #{Time.now}")
       Dir.entries(base_path).each do |path|
         unless path.match(/^\.\.?$/)
-          register_type(namespace, base_path, path, &code) if types.include?(path.to_sym)      
+          register_type(namespace, base_path, path, &code) if type_defined?(namespace, path)      
         end
       end
     end  
@@ -211,70 +196,50 @@ class Manager
     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(namespace, plugin_type, file, &code)
+      Dir.glob(File.join(base_directory, '**', '*.rb')).each do |file|
+        define_plugin(namespace, plugin_type, base_directory, file, &code)
       end
     end
   end
   protected :register_type
   
-  #---
- 
-  def add_build_info(namespace, type, file, &code)
-    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 nucleon #{type} plugin #{provider} at #{Time.now}")
-        
-    unless @load_info[type].has_key?(provider)
-      data = {
-        :namespace => namespace,
-        :type      => type,
-        :provider  => provider,        
-        :directory => directory,
-        :file      => file
-      }
-      code.call(data) if code
-      
-      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 = loaded_plugins
+    
+    load_info.keys.each do |namespace|
+      load_info[namespace].keys.each do |plugin_type|
+        logger.debug("Autoloading type: #{plugin_type}")
       
-      @load_info[type].each do |provider, plugin|
-        logger.debug("Autoloading provider #{provider} at #{plugin[:directory]}")
+        load_info[namespace][plugin_type].each do |provider, plugin|
+          logger.debug("Autoloading provider #{provider} at #{plugin[:directory]}")
         
-        nucleon_require(plugin[:directory], provider)
+          require plugin[:file]
+          
+          load_info[namespace][plugin_type][provider][:class] = class_const(plugin[:class_components])
+          logger.debug("Updated #{plugin_type} #{provider} load info")
         
-        @load_info[type][provider][:class] = provider_class(plugin[:namespace], 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
-        load(:extension, provider, { :name => provider }) if type == :extension # Create a persistent instance
+          # Make sure extensions are listening from the time they are loaded
+          if plugin[:namespace] == :nucleon && plugin_type == :extension 
+            # Create a persistent instance
+            load(plugin[:namespace], :extension, provider, { :name => provider })
+          end 
+        end
       end
     end
   end
   
-  #---
+  #-----------------------------------------------------------------------------
+  # Plugin workflow
   
-  def load_base(type, provider, options = {})
-    logger.info("Fetching plugin #{type} provider #{provider} at #{Time.now}")
+  def load_base(namespace, plugin_type, provider, options = {})
+    logger.info("Fetching plugin #{namespace} #{plugin_type} provider #{provider} at #{Time.now}")
     
-    options    = translate_type(type, options)    
+    type_info  = loaded_plugin(namespace, plugin_type, provider)
+    options    = translate_type(type_info, options)    
     config     = Config.ensure(options)
     name       = config.get(:name, nil)
     ensure_new = config.delete(:new, false)
@@ -282,7 +247,7 @@ class Manager
     if name
       logger.debug("Looking up existing instance of #{name}")
       
-      if existing_instance = get(type, name)
+      if existing_instance = get(namespace, plugin_type, name)
         unless ensure_new
           config.export.each do |property_name, value|
             unless [ :name, :meta ].include?(property_name)
@@ -291,38 +256,38 @@ class Manager
           end
           existing_instance.normalize(true)
       
-          logger.debug("Using existing instance of #{type}, #{name}")
+          logger.debug("Using existing instance of #{plugin_type}, #{name}")
           return existing_instance
         end
       end
     end
-    create(type, provider, options)   
+    create(namespace, plugin_type, provider, config)   
   end
   
   #---
   
-  def load(type, provider = nil, options = {})
-    default_provider = type_default(type)
+  def load(namespace, plugin_type, provider = nil, options = {})
+    default_provider = type_default(namespace, plugin_type)
     
     # Allow options to override provider
     config   = Config.ensure(options)
     provider = config.delete(:provider, provider)
     provider = default_provider unless provider
     
-    load_base(type, provider, config)
+    load_base(namespace, plugin_type, provider, config)
   end
   
   #---
   
-  def load_multiple(type, data, build_hash = false, keep_array = false)
-    logger.info("Fetching multiple plugins of #{type} at #{Time.now}")
+  def load_multiple(namespace, plugin_type, data, build_hash = false, keep_array = false)
+    logger.info("Fetching multiple plugins of #{plugin_type} at #{Time.now}")
     
     group = ( build_hash ? {} : [] )
-    klass = plugin_class(type)   
-    data  = klass.build_info(type, data) if klass.respond_to?(:build_info)
+    klass = plugin_class(namespace, plugin_type)   
+    data  = klass.build_info(namespace, plugin_type, data) if klass.respond_to?(:build_info)
     
     data.each do |options|
-      if plugin = load(type, options[:provider], options)
+      if plugin = load(namespace, plugin_type, options[:provider], options)
         if build_hash
           group[plugin.plugin_name] = plugin
         else
@@ -336,69 +301,46 @@ class Manager
   
   #---
   
-  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
-    
-    info = @load_info[type][provider] if Util::Data.exists?(@load_info, [ type, provider ])
-        
-    if info
-      logger.debug("Plugin information for #{provider} #{type} found.")
-      
-      instance_name = "#{provider}_" + Nucleon.sha1(options)
-      options       = translate(info[:namespace], type, provider, options)      
-              
-      @plugins[type] = {} unless @plugins.has_key?(type)
+  def create(namespace, plugin_type, provider, options = {})
+    @@environments[@actor_id].create_plugin(namespace, plugin_type, provider, options) do |type_info, plugin_options|
+      logger.info("Creating new plugin #{provider} #{plugin_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}")
-       
-        plugin = info[:class].new(type, provider, options)
-        
-        @plugins[type][instance_name] = plugin 
-      end
-      return @plugins[type][instance_name]
+      plugin_options        = translate(type_info, plugin_options)
+      plugin_options[:meta] = Config.new(type_info).import(Util::Data.hash(plugin_options[:meta]))
+      plugin_options  
     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  
+  def get(namespace, plugin_type, plugin_name)
+    @@environments[@actor_id].get_plugin(namespace, plugin_type, plugin_name)
   end
   
   #---
   
+  def remove_by_name(namespace, plugin_type, plugin_instance_name)
+    active_instances = active_plugins(namespace, plugin_type)
+    
+    if active_instances.has_key?(plugin_instance_name)
+      @@environments[@actor_id].remove_plugin(namespace, plugin_type, plugin_instance_name) do |plugin|
+        logger.debug("Removing #{plugin_type} #{plugin_instance_name}")
+        
+        if plugin.respond_to?(:terminate) # For Celluloid plugins
+          plugin.terminate   
+        else
+          plugin.remove_plugin  
+        end         
+      end  
+    end
+  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.remove_plugin
-      plugin.terminate if plugin.respond_to?(:terminate) # For Celluloid plugins
-    else
-      logger.warn("Cannot remove plugin: #{plugin.inspect}")    
+    begin # TODO: Figure out what do do about the plugin proxy being terminated before respond_to? method called.
+      if plugin && plugin.respond_to?(:plugin_type)
+        remove_by_name(plugin.plugin_namespace, plugin.plugin_type, plugin.plugin_instance_name)
+      end
+    rescue
     end
   end
   
@@ -408,11 +350,9 @@ class Manager
   def exec(method, options = {})
     results = nil
     
-    if Nucleon.log_level == :hook # To save processing on rendering
-      logger.hook("Executing extension hook #{Nucleon.blue(method)} at #{Nucleon.green(Time.now.to_s)}")
-    end
+    logger.info("Executing extension hook #{Nucleon.blue(method)} at #{Nucleon.green(Time.now.to_s)}") 
     
-    extensions = plugins(:extension)
+    extensions = active_plugins(:nucleon, :extension)
     
     extensions.each do |name, plugin|
       provider = plugin.plugin_provider
@@ -424,7 +364,7 @@ class Manager
         results = {} if results.nil?       
         
         result = plugin.send(method, options)
-        logger.info("Completed hook #{method} at #{Time.now} with: #{result.inspect}")
+        logger.info("Completed hook #{method} at #{Time.now}")
                     
         if block_given?
           results[provider] = yield(:process, result)
@@ -452,7 +392,7 @@ class Manager
   def config(type, options = {})
     config = Config.ensure(options)
     
-    logger.debug("Generating #{type} extended configuration from: #{config.export.inspect}")
+    logger.debug("Generating #{type} extended configuration")
       
     exec("#{type}_config", Config.new(config.export)) do |op, data|
       if op == :reduce
@@ -465,8 +405,6 @@ class Manager
       end
     end    
     config.delete(:extension_type)
-     
-    logger.debug("Final extended configuration: #{config.export.inspect}")
     config 
   end
   
@@ -475,7 +413,7 @@ class Manager
   def check(method, options = {})
     config = Config.ensure(options)
     
-    logger.debug("Checking extension #{method} given: #{config.export.inspect}")
+    logger.debug("Checking extension #{method}")
     
     success = exec(method, config.import({ :extension_type => :check })) do |op, data|
       if op == :reduce
@@ -496,7 +434,7 @@ class Manager
   def value(method, value, options = {})
     config = Config.ensure(options)
     
-    logger.debug("Setting extension #{method} value given: #{value.inspect}")
+    logger.debug("Setting extension #{method} value")
     
     exec(method, config.import({ :value => value, :extension_type => :value })) do |op, data|
       if op == :process
@@ -530,72 +468,45 @@ class Manager
   #-----------------------------------------------------------------------------
   # Utilities
   
-  def translate_type(type, options)
-    klass = plugin_class(type)
-    logger.debug("Executing option translation for: #{klass.inspect}")          
+  def translate_type(type_info, options)
+    if type_info
+      klass = plugin_class(type_info[:namespace], type_info[:type])
+      logger.debug("Executing option translation for: #{klass.inspect}")          
     
-    options = klass.send(:translate, options) if klass.respond_to?(:translate)
+      options = klass.send(:translate, options) if klass.respond_to?(:translate)
+    end
     options
   end
   
   #---
   
-  def translate(namespace, type, provider, options)
-    klass = provider_class(namespace, type, provider)
-    logger.debug("Executing option translation for: #{klass.inspect}")
+  def translate(type_info, options)
+    if type_info
+      klass = type_info[:class]
+    
+      logger.debug("Executing option translation for: #{klass.inspect}")
               
-    options = klass.send(:translate, options) if klass.respond_to?(:translate)
+      options = klass.send(:translate, options) if klass.respond_to?(:translate)
+    end
     options
   end
   
   #---
   
   def class_name(name, separator = '::', want_array = FALSE)
-    components = []
-    
-    case name
-    when String, Symbol
-      components = name.to_s.split(separator)
-    when Array
-      components = name 
-    end
-    
-    components.collect! do |value|
-      value    = value.to_s.strip      
-      value[0] = value.capitalize[0] if value =~ /^[a-z]/ 
-      value
-    end
-    
-    if want_array
-      return components
-    end    
-    components.join(separator)
+    @@environments[@actor_id].class_name(name, separator, want_array)
   end
   
   #---
   
   def class_const(name, separator = '::')
-    components = class_name(name, separator, TRUE)
-    constant   = Object
-    
-    components.each do |component|
-      constant = constant.const_defined?(component) ? 
-                  constant.const_get(component) : 
-                  constant.const_missing(component)
-    end
-    constant
-  end
-  
-  #---
-  
-  def plugin_class(type)
-    class_const([ :nucleon, :plugin, type ]) 
+    @@environments[@actor_id].class_const(name, separator)
   end
   
   #---
   
-  def provider_class(namespace, type, provider)
-    class_const([ namespace, type, provider ])  
+  def plugin_class(namespace, plugin_type)
+    @@environments[@actor_id].plugin_class(namespace, plugin_type)
   end
 end
 end