kitchen-ssh 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: da447d64c6144ed70e6309db0446f8ef44d79bae
-  data.tar.gz: 210aabce4232e41e815e38bced6230b5e3ad631d
+SHA256:
+  metadata.gz: 65f7fd88777977ba368939cfbeb8890b8f0bf8ae1e14eeb75abc943ece3da4fc
+  data.tar.gz: 04acb0f9b849ce3be2dd61ac66458631e5c88b50116c4c8734966eef6fdf8b5d
 SHA512:
-  metadata.gz: 41fed5b73a96ba20ab61c1bb4897dcfb4d96deb4ee647edf0cefe9040af616fd7f983d5349d11c97240ba29960b809519ffcb5b03f7ddc5aafe10ab180dd5e51
-  data.tar.gz: 4ecb483b8ae03b3073b4e4361959b29894fedc5f725a94f44dfc5050958e50a2840cc8f7673573c7d8d9614f4b4275d76ba355b728dab680be25dfacc4321d89
+  metadata.gz: c17acb9cd005c1882e273d3886dc7113821ba82a47a1dcd5d39d44752b1afce5edfc6fd738317f58cabd9d4242d1029b198cf91193e54907df8d43f4143a08a2
+  data.tar.gz: a887f3ed1826e16cc45ff42eb78944d3c1c747867e691669181f2bf0ad613858bf6ba429fa4a2d031d5de85fe714c31a0e7bbc451a09e4c84f9d22bf002614f7

data/README.md

@@ -1,79 +1,79 @@
-# 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
-```
-
-### Bastion Host
-
-If you use a bastion host, add the following lines:
-
-```yaml
-transport:
-  name: ssh
-  ssh_gateway: bastion-ip
-  ssh_gateway_username: bastion-user
-```
-
-Alternatively add `ProxyCommand ssh -W %h:%p bastion-user@bastion-ip` to your `ssh_config(5)`
-
-## Tips
-
-If you get a hang while running kitchen-ssh with a non-root user check that the user was not set to be NOPASSWORD in the sudoer file either. So it hang there waiting for input of the password prompted. After changing the user and key to be root in the .kitchen.yml file, everything worked.
+# 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
+```
+
+### Bastion Host
+
+If you use a bastion host, add the following lines:
+
+```yaml
+transport:
+  name: ssh
+  ssh_gateway: bastion-ip
+  ssh_gateway_username: bastion-user
+```
+
+Alternatively add `ProxyCommand ssh -W %h:%p bastion-user@bastion-ip` to your `ssh_config(5)`
+
+## Tips
+
+If you get a hang while running kitchen-ssh with a non-root user check that the user was not set to be NOPASSWORD in the sudoer file either. So it hang there waiting for input of the password prompted. After changing the user and key to be root in the .kitchen.yml file, everything worked.

data/kitchen-ssh.gemspec

@@ -1,28 +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.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.6')
-  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
+# 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.6')
+  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] if config[:forward_agent]
-         state[:username] = config[:username]
-         state[:hostname] = config[:hostname]
-         state[:password] = config[:password] if 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.'
-         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] if config[:forward_agent]
+         state[:username] = config[:username]
+         state[:hostname] = config[:hostname]
+         state[:password] = config[:password] if 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.'
+         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[:verify_host_key] = false
-        opts[:keys_only] = true if combined[:ssh_key]
-        opts[:password] = combined[:password] if combined[:password]
-        opts[:forward_agent] = combined[:forward_agent] if 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[:verify_host_key] = false
+        opts[:keys_only] = true if combined[:ssh_key]
+        opts[:password] = combined[:password] if combined[:password]
+        opts[:forward_agent] = combined[:forward_agent] if 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.'
-         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.'
+         debug("ssh:destroy '#{state[:hostname]}'")
+       end
+
+    end
+  end
+end

data/lib/kitchen/ssh/version.rb

@@ -1,5 +1,5 @@
-module Kitchen
-  module Ssh
-    VERSION = "1.0.2"
-  end
-end
+module Kitchen
+  module Ssh
+    VERSION = "1.0.3"
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kitchen-ssh
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Neill Turner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-18 00:00:00.000000000 Z
+date: 2018-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitar
@@ -64,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: "[none]"
-rubygems_version: 2.6.13
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: ssh and ssh_gzip driver for test-kitchen for any running server with an ip