nucleon 0.1.3 → 0.1.4

data/lib/core/plugin/action.rb

@@ -74,7 +74,7 @@ class Action < Base
   
   #---
   
-  def normalize
+  def normalize(reload)
     args = array(delete(:args, []))
        
     @action_interface = Util::Liquid.new do |method, method_args|
@@ -101,7 +101,7 @@ class Action < Base
       set(:settings, Config.new)
       configure
       parse_base(args)
-    end   
+    end 
   end
   
   #-----------------------------------------------------------------------------
@@ -303,11 +303,13 @@ class Action < Base
     # Validate all of the configurations
     success = true
     config.export.each do |name, option|
-      success = false unless option.validate(settings[name], *args)
+      unless ignore.include?(name)
+        success = false unless option.validate(settings[name], *args)
+      end
     end
     if success
       # Check for missing arguments (in case of internal execution mode)
-      arguments.each do |name|        
+      arguments.each do |name| 
         if settings[name.to_sym].nil?
           warn('nucleon.core.exec.errors.missing_argument', { :name => name })
           success = false

data/lib/core/plugin/base.rb

@@ -6,7 +6,7 @@ class Base < Core
   # All Plugin classes should directly or indirectly extend Base
   
   def initialize(type, provider, options)
-    config = Util::Data.clean(Config.ensure(options))
+    config = Util::Data.clean(Config.ensure(options), false)
     name   = Util::Data.ensure_value(config.delete(:plugin_name), config.delete(:name, provider))
     
     @quiet = config.delete(:quiet, false)
@@ -18,7 +18,7 @@ class Base < Core
     myself.plugin_name = name
     
     logger.debug("Normalizing #{plugin_type} plugin #{plugin_name} with meta data: #{meta.inspect}")
-    normalize
+    normalize(false)
   end
   
   #---
@@ -147,7 +147,7 @@ class Base < Core
   #-----------------------------------------------------------------------------
   # Plugin operations
     
-  def normalize
+  def normalize(reload)
     # Implement in sub classes
   end
   

data/lib/core/plugin/command.rb

@@ -6,7 +6,7 @@ class Command < Base
   #-----------------------------------------------------------------------------
   # Command plugin interface
   
-  def normalize
+  def normalize(reload)
     super
   end
   

data/lib/core/plugin/project.rb

@@ -36,21 +36,26 @@ class Project < Base
   #-----------------------------------------------------------------------------
   # Project plugin interface
    
-  def normalize
+  def normalize(reload)
     super
     
-    extension(:normalize)
-    
     set_directory(Util::Disk.filename(get(:directory, Dir.pwd)))
+    register
+    
     set_url(get(:url)) if get(:url, false)
     
     myself.plugin_name = path if myself.plugin_name == plugin_provider
     
+    ui.resource = plugin_name
+    logger      = plugin_name
+    
     if keys = delete(:keys, nil)
       set(:private_key, keys[:private_key])
       set(:public_key, keys[:public_key])
     end
     
+    extension(:normalize)
+    
     init_project
     extension(:init)
     
@@ -63,7 +68,7 @@ class Project < Base
     init_auth
     init_parent
     init_remotes    
-    load_revision
+    load_revision    
   end
    
   #-----------------------------------------------------------------------------
@@ -71,7 +76,12 @@ class Project < Base
   
   def register
     super
-    # TODO: Scan project directory looking for plugins
+    if directory
+      lib_path = File.join(directory, 'lib')
+      if File.directory?(lib_path)
+        CORL.register(lib_path)
+      end
+    end
   end
         
   #-----------------------------------------------------------------------------
@@ -560,7 +570,7 @@ class Project < Base
   
   #---
   
-  def foreach!
+  def each
     if can_persist?
       localize do
         logger.info("Iterating through all sub projects of project #{name}")
@@ -614,14 +624,20 @@ class Project < Base
  
   #---
   
-  def set_remote(name, url)
+  def set_remote(name, url, options = {})
+    config = Config.ensure(options)
+    
     if can_persist?
       localize do
-        if ! url.strip.empty? && url = extension_set(:set_remote, url, { :name => name })
-          delete_remote(name)
+        unless url.strip.empty? 
+          if url = extension_set(:set_remote, url, { :name => name })
+            delete_remote(name)
+            
+            url = translate_edit_url(url) if name == :edit && config.get(:translate, true)
     
-          logger.info("Setting project remote #{name} to #{url}")
-          yield(url) if block_given?
+            logger.info("Setting project remote #{name} to #{url}")
+            yield(url) if block_given?
+          end
         end
       end
     else
@@ -637,6 +653,8 @@ class Project < Base
         config = Config.ensure(options)
       
         if url = extension_set(:add_remote_url, url, { :name => name, :config => config })
+          url = translate_edit_url(url) if name == :edit && config.get(:translate, true)
+          
           logger.info("Adding project remote url #{url} to #{name}")    
           yield(config, url) if block_given?
         end
@@ -651,7 +669,7 @@ class Project < Base
   def set_host_remote(name, hosts, path, options = {})
     if can_persist?
       localize do
-        config = Config.ensure(options).import({ :path => path })
+        config = Config.ensure(options).import({ :path => path, :translate => false })
         hosts  = array(hosts)
       
         unless hosts.empty?
@@ -660,7 +678,7 @@ class Project < Base
               path = config.delete(:path)
           
               logger.info("Setting host remote #{name} for #{hosts.inspect} at #{path}") 
-              set_remote(name, translate_url(hosts.shift, path, config.export))
+              set_remote(name, translate_url(hosts.shift, path, config.export), config)
         
               hosts.each do |host|
                 logger.debug("Adding remote url to #{host}")

data/lib/core/util/cli.rb

@@ -16,11 +16,11 @@ module CLI
   #---
       
   def self.encode(data)
-    Base64.encode64(Util::Data.to_json(data, false))
+    Base64.urlsafe_encode64(Util::Data.to_json(data, false))
   end
       
   def self.decode(encoded_string)
-    Util::Data.symbol_map(Util::Data.parse_json(Base64.decode64(encoded_string)))  
+    Util::Data.symbol_map(Util::Data.parse_json(Base64.urlsafe_decode64(encoded_string)))  
   end
         
   #-------------------------------------------------------------------------
@@ -75,7 +75,7 @@ module CLI
       if sub_command
         results << [ sub_command, sub_args ]
       end
-
+      
       return results.flatten
     end
         
@@ -130,14 +130,14 @@ module CLI
           options[:help] = true
         end  
       end
-          
       parser.parse!(args)
       
-      # Now we can act on options given              
-      Nucleon.log_level = options[:log_level] if options[:log_level]
+      # Now we can act on options given
       return if options[:help]
       
       parse_encoded
+      
+      Nucleon.log_level = options[:log_level] if options[:log_level]
          
       remaining_args = args.dup
       arg_messages   = []
@@ -217,7 +217,7 @@ module CLI
         end
             
         encoded_properties.each do |name, value|
-          self.options[name] = value unless options.has_key?(name)
+          self.options[name] = value
         end
       end
       options.delete(:encoded_params)

data/lib/core/util/data.rb

@@ -234,9 +234,10 @@ class Data
   #-----------------------------------------------------------------------------
   # Operations
   
-  def self.clean(data)
+  def self.clean(data, remove_empty = true)
     data.keys.each do |key|
-      data.delete(key) if data[key].nil?
+      obj = data[key]
+      data.delete(key) if obj.nil? || ( remove_empty && obj.is_a?(Hash) && obj.empty? )
     end
     data
   end

data/lib/core/util/disk.rb

@@ -71,7 +71,10 @@ class Disk
     if file
       file.pos = 0 if options[:mode] == 'w'
       success  = file.write(data)
-      file.flush
+      begin
+        file.flush
+      rescue # In case the file is already closed
+      end
       return success
     end
     return nil

data/lib/core/util/shell.rb

@@ -91,20 +91,22 @@ class Shell < Core
       begin
         t1, output_new, output_orig, output_reader = pipe_exec_stream($stdout, conditions, { 
           :prefix => info_prefix, 
-          :suffix => info_suffix, 
+          :suffix => info_suffix,
+          :quiet  => config.get(:quiet, false) 
         }, 'output') do |data|
           system_result.append_output(data)
-          block_given? ? code.call(:output, command, data) : true
+          code ? 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, 
+          :suffix => error_suffix,
+          :quiet  => config.get(:quiet, false)  
         }, 'error') do |data|
           system_result.append_errors(data)
-          block_given? ? code.call(:error, command, data) : true
+          code ? code.call(:error, command, data) : true
         end
-      
+        
         system_success       = system(command)
         system_result.status = $?.exitstatus
         
@@ -131,7 +133,7 @@ class Shell < Core
     
     thread = process_stream(read, original, options, label) do |data|
       check_conditions(data, conditions, match_prefix) do
-        block_given? ? code.call(data) : true
+        code ? code.call(data) : true
       end
     end
     
@@ -170,7 +172,7 @@ class Shell < Core
     end
     
     result = true
-    if block_given?
+    if code
       result = code.call
       
       unless prefix.empty?
@@ -206,7 +208,7 @@ class Shell < Core
               suffix  = default_suffix
               
               unless line.empty?
-                if block_given?
+                if code
                   result = code.call(line)
                                           
                   if result && result.is_a?(Hash)
@@ -217,11 +219,13 @@ class Shell < Core
                   success = result if success
                 end
             
-                prefix = ( prefix && ! prefix.empty? ? "#{prefix}: " : '' )
+                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)
+                
+                unless options[:quiet]
+                  output.write(prefix.lstrip + line + suffix.rstrip + eol)
+                end
               end
             end
           end

data/lib/core/util/ssh.rb

@@ -0,0 +1,356 @@
+
+module Nucleon
+module Util
+class SSH < Core
+  
+  #-----------------------------------------------------------------------------
+  # User key home
+  
+  @@key_path = nil
+  
+  #---
+  
+  def self.key_path
+    unless @@key_path
+      home_path  = ( ENV['USER'] == 'root' ? '/root' : ENV['HOME'] ) # In case we are using sudo
+      @@key_path = File.join(home_path, '.ssh')
+    
+      FileUtils.mkdir(@@key_path) unless File.directory?(@@key_path)
+    end
+    @@key_path
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Instance generators
+  
+  def self.generate(options = {})
+    config = Config.ensure(options)
+    
+    private_key  = config.get(:private_key, nil)
+    original_key = nil
+    key_comment  = config.get(:comment, '')    
+    
+    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(
+        :type       => key_type, 
+        :bits       => key_bits, 
+        :comment    => key_comment, 
+        :passphrase => passphrase
+      )
+      is_new = true
+      
+    else
+      if private_key.include?('PRIVATE KEY')
+        original_key = private_key   
+      else
+        original_key = Disk.read(private_key)
+      end
+      
+      key_data = SSHKey.new(original_key, :comment => key_comment) if original_key
+      is_new   = false
+    end
+    
+    return nil unless key_data && ! key_data.ssh_public_key.empty?
+    Keypair.new(key_data, is_new, original_key)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def self.valid?(public_ssh_key)
+    SSHKey.valid_ssh_public_key?(public_ssh_key)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Keypair interface
+    
+  class Keypair
+    attr_reader :type, :private_key, :encrypted_key, :public_key, :ssh_key
+    
+    def initialize(key_data, is_new, original_key)
+      @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
+    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")
+      
+      private_success = Disk.write(private_key_file, encrypted_key)
+      FileUtils.chmod(0600, private_key_file) if private_success
+      
+      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
+  end
+  
+  #-----------------------------------------------------------------------------
+  # SSH Execution interface
+  
+  @@sessions = {}
+  
+  #---
+  
+  def self.session_id(hostname, user)
+    "#{hostname}-#{user}"  
+  end
+  
+  #---
+  
+  def self.session(hostname, user, port = 22, private_key = nil, reset = false, options = {})
+    require 'net/ssh'
+    
+    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)
+    
+    ssh_options[:port] = port
+    ssh_options[:keys] = private_key.nil? ? [] : [ private_key ]
+    
+    session_id = session_id(hostname, user)
+    
+    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]
+    @@sessions[session_id] 
+  end
+  
+  def self.init_session(hostname, user, port = 22, private_key = nil, options = {})
+    session(hostname, user, port, private_key, true, options)  
+  end
+  
+  #---
+  
+  def self.close_session(hostname, user)
+    session_id = session_id(hostname, user)
+    
+    if @@sessions.has_key?(session_id)
+      begin # Don't care about errors here
+        @@sessions[session_id].close
+      rescue
+      end
+      @@sessions.delete(session_id)
+    end
+  end
+  
+  #---
+  
+  def self.close(hostname = nil, user = nil)
+    if hostname && user.nil? # Assume we entered a session id
+      if @@sessions.has_key?(hostname)
+        @@sessions[hostname].close
+        @@sessions.delete(hostname)  
+      end
+      
+    elsif hostname && user # Generate session id from args
+      session_id = session_id(hostname, user)
+      
+      if @@sessions.has_key?(session_id)
+        @@sessions[session_id].close
+        @@sessions.delete(session_id)  
+      end
+      
+    else # Close all connections
+      @@sessions.keys.each do |id|
+        @@sessions[id].close
+        @@sessions.delete(id)      
+      end
+    end
+  end
+  
+  #---
+  
+  def self.exec(hostname, user, commands)
+    results = []
+        
+    begin
+      session(hostname, user) do |ssh|
+        Data.array(commands).each do |command|
+          command = command.flatten.join(' ') if command.is_a?(Array)
+          command = command.to_s
+          result  = Shell::Result.new(command)
+              
+          ssh.open_channel do |ssh_channel|
+            ssh_channel.request_pty
+            ssh_channel.exec(command) do |channel, success|
+              unless success
+                raise "Could not execute command: #{command.inspect}"
+              end
+
+              channel.on_data do |ch, data|
+                result.append_output(data)
+                yield(:output, command, data) if block_given?
+              end
+
+              channel.on_extended_data do |ch, type, data|
+                next unless type == 1
+                result.append_errors(data)
+                yield(:error, command, data) if block_given?
+              end
+
+              channel.on_request('exit-status') do |ch, data|
+                result.status = data.read_long
+              end
+
+              channel.on_request('exit-signal') do |ch, data|
+                result.status = 255
+              end
+            end
+          end
+          ssh.loop              
+          results << result
+        end
+      end
+    rescue Net::SSH::HostKeyMismatch => error
+      error.remember_host!
+      sleep 0.2
+      retry
+    end
+    results  
+  end
+  
+  #---
+  
+  def self.download(hostname, user, remote_path, local_path, options = {})
+    config = Config.ensure(options)
+    
+    require 'net/scp'
+    
+    # Accepted options:
+    # * :recursive - the +remote+ parameter refers to a remote directory, which
+    # should be downloaded to a new directory named +local+ on the local
+    # machine.
+    # * :preserve - the atime and mtime of the file should be preserved.
+    # * :verbose - the process should result in verbose output on the server
+    # end (useful for debugging).
+    #
+    config.init(:recursive, true)
+    config.init(:preserve, true)
+    config.init(:verbose, true)
+    
+    blocking = config.delete(:blocking, true)
+    
+    session(hostname, user) do |ssh|
+      if blocking
+        ssh.scp.download!(remote_path, local_path, config.export) do |ch, name, received, total|
+          yield(name, received, total) if block_given?
+        end
+      else
+        ssh.scp.download(remote_path, local_path, config.export)
+      end
+    end
+  end
+  
+  #---
+  
+  def self.upload(hostname, user, local_path, remote_path, options = {})
+    config = Config.ensure(options)
+    
+    require 'net/scp'
+    
+    # Accepted options:
+    # * :recursive - the +local+ parameter refers to a local directory, which
+    # should be uploaded to a new directory named +remote+ on the remote
+    # server.
+    # * :preserve - the atime and mtime of the file should be preserved.
+    # * :verbose - the process should result in verbose output on the server
+    # end (useful for debugging).
+    # * :chunk_size - the size of each "chunk" that should be sent. Defaults
+    # to 2048. Changing this value may improve throughput at the expense
+    # of decreasing interactivity.
+    #
+    config.init(:recursive, true)
+    config.init(:preserve, true)
+    config.init(:verbose, true)
+    config.init(:chunk_size, 2048)
+    
+    blocking = config.delete(:blocking, true)
+    
+    session(hostname, user) do |ssh|
+      if blocking
+        ssh.scp.upload!(local_path, remote_path, config.export) do |ch, name, sent, total|
+          yield(name, sent, total) if block_given?
+        end
+      else
+        ssh.scp.upload(local_path, remote_path, config.export)
+      end
+    end
+  end
+  
+  #---
+  
+  #
+  # Inspired by vagrant ssh implementation
+  #
+  # See: https://github.com/mitchellh/vagrant/blob/master/lib/vagrant/util/ssh.rb
+  #
+  
+  def self.terminal(hostname, user, options = {})
+    config   = Config.ensure(options)
+    ssh_path = nucleon_locate("ssh")
+    
+    raise Errors::SSHUnavailable unless ssh_path
+    
+    port         = config.get(:port, 22)
+    private_keys = config.get(:private_keys, File.join(ENV['HOME'], '.ssh', 'id_rsa'))
+    
+    command_options = [
+      "#{user}@#{hostname}",
+      "-p", port.to_s,
+      "-o", "Compression=yes",
+      "-o", "DSAAuthentication=yes",
+      "-o", "LogLevel=FATAL",
+      "-o", "StrictHostKeyChecking=no",
+      "-o", "UserKnownHostsFile=/dev/null",
+      "-o", "IdentitiesOnly=yes"
+    ]
+
+    Util::Data.array(private_keys).each do |path|
+      command_options += [ "-i", File.expand_path(path) ]
+    end
+    
+    if config.get(:forward_x11, false)
+      command_options += [
+        "-o", "ForwardX11=yes",
+        "-o", "ForwardX11Trusted=yes"
+      ]
+    end
+
+    command_options += [ "-o", "ProxyCommand=#{config[:proxy_command]}" ] if config.get(:proxy_command, false)
+    command_options += [ "-o", "ForwardAgent=yes" ] if config.get(:forward_agent, false)
+    
+    command_options.concat(Util::Data.array(config[:extra_args])) if config.get(:extra_args, false)
+
+    #---
+
+    logger.info("Executing SSH in subprocess: #{command_options.inspect}")
+    
+    process = ChildProcess.build('ssh', *command_options)
+    process.io.inherit!
+    
+    process.start
+    process.wait
+    process.exit_code
+  end
+end
+end
+end