nucleon 0.1.0 → 0.1.1

data/lib/core/util/package.rb

@@ -0,0 +1,93 @@
+
+module Nucleon
+module Util
+class Package
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def initialize(options = {})
+    if options.is_a?(String)
+      @data = Config.new
+      decode(options)  
+    else
+      @data = Config.ensure(options)
+    end
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  attr_reader :data
+ 
+  #-----------------------------------------------------------------------------
+  # Operations
+
+  def encode
+    Base64.encode64(Data.to_json(data.export, false))
+  end
+      
+  def decode(encoded_string)
+    data.import(Data.symbol_map(Data.parse_json(Base64.decode64(encoded_string))))  
+  end
+  
+  #---
+  
+  def add_file(file, target_path = nil, perm = 0600)    
+    target_path = file if target_path.nil?
+    file        = File.expand_path(file)
+    
+    if File.exists?(file)
+      content = Disk.read(file)
+      data.set([ :files, target_path ], { :perm => perm, :content => content }) if content
+    end
+    self
+  end
+  
+  #---
+  
+  def add_files(base_path, file_glob, target_path = nil, perm = 0600)
+    target_path = base_path if target_path.nil?
+    curr_dir    = Dir.pwd
+    
+    Dir.chdir(File.expand_path(base_path))
+    Dir.glob(file_glob.gsub(/^[\/\\]+/, '')) do |file|
+      content = Disk.read(file)
+      
+      if content
+        data.set([ :dir, target_path, file ], { :perm => perm, :content => content })
+      end
+    end
+    Dir.chdir(curr_dir)
+    self      
+  end
+  
+  #---
+  
+  def extract(base_path)
+    success = true
+    
+    data.get_hash(:files).each do |target_path, info|
+      file    = File.join(base_path.to_s, target_path.to_s)
+      perm    = info[:perm]
+      content = info[:content]
+      
+      FileUtils.mkdir_p(File.dirname(file))      
+      success = false unless Disk.write(file, content) && File.chmod(perm, file)
+    end
+    
+    data.get_hash(:dir).each do |target_path, files|
+      files.each do |file, info|
+        file    = File.join(base_path.to_s, target_path.to_s, file.to_s)
+        perm    = info[:perm]
+        content = info[:content]
+        
+        FileUtils.mkdir_p(File.dirname(file))
+        success = false unless Disk.write(file, content) && File.chmod(perm, file)
+      end      
+    end
+    success
+  end
+end
+end
+end

data/lib/core/util/shell.rb

@@ -0,0 +1,239 @@
+
+module Nucleon
+module Util
+class Shell < Core
+  
+  include Celluloid
+  
+  #-----------------------------------------------------------------------------
+  
+  @@supervisors = {}
+  
+  #-----------------------------------------------------------------------------
+  # Execution result interface
+  
+  class Result
+    attr_accessor :status
+    attr_reader :command
+    
+    def initialize(command)
+      @command = command
+      @output  = ''
+      @errors  = ''
+      @status  = Nucleon.code.success
+    end
+    
+    #---
+    
+    def output
+      @output.strip
+    end
+    
+    def errors
+      @errors.strip
+    end
+    
+    #---
+    
+    def append_output(output_str)
+      @output << output_str
+    end
+    
+    def append_errors(error_str)
+      @errors << error_str
+    end  
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Shell interface
+  
+  def self.connection(name = :core)
+    name = name.to_sym
+    init_shell(name) unless @@supervisors.has_key?(name)
+    @@supervisors[name]
+  end  
+  
+  def self.init_shell(name)
+    name = name.to_sym
+    
+    Shell.supervise_as name
+    @@supervisors[name] = Celluloid::Actor[name]  
+  end
+  
+  #---
+  
+  execute_block_on_receiver :exec
+    
+  def exec(command, options = {}, &code)
+    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, Nucleon.ui)
+    
+    conditions   = Nucleon.events(config.get(:exit, {}), true)
+    
+    $stdout.sync = true
+    $stderr.sync = true
+    
+    system_result = Result.new(command)
+    
+    for i in tries.downto(1)
+      logger.info(">> running: #{command}")
+      
+      begin
+        t1, output_new, output_orig, output_reader = pipe_exec_stream($stdout, conditions, { 
+          :prefix => info_prefix, 
+          :suffix => info_suffix, 
+        }, 'output') do |data|
+          system_result.append_output(data)
+          block_given? ? code.call(:output, command, data) : true
+        end
+        
+        t2, error_new, error_orig, error_reader = pipe_exec_stream($stderr, conditions, { 
+          :prefix => error_prefix, 
+          :suffix => error_suffix, 
+        }, 'error') do |data|
+          system_result.append_errors(data)
+          block_given? ? code.call(:error, command, data) : true
+        end
+      
+        system_success       = system(command)
+        system_result.status = $?.exitstatus
+        
+      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
+      
+      success = ( system_success && output_success && error_success )
+                  
+      min -= 1
+      break if success && min <= 0 && conditions.empty?
+    end
+    system_result
+  end
+  
+  #---
+  
+  def pipe_exec_stream(output, conditions, options, label, &code)
+    original     = output.dup
+    read, write  = IO.pipe
+    
+    match_prefix = ( options[:match_prefix] ? options[:match_prefix] : 'EXIT' )
+    
+    thread = process_stream(read, original, options, label) do |data|
+      check_conditions(data, conditions, match_prefix) do
+        block_given? ? code.call(data) : true
+      end
+    end
+    
+    thread.abort_on_exception = false
+    
+    output.reopen(write)    
+    return thread, write, original, read
+  end
+  protected :pipe_exec_stream
+  
+  #---
+  
+  def close_exec_pipe(thread, output, original, write, label)
+    output.reopen(original)
+     
+    write.close
+    success = thread.value
+    
+    original.close
+    return success
+  end
+  protected :close_exec_pipe
+  
+  #---
+  
+  def check_conditions(data, conditions, match_prefix = '', &code)
+    prefix = ''
+    
+    unless ! conditions || conditions.empty?
+      conditions.each do |key, event|
+        if event.check(data)
+          prefix = match_prefix
+          conditions.delete(key)
+        end
+      end
+    end
+    
+    result = true
+    if block_given?
+      result = code.call
+      
+      unless prefix.empty?
+        case result
+        when Hash
+          result[:prefix] = prefix
+        else
+          result = { :success => result, :prefix => prefix }
+        end
+      end
+    end
+    return result
+  end
+  protected :check_conditions
+  
+  #---
+  
+  def process_stream(input, output, options, label, &code)
+    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 = code.call(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
+  protected :process_stream
+end
+end
+end

data/lib/nucleon/action/add.rb

@@ -0,0 +1,69 @@
+
+module Nucleon
+module Action
+class Add < Plugin::Action
+  
+  include Mixin::Action::Project
+  include Mixin::Action::Push
+ 
+  #-----------------------------------------------------------------------------
+  # Add action interface
+  
+  def normalize
+    super('nucleon add <subproject/path> <subproject:::reference>')    
+    
+    codes :project_failure => 20,
+          :add_failure     => 21,
+          :push_failure    => 22
+  end
+
+  #-----------------------------------------------------------------------------
+  # Action operations
+   
+  def parse(parser)
+    parser.arg_str(:sub_path, nil, 
+      'nucleon.core.actions.add.options.sub_path'
+    )
+    parser.arg_str(:sub_reference, nil, 
+      'nucleon.core.actions.add.options.sub_reference'
+    )
+    parser.option_bool(:editable, false, 
+      '--editable', 
+      'nucleon.core.actions.add.options.editable'
+    )
+    project_options(parser, true, true)
+    push_options(parser, true)  
+  end
+  
+  #---
+   
+  def execute
+    super do |node, network, status|
+      info('nucleon.core.actions.add.start')
+      
+      if project = project_load(Dir.pwd, false)
+        sub_info = project.translate_reference(settings[:sub_reference], settings[:editable])
+        sub_path = settings[:sub_path]
+          
+        if sub_info
+          sub_url      = sub_info[:url]
+          sub_revision = sub_info[:revision]
+        else
+          sub_url      = settings[:sub_reference]
+          sub_revision = nil
+        end
+          
+        if project.add_subproject(sub_path, sub_url, sub_revision)
+          status = code.push_failure unless push(project)
+        else
+          status = code.add_failure
+        end
+      else
+        status = code.project_failure               
+      end        
+      status
+    end
+  end
+end
+end
+end

data/lib/nucleon/action/create.rb

@@ -0,0 +1,52 @@
+
+module Nucleon
+module Action
+class Create < Plugin::Action
+ 
+  #-----------------------------------------------------------------------------
+  # Create action interface
+  
+  def normalize
+    super('nucleon create [ <project:::reference> ]')    
+    
+    codes :project_failure => 20
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Action operations
+  
+  def parse(parser)
+    parser.option_str(:path, Dir.pwd, 
+      '--path PROJECT_DIR', 
+      'nucleon.core.actions.create.options.path'
+    )
+    parser.option_str(:revision, :master, 
+      '--revision REVISION/BRANCH', 
+      'nucleon.core.actions.create.options.revision'
+    )
+    parser.arg_str(:reference, 
+      'github:::coralnexus/puppet-cloud-template', 
+      'nucleon.core.actions.create.options.reference'
+    )
+  end
+  
+  #---
+   
+  def execute
+    super do |node, network, status|
+      info('nucleon.core.actions.create.start')
+      
+      project = Nucleon.project(extended_config(:project, {
+        :create    => true,
+        :directory => settings[:path],
+        :url       => settings[:reference],
+        :revision  => settings[:revision],
+        :pull      => true
+      }))
+      
+      project ? status : code.project_failure
+    end
+  end
+end
+end
+end

data/lib/nucleon/action/extract.rb

@@ -0,0 +1,49 @@
+
+module Nucleon
+module Action
+class Extract < Plugin::Action
+ 
+  #-----------------------------------------------------------------------------
+  # Action settings
+  
+  def configure
+    super do
+      codes :extract_failure
+         
+      register :path, :str, nil do |value|
+        unless File.directory?(value)
+          warn('nucleon.actions.extract.errors.path', { :value => value })
+          next false
+        end
+        true
+      end
+      register :encoded, :str, nil do |value|
+        @package = Util::Package.new(value)
+        if @package.data.export.empty?
+          warn('nucleon.actions.extract.errors.encoded', { :value => value })
+          next false  
+        end
+        true
+      end
+    end
+  end
+  
+  #---
+  
+  def arguments
+    [ :path, :encoded ]
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Action operations
+  
+  def execute
+    super do |node, network|
+      unless @package.extract(settings[:path])
+        myself.status = code.extract_failure
+      end
+    end
+  end
+end
+end
+end

data/lib/nucleon/action/remove.rb

@@ -0,0 +1,51 @@
+
+module Nucleon
+module Action
+class Remove < Plugin::Action
+  
+  include Mixin::Action::Project
+  include Mixin::Action::Push
+ 
+  #-----------------------------------------------------------------------------
+  # Remove action interface
+  
+  def normalize
+    super('nucleon remove <subproject/path>')    
+    
+    codes :project_failure => 20,
+          :delete_failure  => 21,
+          :push_failure    => 22
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Action operations
+  
+  def parse(parser)
+    parser.arg_str(:sub_path, nil, 
+      'nucleon.core.actions.remove.options.sub_path'
+    )
+    project_options(parser, true, true)
+    push_options(parser, true)
+  end
+  
+  #---
+   
+  def execute
+    super do |node, network, status|
+      info('nucleon.core.actions.remove.start')
+      
+      if project = project_load(Dir.pwd, false)
+        if project.delete_subproject(settings[:sub_path])
+          status = code.push_failure unless push(project)
+        else
+          status = code.delete_failure
+        end
+      else
+        status = code.project_failure  
+      end      
+      status
+    end
+  end
+end
+end
+end

data/lib/nucleon/action/save.rb

@@ -0,0 +1,53 @@
+
+module Nucleon
+module Action
+class Save < Plugin::Action
+  
+  include Mixin::Action::Project
+  include Mixin::Action::Commit
+  include Mixin::Action::Push
+ 
+  #-----------------------------------------------------------------------------
+  # Save action interface
+  
+  def normalize
+    super('nucleon save [ <file> ... ]')    
+    
+    codes :project_failure => 20,
+          :commit_failure  => 21,
+          :push_failure    => 22
+  end
+
+  #-----------------------------------------------------------------------------
+  # Action operations
+  
+  def parse(parser)
+    parser.arg_array(:files, '.', 
+      'nucleon.core.actions.save.options.files'
+    )
+    project_options(parser, true, false)
+    commit_options(parser, false)
+    push_options(parser, true)
+  end
+  
+  #---
+   
+  def execute          
+    super do |node, network, status|
+      info('nucleon.core.actions.save.start')
+          
+      if project = project_load(Dir.pwd, false)
+        if commit(project, settings[:files])
+          status = code.push_failure unless push(project)
+        else
+          status = code.commit_failure
+        end
+      else
+        status = code.project_failure
+      end
+      status
+    end
+  end
+end
+end
+end

data/lib/nucleon/action/update.rb

@@ -0,0 +1,37 @@
+
+module Nucleon
+module Action
+class Update < Plugin::Action
+  
+  include Mixin::Action::Project
+ 
+  #-----------------------------------------------------------------------------
+  # Update action interface
+  
+  def normalize
+    super('nucleon update')    
+    
+    codes :project_failure => 20
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Action operations
+  
+  def parse(parser)
+    project_options(parser, true, true)
+  end
+  
+  #---
+   
+  def execute
+    super do |node, network, status|
+      info('nucleon.core.actions.update.start')
+      
+      project = project_load(Dir.pwd, true)
+      status  = code.project_failure unless project
+      status
+    end
+  end
+end
+end
+end