coral_core 0.2.30 → 0.4.0

data/lib/coral_core/plugin.rb

@@ -1,261 +0,0 @@
-
-module Coral
-module Plugin
- 
-  #-----------------------------------------------------------------------------
-  # Plugin instances
-  
-  @@load_info = {}
-  @@types     = {}
-  @@plugins   = {}
-  
-  #---
-
-  @@gems = {}
-  @@core = nil
-  
-  #---
-  
-  def self.create_instance(type, provider, options = {})
-    type     = type.to_sym
-    provider = provider.to_sym
-       
-    return nil unless @@types.has_key?(type)
-    
-    options  = translate_type(type, options)
-    provider = options.delete(:provider).to_sym if options.has_key?(:provider)    
-    info     = @@load_info[type][provider] if Util::Data.exists?(@@load_info, [ type, provider ])
-        
-    if info
-      options       = translate(type, provider, options)      
-      instance_name = "#{provider}_" + Coral.sha1(options)
-      
-      @@plugins[type] = {} unless @@plugins.has_key?(type)
-      
-      unless instance_name && @@plugins[type].has_key?(instance_name)
-        info[:instance_name] = instance_name
-        options[:meta]       = info
-        
-        plugin = Coral.class_const([ :coral, type, provider ]).new(type, provider, options)
-        
-        @@plugins[type][instance_name] = plugin 
-      end
-           
-      return @@plugins[type][instance_name]
-    end      
-    return nil
-  end
-  
-  #---
-  
-  def self.get_instance(type, name)
-    if @@plugins.has_key?(type)
-      @@plugins[type].each do |instance_name, plugin|
-        return plugin if plugin.name.to_s == name.to_s
-      end
-    end
-    return nil  
-  end
-  
-  #---
-  
-  def self.remove_instance(plugin)
-    if plugin && plugin.is_a?(Plugin::Base) && @@plugins.has_key?(plugin.plugin_type)
-      @@plugins[plugin.plugin_type].delete(plugin.plugin_instance_name)
-    end
-  end
- 
-  #-----------------------------------------------------------------------------
-  # Plugins and resources
-  
-  def self.core
-    return @@core
-  end
-  
-  #---
-  
-  def self.register_gem(spec)
-    plugin_path = File.join(spec.full_gem_path, 'lib', 'coral')
-    if File.directory?(plugin_path)
-      @@gems[spec.name] = {
-        :lib_dir => plugin_path,
-        :spec    => spec
-      }
-      if spec.name == 'coral_core'
-        @@core = spec
-      else
-        register(plugin_path) # Autoload plugins and related files  
-      end      
-    end  
-  end
-  
-  #---
-  
-  def self.gems(reset = false)
-    if reset || Util::Data.empty?(@@gems)
-      if defined?(Gem) 
-        if ! defined?(Bundler) && Gem::Specification.respond_to?(:latest_specs)
-          Gem::Specification.latest_specs(true).each do |spec|
-            register_gem(spec)
-          end
-        else
-          Gem.loaded_specs.each do |name, spec|
-            register_gem(spec)
-          end     
-        end
-      end
-    end
-    return @@gems
-  end
-  
-  #-----------------------------------------------------------------------------
-  
-  def self.define_type(type_info)
-    if type_info.is_a?(Hash)
-      type_info.each do |type, default_provider|
-        @@types[type.to_sym] = default_provider
-      end
-    end
-  end
-  
-  #---
-  
-  def self.types
-    return @@types.keys
-  end
-  
-  #---
-  
-  def self.type_default(type)
-    return @@types[type.to_sym]
-  end
-  
-  #---
-  
-  def self.plugins(type = nil)
-    results = {}
-    
-    if type
-      results[type] = @@plugins[type] if @@plugins.has_key?(type)
-    else
-      results = @@plugins
-    end    
-    return results
-  end
- 
-  #---
-  
-  def self.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) 
-    
-    puts 'Loading ' + type.to_s + ' plugin: ' + provider.to_s
-        
-    unless @@load_info[type].has_key?(provider)
-      data = {
-        :type      => type,
-        :provider  => provider,        
-        :directory => directory,
-        :file      => file
-      }
-      @@load_info[type][provider] = data
-    end
-  end
- 
-  #-----------------------------------------------------------------------------
-  # Plugin autoloading
-  
-  def self.register_type(base_path, plugin_type)
-    base_directory = File.join(base_path, plugin_type.to_s)
-    
-    if File.directory?(base_directory)
-      Dir.glob(File.join(base_directory, '*.rb')).each do |file|
-        add_build_info(plugin_type, file)
-      end
-    end
-  end
-  
-  #---
- 
-  def self.register(base_path)
-    if File.directory?(base_path)
-      Dir.glob(File.join(base_path, '*.rb')).each do |file|
-        require file
-      end
-      
-      Dir.entries(base_path).each do |path|
-        unless path.match(/^\.\.?$/)
-          register_type(base_path, path)          
-        end
-      end
-    end  
-  end
-  
-  #---
-  
-  def self.autoload
-    @@load_info.keys.each do |type|
-      @@load_info[type].each do |provider, plugin|
-        coral_require(plugin[:directory], provider)
-      end      
-    end 
-  end
-    
-  #---
-  
-  @@initialized = false
-  
-  #---
-  
-  def self.initialize
-    unless @@initialized
-      # Register core plugins
-      register(File.join(File.dirname(__FILE__), '..', 'coral'))      
-      
-      # Register external Gem defined plugins
-      gems(true)
-      
-      # Autoload the registered plugins
-      autoload
-           
-      @@initialized = true
-    end    
-  end
-  
-  #---
-  
-  def self.initialized?
-    return @@initialized
-  end
- 
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.translate_type(type, info, method = :translate)
-    klass = Coral.class_const([ :coral, :plugin, type ])          
-    info  = klass.send(method, info) if klass.respond_to?(method)
-    return info  
-  end
-  
-  #---
-  
-  def self.translate(type, provider, info, method = :translate)
-    klass = Coral.class_const([ :coral, type, provider ])          
-    info  = klass.send(method, info) if klass.respond_to?(method)
-    return info  
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Core plugin types
-  
-  define_type :network => :default, 
-              :node    => :rackspace,
-              :machine => :fog,
-              :command => :shell
-end
-end

data/lib/coral_core/plugin_base.rb

@@ -1,147 +0,0 @@
-
-module Coral
-module Plugin
-class Base < Core
-  # All Plugin classes should directly or indirectly extend Base
-  
-  def initialize(type, provider, options)
-    config = Config.ensure(options)
-    name   = Util::Data.ensure_value(config.delete(:name), provider)
-    
-    set_meta(config.delete(:meta, Config.new))
-    
-    super(config)
-    
-    self.name = name
-    
-    normalize
-  end
-  
-  #---
-  
-  def initialized?(options = {})
-    return true  
-  end
-  
-  #---
-  
-  def method_missing(method, *args, &block)  
-    return nil  
-  end
-  
-  #-----------------------------------------------------------------------------
-  # Property accessor / modifiers
-  
-  def name
-    return get(:name)
-  end
-  
-  #---
-  
-  def name=name
-    set(:name, string(name))
-  end
-  
-  #---
-  
-  def meta
-    return @meta
-  end
-  
-  #---
-  
-  def set_meta(meta)
-    @meta = Config.ensure(meta)
-  end
-  
-  #---
-  
-  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?(Coral::Plugin::Base)
-  end
-  
-  #---
-  
-  def plugin_parent
-    return meta.get(:parent)
-  end
-
-  #-----------------------------------------------------------------------------
-  # Plugin operations
-    
-  def normalize
-  end
-
-  #-----------------------------------------------------------------------------
-  # Utilities
-  
-  def self.build_info(type, data)  
-    plugins = []
-    
-    if data.is_a?(Hash)
-      data = [ data ]
-    end
-    
-    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] = Plugin.type_default(type)
-          end
-          
-          plugins << info
-        end
-      end
-    end
-    return plugins
-  end
-  
-  #---
-
-  def self.translate(data)
-    return ( data.is_a?(Hash) ? symbol_map(data) : {} )
-  end
-  
-  #---
-  
-  def self.ensure_plugin_collection
-    include Mixin::Settings
-    include Mixin::SubConfig
-    
-    extend Mixin::Macro::PluginInterface
-  end
-end
-end
-end

data/lib/coral_core/repository.rb

@@ -1,553 +0,0 @@
-module Coral
-class Repository < Core
-  
-  @@repositories = {}
-  
-  #---
-  
-  def self.collection
-    return @@repositories
-  end
-     
-  #-----------------------------------------------------------------------------
-  # Constructor / Destructor
-  
-  def self.init(directory, url, revision, options = {})
-    config = Config.ensure(options)
-    
-    return new(config.import({
-      :directory => directory,
-      :origin => url,
-      :revision => revision
-    }))
-  end
-  
-  #---
-  
-  def self.open(directory, options = {})
-    config = Config.ensure(options)
-    
-    directory = Util::Disk.filename(directory)
-    
-    if ! @@repositories.has_key?(directory) || config.get(:reset, false)
-      return new(config.import({
-        :directory => directory
-      }))
-    end
-    return @@repositories[directory]
-  end
-  
-  #-----------------------------------------------------------------------------
-  
-  def initialize(options = {})
-    config = Config.ensure(options)
-    
-    super(config)
-    
-    set_location(config.get(:directory, Dir.pwd))
-    
-    @cloud       = config.get(:object_container, nil)
-    @remote_path = config.get(:remote_path, nil)
-    
-    @origin   = config.get(:origin, nil)
-    @revision = config.get(:revision, nil)
-    
-    set_origin(@origin) unless @origin.nil?
-    checkout(@revision) unless @revision.nil?
-    
-    pull if config.get(:pull, false)
-  end
-  
-  #---
-  
-  def inspect
-    "#<#{self.class}: #{directory} : #{@origin} : #{@revision}>"
-  end
-   
-  #-----------------------------------------------------------------------------
-  # Location information
-      
-  def self.git_dir(path, require_top_level = false)
-    path = File.expand_path(path)
-    git_dir = File.join(path, '.git')
-
-    if File.exist?(git_dir)
-      if File.directory?(git_dir)
-        return git_dir
-      elsif ! require_top_level
-        git_dir = Util::Disk.read(git_dir)
-        unless git_dir.nil?
-          git_dir = git_dir.gsub(/^gitdir\:\s*/, '').strip
-          return git_dir if File.directory?(git_dir)
-        end
-      end
-    elsif File.exist?(path) && (path =~ /\.git$/ && File.exist?(File.join(path, 'HEAD')))
-      return path
-    end
-    return nil
-  end
-
-  #-----------------------------------------------------------------------------
-  # URLs
-
-  def self.url(host, repo, options = {})
-    config = Config.ensure(options)
-    
-    user = config.get(:user, 'git')
-    auth = config.get(:auth, true)
-    return user + (auth ? '@' : '://') + host + (auth ? ':' : '/') + repo
-  end
-  
-  #---
-  
-  def self.edit_url(url, options = {})
-    config = Config.ensure(options)
-    
-    if matches = url.strip.match(/^(https?|git)\:\/\/([^\/]+)\/(.+)/)
-      host, path = matches.captures
-      return url(host, path, config.import({ :auth => true }))
-    end
-    return url
-  end
-       
-  #-----------------------------------------------------------------------------
-  # Checks
-   
-  def ensure_git(reset = false)
-    if reset || ! @git_lib
-      @git_lib = nil
-      unless directory.empty?
-        @git_lib = Git.new(directory)
-      end
-    end
-    return self
-  end
-  protected :ensure_git
-  
-  #---
-   
-  def can_persist?
-    ensure_git
-    return true if @git_lib
-    return false
-  end
- 
-  #---
-          
-  def self.top?(path)
-    git_dir = File.join(path, '.git')
-    if File.exist?(git_dir)
-      return true if File.directory?(git_dir)
-    elsif File.exist?(path) && (path =~ /\.git$/ && File.exist?(File.join(path, 'HEAD')))
-      return true
-    end
-    return false
-  end
-  
-  #---
-  
-  def top?
-    return self.class.top?(directory)
-  end
-    
-  #---
-          
-  def self.submodule?(path)
-    git_dir = File.join(path, '.git')
-    if File.exist?(git_dir)
-      unless File.directory?(git_dir)
-        git_dir = Util::Disk.read(git_dir)
-        unless git_dir.nil?
-          git_dir = git_dir.gsub(/^gitdir\:\s*/, '').strip
-          return true if File.directory?(git_dir)
-        end
-      end
-    end
-    return false
-  end
-  
-  #---
-  
-  def submodule?
-    return self.class.submodule?(directory)
-  end
-      
-  #-----------------------------------------------------------------------------
-  # Property accessors / modifiers
-  
-  attr_reader :directory
-   
-  #---
-  
-  def path
-    if parent.nil?
-      return directory
-    end
-    return directory.gsub(parent.directory + File::SEPARATOR, '')
-  end
- 
-  #---
-  
-  def git
-    return @git_lib.git if can_persist?
-    return nil
-  end
-  protected :git
-  
-  #---
-  
-  def config(name, options = {})
-    config = Config.ensure(options) # Just in case we throw a configuration in
-    return git.config(config.export, name) if can_persist?
-    return nil
-  end
-  
-  #---
-  
-  def set_config(name, value, options = {})
-    config = Config.ensure(options) # Just in case we throw a configuration in
-    git.config(config.export, name, string(value)) if can_persist?
-    return self
-  end
-  
-  #---
-  
-  def delete_config(name, options = {})
-    config = Config.ensure(options)
-    git.config(config.import({ :remove_section => true }).options, name) if can_persist?
-    return self
-  end
-  
-  #---
-   
-  def set_location(directory)
-    @@repositories.delete(@directory) if @directory
-    
-    if Util::Data.empty?(directory)
-      @directory = Dir.pwd
-    else
-      @directory = Util::Disk.filename(directory)
-    end
-    
-    @@repositories[@directory] = self
-    
-    ensure_git(true)
-    
-    init_parent
-    init_remotes
-    load_revision
-    return self
-  end
-
-  #-----------------------------------------------------------------------------
-  # Basic Git operations
-  
-  attr_reader :parent, :revision
-  
-  #---
-  
-  def init_parent
-    @parent = nil
-    
-    unless top?
-      search_dir = directory
-      
-      while File.directory?((search_dir = File.expand_path('..', search_dir)))
-        if self.class.git_dir(search_dir)
-          @parent = self.class.open(search_dir)
-          break;
-        end
-      end
-    end
-    return self
-  end
-  protected :init_parent
-
-  #---
-  
-  def load_revision
-    if can_persist?
-      @revision = git.native(:rev_parse, { :abbrev_ref => true }, 'HEAD').strip
-    
-      if @revision.empty?
-        @revision = git.native(:rev_parse, {}, 'HEAD').strip
-      end
-      load_submodules
-    end
-    return self
-  end
-  protected :load_revision
-
-  #---
-  
-  def checkout(revision)
-    if can_persist?
-      revision = revision.strip
-      
-      git.checkout({}, revision) unless @git_lib.bare
-      @revision = revision
-      load_submodules
-    end
-    return self
-  end
-  
-  #---
-  
-  def commit(files = '.', options = {})
-    config = Config.ensure(options)
-    
-    if can_persist?
-      time = Time.new.strftime("%Y-%m-%d %H:%M:%S")
-      user = ENV['USER']
-      message = config.get(:message, 'Saving state')
-      
-      user = 'UNKNOWN' unless user && ! user.empty?
-            
-      git.reset({}, 'HEAD') # Clear the index so we get a clean commit
-      
-      files = array(files)
-      git.add(files) # Get all added and updated files
-      git.add({ :update => true }, files) # Get all deleted files
-    
-      git.commit({
-        :m => "#{time} by <#{user}> - #{message}",
-        :author => config.get(:author, false),
-        :allow_empty => config.get(:allow_empty, false)
-      })
-      
-      if ! parent.nil? && config.get(:propogate, true)
-        parent.commit(directory, config.import({
-          :message => "Updating submodule #{path} with: #{message}"
-        }))
-      end
-    end
-    return self
-  end
-
-  #-----------------------------------------------------------------------------
-  # Submodule operations
-  
-  attr_reader :submodules
-  
-  #---
-  
-  def load_submodules
-    @submodules = {}
-    
-    if can_persist?
-      # Returns a Hash of { <path:String> => { 'url' => <url:String>, 'id' => <id:String> } }
-      # Returns {} if no .gitmodules file was found
-      Grit::Submodule.config(@git_lib, revision).each do |path, data|
-        repo = self.class.open(File.join(directory, path))
-        repo.set_origin(data['url']) # Just a sanity check (might disapear)
-        
-        @submodules[path] = repo
-      end
-    end
-    return self
-  end
-  protected :load_submodules
-  
-  #---
-  
-  def add_submodule(path, url, revision, options = {})
-    if can_persist?
-      git.submodule({ :branch => revision }, 'add', url, path)
-      commit([ '.gitmodules', path ], { :message => "Adding submodule #{url} to #{path}" })
-      load_submodules
-    end
-  end
-  
-  #---
-  
-  def delete_submodule(path)
-    if can_persist?
-      submodule_key = "submodule.#{path}"
-      
-      delete_config(submodule_key)
-      delete_config(submodule_key, { :file => '.gitmodules' })
-      
-      git.rm({ :cached => true }, path)
-      FileUtils.rm_rf(File.join(directory, path))
-      FileUtils.rm_rf(File.join(git.git_dir, 'modules', path))
-      
-      commit([ '.gitmodules', path ], { :message => "Removing submodule #{url} from #{path}" })
-      load_submodules
-    end
-  end
- 
-  #---
-   
-  def update_submodules
-    git.submodule({ :init => true, :recursive => true }, 'update') if can_persist?
-    return self
-  end
-  protected :update_submodules
-  
-  #---
-  
-  def foreach!
-    if can_persist?
-      submodules.each do |path, repo|
-        yield(path, repo)
-      end
-    end
-    return self
-  end
-         
-  #-----------------------------------------------------------------------------
-  # Remote operations
-  
-  attr_reader :origin, :edit
-    
-  #---
-  
-  def init_remotes
-    @origin = config('remote.origin.url')
-    set_edit(edit_url(@origin)) unless config('remote.edit.url')
-    return self
-  end
-  protected :init_remotes
-
-  #---
-  
-  def set_origin(url)
-    set_remote('origin', url)
-    @origin = url
-    return self
-  end
-
-  #---
-  
-  def set_edit(url)
-    set_remote('edit', url)
-    @edit = url
-    return self
-  end
-  
-  #---
-  
-  def set_remote(name, url)
-    delete_remote(name)
-    git.remote({}, 'add', name.to_s, url) if can_persist?
-    return self
-  end
-  
-  #---
-  
-  def add_remote_url(name, url, options = {})
-    config = Config.ensure(options)
-    
-    if can_persist?
-      git.remote({
-        :add => true,
-        :delete => config.get(:delete, false),
-        :push => config.get(:push, false)
-      }, 'set-url', name.to_s, url)
-    end
-    return self
-  end
-  
-  #---
-    
-  def set_host_remote(name, hosts, path, options = {})
-    config = Config.ensure(options)
-    
-    if can_persist?
-      hosts = array(hosts)
-      
-      return self if hosts.empty?
-      
-      set_remote(name.to_s, url(hosts.shift, path, config.options))
-      
-      unless hosts.empty?
-        hosts.each do |host|
-          add_remote_url(name.to_s, url(host, path, config.options), config)
-        end
-      end
-    end
-    return self
-  end
-  
-  #---
-  
-  def delete_remote(name)
-    if can_persist? && git.list_remotes.include?(name)
-      git.remote({}, 'rm', name.to_s)
-    end
-    return self
-  end
- 
-  #-----------------------------------------------------------------------------
-  # SSH operations
- 
-  def pull!(remote = :origin, options = {})
-    config = Config.ensure(options)
-    success = false
-    
-    if can_persist?
-      success = Command.new({
-        :command => :git,
-        :data => { 'git-dir=' => git.git_dir },
-        :subcommand => {
-          :command => :pull,
-          :flags => ( config.get(:tags, true) ? :tags : '' ),
-          :args => [ remote, config.get(:branch, '') ]
-        }
-      }).exec!(config) do |line|
-        block_given? ? yield(line) : true
-      end
-      
-      update_submodules
-      
-      if success && ! parent.nil? && config.get(:propogate, true)
-        parent.commit(directory, config.import({
-          :message => "Pulling updates for submodule #{path}",
-          :allow_empty => true
-        }))
-      end
-    end
-    return success
-  end
-  
-  #---
-  
-  def pull(remote = :origin, options = {})
-    return pull!(remote, options)
-  end
-  
-  #---
-    
-  def push!(remote = :edit, options = {})
-    config = Config.ensure(options)
-    success = false
-    
-    if can_persist?
-      success = Command.new({
-        :command => :git,
-        :data => { 'git-dir=' => git.git_dir },
-        :subcommand => {
-          :command => :push,
-          :flags => ( config.get(:tags, true) ? :tags : '' ),
-          :args => [ remote, config.get(:branch, '') ]
-        }
-      }).exec!(config) do |line|
-        block_given? ? yield(line) : true
-      end
-      
-      if success && config.get(:propogate, true)
-        foreach! do |path, repo|
-          repo.push(remote, config)
-        end
-      end
-    end
-    return success
-  end
-  
-  #---
-  
-  def push(remote = :edit, options = {})
-    return push!(remote, options)
-  end
-end
-end