ztk 0.0.5 → 0.0.6

data/.gitignore

@@ -1,4 +1,5 @@
 *.log
+*.txt
 *.gem
 *.rbc
 .rvmrc

data/lib/ztk.rb

@@ -24,8 +24,10 @@ module ZTK
   class Error < StandardError; end
 
   autoload :Base, "ztk/base"
+  autoload :Command, "ztk/command"
   autoload :Logger, "ztk/logger"
   autoload :Parallel, "ztk/parallel"
+  autoload :Spinner, "ztk/spinner"
   autoload :SSH, "ztk/ssh"
   autoload :TCPSocketCheck, "ztk/tcp_socket_check"
   autoload :Template, "ztk/template"

data/lib/ztk/base.rb

@@ -20,20 +20,24 @@
 
 require "ostruct"
 
-################################################################################
-
 module ZTK
 
-################################################################################
-
+  # ZTK::Base error class
   class BaseError < Error; end
 
-################################################################################
-
+  # This is the base class inherited by most of the other classes in this
+  # library.  It provides a standard set of features to control STDOUT, STDERR
+  # and STDIN, a configuration mechanism and logging mechanism.
+  #
+  # You should never interact with this class directly; you should inherit it
+  # and extend functionality as appropriate.
   class Base
 
-################################################################################
-
+    # @param [Hash] config configuration options hash
+    # @option config [IO] :stdout instance of IO to be used for STDOUT
+    # @option config [IO] :stderr instance of IO to be used for STDERR
+    # @option config [IO] :stdin instance of IO to be used for STDIN
+    # @option config [Logger] :logger instance of Logger to be used for logging
     def initialize(config={})
       defined?(Rails) and rails_logger = Rails.logger
       @config = OpenStruct.new({
@@ -48,11 +52,17 @@ module ZTK
       @config.stdin.respond_to?(:sync=) and @config.stdin.sync = true
       @config.logger.respond_to?(:sync=) and @config.logger.sync = true
 
-      @config.logger and @config.logger.debug{ "config(#{@config.inspect})" }
+      log(:debug) { "config(#{@config.inspect})" }
     end
 
-################################################################################
-
+    # Configuration OpenStruct accessor method.
+    #
+    # If no block is given, the method will return the configuration OpenStruct
+    # object.  If a block is given, the block is yielded with the configuration
+    # OpenStruct object.
+    #
+    # @yieldparam [OpenStruct] config The configuration OpenStruct object.
+    # @return [OpenStruct] The configuration OpenStruct object.
     def config(&block)
       if block_given?
         block.call(@config)
@@ -61,12 +71,22 @@ module ZTK
       end
     end
 
-################################################################################
+    # Base logging method.
+    #
+    # The value returned in the block is passed down to the logger specified in
+    # the classes configuration.
+    #
+    # @param [Symbol] method_name This should be any one of [:debug, :info, :warn, :error, :fatal].
+    # @yield No value is passed to the block.
+    # @yieldreturn [String] The message to log.
+    def log(method_name, &block)
+      if block_given?
+        @config.logger and @config.logger.method(method_name.to_sym).call { yield }
+      else
+        raise(Error, "You must supply a block to the log method!")
+      end
+    end
 
   end
 
-################################################################################
-
 end
-
-################################################################################

data/lib/ztk/command.rb

@@ -0,0 +1,103 @@
+################################################################################
+#
+#      Author: Zachary Patten <zachary@jovelabs.com>
+#   Copyright: Copyright (c) Jove Labs
+#     License: Apache License, Version 2.0
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+################################################################################
+
+require "ostruct"
+
+################################################################################
+
+module ZTK
+
+################################################################################
+
+  class CommandError < Error; end
+
+################################################################################
+
+  class Command < ZTK::Base
+
+################################################################################
+
+    def initialize(config={})
+      super(config)
+    end
+
+################################################################################
+
+    def exec(command, options={})
+      options = OpenStruct.new({ :exit_code => 0, :silence => false }.merge(options))
+      log(:debug) { "config(#{@config.inspect})" }
+      log(:debug) { "options(#{options.inspect})" }
+      log(:debug) { "command(#{command.inspect})" }
+
+      parent_stdout_reader, child_stdout_writer = IO.pipe
+      parent_stderr_reader, child_stderr_writer = IO.pipe
+
+      pid = Process.fork do
+        parent_stdout_reader.close
+        parent_stderr_reader.close
+
+        STDOUT.reopen(child_stdout_writer)
+        STDERR.reopen(child_stderr_writer)
+        STDIN.reopen("/dev/null")
+
+        child_stdout_writer.close
+        child_stderr_writer.close
+
+        Kernel.exec(command)
+      end
+      child_stdout_writer.close
+      child_stderr_writer.close
+
+      Process.waitpid(pid)
+
+      @config.stdout.write(parent_stdout_reader.read) unless options.silence
+      @config.stderr.write(parent_stderr_reader.read) unless options.silence
+
+      parent_stdout_reader.close
+      parent_stderr_reader.close
+
+      log(:debug) { "exit_code(#{$?.inspect})" }
+
+      if ($? != options.exit_code)
+        message = "exec(#{command.inspect}, #{options.inspect}) failed! [#{$?.inspect}]"
+        log(:fatal) { message }
+        raise CommandError, message
+      end
+
+      $?
+    end
+
+    def upload(*args)
+      raise CommandError, "Not Implemented"
+    end
+
+    def download(*args)
+      raise CommandError, "Not Implemented"
+    end
+
+################################################################################
+
+  end
+
+################################################################################
+
+end
+
+################################################################################

data/lib/ztk/parallel.rb

@@ -2,9 +2,9 @@
 #
 #      Author: Zachary Patten <zachary@jovelabs.com>
 #   Copyright: Copyright (c) Jove Labs
-#     License: Apache License, Vers::IOn 2.0
+#     License: Apache License, VersIOn 2.0
 #
-#   Licensed under the Apache License, Vers::IOn 2.0 (the "License");
+#   Licensed under the Apache License, VersIOn 2.0 (the "License");
 #   you may not use this file except in compliance with the License.
 #   You may obtain a copy of the License at
 #
@@ -12,9 +12,9 @@
 #
 #   Unless required by applicable law or agreed to in writing, software
 #   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDIT::IONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permiss::IOns and
-#   limitat::IOns under the License.
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissIOns and
+#   limitatIOns under the License.
 #
 ################################################################################
 
@@ -26,7 +26,11 @@ module ZTK
 
 ################################################################################
 
-  class Parallel < ::ZTK::Base
+  class ParallelError < Error; end
+
+################################################################################
+
+  class Parallel < ZTK::Base
 
 ################################################################################
 
@@ -41,40 +45,42 @@ module ZTK
         :after_fork => nil
       }.merge(config))
 
-      @forks = ::Array.new
-      @results = ::Array.new
-      ::GC.respond_to?(:copy_on_write_friendly=) and ::GC.copy_on_write_friendly = true
+      @forks = Array.new
+      @results = Array.new
+      GC.respond_to?(:copy_on_write_friendly=) and GC.copy_on_write_friendly = true
     end
 
 ################################################################################
 
-    def process(*args)
-      @config.logger and @config.logger.debug{ "forks(#{@forks.inspect})" }
+    def process(&block)
+      raise ParallelError, "You must supply a block to the process method!" if !block_given?
+
+      log(:debug) { "forks(#{@forks.inspect})" }
 
       while (@forks.count >= @config.max_forks) do
         wait
       end
 
-      child_reader, parent_writer = ::IO.pipe
-      parent_reader, child_writer = ::IO.pipe
+      child_reader, parent_writer = IO.pipe
+      parent_reader, child_writer = IO.pipe
 
-      @config.before_fork and @config.before_fork.call(::Process.pid)
-      pid = ::Process.fork do
-        @config.after_fork and @config.after_fork.call(::Process.pid)
+      @config.before_fork and @config.before_fork.call(Process.pid)
+      pid = Process.fork do
+        @config.after_fork and @config.after_fork.call(Process.pid)
 
         parent_writer.close
         parent_reader.close
 
-        if !(data = yield).nil?
-          @config.logger and @config.logger.debug{ "write(#{data.inspect})" }
-          child_writer.write(::Base64.encode64(::Marshal.dump(data)))
+        if !(data = block.call).nil?
+          log(:debug) { "write(#{data.inspect})" }
+          child_writer.write(Base64.encode64(Marshal.dump(data)))
         end
 
         child_reader.close
         child_writer.close
-        ::Process.exit!(0)
+        Process.exit!(0)
       end
-      @config.after_fork and @config.after_fork.call(::Process.pid)
+      @config.after_fork and @config.after_fork.call(Process.pid)
 
       child_reader.close
       child_writer.close
@@ -88,11 +94,11 @@ module ZTK
 ################################################################################
 
     def wait
-      @config.logger and @config.logger.debug{ "forks(#{@forks.inspect})" }
-      pid, status = (::Process.wait2(-1, ::Process::WNOHANG) rescue nil)
+      log(:debug) { "forks(#{@forks.inspect})" }
+      pid, status = (Process.wait2(-1) rescue nil)
       if !pid.nil? && !status.nil? && !(fork = @forks.select{ |f| f[:pid] == pid }.first).nil?
-        data = (::Marshal.load(::Base64.decode64(fork[:reader].read.to_s)) rescue nil)
-        @config.logger and @config.logger.debug{ "read(#{data.inspect})" }
+        data = (Marshal.load(Base64.decode64(fork[:reader].read.to_s)) rescue nil)
+        log(:debug) { "read(#{data.inspect})" }
         !data.nil? and @results.push(data)
         fork[:reader].close
         fork[:writer].close
@@ -100,16 +106,16 @@ module ZTK
         @forks -= [fork]
         return [pid, status, data]
       end
-      sleep(1)
       nil
     end
 
 ################################################################################
 
     def waitall
-      data = ::Array.new
+      data = Array.new
       while @forks.count > 0
-        data << self.wait
+        result = self.wait
+        result and data << result
       end
       data
     end
@@ -117,7 +123,7 @@ module ZTK
 ################################################################################
 
     def count
-      @config.logger and @config.logger.debug{ "count(#{@forks.count})" }
+      log(:debug) { "count(#{@forks.count})" }
       @forks.count
     end
 

data/lib/ztk/spinner.rb

@@ -0,0 +1,71 @@
+################################################################################
+#
+#      Author: Zachary Patten <zachary@jovelabs.com>
+#   Copyright: Copyright (c) Jove Labs
+#     License: Apache License, Version 2.0
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+################################################################################
+
+require "ostruct"
+
+################################################################################
+
+module ZTK
+
+################################################################################
+
+  class SpinnerError < Error; end
+
+################################################################################
+
+  class Spinner
+
+################################################################################
+
+    class << self
+
+################################################################################
+
+      def spin(stdout=$stdout)
+        charset = %w( | / - \\ )
+        count = 0
+        spinner = Thread.new do
+          while count do
+            stdout.print(charset[(count += 1) % charset.length])
+            stdout.respond_to?(:flush) and stdout.flush
+            sleep(0.25)
+            stdout.print("\b")
+            stdout.respond_to?(:flush) and stdout.flush
+          end
+        end
+        yield.tap do
+          count = false
+          spinner.join
+        end
+      end
+
+################################################################################
+
+    end
+
+################################################################################
+
+  end
+
+################################################################################
+
+end
+
+################################################################################

data/lib/ztk/ssh.rb

@@ -23,126 +23,213 @@ require "net/ssh"
 require "net/ssh/proxy/command"
 require "net/sftp"
 
-################################################################################
-
 module ZTK
 
-################################################################################
-
+  # ZTK::SSH error class
   class SSHError < Error; end
 
-################################################################################
-
-  class SSH < ::ZTK::Base
-
-################################################################################
-
+  # We can get a new instance of SSH like so:
+  #     ssh = ZTK::SSH.new
+  #
+  # If we wanted to redirect STDOUT and STDERR to a StringIO we can do this:
+  #     std_combo = StringIO.new
+  #     ssh = ZTK::SSH.new(:stdout => std_combo, :stderr => std_combo)
+  #
+  # If you want to specify SSH options you can:
+  #     keys = File.expand_path(File.join(ENV['HOME'], '.ssh', 'id_rsa'))
+  #     ssh = ZTK::SSH.new(:host_name => '127.0.0.1', :user => ENV['USER'], :keys => keys)
+  #
+  # = Configuration Examples:
+  #
+  # To proxy through another host, for example SSH to 192.168.1.1 through 192.168.0.1:
+  #     ssh.config do |config|
+  #       config.user = ENV['USER']
+  #       config.host_name = '192.168.1.1'
+  #       config.proxy_user = ENV['USER']
+  #       config.proxy_host_name = '192.168.0.1'
+  #     end
+  #
+  # Specify an identity file:
+  #     ssh.config do |config|
+  #       config.keys = File.expand_path(File.join(ENV['HOME'], '.ssh', 'id_rsa'))
+  #       config.proxy_keys = File.expand_path(File.join(ENV['HOME'], '.ssh', 'id_rsa'))
+  #     end
+  #
+  # Specify a timeout:
+  #     ssh.config do |config|
+  #       config.timeout = 30
+  #     end
+  #
+  # Specify a password:
+  #     ssh.config do |config|
+  #       config.password = 'p@$$w0rd'
+  #     end
+  #
+  # Check host keys, the default is false (off):
+  #     ssh.config do |config|
+  #       config.host_key_verify = true
+  #     end
+  class SSH < ZTK::Base
+
+    # @param [Hash] config Configuration options hash.
+    # @option config [String] :host_name Server hostname to connect to.
+    # @option config [String] :user Username to use for authentication.
+    # @option config [String, Array<String>] :keys A single or series of identity files to use for authentication.
+    # @option config [String] :password Password to use for authentication.
+    # @option config [Integer] :timeout SSH connection timeout to use.
+    # @option config [Boolean] :compression Weither or not to use compression for this session.
+    # @option config [Integer] :compression_level What level of compression  to use.
+    # @option config [String] :proxy_host_name Server hostname to proxy through.
+    # @option config [String] :proxy_user Username to use for proxy authentication.
+    # @option config [String, Array<String>] :proxy_keys A single or series of identity files to use for authentication with the proxy.
     def initialize(config={})
-      super({
-        :ssh => ::OpenStruct.new
-      }.merge(config))
+      super(config)
     end
 
-################################################################################
-
+    # Launches an SSH console, replacing the current process with the console process.
+    #
+    # @example Launch a console:
+    #   $logger = ZTK::Logger.new(STDOUT)
+    #   ssh = ZTK::SSH.new
+    #   ssh.config do |config|
+    #     config.user = ENV["USER"]
+    #     config.host_name = "127.0.0.1"
+    #   end
+    #   ssh.console
     def console
-      @config.logger and @config.logger.debug { "config(#{@config.ssh.inspect})" }
+      log(:debug) { "console" }
+      log(:debug) { "config(#{@config.inspect})" }
 
-      command = [ "ssh" ]
-      command << [ "-q" ]
-      command << [ "-o", "UserKnownHostsFile=/dev/null" ]
-      command << [ "-o", "StrictHostKeyChecking=no" ]
-      command << [ "-o", "KeepAlive=yes" ]
-      command << [ "-o", "ServerAliveInterval=60" ]
-      command << [ "-i", @config.ssh.identity_file ] if @config.ssh.identity_file
-      command << [ "-o", "ProxyCommand=\"#{proxy_command}\"" ] if @config.ssh.proxy
-      command << "#{@config.ssh.user}@#{@config.ssh.host}"
-      command = command.flatten.compact.join(" ")
-      @config.logger and @config.logger.info { "command(#{command})" }
-      ::Kernel.exec(command)
+      Kernel.exec(console_command)
     end
 
-################################################################################
-
+    # Executes a command on the remote host.
+    #
+    # @param [String] command The command to execute.
+    # @param [Hash] options The options hash for executing the command.
+    # @option options [Boolean] :silence Squelch output to STDOUT and STDERR.  If the log level is :debug, STDOUT and STDERR will go to the log file regardless of this setting.  STDOUT and STDERR are always returned in the output return value regardless of this setting.
+    #
+    # @return [OpenStruct#output] The output of the command, both STDOUT and STDERR.
+    # @return [OpenStruct#exit] The exit status (i.e. $?).
+    #
+    # @example Execute a command:
+    #   $logger = ZTK::Logger.new(STDOUT)
+    #   ssh = ZTK::SSH.new
+    #   ssh.config do |config|
+    #     config.user = ENV["USER"]
+    #     config.host_name = "127.0.0.1"
+    #   end
+    #   puts ssh.exec("hostname -f").output
     def exec(command, options={})
-      @ssh ||= ::Net::SSH.start(@config.ssh.host, @config.ssh.user, ssh_options)
+      log(:debug) { "exec(#{command.inspect}, #{options.inspect})" }
+      log(:debug) { "config(#{@config.inspect})" }
 
-      options = { :silence => false }.merge(options)
-      silence = options[:silence]
-      output = ""
+      @ssh ||= Net::SSH.start(@config.host_name, @config.user, ssh_options)
+      log(:debug) { "ssh(#{@ssh.inspect})" }
 
-      @config.logger and @config.logger.debug { "config(#{@config.ssh.inspect})" }
-      @config.logger and @config.logger.debug { "options(#{options.inspect})" }
-      @config.logger and @config.logger.info { "command(#{command})" }
+      options = OpenStruct.new({ :silence => false }.merge(options))
+      log(:debug) { "options(#{options.inspect})" }
+
+      output = ""
       channel = @ssh.open_channel do |chan|
-        @config.logger and @config.logger.debug { "channel opened" }
+        log(:debug) { "channel opened" }
         chan.exec(command) do |ch, success|
           raise SSHError, "Could not execute '#{command}'." unless success
 
           ch.on_data do |c, data|
-            output += data
-            @config.logger and @config.logger.debug { data.chomp.strip }
-            @config.stdout.print(data) if !silence
+            log(:debug) { data.chomp.strip }
+            @config.stdout.print(data) unless options.silence
+            output += data.chomp.strip
           end
 
           ch.on_extended_data do |c, type, data|
-            output += data
-            @config.logger and @config.logger.debug { data.chomp.strip }
-            @config.stderr.print(data) if !silence
+            log(:debug) { data.chomp.strip }
+            @config.stderr.print(data) unless options.silence
+            output += data.chomp.strip
           end
 
         end
       end
       channel.wait
-      @config.logger and @config.logger.debug { "channel closed" }
+      log(:debug) { "channel closed" }
 
-      output
+      OpenStruct.new(:output => output, :exit => $?)
     end
 
-################################################################################
-
+    # Uploads a local file to a remote host.
+    #
+    # @param [String] local The local file/path you wish to upload from.
+    # @param [String] remote The remote file/path you with to upload to.
+    #
+    # @example Upload a file:
+    #   $logger = ZTK::Logger.new(STDOUT)
+    #   ssh = ZTK::SSH.new
+    #   ssh.config do |config|
+    #     config.user = ENV["USER"]
+    #     config.host_name = "127.0.0.1"
+    #   end
+    #   local = File.expand_path(File.join(ENV["HOME"], ".ssh", "id_rsa.pub"))
+    #   remote = File.expand_path(File.join("/tmp", "id_rsa.pub"))
+    #   ssh.upload(local, remote)
     def upload(local, remote)
-      @sftp ||= ::Net::SFTP.start(@config.ssh.host, @config.ssh.user, ssh_options)
+      log(:debug) { "upload(#{local.inspect}, #{remote.inspect})" }
+      log(:debug) { "config(#{@config.inspect})" }
+
+      @sftp ||= Net::SFTP.start(@config.host_name, @config.user, ssh_options)
+      log(:debug) { "sftp(#{@sftp.inspect})" }
 
-      @config.logger and @config.logger.debug { "config(#{@config.ssh.inspect})" }
-      @config.logger and @config.logger.info { "parameters(#{local},#{remote})" }
       @sftp.upload!(local.to_s, remote.to_s) do |event, uploader, *args|
         case event
         when :open
-          @config.logger and @config.logger.info { "upload(#{args[0].local} -> #{args[0].remote})" }
+          log(:info) { "upload(#{args[0].local} -> #{args[0].remote})" }
         when :close
-          @config.logger and @config.logger.debug { "close(#{args[0].remote})" }
+          log(:debug) { "close(#{args[0].remote})" }
         when :mkdir
-          @config.logger and @config.logger.debug { "mkdir(#{args[0]})" }
+          log(:debug) { "mkdir(#{args[0]})" }
         when :put
-          @config.logger and @config.logger.debug { "put(#{args[0].remote}, size #{args[2].size} bytes, offset #{args[1]})" }
+          log(:debug) { "put(#{args[0].remote}, size #{args[2].size} bytes, offset #{args[1]})" }
         when :finish
-          @config.logger and @config.logger.info { "finish" }
+          log(:info) { "finish" }
         end
       end
 
       true
     end
 
-################################################################################
-
+    # Downloads a remote file to the local host.
+    #
+    # @param [String] remote The remote file/path you with to download from.
+    # @param [String] local The local file/path you wish to download to.
+    #
+    # @example Download a file:
+    #   $logger = ZTK::Logger.new(STDOUT)
+    #   ssh = ZTK::SSH.new
+    #   ssh.config do |config|
+    #     config.user = ENV["USER"]
+    #     config.host_name = "127.0.0.1"
+    #   end
+    #   local = File.expand_path(File.join("/tmp", "id_rsa.pub"))
+    #   remote = File.expand_path(File.join(ENV["HOME"], ".ssh", "id_rsa.pub"))
+    #   ssh.download(remote, local)
     def download(remote, local)
-      @sftp ||= ::Net::SFTP.start(@config.ssh.host, @config.ssh.user, ssh_options)
+      log(:debug) { "download(#{remote.inspect}, #{local.inspect})" }
+      log(:debug) { "config(#{@config.inspect})" }
+
+      @sftp ||= Net::SFTP.start(@config.host_name, @config.user, ssh_options)
+      log(:debug) { "sftp(#{@sftp.inspect})" }
 
-      @config.logger and @config.logger.debug { "config(#{@config.ssh.inspect})" }
-      @config.logger and @config.logger.info { "parameters(#{remote},#{local})" }
       @sftp.download!(remote.to_s, local.to_s) do |event, downloader, *args|
         case event
         when :open
-          @config.logger and @config.logger.info { "download(#{args[0].remote} -> #{args[0].local})" }
+          log(:info) { "download(#{args[0].remote} -> #{args[0].local})" }
         when :close
-          @config.logger and @config.logger.debug { "close(#{args[0].local})" }
+          log(:debug) { "close(#{args[0].local})" }
         when :mkdir
-          @config.logger and @config.logger.debug { "mkdir(#{args[0]})" }
+          log(:debug) { "mkdir(#{args[0]})" }
         when :get
-          @config.logger and @config.logger.debug { "get(#{args[0].remote}, size #{args[2].size} bytes, offset #{args[1]})" }
+          log(:debug) { "get(#{args[0].remote}, size #{args[2].size} bytes, offset #{args[1]})" }
         when :finish
-          @config.logger and @config.logger.info { "finish" }
+          log(:info) { "finish" }
         end
       end
 
@@ -150,53 +237,98 @@ module ZTK
     end
 
 
-################################################################################
   private
-################################################################################
 
+    # Builds our SSH console command.
+    def console_command
+      log(:debug) { "console_command" }
+      log(:debug) { "config(#{@config.inspect})" }
+
+      command = [ "ssh" ]
+      command << [ "-q" ]
+      command << [ "-A" ]
+      command << [ "-o", "UserKnownHostsFile=/dev/null" ]
+      command << [ "-o", "StrictHostKeyChecking=no" ]
+      command << [ "-o", "KeepAlive=yes" ]
+      command << [ "-o", "ServerAliveInterval=60" ]
+      command << [ "-i", @config.keys ] if @config.keys
+      command << [ "-o", "ProxyCommand=\"#{proxy_command}\"" ] if @config.proxy_host_name
+      command << "#{@config.user}@#{@config.host_name}"
+      command = command.flatten.compact.join(" ")
+      log(:debug) { "console_command(#{command.inspect})" }
+      command
+    end
+
+    # Builds our SSH proxy command.
     def proxy_command
-      @config.logger and @config.logger.debug { "config(#{@config.ssh.inspect})" }
+      log(:debug) { "proxy_command" }
+      log(:debug) { "config(#{@config.inspect})" }
 
-      if !@config.ssh.identity_file
-        message = "You must specify an identity file in order to SSH proxy."
-        @config.logger and @config.logger.fatal { message }
+      if !@config.proxy_user
+        message = "You must specify an proxy user in order to SSH proxy."
+        log(:fatal) { message }
+        raise SSHError, message
+      end
+
+      if !@config.proxy_host_name
+        message = "You must specify an proxy host_name in order to SSH proxy."
+        log(:fatal) { message }
         raise SSHError, message
       end
 
       command = ["ssh"]
       command << [ "-q" ]
+      command << [ "-A" ]
       command << [ "-o", "UserKnownHostsFile=/dev/null" ]
       command << [ "-o", "StrictHostKeyChecking=no" ]
       command << [ "-o", "KeepAlive=yes" ]
       command << [ "-o", "ServerAliveInterval=60" ]
-      command << [ "-i", @config.ssh.proxy_identity_file ] if @config.ssh.proxy_identity_file
-      command << "#{@config.ssh.proxy_user}@#{@config.ssh.proxy_host}"
+      command << [ "-i", @config.proxy_keys ] if @config.proxy_keys
+      command << "#{@config.proxy_user}@#{@config.proxy_host_name}"
       command << "nc %h %p"
       command = command.flatten.compact.join(" ")
-      @config.logger and @config.logger.debug { "command(#{command})" }
+      log(:debug) { "proxy_command(#{command.inspect})" }
       command
     end
 
-################################################################################
-
+    # Builds our SSH options hash.
     def ssh_options
-      @config.logger and @config.logger.debug { "config(#{@config.ssh.inspect})" }
-      options = {}
-      options.merge!(:password => @config.ssh.password) if @config.ssh.password
-      options.merge!(:keys => @config.ssh.identity_file) if @config.ssh.identity_file
-      options.merge!(:timeout => @config.ssh.timeout) if @config.ssh.timeout
-      options.merge!(:user_known_hosts_file  => '/dev/null') if !@config.ssh.host_key_verify
-      options.merge!(:proxy => ::Net::SSH::Proxy::Command.new(proxy_command)) if @config.ssh.proxy
-      @config.logger and @config.logger.debug { "options(#{options.inspect})" }
+      log(:debug) { "ssh_options" }
+      log(:debug) { "config(#{@config.inspect})" }
+
+      options = {
+        :forward_agent => true,
+        :compression => false,
+        :user_known_hosts_file => '/dev/null'
+      }
+
+      # These are plainly documented on the Net::SSH config class.
+      options.merge!(:encryption => @config.encryption) if @config.encryption
+      options.merge!(:compression => @config.compression) if @config.compression
+      options.merge!(:compression_level => @config.compression_level) if @config.compression_level
+      options.merge!(:timeout => @config.timeout) if @config.timeout
+      options.merge!(:forward_agent => @config.forward_agent) if @config.forward_agent
+      options.merge!(:global_known_hosts_file => @config.global_known_hosts_file) if @config.global_known_hosts_file
+      options.merge!(:auth_methods => @config.auth_methods) if @config.auth_methods
+      options.merge!(:host_key => @config.host_key) if @config.host_key
+      options.merge!(:host_key_alias => @config.host_key_alias) if @config.host_key_alias
+      options.merge!(:host_name => @config.host_name) if @config.host_name
+      options.merge!(:keys => @config.keys) if @config.keys
+      options.merge!(:keys_only => @config.keys_only) if @config.keys_only
+      options.merge!(:hmac => @config.hmac) if @config.hmac
+      options.merge!(:port => @config.port) if @config.port
+      options.merge!(:proxy => Net::SSH::Proxy::Command.new(proxy_command)) if @config.proxy_host_name
+      options.merge!(:rekey_limit => @config.rekey_limit) if @config.rekey_limit
+      options.merge!(:user => @config.user) if @config.user
+      options.merge!(:user_known_hosts_file => @config.user_known_hosts_file) if @config.user_known_hosts_file
+
+      # This is not plainly documented on the Net::SSH config class.
+      options.merge!(:password => @config.password) if @config.password
+
+      log(:debug) { "ssh_options(#{options.inspect})" }
       options
     end
 
-################################################################################
-
   end
 
-################################################################################
-
 end
-
-################################################################################