coral_core 0.2.23 → 0.2.24

data/lib/coral_core/memory.rb

@@ -0,0 +1,226 @@
+
+require 'json'
+
+module Coral
+class Memory < Repository
+   
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    config = Config.ensure(options)
+    
+    super(config)
+    
+    @absolute_config_file = ''
+    @config_file          = ''
+    
+    @properties     = config.get(:properties, {})
+    
+    @autoload       = config.get(:autoload, true)
+    @autosave       = config.get(:autosave, true)
+    @autocommit     = config.get(:autocommit, true)
+    @commit_message = config.get(:commit_message, 'Saving state')
+    
+    self.config_file = config.get(:config_file, '')
+  end
+  
+  #---
+  
+  def self.finalize(file_name)
+    proc do
+      Coral::Util::Disk.close(file_name)
+    end
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  attr_accessor :autoload, :autosave, :autocommit, :commit_message
+  attr_reader :config_file, :absolute_config_file
+
+  #---
+ 
+  def set_absolute_config_file
+    if @directory.empty? || @config_file.empty?
+      @absolute_config_file = ''
+    else 
+      @absolute_config_file = ( ! @submodule.empty? ? File.join(@directory, @submodule, @config_file) : File.join(@directory, @config_file) )
+      ObjectSpace.define_finalizer(self, self.class.finalize(@absolute_config_file))
+    end
+    return self
+  end
+ 
+  #---
+  
+  def config_file=file
+    unless Util::Data.empty?(file)
+      @config_file = ( file.is_a?(Array) ? file.join(File::SEPARATOR) : string(file) )
+    end
+    
+    set_absolute_config_file
+    load if @autoload
+  end
+  
+  #-----------------------------------------------------------------------------
+ 
+  def get(key, default = '', format = false)
+    value = default
+    key   = string(key)
+          
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    if @properties.has_key?(key)
+      value = @properties[key]
+    end     
+    return filter(value, format)
+  end
+    
+  #---
+   
+  def set(key, value = '')
+    key = string(key)
+       
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    @properties[key] = value
+    save if @autosave
+    return self
+  end
+    
+  #---
+   
+  def delete(key)
+    key = string(key)
+        
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    @properties.delete(key)
+    save if @autosave
+    return self
+  end
+    
+  #---
+    
+  def get_group(group, name = '', key = nil, default = {}, format = false)
+    info  = get(group, {})
+    value = info
+    
+    if name
+      name = string(name)
+      if info.has_key?(name) && info[name].is_a?(Hash)
+        if key && ! key.empty?
+          key = string(key)
+          if info[name].has_key?(key)
+            value = info[name][key]
+          else
+            value = default
+          end
+        else
+          value = info[name]
+        end          
+      else
+        value = default     
+      end        
+    end
+    return filter(value, format)
+  end
+       
+  #---
+    
+  def set_group(group, name, key = nil, value = {})
+    group = string(group)
+    name  = string(name)
+    
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    if ! @properties[group] || ! @properties[group].is_a?(Hash)
+      @properties[group] = {}
+    end      
+      
+    if key && ! key.empty?
+      key = string(key)
+      if ! @properties[group][name] || ! @properties[group][name].is_a?(Hash)
+        @properties[group][name] = {}  
+      end
+      @properties[group][name][key] = value
+        
+    else
+      @properties[group][name] = value  
+    end
+    save if @autosave
+    return self
+  end
+       
+  #---
+    
+  def delete_group(group, name, key = nil)
+    group = string(group)
+    name  = string(name)
+    
+    if ! @properties || ! @properties.is_a?(Hash)
+      @properties = {}
+    end
+    if ! @properties[group] || ! @properties[group].is_a?(Hash)
+      @properties[group] = {}
+    end      
+      
+    if key && ! key.empty?
+      key = string(key)
+      if @properties[group][name] && @properties[group][name].is_a?(Hash)
+        @properties[group][name].delete(key)
+      end
+    else
+      @properties[group].delete(name)  
+    end
+    save if @autosave
+    return self
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Import / Export
+  
+  def export
+    return @properties
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Configuration loading / saving
+    
+  def load
+    if can_persist?
+      config = Coral::Util::Disk.read(@absolute_config_file)    
+      if config && ! config.empty?
+        @properties = JSON.parse(config)
+      end
+    end
+    return self
+  end
+    
+  #---
+    
+  def save(options = {})
+    if can_persist?
+      config = JSON.generate(@properties)
+      if config && ! config.empty?
+        Coral::Util::Disk.write(@absolute_config_file, config)
+        commit(@absolute_config_file, options) if @autocommit
+      end
+    end
+    return self
+  end  
+     
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def can_persist?
+    success = super
+    success = false if success && @absolute_config_file.empty?
+    return success
+  end
+end
+end

data/lib/coral_core/repository.rb

@@ -0,0 +1,164 @@
+
+module Coral
+class Repository < Core
+    
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    config = Config.ensure(options)
+    
+    super(config)
+    
+    @name       = config.get(:name, '')
+    @directory  = config.get(:directory, '')
+    @submodule  = config.get(:submodule, '')
+    @remote_dir = config.get(:remote_dir, '')
+    
+    ensure_git(true) 
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  attr_accessor :name, :remote_dir
+  attr_reader :directory, :submodule, :git
+
+  #---
+   
+  def ensure_git(reset = false)
+    if reset || ! @git
+      if @directory.empty?
+        @git = nil
+      else
+        directory = @directory
+        unless Util::Data.empty?(@submodule)
+          directory = File.join(@directory, @submodule) 
+        end
+        @git = Git.open(directory, {
+          :log => logger,
+        })
+      end
+    end
+    return self
+  end
+  
+  #---
+    
+  def set_repository(directory = '', submodule = '')
+    @directory = string(directory)
+    @submodule = string(submodule)
+    ensure_git(true)
+    return self
+  end
+      
+  #-----------------------------------------------------------------------------
+    
+  def set_remote(name, hosts, options = {})
+    config = Config.ensure(options)
+    
+    if can_persist?
+      hosts = array(hosts)
+      
+      delete_remote(name)
+      return self if hosts.empty?
+      
+      if @remote_dir && ! config.get(:repo, false)
+        config[:repo] = @remote_dir
+      end
+      
+      git.add_remote(name, Git.url(hosts.shift, config[:repo], options))
+      
+      if ! hosts.empty?
+        remote = git.remote(name)
+        
+        config[:add] = true
+      
+        hosts.each do |host|
+          git_url = Git.url(host, config[:repo], config.options)
+          remote.set_url(git_url, config.options)
+        end
+      end
+    end
+    return self
+  end
+  
+  #---
+  
+  def delete_remote(name)
+    if can_persist?
+      remote = git.remote(name)
+      if remote && remote.url && ! remote.url.empty?
+        remote.remove
+      end
+    end
+    return self  
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Git operations
+  
+  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')
+      
+      config[:author]      = config.get(:author, '')
+      config[:allow_empty] = config.get(:allow_empty, false)
+      
+      unless user && ! user.empty?
+        user = 'UNKNOWN'
+      end
+    
+      array(files).each do |file|
+        git.add(file)                      # Get all added and updated files
+        git.add(file, { :update => true }) # Get all deleted files
+      end
+        
+      git.commit("#{time} by <#{user}> - #{message}", config.options)                
+    end
+    return self      
+  end
+  
+  #-----------------------------------------------------------------------------
+  
+  def push!(remote = 'origin', options = {})
+    config = Config.ensure(options)
+    
+    if can_persist?
+      branch = config.get(:branch, 'master')
+      tags   = config.get(:tags, false)
+    
+      return Coral::Command.new({
+        :command => :git,
+        :data => { 'git-dir=' => git.repo.to_s },
+        :subcommand => {
+          :command => :push,
+          :flags => ( tags ? :tags : '' ),
+          :args => [ remote, branch ]
+        }
+      }).exec!(config) do |line|
+        block_given? ? yield(line) : true
+      end
+    end
+  end
+  
+  #---
+  
+  def push(remote = 'origin', options = {})
+    return push!(remote, options)
+  end  
+     
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def can_persist?
+    ensure_git
+    return true if @git
+    return false
+  end
+end
+end

data/lib/coral_core/resource.rb

@@ -0,0 +1,243 @@
+
+module Coral
+module Resource
+  
+  #-----------------------------------------------------------------------------
+  # Resource groups
+  
+  @@resource_groups = {}
+  
+  #---
+  
+  def self.groups
+    return @@resource_groups
+  end
+  
+  #---
+  
+  def self.clear_groups
+    @@resource_groups = {}
+  end
+  
+  #---
+  
+  def self.add_members(group_name, resource_names)
+    @@resource_groups[group_name] = [] unless @@resource_groups[group_name].is_a?(Array)
+    
+    unless resource_names.is_a?(Array)
+      resource_names = [ resource_names ]
+    end
+    
+    resource_names.each do |name|
+      unless @@resource_groups[group_name].include?(name)
+        @@resource_groups[group_name] << name
+      end
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Resource operations
+  
+  def self.normalize(type_name, resources, options)
+    clear_groups
+    
+    config    = Config.ensure(options)
+    resources = Util::Data.value(resources)
+    
+    #dbg(resources, 'normalize -> init')
+    
+    unless Util::Data.empty?(resources)
+      resources.keys.each do |name|
+        #dbg(name, 'normalize -> name')
+        if ! resources[name] || resources[name].empty? || ! resources[name].is_a?(Hash)        
+          resources.delete(name)
+        else
+          normalize = true
+          
+          namevar = namevar(type_name, name)
+          if resources[name].has_key?(namevar)
+            value = resources[name][namevar]
+            if Util::Data.empty?(value)
+              #dbg(value, "delete #{name}")
+              resources.delete(name)
+              normalize = false
+              
+            elsif value.is_a?(Array)
+              value.each do |item|
+                item_name = "#{name}_#{item}".gsub(/\-/, '_')
+                
+                new_resource = resources[name].clone
+                new_resource[namevar] = item
+                
+                resources[item_name] = render(new_resource, config)
+                add_members(name, item_name)
+              end
+              resources.delete(name)
+              normalize = false
+            end  
+          end
+          
+          #dbg(resources, 'normalize -> resources')
+          
+          if normalize
+            resources[name] = render(resources[name], config)
+          end
+        end
+      end
+    end
+    return resources
+  end
+  
+  #---
+  
+  def self.render(resource, options = {})
+    resource = Core.string_map(resource.clone)
+    config   = Config.ensure(options)
+    
+    resource.keys.each do |name|
+      if match = name.match(/^(.+)_template$/)
+        target = match.captures[0]
+        
+        #dbg(name, 'name')
+        #dbg(target, 'target')
+        
+        config.set(:normalize_template, config.get("normalize_#{target}", true))
+        config.set(:interpolate_template, config.get("interpolate_#{target}", true))
+        
+        resource[target] = Template.render(resource[name], resource[target], config)
+        resource.delete(name)         
+      end
+    end
+    
+    #dbg(resource, 'render exit')
+    return resource
+  end
+  
+  #---
+  
+  def self.translate(type_name, resources, options = {})
+    config    = Config.ensure(options)
+    resources = Util::Data.value(resources)
+    results   = {}
+        
+    #dbg(resources, 'resources -> translate')
+    
+    prefix = config.get(:resource_prefix, '')
+    
+    name_map = {}
+    resources.keys.each do |name|
+      name_map[name] = true
+    end
+    config[:resource_names] = name_map
+    
+    resources.each do |name, data|
+      #dbg(name, 'name')
+      #dbg(data, 'data')
+      
+      resource = resources[name]
+      resource['before']    = translate_resource_refs(type_name, data['before'], config) if data.has_key?('before')
+      resource['notify']    = translate_resource_refs(type_name, data['notify'], config) if data.has_key?('notify')
+      resource['require']   = translate_resource_refs(type_name, data['require'], config) if data.has_key?('require')       
+      resource['subscribe'] = translate_resource_refs(type_name, data['subscribe'], config) if data.has_key?('subscribe')
+      
+      unless prefix.empty?
+        name = "#{prefix}_#{name}"
+      end
+      results[name] = resource
+    end
+    return results
+  end
+  
+  #---
+  
+  def self.translate_resource_refs(type_name, resource_refs, options = {})
+    return :undef if Util::Data.undef?(resource_refs)
+    
+    config         = Config.ensure(options)
+    resource_names = config.get(:resource_names, {})
+    title_prefix   = config.get(:title_prefix, '')
+    
+    title_pattern  = config.get(:title_pattern, '^\s*([^\[\]]+)\s*$')
+    title_group    = config.get(:title_var_group, 1)
+    title_flags    = config.get(:title_flags, '')
+    title_regexp   = Regexp.new(title_pattern, title_flags.split(''))
+    
+    allow_single   = config.get(:allow_single_return, true)    
+    
+    type_name      = type_name.sub(/^\@?\@/, '')
+    values         = []
+        
+    case resource_refs
+    when String
+      if resource_refs.empty?
+        return :undef 
+      else
+        resource_refs = resource_refs.split(/\s*,\s*/)
+      end
+        
+    when Puppet::Resource
+      resource_refs = [ resource_refs ]  
+    end
+    
+    resource_refs.collect! do |value|
+      if value.is_a?(Puppet::Resource) || ! value.match(title_regexp)
+        value
+          
+      elsif resource_names.has_key?(value)
+        if ! title_prefix.empty?
+          "#{title_prefix}_#{value}"
+        else
+          value
+        end
+        
+      elsif groups.has_key?(value) && ! groups[value].empty?
+        results = []
+        groups[value].each do |resource_name|
+          unless title_prefix.empty?
+            resource_name = "#{title_prefix}_#{resource_name}"
+          end
+          results << resource_name        
+        end
+        results
+        
+      else
+        nil
+      end           
+    end
+    
+    resource_refs.flatten.each do |ref|
+      #dbg(ref, 'reference -> init')
+      unless ref.nil?        
+        unless ref.is_a?(Puppet::Resource)
+          ref = ref.match(title_regexp) ? Puppet::Resource.new(type_name, ref) : Puppet::Resource.new(ref)
+        end
+        #dbg(ref, 'reference -> final')       
+        values << ref unless ref.nil?
+      end
+    end
+    return values[0] if allow_single && values.length == 1
+    return values
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.type_name(value) # Basically borrowed from Puppet (damn private methods!)
+    return :main if value == :main
+    return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
+    return value.to_s.split("::").collect { |s| s.capitalize }.join("::")
+  end
+  
+  #---
+  
+  def self.namevar(type_name, resource_name) # Basically borrowed from Puppet (damn private methods!)
+    resource = Puppet::Resource.new(type_name.sub(/^\@?\@/, ''), resource_name)
+    
+    if resource.builtin_type? and type = resource.resource_type and type.key_attributes.length == 1
+      return type.key_attributes.first.to_s
+    else
+      return 'name'
+    end
+  end
+end
+end