sshkit 1.8.1 → 1.9.0.rc1

data/lib/sshkit/backends/connection_pool/cache.rb

@@ -0,0 +1,67 @@
+# A Cache holds connections for a given key. Each connection is stored along
+# with an expiration time so that its idle duration can be measured.
+class SSHKit::Backend::ConnectionPool::Cache
+  def initialize(idle_timeout, closer)
+    @connections = []
+    @connections.extend(MonitorMixin)
+    @idle_timeout = idle_timeout
+    @closer = closer
+  end
+
+  # Remove and return a fresh connection from this Cache. Returns `nil` if
+  # the Cache is empty or if all existing connections have gone stale.
+  def pop
+    connections.synchronize do
+      evict
+      _, connection = connections.pop
+      connection
+    end
+  end
+
+  # Return a connection to this Cache.
+  def push(conn)
+    # No need to cache if the connection has already been closed.
+    return if closed?(conn)
+
+    connections.synchronize do
+      connections.push([Time.now + idle_timeout, conn])
+    end
+  end
+
+  # Close and remove any connections in this Cache that have been idle for
+  # too long.
+  def evict
+    # Peek at the first connection to see if it is still fresh. If so, we can
+    # return right away without needing to use `synchronize`.
+    first_expires_at, _connection = connections.first
+    return if first_expires_at.nil? || fresh?(first_expires_at)
+
+    connections.synchronize do
+      fresh, stale = connections.partition do |expires_at, _|
+        fresh?(expires_at)
+      end
+      connections.replace(fresh)
+      stale.each { |_, conn| closer.call(conn) }
+    end
+  end
+
+  # Close all connections and completely clear the cache.
+  def clear
+    connections.synchronize do
+      connections.map(&:last).each(&closer)
+      connections.clear
+    end
+  end
+
+  private
+
+  attr_reader :connections, :idle_timeout, :closer
+
+  def fresh?(expires_at)
+    expires_at > Time.now
+  end
+
+  def closed?(conn)
+    conn.respond_to?(:closed?) && conn.closed?
+  end
+end

data/lib/sshkit/backends/connection_pool/nil_cache.rb

@@ -0,0 +1,11 @@
+# A cache that holds no connections. Any connection provided to this cache
+# is simply closed.
+SSHKit::Backend::ConnectionPool::NilCache = Struct.new(:closer) do
+  def pop
+    nil
+  end
+
+  def push(conn)
+    closer.call(conn)
+  end
+end

data/lib/sshkit/backends/netssh.rb

@@ -129,19 +129,15 @@ module SSHKit
         end
       end
 
-      def with_ssh
-        host.ssh_options = Netssh.config.ssh_options.merge(host.ssh_options || {})
-        conn = self.class.pool.checkout(
+      def with_ssh(&block)
+        host.ssh_options = self.class.config.ssh_options.merge(host.ssh_options || {})
+        self.class.pool.with(
+          Net::SSH.method(:start),
           String(host.hostname),
           host.username,
           host.netssh_options,
-          &Net::SSH.method(:start)
+          &block
         )
-        begin
-          yield conn.connection
-        ensure
-          self.class.pool.checkin conn
-        end
       end
 
     end

data/lib/sshkit/backends/printer.rb

@@ -10,6 +10,11 @@ module SSHKit
 
       alias :upload! :execute
       alias :download! :execute
+
+      def test(*)
+        super
+        true
+      end
     end
   end
 end

data/lib/sshkit/command.rb

@@ -206,7 +206,11 @@ module SSHKit
     end
 
     def to_s
-      [SSHKit.config.command_map[command.to_sym], *Array(args)].join(' ')
+      if should_map?
+        [SSHKit.config.command_map[command.to_sym], *Array(args)].join(' ')
+      else
+        command.to_s
+      end
     end
 
     private

data/lib/sshkit/command_map.rb

@@ -28,8 +28,6 @@ module SSHKit
 
       def [](command)
         @storage[command] ||= []
-
-        @storage[command]
       end
     end
 

data/lib/sshkit/configuration.rb

@@ -3,7 +3,7 @@ module SSHKit
   class Configuration
 
     attr_accessor :umask, :output_verbosity
-    attr_writer :output, :backend, :default_env
+    attr_writer :output, :backend, :default_env, :default_runner
 
     def output
       @output ||= use_format(:pretty)
@@ -22,6 +22,10 @@ module SSHKit
       @default_env ||= {}
     end
 
+    def default_runner
+      @default_runner ||= :parallel
+    end
+
     def backend
       @backend ||= SSHKit::Backend::Netssh
     end
@@ -78,7 +82,7 @@ module SSHKit
       found = SSHKit::Formatter.constants.find do |const|
         const.to_s.downcase == name
       end
-      fail NameError, 'Unrecognized SSHKit::Formatter "#{symbol}"' if found.nil?
+      fail NameError, %Q{Unrecognized SSHKit::Formatter "#{symbol}"} if found.nil?
       SSHKit::Formatter.const_get(found)
     end
 

data/lib/sshkit/coordinator.rb

@@ -17,7 +17,7 @@ module SSHKit
         when :sequence then Runner::Sequential
         when :groups   then Runner::Group
         else
-          raise RuntimeError, "Don't know how to handle run style #{options[:in].inspect}"
+          options[:in]
         end.new(hosts, options, &block).execute
       else
         Runner::Null.new(hosts, options, &block).execute
@@ -26,13 +26,13 @@ module SSHKit
 
     private
 
-      def default_options
-        { in: :parallel }
-      end
+    def default_options
+      { in: SSHKit.config.default_runner }
+    end
 
-      def resolve_hosts
-        @raw_hosts.collect { |rh| rh.is_a?(Host) ? rh : Host.new(rh) }.uniq
-      end
+    def resolve_hosts
+      @raw_hosts.collect { |rh| rh.is_a?(Host) ? rh : Host.new(rh) }.uniq
+    end
 
   end
 

data/lib/sshkit/dsl.rb

@@ -13,5 +13,3 @@ module SSHKit
   end
 
 end
-
-include SSHKit::DSL

data/lib/sshkit/formatters/abstract.rb

@@ -7,12 +7,13 @@ module SSHKit
     class Abstract
 
       extend Forwardable
-      attr_reader :original_output
+      attr_reader :original_output, :options
       def_delegators :@original_output, :read, :rewind
       def_delegators :@color, :colorize
 
-      def initialize(output)
+      def initialize(output, options={})
         @original_output = output
+        @options = options
         @color = SSHKit::Color.new(output)
       end
 

data/lib/sshkit/formatters/pretty.rb

@@ -23,11 +23,12 @@ module SSHKit
       end
 
       def log_command_data(command, stream_type, stream_data)
-        color = case stream_type
+        color = \
+          case stream_type
           when :stdout then :green
           when :stderr then :red
           else raise "Unrecognised stream_type #{stream_type}, expected :stdout or :stderr"
-        end
+          end
         write_message(Logger::DEBUG, colorize("\t#{stream_data}".chomp, color), command.uuid)
       end
 

data/lib/sshkit/mapping_interaction_handler.rb

@@ -4,7 +4,8 @@ module SSHKit
 
     def initialize(mapping, log_level=nil)
       @log_level = log_level
-      @mapping_proc = case mapping
+      @mapping_proc = \
+        case mapping
         when Hash
           lambda do |server_output|
             first_matching_key_value = mapping.find { |k, _v| k === server_output }
@@ -14,7 +15,7 @@ module SSHKit
           mapping
         else
           raise "Unsupported mapping type: #{mapping.class} - only Hash and Proc mappings are supported"
-      end
+        end
     end
 
     def on_data(_command, stream_name, data, channel)
@@ -44,4 +45,4 @@ module SSHKit
 
   end
 
-end
+end

data/lib/sshkit/runners/parallel.rb

@@ -6,9 +6,8 @@ module SSHKit
 
     class Parallel < Abstract
       def execute
-        threads = []
-        hosts.each do |host|
-          threads << Thread.new(host) do |h|
+        threads = hosts.map do |host|
+          Thread.new(host) do |h|
             begin
               backend(h, &block).run
             rescue StandardError => e
@@ -17,7 +16,7 @@ module SSHKit
             end
           end
         end
-        threads.map(&:join)
+        threads.each(&:join)
       end
     end
 

data/lib/sshkit/version.rb

@@ -1,3 +1,3 @@
 module SSHKit
-  VERSION = "1.8.1"
+  VERSION = "1.9.0.rc1"
 end

data/sshkit.gemspec

@@ -20,9 +20,10 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency('net-ssh',  '>= 2.8.0')
   gem.add_runtime_dependency('net-scp',  '>= 1.1.2')
 
-  gem.add_development_dependency('minitest', ['>= 2.11.3', '< 2.12.0'])
+  gem.add_development_dependency('minitest', '>= 5.0.0')
+  gem.add_development_dependency('minitest-reporters')
   gem.add_development_dependency('rake')
-  gem.add_development_dependency('turn')
+  gem.add_development_dependency('rubocop')
   gem.add_development_dependency('unindent')
   gem.add_development_dependency('mocha')
 end

data/test/functional/backends/test_local.rb

@@ -3,7 +3,7 @@ module SSHKit
 
   module Backend
 
-    class TestLocal < MiniTest::Unit::TestCase
+    class TestLocal < Minitest::Test
 
       def setup
         super

data/test/helper.rb

@@ -1,9 +1,9 @@
 require 'rubygems'
 require 'bundler/setup'
 require 'tempfile'
-require 'minitest/unit'
+require 'minitest/autorun'
+require 'minitest/reporters'
 require 'mocha/setup'
-require 'turn'
 require 'unindent'
 require 'stringio'
 require 'json'
@@ -14,7 +14,7 @@ require 'sshkit'
 
 Dir[File.expand_path('test/support/*.rb')].each { |file| require file }
 
-class UnitTest < MiniTest::Unit::TestCase
+class UnitTest < Minitest::Test
 
   def setup
     SSHKit.reset_configuration!
@@ -27,7 +27,7 @@ class UnitTest < MiniTest::Unit::TestCase
   end
 end
 
-class FunctionalTest < MiniTest::Unit::TestCase
+class FunctionalTest < Minitest::Test
 
   def setup
     unless VagrantWrapper.running?
@@ -78,7 +78,4 @@ end
 #
 # Force colours in Autotest
 #
-Turn.config.ansi = true
-Turn.config.format = :pretty
-
-MiniTest::Unit.autorun
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new

data/test/unit/backends/test_abstract.rb

@@ -77,6 +77,20 @@ module SSHKit
         assert_equal "Some stdout\n     ", output
       end
 
+      def test_within_properly_clears
+        backend = ExampleBackend.new do
+          within 'a' do
+            execute :cat, 'file', :strip => false
+          end
+
+          execute :cat, 'file', :strip => false
+        end
+
+        backend.run
+
+        assert_equal '/usr/bin/env cat file', backend.executed_command.to_command
+      end
+
       def test_background_logs_deprecation_warnings
         deprecation_out = ''
         SSHKit.config.deprecation_output = deprecation_out
@@ -117,6 +131,28 @@ module SSHKit
         end
       end
 
+      def test_current_refers_to_currently_executing_backend
+        backend = nil
+        current = nil
+
+        backend = ExampleBackend.new do
+          backend = self
+          current = SSHKit::Backend.current
+        end
+        backend.run
+
+        assert_equal(backend, current)
+      end
+
+      def test_current_is_nil_outside_of_the_block
+        backend = ExampleBackend.new do
+          # nothing
+        end
+        backend.run
+
+        assert_nil(SSHKit::Backend.current)
+      end
+
       # Use a concrete ExampleBackend rather than a mock for improved assertion granularity
       class ExampleBackend < Abstract
         attr_writer :full_stdout

data/test/unit/backends/test_connection_pool.rb

@@ -32,65 +32,62 @@ module SSHKit
 
       def test_connection_factory_receives_args
         args = %w(a b c)
-        conn = pool.checkout(*args, &echo_args)
+        conn = pool.with(echo_args, *args) { |c| c }
 
-        assert_equal args, conn.connection
+        assert_equal args, conn
       end
 
       def test_connections_are_not_reused_if_not_checked_in
-        conn1 = pool.checkout("conn", &connect)
-        conn2 = pool.checkout("conn", &connect)
+        conn1 = nil
+        conn2 = nil
+
+        pool.with(connect, "conn") do |yielded_conn_1|
+          conn1 = yielded_conn_1
+          conn2 = pool.with(connect, "conn") { |c| c }
+        end
 
         refute_equal conn1, conn2
       end
 
       def test_connections_are_reused_if_checked_in
-        conn1 = pool.checkout("conn", &connect)
-        pool.checkin conn1
-        conn2 = pool.checkout("conn", &connect)
+        conn1 = pool.with(connect, "conn") {}
+        conn2 = pool.with(connect, "conn") {}
 
         assert_equal conn1, conn2
       end
 
       def test_connections_are_reused_across_threads_multiple_times
-        t1 = Thread.new {
-          Thread.current[:conn] = pool.checkout("conn", &connect)
-          pool.checkin Thread.current[:conn]
-        }.join
+        t1 = Thread.new do
+          pool.with(connect, "conn") { |c| c }
+        end
 
-        t2 = Thread.new {
-          Thread.current[:conn] = pool.checkout("conn", &connect)
-          pool.checkin Thread.current[:conn]
-        }.join
+        t2 = Thread.new do
+          pool.with(connect, "conn") { |c| c }
+        end
 
-        t3 = Thread.new {
-          Thread.current[:conn] = pool.checkout("conn", &connect)
-          pool.checkin Thread.current[:conn]
-        }.join
+        t3 = Thread.new do
+          pool.with(connect, "conn") { |c| c }
+        end
 
-        refute_equal t1[:conn], nil
-        assert_equal t1[:conn], t2[:conn]
-        assert_equal t2[:conn], t3[:conn]
+        refute_nil t1.value
+        assert_equal t1.value, t2.value
+        assert_equal t2.value, t3.value
       end
 
-      def test_zero_idle_timeout_disables_reuse
+      def test_zero_idle_timeout_disables_pooling
         pool.idle_timeout = 0
 
-        conn1 = pool.checkout("conn", &connect)
-        pool.checkin conn1
-
-        conn2 = pool.checkout("conn", &connect)
-
+        conn1 = pool.with(connect, "conn") { |c| c }
+        conn2 = pool.with(connect, "conn") { |c| c }
         refute_equal conn1, conn2
       end
 
       def test_expired_connection_is_not_reused
         pool.idle_timeout = 0.1
 
-        conn1 = pool.checkout("conn", &connect)
-        pool.checkin conn1
+        conn1 = pool.with(connect, "conn") { |c| c }
         sleep(pool.idle_timeout)
-        conn2 = pool.checkout("conn", &connect)
+        conn2 = pool.with(connect, "conn") { |c| c }
 
         refute_equal conn1, conn2
       end
@@ -98,43 +95,45 @@ module SSHKit
       def test_expired_connection_is_closed
         pool.idle_timeout = 0.1
         conn1 = mock
-        conn1.expects(:closed?).returns(false)
+        conn1.expects(:closed?).twice.returns(false)
         conn1.expects(:close)
 
-        entry1 = pool.checkout("conn1"){|*args| conn1 }
-        pool.checkin entry1
-        sleep(pool.idle_timeout)
-        pool.checkout("conn2"){|*args| Object.new}
+        pool.with(->(*) { conn1 }, "conn1") {}
+        # Pause to allow the background thread to wake and close the conn
+        sleep(5 + pool.idle_timeout)
       end
 
       def test_closed_connection_is_not_reused
-        conn1 = pool.checkout("conn", &connect_and_close)
-        pool.checkin conn1
-        conn2 = pool.checkout("conn", &connect)
+        conn1 = pool.with(connect_and_close, "conn") { |c| c }
+        conn2 = pool.with(connect, "conn") { |c| c }
 
         refute_equal conn1, conn2
       end
 
       def test_connections_with_different_args_are_not_reused
-        conn1 = pool.checkout("conn1", &connect)
-        pool.checkin conn1
-        conn2 = pool.checkout("conn2", &connect)
+        conn1 = pool.with(connect, "conn1") { |c| c }
+        conn2 = pool.with(connect, "conn2") { |c| c }
 
         refute_equal conn1, conn2
       end
 
       def test_close_connections
         conn1 = mock
-        conn1.expects(:closed?).returns(false)
+        conn1.expects(:closed?).twice.returns(false)
         conn1.expects(:close)
-        entry1 = pool.checkout("conn1"){|*args| conn1 }
-        pool.checkin entry1
-        entry2 = pool.checkout("conn2", &connect)
-        # entry2 isn't closed if close_connections is called
 
-        pool.close_connections
-      end
+        conn2 = mock
+        conn2.expects(:closed?).returns(false)
+        conn2.expects(:close).never
+
+        pool.with(->(*) { conn1 }, "conn1") {}
 
+        # We are using conn2 when close_connections is called, so it should
+        # not be closed.
+        pool.with(->(*) { conn2 }, "conn2") do
+          pool.close_connections
+        end
+      end
     end
   end
 end