nucleon 0.1.19 → 0.2.0

data/lib/core/util/shell.rb

@@ -37,11 +37,11 @@ class Shell < Core
     #---
     
     def append_output(output_str)
-      @output << output_str
+      @output << output_str.rstrip << "\n"
     end
     
     def append_errors(error_str)
-      @errors << error_str
+      @errors << error_str.rstrip << "\n"
     end  
   end
   
@@ -82,7 +82,7 @@ class Shell < Core
     system_result = Result.new(command)
     
     for i in tries.downto(1)
-      logger.info(">> running: #{command}")
+      logger.info(">> running shell: #{command}")
       
       begin
         t1, output_new, output_orig, output_reader = pipe_exec_stream($stdout, conditions, { 
@@ -111,6 +111,9 @@ class Shell < Core
         error_success  = close_exec_pipe(t2, $stderr, error_orig, error_new, 'error')
       end
       
+      logger.warn("`#{command}` messages: #{system_result.errors}") if system_result.errors.length > 0
+      logger.warn("`#{command}` status: #{system_result.status}") unless system_result.status == 0
+        
       success = ( system_success && output_success && error_success )
                   
       min -= 1

data/lib/core/util/ssh.rb

@@ -28,19 +28,20 @@ class SSH < Core
     
     private_key  = config.get(:private_key, nil)
     original_key = nil
-    key_comment  = config.get(:comment, '')    
+    key_comment  = config.get(:comment, '')
+    passphrase   = config.get(:passphrase, nil)
+    force        = config.get(:force, false)    
     
     if private_key.nil?
       key_type    = config.get(:type, "RSA")
       key_bits    = config.get(:bits, 2048)
-      passphrase  = config.get(:passphrase, nil)
-    
-      key_data = SSHKey.generate(
+      
+      key_data = SSHKey.generate({
         :type       => key_type, 
         :bits       => key_bits, 
         :comment    => key_comment, 
         :passphrase => passphrase
-      )
+      })
       is_new = true
       
     else
@@ -50,12 +51,18 @@ class SSH < Core
         original_key = Disk.read(private_key)
       end
       
-      key_data = SSHKey.new(original_key, :comment => key_comment) if original_key
-      is_new   = false
+      if original_key
+        encrypted = original_key.include?('ENCRYPTED')
+        key_data  = SSHKey.new(original_key, { 
+          :comment    => key_comment, 
+          :passphrase => passphrase 
+        }) if force || ! encrypted || passphrase 
+      end      
+      is_new = false
     end
     
     return nil unless key_data && ! key_data.ssh_public_key.empty?
-    Keypair.new(key_data, is_new, original_key)
+    Keypair.new(key_data, is_new, original_key, passphrase)
   end
   
   #-----------------------------------------------------------------------------
@@ -69,39 +76,69 @@ class SSH < Core
   # Keypair interface
     
   class Keypair
-    attr_reader :type, :private_key, :encrypted_key, :public_key, :ssh_key
+    attr_reader :type, :private_key, :encrypted_key, :public_key, :ssh_key, :passphrase
+    
+    #---
     
-    def initialize(key_data, is_new, original_key)
+    def initialize(key_data, is_new, original_key, passphrase = nil)
       @type          = key_data.type
       @private_key   = key_data.private_key
       @encrypted_key = is_new ? key_data.encrypted_private_key : original_key
       @public_key    = key_data.public_key
       @ssh_key       = key_data.ssh_public_key
+      @passphrase    = passphrase
+    end
+    
+    #---
+    
+    def private_key_file(key_path = nil, key_base = 'id')
+      key_path = SSH.key_path if key_path.nil?
+      key_name = render(key_base)
+      
+      File.join(key_path, "#{key_name}")  
+    end
+    
+    def public_key_file(key_path = nil, key_base = 'id')
+      private_key_file(key_path, key_base) + '.pub'  
     end
     
     #---
     
-    def store(key_path = nil, key_base = 'id')
-      key_path         = SSH.key_path if key_path.nil?
-      private_key_file = File.join(key_path, "#{key_base}_#{type.downcase}")
-      public_key_file  = File.join(key_path, "#{key_base}_#{type.downcase}.pub")
+    def store(key_path = nil, key_base = 'id', secure = true)
+      private_key_file = private_key_file(key_path, key_base)
+      public_key_file  = public_key_file(key_path, key_base)
       
-      private_success = Disk.write(private_key_file, encrypted_key)
+      if secure
+        private_success = Disk.write(private_key_file, encrypted_key)
+      else
+        private_success = Disk.write(private_key_file, private_key)  
+      end
       FileUtils.chmod(0600, private_key_file) if private_success
       
-      public_success  = Disk.write(public_key_file, ssh_key)
+      public_success = Disk.write(public_key_file, ssh_key)
       
       if private_success && public_success
         return { :private_key => private_key_file, :public_key => public_key_file }
       end
       false
     end
+    
+    #---
+    
+    def render(key_base = 'id')
+      self.class.render(type, key_base)
+    end
+    
+    def self.render(type, key_base = 'id')
+      "#{key_base}_#{type.downcase}"  
+    end
   end
   
   #-----------------------------------------------------------------------------
   # SSH Execution interface
   
   @@sessions = {}
+  @@auth     = {}
   
   #---
   
@@ -114,23 +151,38 @@ class SSH < Core
   def self.session(hostname, user, port = 22, private_key = nil, reset = false, options = {})
     require 'net/ssh'
     
+    session_id  = session_id(hostname, user)
+    config      = Config.ensure(options)
+    
     ssh_options = Config.new({
       :user_known_hosts_file => [ File.join(key_path, 'known_hosts'), File.join(key_path, 'known_hosts2') ],
-      :key_data              => [],
-      :keys_only             => false,
       :auth_methods          => [ 'publickey' ],
       :paranoid              => :very
-    }).import(options)
+    }).import(Util::Data.subset(config, config.keys - [ :keypair, :key_dir, :key_name ]))
     
-    ssh_options[:port] = port
-    ssh_options[:keys] = private_key.nil? ? [] : [ private_key ]
+    if private_key
+      auth_id = [ session_id, private_key ].join('_')      
+      
+      if ! @@auth[auth_id] && keypair = unlock_private_key(private_key, config)
+        @@auth[auth_id] = keypair
+      end
+      config[:keypair] = @@auth[auth_id] # Reset so caller can access updated keypair      
+      
+      if @@auth[auth_id].is_a?(String)
+        ssh_options[:keys_only] = false
+        ssh_options[:keys]      = [ @@auth[auth_id] ]  
+      else
+        ssh_options[:keys_only] = true
+        ssh_options[:key_data]  = [ @@auth[auth_id].private_key ]
+      end
+    end
     
-    session_id = session_id(hostname, user)
+    ssh_options[:port] = port    
     
     if reset || ! @@sessions.has_key?(session_id)
       @@sessions[session_id] = Net::SSH.start(hostname, user, ssh_options.export)
     end
-    yield(@@sessions[session_id]) if block_given? && @@sessions[session_id]
+    yield(@@sessions[session_id]) if block_given? && @@sessions[session_id]    
     @@sessions[session_id] 
   end
   
@@ -188,6 +240,8 @@ class SSH < Core
           command = command.flatten.join(' ') if command.is_a?(Array)
           command = command.to_s
           result  = Shell::Result.new(command)
+          
+          logger.info(">> running SSH: #{command}")
               
           ssh.open_channel do |ssh_channel|
             ssh_channel.request_pty
@@ -216,8 +270,11 @@ class SSH < Core
               end
             end
           end
-          ssh.loop              
+          logger.warn("`#{command}` messages: #{result.errors}") if result.errors.length > 0
+          logger.warn("`#{command}` status: #{result.status}") unless result.status == 0
+       
           results << result
+          ssh.loop          
         end
       end
     rescue Net::SSH::HostKeyMismatch => error
@@ -351,6 +408,73 @@ class SSH < Core
     process.wait
     process.exit_code
   end
+  
+  #-----------------------------------------------------------------------------
+  # SSH utilities
+  
+  def self.unlock_private_key(private_key, options = {})
+    require 'net/ssh'
+    
+    config   = Config.ensure(options)
+    keypair  = config.get(:keypair, nil)
+    key_dir  = config.get(:key_dir, nil)
+    key_name = config.get(:key_name, 'default')
+    no_file  = ENV['NUCLEON_NO_SSH_KEY_SAVE']
+    
+    password    = nil
+    tmp_key_dir = nil
+    
+    if private_key
+      keypair = nil if keypair && ! keypair.private_key
+      
+      unless no_file
+        if key_dir && key_name && File.exists?(private_key) && loaded_private_key = Util::Disk.read(private_key)
+          FileUtils.mkdir_p(key_dir)
+      
+          loaded_private_key =~ /BEGIN\s+([A-Z]+)\s+/
+        
+          local_key_type = $1
+          local_key_name = Keypair.render(local_key_type, key_name)
+          local_key_path = File.join(key_dir, local_key_name)
+        
+          keypair = generate({ :private_key => local_key_path }) if File.exists?(local_key_path)
+        end
+      end
+      
+      unless keypair
+        key_manager_logger       = ::Logger.new(STDERR)
+        key_manager_logger.level = ::Logger::FATAL
+        key_manager              = Net::SSH::Authentication::KeyManager.new(key_manager_logger)        
+        
+        key_manager.each_identity do |identity|
+          if identity.comment == private_key
+            # Feed the key to the system password manager if it exists
+            keypair = private_key
+          end
+        end
+        key_manager.finish
+      
+        until keypair
+          keypair = generate({
+            :private_key => private_key,
+            :passphrase  => password
+          })        
+          password = ui.ask("Enter passphrase for #{private_key}: ", { :echo => false }) unless keypair
+        end
+        
+        unless no_file
+          if key_dir && key_name && ! keypair.is_a?(String)
+            key_files = keypair.store(key_dir, key_name, false)
+          
+            if key_files && File.exists?(key_files[:private_key])
+              keypair = generate({ :private_key => key_files[:private_key] })
+            end
+          end
+        end
+      end
+    end
+    keypair      
+  end
 end
 end
 end

data/lib/nucleon/action/extract.rb

@@ -1,8 +1,15 @@
 
 module Nucleon
 module Action
-class Extract < Nucleon.plugin_class(:action)
- 
+class Extract < Nucleon.plugin_class(:nucleon, :action)
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(nil, :extract, -50)
+  end
+  
   #-----------------------------------------------------------------------------
   # Settings
   
@@ -12,7 +19,7 @@ class Extract < Nucleon.plugin_class(:action)
          
       register :path, :str, nil do |value|
         unless File.directory?(value)
-          warn('nucleon.actions.extract.errors.path', { :value => value })
+          warn('nucleon.action.extract.errors.path', { :value => value })
           next false
         end
         true
@@ -20,7 +27,7 @@ class Extract < Nucleon.plugin_class(:action)
       register :encoded, :str, nil do |value|
         @package = Util::Package.new(value)
         if @package.data.export.empty?
-          warn('nucleon.actions.extract.errors.encoded', { :value => value })
+          warn('nucleon.action.extract.errors.encoded', { :value => value })
           next false  
         end
         true

data/lib/nucleon/action/{add.rb → project/add.rb}

@@ -1,10 +1,18 @@
 
 module Nucleon
 module Action
-class Add < Nucleon.plugin_class(:action)
+module Project
+class Add < Nucleon.plugin_class(:nucleon, :action)
   
   include Mixin::Action::Project
   include Mixin::Action::Push
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:project, :add, 700)
+  end
  
   #-----------------------------------------------------------------------------
   # Settings
@@ -20,8 +28,8 @@ class Add < Nucleon.plugin_class(:action)
       register :sub_path, :str, nil
       register :sub_reference, :str, nil do |value|
         success = true
-        if info = Nucleon.plugin_class(:project).translate_reference(value)
-          if ! Nucleon.loaded_plugins(:project).keys.include?(info[:provider].to_sym)
+        if info = Nucleon.plugin_class(:nucleon, :project).translate_reference(value)
+          if ! Nucleon.loaded_plugins(:nucleon, :project).keys.include?(info[:provider].to_sym)
             warn('nucleon.core.mixin.action.project.errors.project_reference', { 
               :value     => value, 
               :provider  => info[:provider],  
@@ -52,7 +60,7 @@ class Add < Nucleon.plugin_class(:action)
    
   def execute
     super do
-      info('nucleon.actions.add.start')
+      info('nucleon.action.project.add.start')
       
       if project = project_load(settings[:path], false)
         sub_info = project.translate_reference(settings[:sub_reference], settings[:editable])
@@ -79,3 +87,4 @@ class Add < Nucleon.plugin_class(:action)
 end
 end
 end
+end

data/lib/nucleon/action/{create.rb → project/create.rb}

@@ -1,10 +1,18 @@
 
 module Nucleon
 module Action
-class Create < Nucleon.plugin_class(:action)
+module Project
+class Create < Nucleon.plugin_class(:nucleon, :action)
   
   include Mixin::Action::Project
- 
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:project, :create, 1000)
+  end
+  
   #-----------------------------------------------------------------------------
   # Settings
   
@@ -30,7 +38,7 @@ class Create < Nucleon.plugin_class(:action)
    
   def execute
     super do
-      info('nucleon.actions.create.start')
+      info('nucleon.action.project.create.start')
       
       project       = project_load(settings[:path], true, true)
       myself.status = code.project_failure unless project
@@ -39,3 +47,4 @@ class Create < Nucleon.plugin_class(:action)
 end
 end
 end
+end

data/lib/nucleon/action/{remove.rb → project/remove.rb}

@@ -1,10 +1,18 @@
 
 module Nucleon
 module Action
-class Remove < Nucleon.plugin_class(:action)
+module Project
+class Remove < Nucleon.plugin_class(:nucleon, :action)
   
   include Mixin::Action::Project
   include Mixin::Action::Push
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:project, :remove, 600)
+  end
  
   #-----------------------------------------------------------------------------
   # Settings
@@ -38,7 +46,7 @@ class Remove < Nucleon.plugin_class(:action)
   
   def execute
     super do
-      info('nucleon.actions.remove.start')
+      info('nucleon.action.project.remove.start')
       
       if project = project_load(settings[:path], false)
         if project.delete_subproject(settings[:sub_path])
@@ -54,3 +62,4 @@ class Remove < Nucleon.plugin_class(:action)
 end
 end
 end
+end

data/lib/nucleon/action/{save.rb → project/save.rb}

@@ -1,11 +1,19 @@
 
 module Nucleon
 module Action
-class Save < Nucleon.plugin_class(:action)
+module Project
+class Save < Nucleon.plugin_class(:nucleon, :action)
   
   include Mixin::Action::Project
   include Mixin::Action::Commit
   include Mixin::Action::Push
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:project, :save, 800)
+  end
  
   #-----------------------------------------------------------------------------
   # Settings
@@ -36,7 +44,7 @@ class Save < Nucleon.plugin_class(:action)
    
   def execute          
     super do
-      info('nucleon.actions.save.start')
+      info('nucleon.action.project.save.start')
           
       if project = project_load(settings[:path], false, false)
         if commit(project, settings[:files])
@@ -52,3 +60,4 @@ class Save < Nucleon.plugin_class(:action)
 end
 end
 end
+end