coral_core 0.2.23 → 0.2.24

data/lib/coral_core/util/git.rb

@@ -0,0 +1,15 @@
+
+require 'git'
+
+module Git
+
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def self.url(host, repo, options = {})
+    options[:user] = ( options[:user] ? options[:user] : 'git' )
+    options[:auth] = ( options[:auth] ? options[:auth] : true )
+    
+    return options[:user] + ( options[:auth] ? '@' : '://' ) + host + ( options[:auth] ? ':' : '/' ) + repo
+  end
+end

data/lib/coral_core/util/git/base.rb

@@ -0,0 +1,58 @@
+
+module Git
+
+#*******************************************************************************
+# Errors
+  
+class GitDirectoryError < StandardError 
+end
+
+#*******************************************************************************
+# Base Git definition
+
+class Base
+ 
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    if working_dir = options[:working_directory]
+      options[:repository] ||= File.join(working_dir, '.git')
+      
+      if File.file?(options[:repository])
+        File.read(options[:repository]).each_line do |line|
+          matches = line.match(/^\s*gitdir:\s*(.+)\s*/)
+          if matches.length && matches[1]
+            options[:repository] = matches[1]
+            break
+          end
+        end        
+      end
+      
+      if File.directory?(options[:repository])
+        options[:index] ||= File.join(options[:repository], 'index')
+      else
+        raise GitDirectoryError.new("Git repository directory #{options[:repository]} not found for #{working_dir}")
+      end
+    end
+    
+    if options[:log]
+      @logger = options[:log]
+      @logger.info("Starting Git")
+    else
+      @logger = nil
+    end
+     
+    @working_directory = options[:working_directory] ? Git::WorkingDirectory.new(options[:working_directory]) : nil
+    @repository        = options[:repository] ? Git::Repository.new(options[:repository]) : nil 
+    @index             = options[:index] ? Git::Index.new(options[:index], false) : nil
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Commit extensions
+
+  def add(path = '.', opts = {})
+    self.lib.add(path, opts)
+  end
+end
+end

data/lib/coral_core/util/git/lib.rb

@@ -0,0 +1,82 @@
+
+module Git
+class Lib
+
+  #-----------------------------------------------------------------------------
+  # Commit extensions
+  
+  def add(path = '.', opts = {})
+    arr_opts = []
+    arr_opts << '-u' if opts[:update]
+    if path.is_a?(Array)
+      arr_opts += path
+    else
+      arr_opts << path
+    end
+    command('add', arr_opts)
+  end
+  
+  #---
+  
+  def commit(message, opts = {})
+    arr_opts = ['-m', message]
+    arr_opts << "--author=\'#{opts[:author]}\'" unless opts[:author] && opts[:author].empty?
+    arr_opts << '-a' if opts[:add_all]
+    arr_opts << '--allow-empty' if opts[:allow_empty]      
+    command('commit', arr_opts)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Remote extensions
+  
+  def remote_add(name, url, opts = {})
+    arr_opts = ['add']
+    arr_opts << '-f' if opts[:with_fetch]
+    arr_opts << name
+    arr_opts << url
+      
+    command('remote', arr_opts)
+  end
+  
+  #---
+
+  def remote_set_url(name, url, opts = {})
+    arr_opts = ['set-url']
+      
+    if opts[:add]
+      arr_opts << '--add' if opts[:add]
+    end
+      
+    if opts[:delete]
+      arr_opts << '--delete' if opts[:delete]
+    end
+      
+    if opts[:push]
+      arr_opts << '--push' if opts[:push]
+    end
+        
+    arr_opts << name
+    arr_opts << url
+      
+    command('remote', arr_opts)
+  end
+  
+  #---
+      
+  def remote_remove(name)
+    command('remote', ['rm', name])
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def escape(s)
+    escaped = s.to_s.gsub('"', '\'')
+    if escaped =~ /^\-+/
+      escaped  
+    else
+      %Q{"#{escaped}"}
+    end
+  end
+end
+end

data/lib/coral_core/util/git/remote.rb

@@ -0,0 +1,12 @@
+
+module Git
+class Remote
+  
+  #-----------------------------------------------------------------------------
+  # Remote endpoints
+
+  def set_url(url, opts = {})
+    @base.lib.remote_set_url(@name, url, opts)  
+  end
+end
+end

data/lib/coral_core/util/shell.rb

@@ -0,0 +1,183 @@
+
+module Coral
+module Util
+class Shell < Core
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def self.exec!(command, options = {})
+    config = Config.ensure(options)
+    
+    min   = config.get(:min, 1).to_i
+    tries = config.get(:tries, min).to_i
+    tries = ( min > tries ? min : tries )
+    
+    info_prefix  = config.get(:info_prefix, '')
+    info_suffix  = config.get(:info_suffix, '')
+    error_prefix = config.get(:error_prefix, '')
+    error_suffix = config.get(:error_suffix, '')
+    
+    ui           = config.get(:ui, Coral.ui)
+    
+    conditions   = Coral::Event.instance(config.get(:exit, {}), true)
+    
+    $stdout.sync = true
+    $stderr.sync = true  
+    
+    for i in tries.downto(1)
+      ui.info(">> running: #{command}")
+      
+      begin
+        t1, output_new, output_orig, output_reader = pipe_exec_stream!($stdout, conditions, { 
+          :prefix => info_prefix, 
+          :suffix => info_suffix, 
+        }, 'output') do |line|
+          block_given? ? yield(line) : true
+        end
+      
+        t2, error_new, error_orig, error_reader = pipe_exec_stream!($stderr, conditions, { 
+          :prefix => error_prefix, 
+          :suffix => error_suffix, 
+        }, 'error') do |line|
+          block_given? ? yield(line) : true
+        end
+      
+        system_success = system(command)
+      
+      ensure
+        output_success = close_exec_pipe(t1, $stdout, output_orig, output_new, 'output')
+        error_success  = close_exec_pipe(t2, $stderr, error_orig, error_new, 'error')
+      end
+      ui.info('')
+      
+      success = ( system_success && output_success && error_success )
+                  
+      min -= 1
+      break if success && min <= 0 && conditions.empty?
+    end
+    unless conditions.empty?
+      success = false
+    end
+    
+    return success   
+  end
+  
+  #---
+  
+  def self.exec(command, options = {})
+    return exec!(command, options)
+  end
+  
+  #---
+  
+  def self.pipe_exec_stream!(output, conditions, options, label)
+    original     = output.dup
+    read, write  = IO.pipe
+    
+    match_prefix = ( options[:match_prefix] ? options[:match_prefix] : 'EXIT' )
+            
+    thread = process_stream!(read, original, options, label) do |line|
+      check_conditions!(line, conditions, match_prefix) do
+        block_given? ? yield(line) : true
+      end
+    end
+    
+    thread.abort_on_exception = false
+    
+    output.reopen(write)    
+    return thread, write, original, read
+  end
+  
+  #---
+  
+  def self.close_exec_pipe(thread, output, original, write, label)
+    output.reopen(original)
+     
+    write.close
+    success = thread.value
+    
+    original.close
+    return success
+  end
+  
+  #---
+  
+  def self.check_conditions!(line, conditions, match_prefix = '')
+    prefix = ''
+    
+    unless ! conditions || conditions.empty?
+      conditions.each do |key, event|
+        if event.check(line)
+          prefix = match_prefix
+          conditions.delete(key)
+        end
+      end
+    end
+    
+    result = true
+    if block_given?
+      result = yield
+      
+      unless prefix.empty?
+        case result
+        when Hash
+          result[:prefix] = prefix
+        else
+          result = { :success => result, :prefix => prefix }
+        end
+      end
+    end
+    return result
+  end
+  
+  #---
+  
+  def self.process_stream!(input, output, options, label)
+    return Thread.new do
+      success        = true      
+      default_prefix = ( options[:prefix] ? options[:prefix] : '' )
+      default_suffix = ( options[:suffix] ? options[:suffix] : '' )
+      
+      begin
+        while ( data = input.readpartial(1024) )
+          message = data.strip
+          newline = ( data[-1,1].match(/\n/) ? true : false )
+                                 
+          unless message.empty?
+            lines = message.split(/\n/)
+            lines.each_with_index do |line, index|
+              prefix  = default_prefix
+              suffix  = default_suffix
+              
+              unless line.empty?
+                if block_given?
+                  result = yield(line)
+                                          
+                  if result && result.is_a?(Hash)
+                    prefix = result[:prefix]
+                    suffix = result[:suffix]
+                    result = result[:success]                 
+                  end
+                  success = result if success
+                end
+            
+                prefix = ( prefix && ! prefix.empty? ? "#{prefix}: " : '' )
+                suffix = ( suffix && ! suffix.empty? ? suffix : '' )            
+                eol    = ( index < lines.length - 1 || newline ? "\n" : ' ' )
+            
+                output.write(prefix.lstrip + line + suffix.rstrip + eol)
+              end
+            end
+          end
+        end
+      rescue EOFError
+      end
+      
+      input.close()
+      success
+    end
+  end
+end
+end
+end

data/lib/hiera_backend.rb

@@ -0,0 +1,63 @@
+begin
+  require 'hiera/backend'
+
+  class Hiera
+    module Backend
+      #
+      # NOTE: This function is overridden so we can collect accumulated hiera
+      # parameters and their values on a particular puppet run for reporting 
+      # purposes.
+      #
+      # Calls out to all configured backends in the order they
+      # were specified.  The first one to answer will win.
+      #
+      # This lets you declare multiple backends, a possible
+      # use case might be in Puppet where a Puppet module declares
+      # default data using in-module data while users can override
+      # using JSON/YAML etc.  By layering the backends and putting
+      # the Puppet one last you can override module author data
+      # easily.
+      #
+      # Backend instances are cached so if you need to connect to any
+      # databases then do so in your constructor, future calls to your
+      # backend will not create new instances
+      def lookup(key, default, scope, order_override, resolution_type)
+        @backends ||= {}
+        answer = nil
+
+        Config[:backends].each do |backend|
+          if constants.include?("#{backend.capitalize}_backend") || constants.include?("#{backend.capitalize}_backend".to_sym)
+            @backends[backend] ||= Backend.const_get("#{backend.capitalize}_backend").new
+            new_answer = @backends[backend].lookup(key, scope, order_override, resolution_type)
+
+            if not new_answer.nil?
+              case resolution_type
+              when :array
+                raise Exception, "Hiera type mismatch: expected Array and got #{new_answer.class}" unless new_answer.kind_of? Array or new_answer.kind_of? String
+                answer ||= []
+                answer << new_answer
+              when :hash
+                raise Exception, "Hiera type mismatch: expected Hash and got #{new_answer.class}" unless new_answer.kind_of? Hash
+                answer ||= {}
+                answer = merge_answer(new_answer,answer)
+              else
+              answer = new_answer
+              break
+              end
+            end
+          end
+        end
+
+        answer = resolve_answer(answer, resolution_type) unless answer.nil?
+        answer = parse_string(default, scope) if answer.nil? and default.is_a?(String)
+
+        answer = default if answer.nil?
+        
+        Coral::Config.set_property(key, answer) # This is why we override this function!!
+        return answer
+      end
+    end
+  end
+
+rescue LoadError
+end

data/spec/coral_core/interface_spec.rb

@@ -0,0 +1,489 @@
+
+require 'spec_helper'
+
+module Coral
+
+  describe Interface do
+
+    #---------------------------------------------------------------------------
+    # UI functionality
+    
+    describe "#say" do
+    
+      #-------------------------------------------------------------------------
+      # Delegation
+      
+      it "can delegate to another class that contains this method" do
+        output  = double('output')
+        output.should_receive(:puts).with('message')
+        
+        ui = Interface.new({
+          :output  => output,
+          :printer => :puts,
+        })        
+        Interface.new({ :ui_delegate => ui }).say(:info, 'message')
+      end
+      
+      #-------------------------------------------------------------------------
+      # Output formats
+
+      it "prints a message with default options" do
+        output1 = double('output1')
+        output1.should_receive(:puts).with('message')
+        
+        Interface.new({ :output => output1 }).say(:info, 'message')
+        
+        output2 = double('output2')
+        output2.should_receive(:puts).with('[component] message')
+        
+        Interface.new({
+          :resource => 'component', 
+          :output   => output2, 
+        }).say(:info, 'message')      
+      end
+      
+      #---
+      
+      it "prints a message with and without newlines included" do
+        output1 = double('output1')
+        output1.should_receive(:puts).with('message')
+        
+        test = Interface.new({ :output => output1 })
+        test.say(:info, 'message', { :new_line => true })
+        
+        output2 = double('output2')
+        output2.should_receive(:print).with('message')
+        
+        test = Interface.new({ :output => output2 })
+        test.say(:info, 'message', { :new_line => false })      
+      end
+      
+      #---
+      
+      it "routes message to output and error channels based on type given" do       
+        [:info, :warn, :success].each do |type|
+          output = double('output')
+          output.should_receive(:puts).with('message')
+        
+          Interface.new({
+            :output  => output,
+            :printer => :puts,
+            :color   => false,
+          }).say(type, 'message')
+        end
+        
+        error = double('error')
+        error.should_receive(:puts).with('message')
+        
+        Interface.new({
+          :error   => error,
+          :printer => :puts,
+          :color   => false,
+        }).say(:error, 'message')   
+      end
+      
+      #---
+      
+      it "routes message to output and error channels based on channel given" do
+        [:info, :warn, :success].each do |type|
+          output = double('output')
+          output.should_receive(:puts).with('message')
+        
+          Interface.new({
+            :output  => output,
+            :printer => :puts,
+          }).say(:info, 'message', { :channel => type })        
+        end
+        
+        error = double('error')
+        error.should_receive(:puts).with('message')
+        
+        Interface.new({
+          :error   => error,
+          :printer => :puts,
+          :color   => false,
+        }).say(:info, 'message', { :channel => :error })
+      end  
+    end
+    
+    #---
+    
+    describe "#ask" do
+    
+      #-------------------------------------------------------------------------
+      # Delegation
+      
+      it "can delegate to another class that contains this method"
+      
+      #-------------------------------------------------------------------------
+      # Input
+      
+      it "displays a prompt and returns user feedback"
+    end
+    
+    #---
+    
+    describe "#info" do
+    
+      #-------------------------------------------------------------------------
+      # Delegation
+      
+      it "can delegate to another class that contains this method" do
+        output  = double('output')
+        output.should_receive(:puts).with('message')
+        
+        ui = Interface.new({
+          :output  => output,
+          :printer => :puts,
+        })        
+        Interface.new({ :ui_delegate => ui }).info('message')
+      end
+      
+      #-------------------------------------------------------------------------
+      # Printing
+      
+      it "prints an uncolored information message" do
+        output = double('output')
+        output.should_receive(:puts).with('message')
+        
+        Interface.new({ 
+          :output  => output,
+          :printer => :puts, 
+        }).info('message')
+      end    
+    end
+    
+    #---
+    
+    describe "#warn" do
+    
+      #-------------------------------------------------------------------------
+      # Delegation
+      
+      it "can delegate to another class that contains this method" do
+        output  = double('output')
+        output.should_receive(:puts).with('message')
+        
+        ui = Interface.new({
+          :output  => output,
+          :printer => :puts,
+          :color   => false,
+        })        
+        Interface.new({ :ui_delegate => ui }).warn('message')
+      end
+      
+      #-------------------------------------------------------------------------
+      # Printing
+      
+      it "prints an uncolored warning message" do
+        output = double('output')
+        output.should_receive(:puts).with('message')
+        
+        Interface.new({ 
+          :output  => output,
+          :printer => :puts,
+          :color   => false, 
+        }).warn('message')
+      end
+      
+      #---
+      
+      it "prints a colored warning message" do
+        output = double('output')
+        output.should_receive(:print).with(/^\e\[33mmessage\e\[0m$/)
+        
+        Interface.new({ 
+          :output => output,
+          :color  => true, 
+        }).warn('message', { :new_line => false })
+      end    
+    end
+    
+    #---
+    
+    describe "#error" do
+    
+      #-------------------------------------------------------------------------
+      # Delegation
+      
+      it "can delegate to another class that contains this method" do
+        error  = double('error')
+        error.should_receive(:puts).with('message')
+        
+        ui = Interface.new({
+          :error   => error,
+          :printer => :puts,
+          :color   => false,
+        })        
+        Interface.new({ :ui_delegate => ui }).error('message')
+      end
+      
+      #-------------------------------------------------------------------------
+      # Printing
+      
+      it "prints an uncolored error message" do
+        error = double('error')
+        error.should_receive(:puts).with('message')
+        
+        Interface.new({ 
+          :error   => error,
+          :printer => :puts,
+          :color   => false, 
+        }).error('message')
+      end
+      
+      #---
+      
+      it "prints a colored error message" do
+        error = double('error')
+        error.should_receive(:print).with(/^\e\[31mmessage\e\[0m$/)
+        
+        Interface.new({ 
+          :error => error,
+          :color => true, 
+        }).error('message', { :new_line => false })
+      end 
+    end
+    
+    #---
+    
+    describe "#success" do
+    
+      #-------------------------------------------------------------------------
+      # Delegation
+      
+      it "can delegate to another class that contains this method" do
+        output  = double('output')
+        output.should_receive(:puts).with('message')
+        
+        ui = Interface.new({
+          :output  => output,
+          :printer => :puts,
+          :color   => false,
+        })        
+        Interface.new({ :ui_delegate => ui }).success('message')
+      end
+      
+      #-------------------------------------------------------------------------
+      # Printing
+      
+      it "prints an uncolored success message" do
+        output = double('output')
+        output.should_receive(:puts).with('message')
+        
+        Interface.new({ 
+          :output  => output,
+          :printer => :puts,
+          :color   => false, 
+        }).success('message')
+      end
+      
+      #---
+      
+      it "prints a colored success message" do
+        output = double('output')
+        output.should_receive(:print).with(/^\e\[32mmessage\e\[0m$/)
+        
+        Interface.new({ 
+          :output => output,
+          :color  => true, 
+        }).success('message', { :new_line => false })
+      end  
+    end
+  
+    #---------------------------------------------------------------------------
+    # Utilities
+    
+    describe "#format_message" do
+    
+      #-------------------------------------------------------------------------
+      # Delegation
+      
+      it "can delegate to another class that contains this method" do
+        message = Interface.new({ 
+          :ui_delegate => Interface.new('delegate')
+        }).format_message(:info, 'message', { :prefix => true })
+        
+        message.should == '[delegate] message'
+      end
+    
+      #-------------------------------------------------------------------------
+      # Prefix specifications
+      
+      it "returns without a prefix because no resource" do
+        message = Interface.new.format_message(:info, 'message', { :prefix => true })
+        message.should == 'message'
+      end
+      
+      #---
+      
+      it "returns without a prefix because prefix is false" do
+        message = Interface.new('component').format_message(:info, 'message', { :prefix => false })
+        message.should == 'message'
+      end
+      
+      #---
+            
+      it "returns without a prefix because no prefix option given" do
+        message = Interface.new('component').format_message(:info, 'message')
+        message.should == 'message'
+      end
+      
+      #---
+            
+      it "returns with a prefix if resource and prefix option given" do
+        message = Interface.new('component').format_message(:info, 'message', { :prefix => true })
+        message.should == '[component] message'
+      end
+      
+      #-------------------------------------------------------------------------
+      # Color specifications
+      
+      it "formats a error message in red if color enabled" do
+        message = Interface.new({
+          :resource => 'component',
+          :color    => true,
+        }).format_message(:error, 'message')
+        message.should match(/^\e\[31mmessage\e\[0m$/)
+      end
+      
+      #---
+      
+      it "formats a warning message in yellow if color enabled" do
+        message = Interface.new({
+          :resource => 'component',
+          :color    => true,
+        }).format_message(:warn, 'message')
+        message.should match(/^\e\[33mmessage\e\[0m$/)
+      end
+      
+      #---
+      
+      it "formats a success message in green if color enabled" do
+        message = Interface.new({
+          :resource => 'component',
+          :color    => true,
+        }).format_message(:success, 'message')
+        message.should match(/^\e\[32mmessage\e\[0m$/)
+      end
+    end
+    
+    #---------------------------------------------------------------------------
+    
+    describe "#safe_puts" do
+    
+      #-------------------------------------------------------------------------
+      # Delegation
+      
+      it "can delegate to another class that contains this method" do
+        output  = double('output')
+        output.should_receive(:puts).with('message')
+        
+        ui = Interface.new({
+          :output  => output,
+          :printer => :puts,
+        })        
+        Interface.new({ :ui_delegate => ui }).safe_puts('message')
+      end
+      
+      #-------------------------------------------------------------------------
+      # Instance configuration
+      
+      it "prints an empty string unless message given" do
+        output  = double('output')
+        output.should_receive(:puts).with('')
+        
+        Interface.new({
+          :output  => output,
+          :printer => :puts,
+        }).safe_puts()
+      end
+      
+      #---
+      
+      it "prints to different output channels if they are given" do
+        output1 = double('output1')
+        output1.should_receive(:puts).with('message')
+        
+        test = Interface.new({
+          :output  => output1,
+          :printer => :puts,
+        })
+        test.safe_puts('message')
+        
+        output2 = double('output2')
+        output2.should_receive(:puts).with('message')
+        
+        test.output = output2
+        test.safe_puts('message')
+      end
+      
+      #---
+      
+      it "prints with puts if puts printer option given" do
+        output = double('output')
+        output.should_receive(:puts).with('message')
+        
+        Interface.new({
+          :output  => output,
+          :printer => :puts,
+        }).safe_puts('message')
+      end
+      
+      #---
+      
+      it "prints with print if print printer option given" do
+        output = double('output')
+        output.should_receive(:print).with('message')
+        
+        Interface.new({
+          :output  => output,
+          :printer => :print,
+        }).safe_puts('message')
+      end
+      
+      #-------------------------------------------------------------------------
+      # Method configuration
+      
+      it "can override the instance output channel" do
+        output1 = double('output1')
+        output1.should_not_receive(:puts).with('message')
+        
+        output2 = double('output2')
+        output2.should_receive(:puts).with('message')
+        
+        Interface.new({
+          :output  => output1,
+          :printer => :puts,
+        }).safe_puts('message', { :channel => output2 })  
+      end
+      
+      #---
+      
+      it "can override the instance printer handler" do
+        output = double('output')
+        output.should_not_receive(:puts).with('message')
+        output.should_receive(:print).with('message')
+        
+        Interface.new({
+          :output  => output,
+          :printer => :puts,
+        }).safe_puts('message', { :printer => :print })
+      end
+    end
+    
+    #---------------------------------------------------------------------------
+    
+    describe "#check_delegate" do
+      
+      it "returns false if no delegate exists" do
+        Interface.new.check_delegate('safe_puts').should be_false
+      end
+      it "returns true if a delegate exists and it implements given method" do
+        test = Interface.new({ :ui_delegate => Interface.new })
+        test.check_delegate('safe_puts').should be_true
+        test.check_delegate('nonexistent').should be_false
+      end
+    end  
+  end
+end