ridley-connectors 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75a45b3d5ebe84723f39a4eab4449f2d62232a7e
-  data.tar.gz: c35e78280d736f252028d9a167092d8bdfe85b7f
+  metadata.gz: 0963bedc809b1573895731a6ef403acd8bb22d36
+  data.tar.gz: 585e09bb5fe887c8b234c93e447353c5c632eca4
 SHA512:
-  metadata.gz: d55c6296fc29e58250b15c4d80dc01eda0efd20014c8beb2e5ca707145cc8824251a0350e6fb470b319dbc1e05d65f2404ec0a2ff56dc98984cfb8d0bab36e85
-  data.tar.gz: c7bbc2ae0143b1db7c5c6bc52a4fc5b8c848fe8b753a3853098f6f7d851324e25cd485791ecb4b7b5c9eed452cc0053ee2263820f7e1ce9cdf09990f85ce94ef
+  metadata.gz: 85cd162eede9fb6ef393460caf4a71e77a00149242876906c10ea19c1d9d6665347d67856bc71f463d20fd7d59a267adca978c3e80fc3f5c960ffb49c6be50f2
+  data.tar.gz: bd05027c733e9b157de24014fcff761191a880e59f1a78366c23f625d7c9d401d9b12baa7aef021d758f20434c3374883c936dcd649ae36956601f8a104d5dd0

data/lib/ridley-connectors/host_commander.rb

@@ -23,24 +23,11 @@ module Ridley
     include Celluloid
     include Ridley::Logging
 
-    PORT_CHECK_TIMEOUT = 3
-    RETRY_COUNT = 3
-
     DEFAULT_WINDOWS_CONNECTOR = "winrm"
     DEFAULT_LINUX_CONNECTOR = "ssh"
 
     VALID_CONNECTORS = [ DEFAULT_WINDOWS_CONNECTOR, DEFAULT_LINUX_CONNECTOR ]
 
-    CONNECTOR_PORT_ERRORS = [
-      Errno::ETIMEDOUT, Timeout::Error, SocketError, 
-      Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::EADDRNOTAVAIL,
-      Resolv::ResolvError
-    ]
-
-    if Buff::RubyEngine.jruby?
-      CONNECTOR_PORT_ERRORS << Java::JavaNet::ConnectException
-    end
-
     finalizer :finalize_callback
 
     def initialize(connector_pool_size=nil)
@@ -228,6 +215,7 @@ module Ridley
     # @option options [Hash] :ssh
     #   * :port (Fixnum) the ssh port to connect on the node the bootstrap will be performed on (22)
     #   * :timeout (Float) [5.0] timeout value for testing SSH connection
+    #   * :gateway (String) user@host:port
     # @option options [Hash] :winrm
     #   * :port (Fixnum) the winrm port to connect on the node the bootstrap will be performed on (5985)
     # @option options [String] :connector
@@ -237,12 +225,6 @@ module Ridley
     #
     # @return [HostConnector::SSH, HostConnector::WinRM, NilClass]
     def connector_for(host, options = {})
-      options[:ssh]          ||= Hash.new
-      options[:winrm]        ||= Hash.new
-      options[:ssh][:port]   ||= HostConnector::SSH::DEFAULT_PORT
-      options[:winrm][:port] ||= HostConnector::WinRM::DEFAULT_PORT
-      options[:retries]      ||= RETRY_COUNT
-
       connector = options[:connector]
 
       if !VALID_CONNECTORS.include?(connector)
@@ -250,10 +232,12 @@ module Ridley
         connector = nil
       end
 
-      if (connector == DEFAULT_WINDOWS_CONNECTOR || connector.nil?) && connector_port_open?(host, options[:winrm][:port], options[:winrm][:timeout], options[:retries])
+      if (connector == DEFAULT_WINDOWS_CONNECTOR || connector.nil?) && 
+          winrm.connector_port_open?(host, options)
         options.delete(:ssh)
         winrm
-      elsif (connector == DEFAULT_LINUX_CONNECTOR || connector.nil?) && connector_port_open?(host, options[:ssh][:port], options[:ssh][:timeout], options[:retries])
+      elsif (connector == DEFAULT_LINUX_CONNECTOR || connector.nil?) && 
+          ssh.connector_port_open?(host, options)
         options.delete(:winrm)
         ssh
       else
@@ -286,75 +270,6 @@ module Ridley
         end
       end
 
-      # Checks to see if the given port is open for TCP connections
-      # on the given host.
-      #
-      # @param [String] host
-      #   the host to attempt to connect to
-      # @param [Fixnum] port
-      #   the port to attempt to connect on
-      # @param [Float] timeout ({PORT_CHECK_TIMEOUT})
-      #   the number of seconds to wait
-      # @param [Int] retries ({RETRY_COUNT})
-      #   the number of times to retry the connection before counting it unavailable
-      #
-      # @return [Boolean]
-      def connector_port_open?(host, port, timeout = PORT_CHECK_TIMEOUT, retries = RETRY_COUNT)
-        @retry_count = retries
-        begin
-          defer {
-            connectable?(host, port, timeout || PORT_CHECK_TIMEOUT)
-          }
-        rescue *CONNECTOR_PORT_ERRORS => ex
-          @retry_count -= 1
-          if @retry_count > 0
-            log.info { "Retrying connector_port_open? on '#{host}' #{port} due to: #{ex.class}" }
-            retry
-          end
-          false
-        end
-      end
-
-      # Check if a port on a host is able to be connected, failing if the timeout transpires.
-      #
-      # @param [String] host
-      #   the host to attempt to connect to
-      # @param [Fixnum] port
-      #   the port to attempt to connect on
-      # @param [Fixnum] timeout ({PORT_CHECK_TIMEOUT})
-      # 
-      # @return [Boolean]
-      def connectable?(host, port, timeout = PORT_CHECK_TIMEOUT)
-        addr = Socket.getaddrinfo(host, nil)
-        sockaddr = Socket.pack_sockaddr_in(port, addr[0][3])
-        socket = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
-        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-
-        success = false
-        begin
-          socket.connect_nonblock(sockaddr)
-          success = true
-        rescue ::IO::WaitWritable
-          if ::IO.select(nil, [socket], nil, timeout || PORT_CHECK_TIMEOUT)
-            begin
-              socket.connect_nonblock(sockaddr)
-              success = true
-            rescue Errno::EISCONN
-              success = true
-            rescue
-              begin
-                socket.close
-              rescue Errno::EBADF
-                # socket is not open
-              end
-            end
-          else
-            socket.close
-          end
-        end
-        success
-      end
-
       def finalize_callback
         @connector_supervisor.async.terminate if @connector_supervisor && @connector_supervisor.alive?
       end

data/lib/ridley-connectors/host_connector.rb

@@ -4,6 +4,20 @@ module Ridley
       include Celluloid
       include Ridley::Logging
 
+      PORT_CHECK_TIMEOUT = 3
+      RETRY_COUNT = 3
+      CONNECTOR_PORT_ERRORS = [Errno::ETIMEDOUT,
+                               Timeout::Error,
+                               SocketError, 
+                               Errno::ECONNREFUSED,
+                               Errno::EHOSTUNREACH,
+                               Errno::EADDRNOTAVAIL,
+                               Resolv::ResolvError]
+
+      if Buff::RubyEngine.jruby?
+        CONNECTOR_PORT_ERRORS << Java::JavaNet::ConnectException
+      end
+
       # Execute a shell command on a node
       #
       # @param [String] host
@@ -74,6 +88,79 @@ module Ridley
       def uninstall_chef(host, options = {})
         raise RuntimeError, "abstract function: must be implemented on includer"
       end
+
+      def connector_port_open?
+        raise RuntimeError, "abstract function: must be implemented on includer"
+      end
+
+      # Checks to see if the given port is open for TCP connections
+      # on the given host.
+      #
+      # @param [String] host
+      #   the host to attempt to connect to
+      # @param [Fixnum] port
+      #   the port to attempt to connect on
+      # @param [Float] timeout ({PORT_CHECK_TIMEOUT})
+      #   the number of seconds to wait
+      # @param [Int] retries ({RETRY_COUNT})
+      #   the number of times to retry the connection before counting it unavailable
+      #
+      # @return [Boolean]
+      def port_open?(host, port, timeout = PORT_CHECK_TIMEOUT, retries = RETRY_COUNT)
+        @retry_count = retries
+        begin
+          defer {
+            connectable?(host, port, timeout || PORT_CHECK_TIMEOUT)
+          }
+        rescue *CONNECTOR_PORT_ERRORS => ex
+          @retry_count -= 1
+          if @retry_count > 0
+            log.info { "Retrying connector_port_open? on '#{host}' #{port} due to: #{ex.class}" }
+            retry
+          end
+          false
+        end
+      end
+
+      # Check if a port on a host is able to be connected, failing if the timeout transpires.
+      #
+      # @param [String] host
+      #   the host to attempt to connect to
+      # @param [Fixnum] port
+      #   the port to attempt to connect on
+      # @param [Fixnum] timeout ({PORT_CHECK_TIMEOUT})
+      # 
+      # @return [Boolean]
+      def connectable?(host, port, timeout = PORT_CHECK_TIMEOUT)
+        addr = Socket.getaddrinfo(host, nil)
+        sockaddr = Socket.pack_sockaddr_in(port, addr[0][3])
+        socket = Socket.new(Socket.const_get(addr[0][0]), Socket::SOCK_STREAM, 0)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+        success = false
+        begin
+          socket.connect_nonblock(sockaddr)
+          success = true
+        rescue ::IO::WaitWritable
+          if ::IO.select(nil, [socket], nil, timeout || PORT_CHECK_TIMEOUT)
+            begin
+              socket.connect_nonblock(sockaddr)
+              success = true
+            rescue Errno::EISCONN
+              success = true
+            rescue
+              begin
+                socket.close
+              rescue Errno::EBADF
+                # socket is not open
+              end
+            end
+          else
+            socket.close
+          end
+        end
+        success
+      end
     end
 
     require_relative 'host_connector/response'

data/lib/ridley-connectors/host_connector/ssh.rb

@@ -1,4 +1,5 @@
 require 'net/ssh'
+require 'net/ssh/gateway'
 
 module Ridley
   module HostConnector
@@ -6,7 +7,8 @@ module Ridley
       DEFAULT_PORT       = 22
       EMBEDDED_RUBY_PATH = '/opt/chef/embedded/bin/ruby'.freeze
 
-      # Execute a shell command on a node
+      # Execute a shell command on a node using ssh. If the gateway option is present then
+      # execute the command through the gateway.
       #
       # @param [String] host
       #   the host to perform the action on
@@ -18,6 +20,7 @@ module Ridley
       #   * :keys (Array, String) an array of key(s) to authenticate the ssh user with instead of a password
       #   * :timeout (Float) timeout value for SSH bootstrap (5.0)
       #   * :sudo (Boolean) run as sudo
+      #   * :gateway (String) user@host:port
       #
       # @return [HostConnector::Response]
       def run(host, command, options = {})
@@ -31,7 +34,7 @@ module Ridley
             log.info "Running SSH command: '#{command}' on: '#{host}' as: '#{options[:ssh][:user]}'"
 
             defer {
-              Net::SSH.start(host, options[:ssh][:user], options[:ssh].slice(*Net::SSH::VALID_OPTIONS)) do |ssh|
+              ssh(host, options) do |ssh|
                 ssh.open_channel do |channel|
                   if options[:sudo]
                     channel.request_pty do |channel, success|
@@ -225,8 +228,66 @@ module Ridley
         run(host, CommandContext::UnixUpdateOmnibus.command(options), options)
       end
 
+      # Checks to see if the given port is open for TCP connections
+      # on the given host. If a gateway is provided in the ssh
+      # options, then return true if we can connect to the gateway host.
+      # If no gateway config is found then just verify we can connect to
+      # the destination host.
+      #
+      # @param [String] host
+      #   the host to attempt to connect to
+      # @option options [Hash] :ssh
+      #   * :gateway (String) user@host:port
+      #   * :timeout (Float) timeout value for SSH
+      #   * :port (Fixnum) the SSH port
+      # @return [Boolean]
+      def connector_port_open?(host, options = {})
+        options[:ssh]          ||= Hash.new
+        options[:ssh][:port]   ||= HostConnector::SSH::DEFAULT_PORT
+
+        if options[:ssh][:gateway]
+          gw_host, gw_port, _ = gateway(options)
+          log.info("Connecting to host '#{gw_host}' via SSH gateway over port '#{gw_port}'")
+          port_open?(gw_host, gw_port, options[:ssh][:timeout])
+        else
+          port_open?(host, options[:ssh][:port], options[:ssh][:timeout])
+        end
+      end
+
       private
 
+        def gateway(options)
+          options[:ssh] ||= Hash.new
+
+          if options[:ssh][:gateway]
+            gw_host, gw_user = options[:ssh][:gateway].split("@").reverse
+            gw_host, gw_port = gw_host.split(":")
+            gw_port ||= HostConnector::SSH::DEFAULT_PORT
+            [gw_host, gw_port, gw_user]
+          else
+            [nil, nil, nil]
+          end
+        end
+
+        # Open an SSH connection either directly or through a gateway.
+        def ssh(host, options, &block)
+          if options[:ssh][:gateway]
+            gw_host, gw_port, gw_user = gateway(options)
+            gateway = Net::SSH::Gateway.new(gw_host, gw_user, {:port => gw_port})
+            begin
+              gateway.ssh(host, options[:ssh][:user], options[:ssh].slice(*Net::SSH::VALID_OPTIONS)) do |ssh|
+                yield ssh
+              end
+            ensure
+              gateway.shutdown!
+            end
+          else
+            Net::SSH.start(host, options[:ssh][:user], options[:ssh].slice(*Net::SSH::VALID_OPTIONS)) do |ssh|
+              yield ssh
+            end
+          end
+        end
+
         def channel_exec(channel, command, host, response)
           channel.exec(command) do |ch, success|
             unless success

data/lib/ridley-connectors/host_connector/winrm.rb

@@ -218,6 +218,23 @@ module Ridley
         run(host, CommandContext::WindowsUpdateOmnibus.command(options), options)
       end
 
+      # Checks to see if the given port is open for TCP connections
+      # on the given host.
+      #
+      # @param [String] host
+      #   the host to attempt to connect to
+      # @option options [Hash] :winrm
+      #   * port (Fixnum) the winrm port to connect to
+      # @option options [Fixnum] :retries
+      #
+      # @return [Boolean]
+      def connector_port_open?(host, options = {})
+        options[:winrm]        ||= Hash.new
+        options[:winrm][:port] ||= HostConnector::WinRM::DEFAULT_PORT
+
+        port_open?(host, options[:winrm][:port], options[:retries])
+      end
+
       private
 
         # @param [String] host

data/lib/ridley-connectors/version.rb

@@ -1,5 +1,5 @@
 module Ridley
   module Connectors
-    VERSION = "2.2.0"
+    VERSION = "2.3.0"
   end
 end

data/ridley-connectors.gemspec

@@ -21,7 +21,8 @@ Gem::Specification.new do |s|
   s.add_dependency 'celluloid-io', '~> 0.16.0.pre'
   s.add_dependency 'erubis'
   s.add_dependency 'net-ssh'
-  s.add_dependency 'ridley',       '~> 3.1'
+  s.add_dependency 'net-ssh-gateway'
+  s.add_dependency 'ridley',       '~> 4.0'
   s.add_dependency 'winrm',        '~> 1.1.0'
 
   s.add_development_dependency 'buff-ruby_engine', '~> 0.1'

data/spec/unit/ridley-connectors/host_commander_spec.rb

@@ -12,8 +12,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a unix node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(false)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(true)
+        subject.send(:winrm).stub(:port_open?).and_return(false)
+        subject.send(:ssh).stub(:port_open?).and_return(true)
       end
 
       it "sends a #run message to the ssh host connector" do
@@ -24,8 +24,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a windows node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(true)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(false)
+        subject.send(:winrm).stub(:port_open?).and_return(true)
+        subject.send(:ssh).stub(:port_open?).and_return(false)
       end
 
       it "sends a #run message to the ssh host connector" do
@@ -43,8 +43,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a unix node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(false)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(true)
+        subject.send(:winrm).stub(:port_open?).and_return(false)
+        subject.send(:ssh).stub(:port_open?).and_return(true)
       end
 
       it "sends a #bootstrap message to the ssh host connector" do
@@ -56,8 +56,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a windows node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(true)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(false)
+        subject.send(:winrm).stub(:port_open?).and_return(true)
+        subject.send(:ssh).stub(:port_open?).and_return(false)
       end
 
       it "sends a #bootstrap message to the winrm host connector" do
@@ -75,8 +75,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a unix node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(false)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(true)
+        subject.send(:winrm).stub(:port_open?).and_return(false)
+        subject.send(:ssh).stub(:port_open?).and_return(true)
       end
 
       it "sends a #chef_client message to the ssh host connector" do
@@ -88,8 +88,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a windows node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(true)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(false)
+        subject.send(:winrm).stub(:port_open?).and_return(true)
+        subject.send(:ssh).stub(:port_open?).and_return(false)
       end
 
       it "sends a #chef_client message to the ssh host connector" do
@@ -108,8 +108,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a unix node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(false)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(true)
+        subject.send(:winrm).stub(:port_open?).and_return(false)
+        subject.send(:ssh).stub(:port_open?).and_return(true)
       end
 
       it "sends a #put_secret message to the ssh host connector" do
@@ -121,8 +121,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a windows node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(true)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(false)
+        subject.send(:winrm).stub(:port_open?).and_return(true)
+        subject.send(:ssh).stub(:port_open?).and_return(false)
       end
 
       it "sends a #put_secret message to the ssh host connector" do
@@ -141,8 +141,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a unix node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(false)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(true)
+        subject.send(:winrm).stub(:port_open?).and_return(false)
+        subject.send(:ssh).stub(:port_open?).and_return(true)
       end
 
       it "sends a #ruby_script message to the ssh host connector" do
@@ -154,8 +154,8 @@ describe Ridley::HostCommander do
 
     context "when communicating to a windows node" do
       before do
-        subject.stub(:connector_port_open?).with(host, options[:winrm][:port], anything, anything).and_return(true)
-        subject.stub(:connector_port_open?).with(host, options[:ssh][:port], anything, anything).and_return(false)
+        subject.send(:winrm).stub(:port_open?).and_return(true)
+        subject.send(:ssh).stub(:port_open?).and_return(false)
       end
 
       it "sends a #ruby_script message to the ssh host connector" do
@@ -171,12 +171,12 @@ describe Ridley::HostCommander do
       { ssh: { port: 22, timeout: 3 }, winrm: { port: 5985, timeout: 3 }, retries: 3 }
     end
 
-    context "when connector_port_open? experiences an error" do
+    context "when port_open? experiences an error" do
       let(:socket) { double(close: true) }
 
       it "executes retry logic" do
         @times_called = 0
-        subject.should_receive(:connectable?).twice.and_return do
+        subject.send(:winrm).should_receive(:connectable?).twice.and_return do
           @times_called += 1
           if @times_called == 1
             raise Errno::ETIMEDOUT
@@ -190,22 +190,14 @@ describe Ridley::HostCommander do
     end
 
     it "should return winrm if winrm is open" do
-      subject.stub(:connector_port_open?).with(host, Ridley::HostConnector::WinRM::DEFAULT_PORT, anything, anything).and_return(true)
-      subject.should_receive(:winrm)
-      subject.connector_for(host)
+      subject.send(:winrm).stub(:port_open?).and_return(true)
+      expect(subject.connector_for(host).class).to eq(Ridley::HostConnector::WinRM)
     end
     
     it "should return ssh if winrm is closed" do
-      subject.stub(:connector_port_open?).with(host, Ridley::HostConnector::WinRM::DEFAULT_PORT, anything, anything).and_return(false)
-      subject.stub(:connector_port_open?).with(host, Ridley::HostConnector::SSH::DEFAULT_PORT, anything, anything).and_return(true)
-      subject.should_receive(:ssh)
-      subject.connector_for(host)
-    end
-
-    it "should still set the default ports if an explicit nil is passed in" do
-      subject.stub(:connector_port_open?).with(host, Ridley::HostConnector::WinRM::DEFAULT_PORT, anything, anything).and_return(true)
-      subject.should_receive(:winrm)
-      subject.connector_for(host, winrm: nil, ssh: nil)
+      subject.send(:winrm).stub(:port_open?).and_return(false)
+      subject.send(:ssh).stub(:port_open?).and_return(true)
+      expect(subject.connector_for(host).class).to eq(Ridley::HostConnector::SSH)
     end
 
     context "when a connector of winrm is given" do
@@ -213,31 +205,28 @@ describe Ridley::HostCommander do
       let(:winrm) { double }
 
       it "should return winrm if winrm is open" do
-        subject.stub(:connector_port_open?).with(host, Ridley::HostConnector::WinRM::DEFAULT_PORT, anything, anything).and_return(true)
-        subject.stub(:winrm).and_return(winrm)
-        expect(subject.connector_for(host, connector_options)).to eql(winrm)
+        subject.send(:winrm).stub(:port_open?).and_return(true)
+        expect(subject.connector_for(host, options).class).to eql(Ridley::HostConnector::WinRM)
       end
 
       it "should return nil if winrm is closed" do
-        subject.stub(:connector_port_open?).with(host, Ridley::HostConnector::WinRM::DEFAULT_PORT, anything, anything).and_return(false)
+        subject.stub(:port_open?).and_return(false)
         expect(subject.connector_for(host, connector_options)).to be_nil
       end
     end
 
     context "when a connector of ssh is given" do
       let(:connector_options) { options.merge(connector: "ssh") }
-      let(:ssh) { double }
 
       it "should return ssh if ssh is open" do
-        subject.stub(:connector_port_open?).with(host, Ridley::HostConnector::SSH::DEFAULT_PORT, anything, anything).and_return(true)
-        subject.stub(:ssh).and_return(ssh)
-        subject.should_not_receive(:connector_port_open?).with(host, Ridley::HostConnector::WinRM::DEFAULT_PORT, anything, anything)
-        expect(subject.connector_for(host, connector_options)).to eql(ssh)
+        subject.send(:ssh).stub(:port_open?).and_return(true)
+        subject.send(:winrm).should_not_receive(:port_open?)
+        expect(subject.connector_for(host, connector_options).class).to eql(Ridley::HostConnector::SSH)
       end
 
       it "should return nil if ssh is closed" do
-        subject.stub(:connector_port_open?).with(host, Ridley::HostConnector::SSH::DEFAULT_PORT, anything, anything).and_return(false)
-        subject.should_not_receive(:connector_port_open?).with(host, Ridley::HostConnector::WinRM::DEFAULT_PORT, anything, anything)
+        subject.send(:ssh).stub(:port_open?).and_return(false)
+        subject.send(:winrm).should_not_receive(:port_open?)
         expect(subject.connector_for(host, connector_options)).to be_nil
       end
     end
@@ -246,87 +235,9 @@ describe Ridley::HostCommander do
       let(:connector_options) { options.merge(connector: "foo") }
 
       it "should try both connectors" do
-        subject.should_receive(:connector_port_open?).twice
+        [:winrm, :ssh].each { |c| subject.send(c).should_receive(:port_open?) }
         subject.connector_for(host, connector_options)
       end
     end
   end
-
-  describe "#connectable?" do
-    let(:port) { 1234 }
-
-    before do
-      Socket
-        .stub(:getaddrinfo)
-        .with(host, nil)
-        .and_return [["AF_INET", 0, "33.33.33.10", "33.33.33.10", 2, 2, 17], 
-                     ["AF_INET", 0, "33.33.33.10", "33.33.33.10", 2, 1,  6]]
-    end
-
-    context "when the target is accessible" do
-      before do
-        calls = 0
-        Socket.any_instance.stub(:connect_nonblock).and_return do
-          calls += 1
-          if calls == 1
-            raise WaitWritableError.new
-          end
-          raise Errno::EISCONN.new
-        end
-      end
-
-      it "should return true when a connection is initiated" do
-        ::IO.stub(:select).and_return ["an array!"]
-        
-        expect(subject.send(:connectable?, host, port)).to be_true
-      end
-
-      it "should return true when a connection is initiated and an explicit nil is passed as the timeout" do
-        ::IO.stub(:select).with(anything, anything, anything, Ridley::HostCommander::PORT_CHECK_TIMEOUT).and_return ["an array!"]
-        
-        expect(subject.send(:connectable?, host, port, nil)).to be_true
-      end
-
-      it "should return false when select times out" do
-        ::IO.stub(:select).and_return nil
-
-        expect(subject.send(:connectable?, host, port)).to be_false
-      end
-
-      it "should return true when the connection does not have to wait" do
-        Socket.any_instance.stub(:connect_nonblock).and_return 0
-        
-        expect(subject.send(:connectable?, host, port)).to be_true
-      end
-    end
-
-    Ridley::HostCommander::CONNECTOR_PORT_ERRORS.each do |error|
-      context "when the target causes #{error}" do
-        before do
-          calls = 0
-          Socket.any_instance.stub(:connect_nonblock).and_return do
-            calls += 1
-            if calls == 1
-              raise WaitWritableError.new
-            end
-            raise error.new
-          end
-
-          ::IO.stub(:select).and_return []
-        end
-
-        context "should return false" do
-          it "" do
-            expect(subject.send(:connectable?, host, port)).to be_false
-          end
-
-          it "when the socket close throws EBAFD" do
-            Socket.any_instance.stub(:close).and_return { raise Errno::EBADF.new }
-
-            expect(subject.send(:connectable?, host, port)).to be_false
-          end
-        end
-      end
-    end
-  end
 end

data/spec/unit/ridley-connectors/host_connector/ssh_spec.rb

@@ -16,6 +16,34 @@ describe Ridley::HostConnector::SSH do
     }
   end
 
+  describe "#run" do
+    let(:ssh_user) { 'ssh_user' }
+
+    context "when a gateway is given" do
+      let(:gw_host) { "bar.com" }
+      let(:gw_user) { "foo" }
+      let(:gw_port) { "1234" }
+      let(:gateway) { double(Net::SSH::Gateway) }
+
+      before do
+        Net::SSH::Gateway.stub(:new).with(gw_host, gw_user, {:port => gw_port}).and_return(gateway)
+      end
+
+      it "should connect to the gateway with Net::SSH::Gateway and then to the destination host via the gateway" do
+        gateway.should_receive(:ssh).with(host, ssh_user, anything).ordered
+        gateway.should_receive(:shutdown!).ordered
+        subject.run(host, "some_command", ssh: { user: ssh_user, gateway: 'foo@bar.com:1234' })
+      end
+    end
+
+    context "when a gateway is not given" do
+      it "should use Net::SSH to connect to the destination host" do
+        Net::SSH.should_receive(:start).with(host, ssh_user, {:paranoid=>false, :port=>"1234", :user=>"ssh_user"})
+        subject.run(host, "some_command", ssh: { user: ssh_user, port: "1234" })
+      end
+    end
+  end
+
   describe "#bootstrap" do
     let(:bootstrap_context) { Ridley::BootstrapContext::Unix.new(options) }
 
@@ -94,4 +122,32 @@ describe Ridley::HostConnector::SSH do
       connector.update_omnibus(host, options)
     end
   end
+
+  describe "#connector_port_open?" do
+    context "when there are no ssh options specified" do
+      it "should try to connect to the host on the defaul ssh port" do
+        subject.should_receive(:port_open?).with(host, Ridley::HostConnector::SSH::DEFAULT_PORT, nil)
+        subject.connector_port_open?(host, {})
+      end
+    end
+
+    context "when the port is specified" do
+      it "should try to connecto to the host on the given port" do
+        subject.should_receive(:port_open?).with(host, 1234, nil)
+        subject.connector_port_open?(host, ssh: {port: 1234} )
+      end
+    end
+
+    context "when the gateway is given" do
+      it "should try to connect to the gateway host" do
+        subject.should_receive(:port_open?).with("bar.com", "1234", nil)
+        subject.connector_port_open?(host, ssh: {gateway: 'foo@bar.com:1234'} )
+      end
+
+      it "should use the timeout from the ssh settings" do
+        subject.should_receive(:port_open?).with("bar.com", "1234", 12)
+        subject.connector_port_open?(host, ssh: {timeout: 12, gateway: 'foo@bar.com:1234'} )
+      end
+    end
+  end
 end

data/spec/unit/ridley-connectors/host_connector/winrm_spec.rb

@@ -180,4 +180,20 @@ describe Ridley::HostConnector::WinRM do
       ruby_script
     end
   end
+
+  describe "#connector_port_open?" do
+    context "when no winrm options are specified" do
+      it "should connect using the default winrm port" do
+        subject.should_receive(:port_open?).with(host, Ridley::HostConnector::WinRM::DEFAULT_PORT, nil)
+        subject.connector_port_open?(host, {})
+      end
+    end
+
+    context "when winrm options are given"  do
+      it "should use the winrm port" do
+        subject.should_receive(:port_open?).with(host, 1234, nil)
+        subject.connector_port_open?(host, winrm: {port: 1234})
+      end
+    end
+  end
 end

data/spec/unit/ridley-connectors/host_connector_spec.rb

@@ -47,4 +47,82 @@ describe Ridley::HostConnector::Base do
       expect { subject.uninstall_chef(host, options) }.to raise_error(RuntimeError)
     end
   end
+
+  describe "#connectable?" do
+    let(:port) { 1234 }
+
+    before do
+      Socket
+        .stub(:getaddrinfo)
+        .with(host, nil)
+        .and_return [["AF_INET", 0, "33.33.33.10", "33.33.33.10", 2, 2, 17], 
+                     ["AF_INET", 0, "33.33.33.10", "33.33.33.10", 2, 1,  6]]
+    end
+
+    context "when the target is accessible" do
+      before do
+        calls = 0
+        Socket.any_instance.stub(:connect_nonblock).and_return do
+          calls += 1
+          if calls == 1
+            raise WaitWritableError.new
+          end
+          raise Errno::EISCONN.new
+        end
+      end
+
+      it "should return true when a connection is initiated" do
+        ::IO.stub(:select).and_return ["an array!"]
+        
+        expect(subject.send(:connectable?, host, port)).to be_true
+      end
+
+      it "should return true when a connection is initiated and an explicit nil is passed as the timeout" do
+        ::IO.stub(:select).with(anything, anything, anything, Ridley::HostConnector::Base::PORT_CHECK_TIMEOUT).and_return ["an array!"]
+        
+        expect(subject.send(:connectable?, host, port, nil)).to be_true
+      end
+
+      it "should return false when select times out" do
+        ::IO.stub(:select).and_return nil
+
+        expect(subject.send(:connectable?, host, port)).to be_false
+      end
+
+      it "should return true when the connection does not have to wait" do
+        Socket.any_instance.stub(:connect_nonblock).and_return 0
+        
+        expect(subject.send(:connectable?, host, port)).to be_true
+      end
+    end
+
+    Ridley::HostConnector::Base::CONNECTOR_PORT_ERRORS.each do |error|
+      context "when the target causes #{error}" do
+        before do
+          calls = 0
+          Socket.any_instance.stub(:connect_nonblock).and_return do
+            calls += 1
+            if calls == 1
+              raise WaitWritableError.new
+            end
+            raise error.new
+          end
+
+          ::IO.stub(:select).and_return []
+        end
+
+        context "should return false" do
+          it "" do
+            expect(subject.send(:connectable?, host, port)).to be_false
+          end
+
+          it "when the socket close throws EBAFD" do
+            Socket.any_instance.stub(:close).and_return { raise Errno::EBADF.new }
+
+            expect(subject.send(:connectable?, host, port)).to be_false
+          end
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ridley-connectors
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Jamie Winsor
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-20 00:00:00.000000000 Z
+date: 2014-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -67,20 +67,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh-gateway
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ridley
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: winrm
   requirement: !ruby/object:Gem::Requirement