sshkit 1.7.1 → 1.8.0

data/lib/sshkit/backends/connection_pool.rb

@@ -1,5 +1,19 @@
 require "thread"
 
+# Since we call to_s on new_connection_args and use that as a hash
+# We need to make sure the memory address of the object is not used as part of the key
+# Otherwise identical objects with different memory address won't get a hash hit.
+# In the case of proxy commands, this can lead to proxy processes leaking
+# And in severe cases can cause deploys to fail due to default file descriptor limits
+# An alternate solution would be to use a different means of generating hash keys
+module Net; module SSH; module Proxy
+  class Command
+    def inspect
+      @command_line_template
+    end
+  end
+end;end;end
+
 module SSHKit
 
   module Backend
@@ -15,18 +29,34 @@ module SSHKit
       end
 
       def checkout(*new_connection_args, &block)
-        # Optimization: completely bypass the pool if idle_timeout is zero.
+        entry = nil
         key = new_connection_args.to_s
-        return create_new_entry(new_connection_args, key, &block) if idle_timeout == 0
-
-        find_live_entry(key) || create_new_entry(new_connection_args, key, &block)
+        if idle_timeout
+          prune_expired
+          entry = find_live_entry(key)
+        end
+        entry || create_new_entry(new_connection_args, key, &block)
       end
 
       def checkin(entry)
-        entry.expires_at = Time.now + idle_timeout if idle_timeout
+        if idle_timeout
+          prune_expired
+          entry.expires_at = Time.now + idle_timeout
+          @mutex.synchronize do
+            @pool[entry.key] ||= []
+            @pool[entry.key] << entry
+          end
+        end
+      end
+
+      def close_connections
         @mutex.synchronize do
-          @pool[entry.key] ||= []
-          @pool[entry.key] << entry
+          @pool.values.flatten.map(&:connection).uniq.each do |conn|
+            if conn.respond_to?(:closed?) && conn.respond_to?(:close)
+              conn.close unless conn.closed?
+            end
+          end
+          @pool.clear
         end
       end
 
@@ -36,10 +66,25 @@ module SSHKit
 
       private
 
+      def prune_expired
+        @mutex.synchronize do
+          @pool.each_value do |entries|
+            entries.collect! do |entry|
+              if entry.expired?
+                entry.close unless entry.closed?
+                nil
+              else
+                entry
+              end
+            end.compact!
+          end
+        end
+      end
+
       def find_live_entry(key)
         @mutex.synchronize do
           return nil unless @pool.key?(key)
-          while entry = @pool[key].shift
+          while (entry = @pool[key].shift)
             return entry if entry.live?
           end
         end
@@ -61,6 +106,10 @@ module SSHKit
           expires_at && Time.now > expires_at
         end
 
+        def close
+          connection.respond_to?(:close) && connection.close
+        end
+
         def closed?
           connection.respond_to?(:closed?) && connection.closed?
         end

data/lib/sshkit/backends/local.rb

@@ -4,35 +4,14 @@ module SSHKit
 
   module Backend
 
-    class Local < Printer
+    class Local < Abstract
 
       def initialize(_ = nil, &block)
         @host = Host.new(:local) # just for logging
         @block = block
       end
 
-      def run
-        instance_exec(@host, &@block)
-      end
-
-      def test(*args)
-        options = args.extract_options!.merge(
-          raise_on_non_zero_exit: false,
-          verbosity: Logger::DEBUG
-        )
-        _execute(*[*args, options]).success?
-      end
-
-      def execute(*args)
-        _execute(*args).success?
-      end
-
-      def capture(*args)
-        options = { verbosity: Logger::DEBUG }.merge(args.extract_options!)
-        _execute(*[*args, options]).full_stdout
-      end
-
-      def upload!(local, remote, options = {})
+      def upload!(local, remote, _options = {})
         if local.is_a?(String)
           FileUtils.cp(local, remote)
         else
@@ -42,7 +21,7 @@ module SSHKit
         end
       end
 
-      def download!(remote, local=nil, options = {})
+      def download!(remote, local=nil, _options = {})
         if local.nil?
           FileUtils.cp(remote, File.basename(remote))
         else
@@ -54,40 +33,32 @@ module SSHKit
 
       private
 
-      def _execute(*args)
-        command(*args).tap do |cmd|
-          output << cmd
-
-          cmd.started = Time.now
+      def execute_command(cmd)
+        output.log_command_start(cmd)
 
-          Open3.popen3(cmd.to_command) do |stdin, stdout, stderr, wait_thr|
-            stdout_thread = Thread.new do
-              while line = stdout.gets do
-                cmd.stdout = line
-                cmd.full_stdout += line
+        cmd.started = Time.now
 
-                output << cmd
-              end
+        Open3.popen3(cmd.to_command) do |stdin, stdout, stderr, wait_thr|
+          stdout_thread = Thread.new do
+            while (line = stdout.gets) do
+              cmd.on_stdout(stdin, line)
+              output.log_command_data(cmd, :stdout, line)
             end
+          end
 
-            stderr_thread = Thread.new do
-              while line = stderr.gets do
-                cmd.stderr = line
-                cmd.full_stderr += line
-
-                output << cmd
-              end
+          stderr_thread = Thread.new do
+            while (line = stderr.gets) do
+              cmd.on_stderr(stdin, line)
+              output.log_command_data(cmd, :stderr, line)
             end
+          end
 
-            stdout_thread.join
-            stderr_thread.join
+          stdout_thread.join
+          stderr_thread.join
 
-            cmd.exit_status = wait_thr.value.to_i
-            cmd.stdout = ''
-            cmd.stderr = ''
+          cmd.exit_status = wait_thr.value.to_i
 
-            output << cmd
-          end
+          output.log_command_exit(cmd)
         end
       end
 

data/lib/sshkit/backends/netssh.rb

@@ -15,29 +15,9 @@ end
 
 module SSHKit
 
-  class Logger
-
-    class Net::SSH::LogLevelShim
-      attr_reader :output
-      def initialize(output)
-        @output = output
-      end
-      def debug(args)
-        output << LogMessage.new(Logger::TRACE, args)
-      end
-      def error(args)
-        output << LogMessage.new(Logger::ERROR, args)
-      end
-      def lwarn(args)
-        output << LogMessage.new(Logger::WARN, args)
-      end
-    end
-
-  end
-
   module Backend
 
-    class Netssh < Printer
+    class Netssh < Abstract
 
       class Configuration
         attr_accessor :connection_timeout, :pty
@@ -48,35 +28,6 @@ module SSHKit
         end
       end
 
-      include SSHKit::CommandHelper
-
-      def run
-        instance_exec(host, &@block)
-      end
-
-      def test(*args)
-        options = args.extract_options!.merge(
-          raise_on_non_zero_exit: false,
-          verbosity: Logger::DEBUG
-        )
-        _execute(*[*args, options]).success?
-      end
-
-      def execute(*args)
-        _execute(*args).success?
-      end
-
-      def background(*args)
-        warn "[Deprecated] The background method is deprecated. Blame badly behaved pseudo-daemons!"
-        options = args.extract_options!.merge(run_in_background: true)
-        _execute(*[*args, options]).success?
-      end
-
-      def capture(*args)
-        options = { verbosity: Logger::DEBUG }.merge(args.extract_options!)
-        _execute(*[*args, options]).full_stdout.strip
-      end
-
       def upload!(local, remote, options = {})
         summarizer = transfer_summarizer('Uploading')
         with_ssh do |ssh|
@@ -110,7 +61,7 @@ module SSHKit
       def transfer_summarizer(action)
         last_name = nil
         last_percentage = nil
-        proc do |ch, name, transferred, total|
+        proc do |_ch, name, transferred, total|
           percentage = (transferred.to_f * 100 / total.to_f)
           unless percentage.nan?
             message = "#{action} #{name} #{percentage.round(2)}%"
@@ -129,56 +80,52 @@ module SSHKit
         end
       end
 
-      def _execute(*args)
-        command(*args).tap do |cmd|
-          output << cmd
-          cmd.started = true
-          exit_status = nil
-          with_ssh do |ssh|
-            ssh.open_channel do |chan|
-              chan.request_pty if Netssh.config.pty
-              chan.exec cmd.to_command do |ch, success|
-                chan.on_data do |ch, data|
-                  cmd.stdout = data
-                  cmd.full_stdout += data
-                  output << cmd
-                end
-                chan.on_extended_data do |ch, type, data|
-                  cmd.stderr = data
-                  cmd.full_stderr += data
-                  output << cmd
-                end
-                chan.on_request("exit-status") do |ch, data|
-                  exit_status = data.read_long
-                end
-                #chan.on_request("exit-signal") do |ch, data|
-                #  # TODO: This gets called if the program is killed by a signal
-                #  # might also be a worthwhile thing to report
-                #  exit_signal = data.read_string.to_i
-                #  warn ">>> " + exit_signal.inspect
-                #  output << cmd
-                #end
-                chan.on_open_failed do |ch|
-                  # TODO: What do do here?
-                  # I think we should raise something
-                end
-                chan.on_process do |ch|
-                  # TODO: I don't know if this is useful
-                end
-                chan.on_eof do |ch|
-                  # TODO: chan sends EOF before the exit status has been
-                  # writtend
-                end
+      def execute_command(cmd)
+        output.log_command_start(cmd)
+        cmd.started = true
+        exit_status = nil
+        with_ssh do |ssh|
+          ssh.open_channel do |chan|
+            chan.request_pty if Netssh.config.pty
+            chan.exec cmd.to_command do |_ch, _success|
+              chan.on_data do |ch, data|
+                cmd.on_stdout(ch, data)
+                output.log_command_data(cmd, :stdout, data)
+              end
+              chan.on_extended_data do |ch, _type, data|
+                cmd.on_stderr(ch, data)
+                output.log_command_data(cmd, :stderr, data)
+              end
+              chan.on_request("exit-status") do |_ch, data|
+                exit_status = data.read_long
+              end
+              #chan.on_request("exit-signal") do |ch, data|
+              #  # TODO: This gets called if the program is killed by a signal
+              #  # might also be a worthwhile thing to report
+              #  exit_signal = data.read_string.to_i
+              #  warn ">>> " + exit_signal.inspect
+              #  output.log_command_killed(cmd, exit_signal)
+              #end
+              chan.on_open_failed do |_ch|
+                # TODO: What do do here?
+                # I think we should raise something
+              end
+              chan.on_process do |_ch|
+                # TODO: I don't know if this is useful
+              end
+              chan.on_eof do |_ch|
+                # TODO: chan sends EOF before the exit status has been
+                # writtend
               end
-              chan.wait
             end
-            ssh.loop
-          end
-          # Set exit_status and log the result upon completion
-          if exit_status
-            cmd.exit_status = exit_status
-            output << cmd
+            chan.wait
           end
+          ssh.loop
+        end
+        # Set exit_status and log the result upon completion
+        if exit_status
+          cmd.exit_status = exit_status
+          output.log_command_exit(cmd)
         end
       end
 

data/lib/sshkit/backends/printer.rb

@@ -1,35 +1,15 @@
 module SSHKit
   module Backend
 
+    # Printer is used to implement --dry-run in Capistrano
     class Printer < Abstract
 
-      include SSHKit::CommandHelper
-
-      def run
-        instance_exec(host, &@block)
+      def execute_command(cmd)
+        output.log_command_start(cmd)
       end
 
-      def execute(*args)
-        command(*args).tap do |cmd|
-          output << cmd
-        end
-      end
       alias :upload! :execute
       alias :download! :execute
-      alias :test :execute
-
-      def capture(*args)
-        String.new.tap { execute(*args) }
-      end
-      alias :capture! :capture
-
-
-      private
-
-      def output
-        SSHKit.config.output
-      end
-
     end
   end
 end

data/lib/sshkit/backends/skipper.rb

@@ -1,30 +1,26 @@
 module SSHKit
   module Backend
 
-    class Skipper < Printer
+    class Skipper < Abstract
 
       def initialize(&block)
         @block = block
       end
 
-      def execute(*args)
-        command(*args).tap do |cmd|
-          warn "[SKIPPING] No Matching Host for #{cmd}"
-        end
+      def execute_command(cmd)
+        warn "[SKIPPING] No Matching Host for #{cmd}"
       end
       alias :upload! :execute
       alias :download! :execute
       alias :test :execute
-      alias :invoke :execute
 
-      def info(messages)
+      def info(_messages)
         # suppress all messages except `warn`
       end
       alias :log :info
       alias :fatal :info
       alias :error :info
       alias :debug :info
-      alias :trace :info
 
     end
   end