kitchen-ssh 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05bc5e6294e6f5689135c56ff96384cc819f7220
-  data.tar.gz: aa64f3bcce9afbe859c07fc59d4c3ed7459293e8
+  metadata.gz: c5cac5019b09aeac0fb2ffe4f784d78a0f25f3c8
+  data.tar.gz: 4f7a0a2df1d7371c3ab021608d1365798ae64860
 SHA512:
-  metadata.gz: 26a8743b008abdff35f2fe61016631ad398b2e0fb8fe317b747b62ab9db40216524135c3bd02fcf3146ec2d450c43f668e35c9628500c8b360ec9365d0b22f8e
-  data.tar.gz: 6aac7f1c9b1dc71eb44a494d48754084ffe795cb6ce2fb7110afbb341d347949a10516962338c9c94593fcfb153cd3ffca997340fb18dd99d3d948d88b5b4ada
+  metadata.gz: 869f95c057d6110409689d5d7795e9c431b50f25972f2024a89d491caaf8f83548e16ac26d0bf59fb1a4b5ba3e133d22c607d4c4439960059efa3e0681a506e9
+  data.tar.gz: e4692e8ff4c1a84060dc7b5375a8e3e97f8e43333b0fde890eda875ad4bdf697e5d592db45b14363ef73e509b00cd644cbde7ca253b648ab33d87dabce4e8ba8

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kitchen-sshgzip.gemspec
+gemspec

data/README.md

@@ -1,62 +1,62 @@
-# kitchen-ssh
-
-ssh and ssh_gzip driver for test-kitchen for any running server with an ip address.
-
-As well as ssh it supports a second driver called ssh_gzip that will also gzip file before transfer which can provide 
-a big performance improvement when alot of files are transfered. 
-
-server must be created and destroyed natively (e.g. via cloudformation, heat, or cloud or virtualization console).
-specify driver parameters
-*  hostname
-*  port
-*  username
-*  password
-*  sudo
-*  ssh_key
-*  forward_agent
-
-NOTE: ssh driver is compatibile with test-kitchen 1.4 while ssh_gzip has legacy driver compatiability 
-with test-kitchen 1.4 
-
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'kitchen-ssh', group: :integration
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install kitchen-ssh
-
-## Usage
-
-In your .kitchen.yml file set driver to be 'ssh' or 'ssh_gzip'.
-
-##Example
-
-```yaml
----
-driver:
-  name: ssh
-  hostname: your-ip
-  port: 22
-  username: username 
-  ssh_key: /path/to/id_rsa
-```
-
-or 
-
-```yaml
----
-driver:
-  name: ssh_gzip
-  hostname: your-ip
-  port: 22
-  username: username 
-  ssh_key: /path/to/id_rsa
-```
+# kitchen-ssh
+
+ssh and ssh_gzip driver for test-kitchen for any running server with an ip address.
+
+As well as ssh it supports a second driver called ssh_gzip that will also gzip file before transfer which can provide 
+a big performance improvement when alot of files are transfered. 
+
+server must be created and destroyed natively (e.g. via cloudformation, heat, or cloud or virtualization console).
+specify driver parameters
+*  hostname
+*  port
+*  username
+*  password
+*  sudo
+*  ssh_key
+*  forward_agent
+
+NOTE: ssh driver is compatibile with test-kitchen 1.4 while ssh_gzip has legacy driver compatiability 
+with test-kitchen 1.4 
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kitchen-ssh', group: :integration
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kitchen-ssh
+
+## Usage
+
+In your .kitchen.yml file set driver to be 'ssh' or 'ssh_gzip'.
+
+##Example
+
+```yaml
+---
+driver:
+  name: ssh
+  hostname: your-ip
+  port: 22
+  username: username 
+  ssh_key: /path/to/id_rsa
+```
+
+or 
+
+```yaml
+---
+driver:
+  name: ssh_gzip
+  hostname: your-ip
+  port: 22
+  username: username 
+  ssh_key: /path/to/id_rsa
+```

data/kitchen-ssh.gemspec

@@ -1,27 +1,28 @@
-# encoding: utf-8
-
-$:.unshift File.expand_path('../lib', __FILE__)
-require 'kitchen/ssh/version'
-
-Gem::Specification.new do |s|
-  s.name          = "kitchen-ssh"
-  s.version       = Kitchen::Ssh::VERSION
-  s.authors       = ["Neill Turner"]
-  s.email         = ["neillwturner@gmail.com"]
-  s.homepage      = "https://github.com/neillturner/kitchen-ssh"
-  s.add_dependency('minitar', '~> 0.5')
-  s.summary       = "ssh and ssh_gzip driver for test-kitchen for any running server with an ip address"
-  candidates = Dir.glob("{lib}/**/*") +  ['README.md', 'LICENSE.txt', 'kitchen-ssh.gemspec']
-  s.files = candidates.sort
-  s.platform      = Gem::Platform::RUBY
-  s.require_paths = ['lib']
-  s.rubyforge_project = '[none]'
-  s.description = <<-EOF
-ssh and ssh_gzip driver for test-kitchen for any running server with an ip address
-
-*** As well as ssh it supports a second driver called ssh_gzip that will also gzip file before transfer which can provide 
-a big performance improvement when alot of files are transfered. ****
-
-EOF
-
-end
+# encoding: utf-8
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'kitchen/ssh/version'
+
+Gem::Specification.new do |s|
+  s.name          = "kitchen-ssh"
+  s.license       = 'Apache-2.0'
+  s.version       = Kitchen::Ssh::VERSION
+  s.authors       = ["Neill Turner"]
+  s.email         = ["neillwturner@gmail.com"]
+  s.homepage      = "https://github.com/neillturner/kitchen-ssh"
+  s.add_dependency('minitar', '~> 0.5')
+  s.summary       = "ssh and ssh_gzip driver for test-kitchen for any running server with an ip address"
+  candidates = Dir.glob("{lib}/**/*") +  ['README.md', 'LICENSE.txt', 'kitchen-ssh.gemspec', 'Gemfile']
+  s.files = candidates.sort
+  s.platform      = Gem::Platform::RUBY
+  s.require_paths = ['lib']
+  s.rubyforge_project = '[none]'
+  s.description = <<-EOF
+ssh and ssh_gzip driver for test-kitchen for any running server with an ip address
+
+*** As well as ssh it supports a second driver called ssh_gzip that will also gzip file before transfer which can provide
+a big performance improvement when alot of files are transfered. ****
+
+EOF
+
+end

data/lib/kitchen/driver/ssh.rb

@@ -1,30 +1,30 @@
-require 'kitchen'
-require 'kitchen/driver/ssh_base'
-
-module Kitchen
-  module Driver
-    class Ssh < SSHBase
-       def create(state)
-         state[:sudo] = config[:sudo]
-         state[:port] = config[:port]
-         state[:ssh_key] = config[:ssh_key]
-         state[:forward_agent] = config[:forward_agent]
-         state[:username] = config[:username]
-         state[:hostname] = config[:hostname]
-         state[:password] = config[:password]
-         print "Kitchen-ssh does not start your server '#{state[:hostname]}' but will look for an ssh connection with user '#{state[:username]}'"
-         wait_for_sshd(state[:hostname], state[:username], {:port => state[:port]})
-         print "Kitchen-ssh found ssh ready on host '#{state[:hostname]}' with user '#{state[:username]}'\n"
-         debug("ssh:create '#{state[:hostname]}'")
-       end
-
-       def destroy(state)
-         print "Kitchen-ssh does not destroy your server '#{state[:hostname]}' by shutting it down..."
-         print "Shutdown your server '#{state[:hostname]}' natively with user '#{state[:username]}'"
-         print 'in your cloud or virtualisation console etc.\n'
-         debug("ssh:destroy '#{state[:hostname]}'")
-       end
-
-    end
-  end
-end
+require 'kitchen'
+require 'kitchen/driver/ssh_base'
+
+module Kitchen
+  module Driver
+    class Ssh < SSHBase
+       def create(state)
+         state[:sudo] = config[:sudo]
+         state[:port] = config[:port]
+         state[:ssh_key] = config[:ssh_key]
+         state[:forward_agent] = config[:forward_agent]
+         state[:username] = config[:username]
+         state[:hostname] = config[:hostname]
+         state[:password] = config[:password]
+         print "Kitchen-ssh does not start your server '#{state[:hostname]}' but will look for an ssh connection with user '#{state[:username]}'"
+         wait_for_sshd(state[:hostname], state[:username], {:port => state[:port]})
+         print "Kitchen-ssh found ssh ready on host '#{state[:hostname]}' with user '#{state[:username]}'\n"
+         debug("ssh:create '#{state[:hostname]}'")
+       end
+
+       def destroy(state)
+         print "Kitchen-ssh does not destroy your server '#{state[:hostname]}' by shutting it down..."
+         print "Shutdown your server '#{state[:hostname]}' natively with user '#{state[:username]}'"
+         print 'in your cloud or virtualisation console etc.\n'
+         debug("ssh:destroy '#{state[:hostname]}'")
+       end
+
+    end
+  end
+end

data/lib/kitchen/driver/ssh_base_gzip.rb

@@ -1,251 +1,251 @@
-# -*- encoding: utf-8 -*-
-#
-# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
-#
-# Copyright (C) 2012, Fletcher Nichol
-#
-# 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 'archive/tar/minitar'
-
-module Kitchen
-
-  module Driver
-
-    # Base class for a driver that uses SSH to communication with an instance.
-    # A subclass must implement the following methods:
-    # * #create(state)
-    # * #destroy(state)
-    #
-    # @author Fletcher Nichol <fnichol@nichol.ca>
-    class SSHBaseGzip < Kitchen::Driver::SSHBase
-
-      default_config :sudo,             true
-      default_config :port,             22
-      default_config :sandbox_archive,  'testkitchen-sandbox.tar.gz'
-
-      # (see Base#create)
-      def create(state) # rubocop:disable Lint/UnusedMethodArgument
-        raise ClientError, "#{self.class}#create must be implemented"
-      end
-
-      # (see Base#converge)
-      def converge(state)
-        provisioner = instance.provisioner
-        provisioner.create_sandbox
-
-        Kitchen::SSH.new(*build_ssh_args(state)) do |conn|
-          run_remote(provisioner.install_command, conn)
-          run_remote(provisioner.init_command, conn)
-          do_sandbox_transfer provisioner, conn
-          run_remote(provisioner.prepare_command, conn)
-          run_remote(provisioner.run_command, conn)
-        end
-      ensure
-        provisioner && provisioner.cleanup_sandbox
-      end
-
-      # (see Base#setup)
-      def setup(state)
-        Kitchen::SSH.new(*build_ssh_args(state)) do |conn|
-          run_remote(busser.setup_cmd, conn)
-        end
-      end
-
-      # (see Base#verify) - changed in kitchen >=1.4
-      #def verify(state)
-      #  Kitchen::SSH.new(*build_ssh_args(state)) do |conn|
-      #    run_remote(busser.sync_cmd, conn)
-      #    run_remote(busser.run_cmd, conn)
-      #  end
-      #end
-
-      # (see Base#destroy)
-      def destroy(state) # rubocop:disable Lint/UnusedMethodArgument
-        raise ClientError, "#{self.class}#destroy must be implemented"
-      end
-
-      # (see Base#login_command)
-      def login_command(state)
-        SSH.new(*build_ssh_args(state)).login_command
-      end
-
-      # Executes an arbitrary command on an instance over an SSH connection.
-      #
-      # @param state [Hash] mutable instance and driver state
-      # @param command [String] the command to be executed
-      # @raise [ActionFailed] if the command could not be successfully completed
-      def remote_command(state, command)
-        Kitchen::SSH.new(*build_ssh_args(state)) do |conn|
-          run_remote(command, conn)
-        end
-      end
-
-      # **(Deprecated)** Executes a remote command over SSH.
-      #
-      # @param ssh_args [Array] ssh arguments
-      # @param command [String] remote command to invoke
-      # @deprecated This method should no longer be called directly and exists
-      #   to support very old drivers. This will be removed in the future.
-      def ssh(ssh_args, command)
-        Kitchen::SSH.new(*ssh_args) do |conn|
-          run_remote(command, conn)
-        end
-      end
-
-      private
-
-      # Builds arguments for constructing a `Kitchen::SSH` instance.
-      #
-      # @param state [Hash] state hash
-      # @return [Array] SSH constructor arguments
-      # @api private
-      def build_ssh_args(state)
-        combined = config.to_hash.merge(state)
-
-        opts = Hash.new
-        opts[:user_known_hosts_file] = "/dev/null"
-        opts[:paranoid] = false
-        opts[:keys_only] = true if combined[:ssh_key]
-        opts[:password] = combined[:password] if combined[:password]
-        opts[:forward_agent] = combined[:forward_agent] if combined.key? :forward_agent
-        opts[:port] = combined[:port] if combined[:port]
-        opts[:keys] = Array(combined[:ssh_key]) if combined[:ssh_key]
-        opts[:logger] = logger
-
-        [combined[:hostname], combined[:username], opts]
-      end
-
-      # Adds http and https proxy environment variables to a command, if set
-      # in configuration data.
-      #
-      # @param cmd [String] command string
-      # @return [String] command string
-      # @api private
-      def env_cmd(cmd)
-        env = "env"
-        env << " http_proxy=#{config[:http_proxy]}"   if config[:http_proxy]
-        env << " https_proxy=#{config[:https_proxy]}" if config[:https_proxy]
-
-        env == "env" ? cmd : "#{env} #{cmd}"
-      end
-
-      # Executes a remote command over SSH.
-      #
-      # @param command [String] remove command to run
-      # @param connection [Kitchen::SSH] an SSH connection
-      # @raise [ActionFailed] if an exception occurs
-      # @api private
-      def run_remote(command, connection)
-        return if command.nil?
-
-        connection.exec(env_cmd(command))
-      rescue SSHFailed, Net::SSH::Exception => ex
-        raise ActionFailed, ex.message
-      end
-
-      # Transfers one or more local paths over SSH.
-      #
-      # @param locals [Array<String>] array of local paths
-      # @param remote [String] remote destination path
-      # @param connection [Kitchen::SSH] an SSH connection
-      # @raise [ActionFailed] if an exception occurs
-      # @api private
-      def transfer_path(locals, remote, connection)
-        return if locals.nil? || Array(locals).empty?
-
-        info("Transferring files to #{instance.to_str}")
-        locals.each { |local| connection.upload_path!(local, remote) }
-        debug("Transfer complete")
-      rescue SSHFailed, Net::SSH::Exception => ex
-        raise ActionFailed, ex.message
-      end
-
-      # Blocks until a TCP socket is available where a remote SSH server
-      # should be listening.
-      #
-      # @param hostname [String] remote SSH server host
-      # @param username [String] SSH username (default: `nil`)
-      # @param options [Hash] configuration hash (default: `{}`)
-      # @api private
-      def wait_for_sshd(hostname, username = nil, options = {})
-        SSH.new(hostname, username, { :logger => logger }.merge(options)).wait
-      end
-
-
-      # Creates a temporary folder containing an archive of the current
-      # TestKitchen sandbox.
-      #
-      # @param sandbox_path [String]
-      def archive_sandbox(sandbox_path)
-        archive_dir  = Dir.mktmpdir("#{instance.name}-sandbox-archive-")
-        archive_file = "#{archive_dir}/#{self[:sandbox_archive]}"
-
-        Dir.chdir(sandbox_path) do |dir|
-          tgz = Zlib::GzipWriter.new(File.open(archive_file, 'wb'), Zlib::DEFAULT_COMPRESSION, Zlib::DEFAULT_STRATEGY)
-          Archive::Tar::Minitar.pack('.', tgz)
-        end
-
-        archive_dir
-      end
-
-      # Transfers the local sandbox to the instance.
-      # - Archives/extracts if the tar command is available remotely.
-      #
-      # @param provisioner [Kitchen::Provisioner::Base] the provisioner
-      # @param connection [Kitchen:SSH] an SSH connection
-      def do_sandbox_transfer(provisioner, connection)
-        root_path     = provisioner[:root_path]
-        sandbox_path  = provisioner.sandbox_path
-        archive_file  = self[:sandbox_archive]
-        archive_path  = false
-        do_archive    = remote_supports_tar? connection
-
-        begin
-          # Archive sandbox if enabled (We keep a copy of the archive path so that we do not)
-          # delete the sandbox if an exception is thrown
-          if do_archive
-            info 'Creating sandbox archive'
-            archive_path = archive_sandbox sandbox_path
-            sandbox_path = archive_path
-          end
-
-          # Initiate transfer
-          transfer_path(Dir.glob("#{sandbox_path}/*"), root_path, connection)
-
-          # Extract archive if enabled (and cleanup locally)
-          if do_archive
-            info 'Extracting sandbox archive remotely'
-            run_remote("tar xf #{root_path}/#{archive_file} -C #{root_path}", connection)
-          end
-        ensure
-          # Ensure archive temporary directory is removed, if used.
-          FileUtils.rmtree(archive_path) if archive_path
-        end
-      end
-
-      # Checks whether the remote instance supports archive extraction using
-      # the `tar` command.
-      #
-      # @param connection [Kitchen::SSH] an SSH connection
-      def remote_supports_tar?(connection)
-        begin
-          run_remote('tar --version > /dev/null 2>&1', connection)
-          return true
-        rescue ActionFailed => ex
-            return false
-        end
-      end
-    end
-  end
-end
+# -*- encoding: utf-8 -*-
+#
+# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
+#
+# Copyright (C) 2012, Fletcher Nichol
+#
+# 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 'archive/tar/minitar'
+
+module Kitchen
+
+  module Driver
+
+    # Base class for a driver that uses SSH to communication with an instance.
+    # A subclass must implement the following methods:
+    # * #create(state)
+    # * #destroy(state)
+    #
+    # @author Fletcher Nichol <fnichol@nichol.ca>
+    class SSHBaseGzip < Kitchen::Driver::SSHBase
+
+      default_config :sudo,             true
+      default_config :port,             22
+      default_config :sandbox_archive,  'testkitchen-sandbox.tar.gz'
+
+      # (see Base#create)
+      def create(state) # rubocop:disable Lint/UnusedMethodArgument
+        raise ClientError, "#{self.class}#create must be implemented"
+      end
+
+      # (see Base#converge)
+      def converge(state)
+        provisioner = instance.provisioner
+        provisioner.create_sandbox
+
+        Kitchen::SSH.new(*build_ssh_args(state)) do |conn|
+          run_remote(provisioner.install_command, conn)
+          run_remote(provisioner.init_command, conn)
+          do_sandbox_transfer provisioner, conn
+          run_remote(provisioner.prepare_command, conn)
+          run_remote(provisioner.run_command, conn)
+        end
+      ensure
+        provisioner && provisioner.cleanup_sandbox
+      end
+
+      # (see Base#setup)
+      def setup(state)
+        Kitchen::SSH.new(*build_ssh_args(state)) do |conn|
+          run_remote(busser.setup_cmd, conn)
+        end
+      end
+
+      # (see Base#verify) - changed in kitchen >=1.4
+      #def verify(state)
+      #  Kitchen::SSH.new(*build_ssh_args(state)) do |conn|
+      #    run_remote(busser.sync_cmd, conn)
+      #    run_remote(busser.run_cmd, conn)
+      #  end
+      #end
+
+      # (see Base#destroy)
+      def destroy(state) # rubocop:disable Lint/UnusedMethodArgument
+        raise ClientError, "#{self.class}#destroy must be implemented"
+      end
+
+      # (see Base#login_command)
+      def login_command(state)
+        SSH.new(*build_ssh_args(state)).login_command
+      end
+
+      # Executes an arbitrary command on an instance over an SSH connection.
+      #
+      # @param state [Hash] mutable instance and driver state
+      # @param command [String] the command to be executed
+      # @raise [ActionFailed] if the command could not be successfully completed
+      def remote_command(state, command)
+        Kitchen::SSH.new(*build_ssh_args(state)) do |conn|
+          run_remote(command, conn)
+        end
+      end
+
+      # **(Deprecated)** Executes a remote command over SSH.
+      #
+      # @param ssh_args [Array] ssh arguments
+      # @param command [String] remote command to invoke
+      # @deprecated This method should no longer be called directly and exists
+      #   to support very old drivers. This will be removed in the future.
+      def ssh(ssh_args, command)
+        Kitchen::SSH.new(*ssh_args) do |conn|
+          run_remote(command, conn)
+        end
+      end
+
+      private
+
+      # Builds arguments for constructing a `Kitchen::SSH` instance.
+      #
+      # @param state [Hash] state hash
+      # @return [Array] SSH constructor arguments
+      # @api private
+      def build_ssh_args(state)
+        combined = config.to_hash.merge(state)
+
+        opts = Hash.new
+        opts[:user_known_hosts_file] = "/dev/null"
+        opts[:paranoid] = false
+        opts[:keys_only] = true if combined[:ssh_key]
+        opts[:password] = combined[:password] if combined[:password]
+        opts[:forward_agent] = combined[:forward_agent] if combined.key? :forward_agent
+        opts[:port] = combined[:port] if combined[:port]
+        opts[:keys] = Array(combined[:ssh_key]) if combined[:ssh_key]
+        opts[:logger] = logger
+
+        [combined[:hostname], combined[:username], opts]
+      end
+
+      # Adds http and https proxy environment variables to a command, if set
+      # in configuration data.
+      #
+      # @param cmd [String] command string
+      # @return [String] command string
+      # @api private
+      def env_cmd(cmd)
+        env = "env"
+        env << " http_proxy=#{config[:http_proxy]}"   if config[:http_proxy]
+        env << " https_proxy=#{config[:https_proxy]}" if config[:https_proxy]
+
+        env == "env" ? cmd : "#{env} #{cmd}"
+      end
+
+      # Executes a remote command over SSH.
+      #
+      # @param command [String] remove command to run
+      # @param connection [Kitchen::SSH] an SSH connection
+      # @raise [ActionFailed] if an exception occurs
+      # @api private
+      def run_remote(command, connection)
+        return if command.nil?
+
+        connection.exec(env_cmd(command))
+      rescue SSHFailed, Net::SSH::Exception => ex
+        raise ActionFailed, ex.message
+      end
+
+      # Transfers one or more local paths over SSH.
+      #
+      # @param locals [Array<String>] array of local paths
+      # @param remote [String] remote destination path
+      # @param connection [Kitchen::SSH] an SSH connection
+      # @raise [ActionFailed] if an exception occurs
+      # @api private
+      def transfer_path(locals, remote, connection)
+        return if locals.nil? || Array(locals).empty?
+
+        info("Transferring files to #{instance.to_str}")
+        locals.each { |local| connection.upload_path!(local, remote) }
+        debug("Transfer complete")
+      rescue SSHFailed, Net::SSH::Exception => ex
+        raise ActionFailed, ex.message
+      end
+
+      # Blocks until a TCP socket is available where a remote SSH server
+      # should be listening.
+      #
+      # @param hostname [String] remote SSH server host
+      # @param username [String] SSH username (default: `nil`)
+      # @param options [Hash] configuration hash (default: `{}`)
+      # @api private
+      def wait_for_sshd(hostname, username = nil, options = {})
+        SSH.new(hostname, username, { :logger => logger }.merge(options)).wait
+      end
+
+
+      # Creates a temporary folder containing an archive of the current
+      # TestKitchen sandbox.
+      #
+      # @param sandbox_path [String]
+      def archive_sandbox(sandbox_path)
+        archive_dir  = Dir.mktmpdir("#{instance.name}-sandbox-archive-")
+        archive_file = "#{archive_dir}/#{self[:sandbox_archive]}"
+
+        Dir.chdir(sandbox_path) do |dir|
+          tgz = Zlib::GzipWriter.new(File.open(archive_file, 'wb'), Zlib::DEFAULT_COMPRESSION, Zlib::DEFAULT_STRATEGY)
+          Archive::Tar::Minitar.pack('.', tgz)
+        end
+
+        archive_dir
+      end
+
+      # Transfers the local sandbox to the instance.
+      # - Archives/extracts if the tar command is available remotely.
+      #
+      # @param provisioner [Kitchen::Provisioner::Base] the provisioner
+      # @param connection [Kitchen:SSH] an SSH connection
+      def do_sandbox_transfer(provisioner, connection)
+        root_path     = provisioner[:root_path]
+        sandbox_path  = provisioner.sandbox_path
+        archive_file  = self[:sandbox_archive]
+        archive_path  = false
+        do_archive    = remote_supports_tar? connection
+
+        begin
+          # Archive sandbox if enabled (We keep a copy of the archive path so that we do not)
+          # delete the sandbox if an exception is thrown
+          if do_archive
+            info 'Creating sandbox archive'
+            archive_path = archive_sandbox sandbox_path
+            sandbox_path = archive_path
+          end
+
+          # Initiate transfer
+          transfer_path(Dir.glob("#{sandbox_path}/*"), root_path, connection)
+
+          # Extract archive if enabled (and cleanup locally)
+          if do_archive
+            info 'Extracting sandbox archive remotely'
+            run_remote("tar xf #{root_path}/#{archive_file} -C #{root_path}", connection)
+          end
+        ensure
+          # Ensure archive temporary directory is removed, if used.
+          FileUtils.rmtree(archive_path) if archive_path
+        end
+      end
+
+      # Checks whether the remote instance supports archive extraction using
+      # the `tar` command.
+      #
+      # @param connection [Kitchen::SSH] an SSH connection
+      def remote_supports_tar?(connection)
+        begin
+          run_remote('tar --version > /dev/null 2>&1', connection)
+          return true
+        rescue ActionFailed => ex
+            return false
+        end
+      end
+    end
+  end
+end

data/lib/kitchen/driver/ssh_gzip.rb

@@ -1,30 +1,30 @@
-require 'kitchen'
-require 'kitchen/driver/ssh_base_gzip'
-
-module Kitchen
-  module Driver
-    class SshGzip < SSHBaseGzip
-       def create(state)
-         state[:sudo] = config[:sudo]
-         state[:port] = config[:port]
-         state[:ssh_key] = config[:ssh_key]
-         state[:forward_agent] = config[:forward_agent]
-         state[:username] = config[:username]
-         state[:hostname] = config[:hostname]
-         state[:password] = config[:password]
-         print "Kitchen-sshGzip does not start your server '#{state[:hostname]}' but will look for an ssh connection with user '#{state[:username]}'"
-         wait_for_sshd(state[:hostname], state[:username], {:port => state[:port]})
-         print "Kitchen-sshGzip found ssh ready on host '#{state[:hostname]}' with user '#{state[:username]}'\n"
-         debug("ssh:create '#{state[:hostname]}'")
-       end
-
-       def destroy(state)
-         print "Kitchen-sshGzip does not destroy your server '#{state[:hostname]}' by shutting it down..."
-         print "Shutdown your server '#{state[:hostname]}' natively with user '#{state[:username]}'"
-         print 'in your cloud or virtualisation console etc.\n'
-         debug("ssh:destroy '#{state[:hostname]}'")
-       end
-
-    end
-  end
-end
+require 'kitchen'
+require 'kitchen/driver/ssh_base_gzip'
+
+module Kitchen
+  module Driver
+    class SshGzip < SSHBaseGzip
+       def create(state)
+         state[:sudo] = config[:sudo]
+         state[:port] = config[:port]
+         state[:ssh_key] = config[:ssh_key]
+         state[:forward_agent] = config[:forward_agent]
+         state[:username] = config[:username]
+         state[:hostname] = config[:hostname]
+         state[:password] = config[:password]
+         print "Kitchen-sshGzip does not start your server '#{state[:hostname]}' but will look for an ssh connection with user '#{state[:username]}'"
+         wait_for_sshd(state[:hostname], state[:username], {:port => state[:port]})
+         print "Kitchen-sshGzip found ssh ready on host '#{state[:hostname]}' with user '#{state[:username]}'\n"
+         debug("ssh:create '#{state[:hostname]}'")
+       end
+
+       def destroy(state)
+         print "Kitchen-sshGzip does not destroy your server '#{state[:hostname]}' by shutting it down..."
+         print "Shutdown your server '#{state[:hostname]}' natively with user '#{state[:username]}'"
+         print 'in your cloud or virtualisation console etc.\n'
+         debug("ssh:destroy '#{state[:hostname]}'")
+       end
+
+    end
+  end
+end

data/lib/kitchen/ssh/version.rb

@@ -1,5 +1,5 @@
-module Kitchen
-  module Ssh
-    VERSION = "0.0.10"
-  end
-end
+module Kitchen
+  module Ssh
+    VERSION = "0.0.11"
+  end
+end

metadata

@@ -1,39 +1,42 @@
 --- !ruby/object:Gem::Specification
 name: kitchen-ssh
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Neill Turner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-10 00:00:00.000000000 Z
+date: 2016-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
-description: "ssh and ssh_gzip driver for test-kitchen for any running server with
-  an ip address\n\n*** As well as ssh it supports a second driver called ssh_gzip
-  that will also gzip file before transfer which can provide \na big performance improvement
-  when alot of files are transfered. ****\n\n"
+description: |+
+  ssh and ssh_gzip driver for test-kitchen for any running server with an ip address
+
+  *** As well as ssh it supports a second driver called ssh_gzip that will also gzip file before transfer which can provide
+  a big performance improvement when alot of files are transfered. ****
+
 email:
 - neillwturner@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Gemfile
 - LICENSE.txt
 - README.md
 - kitchen-ssh.gemspec
@@ -42,7 +45,8 @@ files:
 - lib/kitchen/driver/ssh_gzip.rb
 - lib/kitchen/ssh/version.rb
 homepage: https://github.com/neillturner/kitchen-ssh
-licenses: []
+licenses:
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -50,17 +54,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: '[none]'
-rubygems_version: 2.0.14
+rubyforge_project: "[none]"
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: ssh and ssh_gzip driver for test-kitchen for any running server with an ip