Merge pull request #3721 from ytti/feat/3597-refactor-ssh-scp

Refactor input/ssh and input/scp into SSHBase

Author: robertcheramy

CHANGELOG.md

@@ -12,6 +12,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Changed
 - Refactored models: Use `keep_lines` and `reject_lines` in aosw, arubainstant, asa, efos, firelinuxos, fsos, ironware, mlnxos and perle to (@robertcheramy)
+- Refactor SSH and SCP into a common class SSHBase. Fixes #3597 (@robertcheramy)
+- SSH#disconnect directly calls @ssh.close, as #close waits for the channels to be closed anyway. This might have side effects, please open an issue if you observe a regression. (@robertcheramy)
 - Modified models to support store mode on significant changes: ios, fortios, perle (@robertcheramy)
 
 ### Fixed

lib/oxidized/input/exec.rb

@@ -1,9 +1,5 @@
 module Oxidized
-  require "oxidized/input/cli"
-
   class Exec < Input
-    include Input::CLI
-
     def connect(node)
       @node = node
       @log = File.open(Oxidized::Config::LOG + "/#{@node.ip}-exec", "w") if Oxidized.config.input.debug?

lib/oxidized/input/ftp.rb

@@ -1,20 +1,7 @@
 module Oxidized
   require 'net/ftp'
   require 'timeout'
-  require_relative 'cli'
-
   class FTP < Input
-    RESCUE_FAIL = {
-      debug: [
-        # Net::SSH::Disconnect,
-      ],
-      warn:  [
-        # RuntimeError,
-        # Net::SSH::AuthenticationFailed,
-      ]
-    }.freeze
-    include Input::CLI
-
     def connect(node) # rubocop:disable Naming/PredicateMethod
       @node = node
       @node.model.cfg['ftp'].each { |cb| instance_exec(&cb) }

lib/oxidized/input/http.rb

@@ -1,12 +1,9 @@
 module Oxidized
-  require "oxidized/input/cli"
   require "net/http"
   require "json"
   require "net/http/digest_auth"
 
   class HTTP < Input
-    include Input::CLI
-
     def connect(node)
       @node = node
       @secure = false

lib/oxidized/input/input.rb

@@ -1,24 +1,28 @@
+require_relative 'cli'
+
 module Oxidized
   class PromptUndetect < OxidizedError; end
 
   class Input
     include SemanticLogger::Loggable
     include Oxidized::Config::Vars
+    include Oxidized::Input::CLI
 
     RESCUE_FAIL = {
-      debug: [
-        Errno::ECONNREFUSED
-      ],
-      warn:  [
-        IOError,
-        PromptUndetect,
-        Timeout::Error,
-        Errno::ECONNRESET,
-        Errno::EHOSTUNREACH,
-        Errno::ENETUNREACH,
-        Errno::EPIPE,
-        Errno::ETIMEDOUT
-      ]
+      Errno::ECONNREFUSED => :debug,
+      IOError             => :warn,
+      PromptUndetect      => :warn,
+      Timeout::Error      => :warn,
+      Errno::ECONNRESET   => :warn,
+      Errno::EHOSTUNREACH => :warn,
+      Errno::ENETUNREACH  => :warn,
+      Errno::EPIPE        => :warn,
+      Errno::ETIMEDOUT    => :warn
     }.freeze
+
+    # Returns a hash mapping exception classes to their log level
+    def self.rescue_fail
+      RESCUE_FAIL.dup
+    end
   end
 end

lib/oxidized/input/scp.rb

@@ -2,53 +2,15 @@ module Oxidized
   require 'net/ssh'
   require 'net/scp'
   require 'timeout'
-  require_relative 'cli'
+  require_relative 'sshbase'
 
-  class SCP < Input
+  class SCP < SSHBase
     RESCUE_FAIL = {
-      debug: [
-        Net::SSH::Disconnect,
-        Net::SSH::ConnectionTimeout
-      ],
-      warn:  [
-        Net::SCP::Error,
-        Net::SSH::HostKeyUnknown,
-        Net::SSH::AuthenticationFailed,
-        Timeout::Error
-      ]
+      Net::SCP::Error => :warn
     }.freeze
-    include Input::CLI
 
-    def connect(node) # rubocop:disable Naming/PredicateMethod
-      @node = node
-      @node.model.cfg['scp'].each { |cb| instance_exec(&cb) }
-      @log = File.open(Oxidized::Config::LOG + "/#{@node.ip}-scp", 'w') if Oxidized.config.input.debug?
-      @ssh = Net::SSH.start(@node.ip, @node.auth[:username], make_ssh_opts)
-      connected?
-    end
-
-    def make_ssh_opts
-      secure = Oxidized.config.input.scp.secure?
-      ssh_opts = {
-        number_of_password_prompts:      0,
-        verify_host_key:                 secure ? :always : :never,
-        append_all_supported_algorithms: true,
-        password:                        @node.auth[:password],
-        timeout:                         @node.timeout,
-        port:                            (vars(:ssh_port) || 22).to_i,
-        forward_agent:                   false
-      }
-
-      # Use our logger for Net::SSH
-      ssh_logger = SemanticLogger[Net::SSH]
-      ssh_logger.level = Oxidized.config.input.debug? ? :debug : :fatal
-      ssh_opts[:logger] = ssh_logger
-
-      ssh_opts
-    end
-
-    def connected?
-      @ssh && (not @ssh.closed?)
+    def self.rescue_fail
+      super.merge(RESCUE_FAIL)
     end
 
     def cmd(file)
@@ -57,25 +19,5 @@ def cmd(file)
         @ssh.scp.download!(file)
       end
     end
-
-    def send(my_proc)
-      my_proc.call
-    end
-
-    def output
-      ""
-    end
-
-    private
-
-    def disconnect
-      Timeout.timeout(@node.timeout) do
-        @ssh.close
-      end
-    rescue Timeout::Error
-      logger.debug "#{@node.name} timed out while disconnecting"
-    ensure
-      @log.close if Oxidized.config.input.debug?
-    end
   end
 end

lib/oxidized/input/ssh.rb

@@ -2,20 +2,18 @@ module Oxidized
   require 'net/ssh'
   require 'net/ssh/proxy/command'
   require 'timeout'
-  require 'oxidized/input/cli'
-  class SSH < Input
+  require_relative 'sshbase'
+
+  class SSH < SSHBase
+    class NoShell < OxidizedError; end
+
     RESCUE_FAIL = {
-      debug: [
-        Net::SSH::Disconnect
-      ],
-      warn:  [
-        RuntimeError,
-        Net::SSH::AuthenticationFailed
-      ]
+      RuntimeError => :warn
     }.freeze
-    include Input::CLI
 
-    class NoShell < OxidizedError; end
+    def self.rescue_fail
+      super.merge(RESCUE_FAIL)
+    end
 
     def connect(node) # rubocop:disable Naming/PredicateMethod
       @node        = node
@@ -41,10 +39,6 @@ def connect(node) # rubocop:disable Naming/PredicateMethod
       connected?
     end
 
-    def connected?
-      @ssh && (not @ssh.closed?)
-    end
-
     def cmd(cmd, expect = node.prompt)
       logger.debug "Sending '#{cmd.dump}' @ #{node.name} with expect: #{expect.inspect}"
       if Oxidized.config.input.debug?
@@ -76,20 +70,6 @@ def pty_options(hash)
 
     private
 
-    def disconnect
-      disconnect_cli
-      # if disconnect does not disconnect us, give up after timeout
-      Timeout.timeout(@node.timeout) { @ssh.loop }
-    rescue Errno::ECONNRESET, Net::SSH::Disconnect, IOError => e
-      logger.debug 'The other side closed the connection while ' \
-                   "disconnecting, raising #{e.class} with #{e.message}"
-    rescue Timeout::Error
-      logger.debug "#{@node.name} timed out while disconnecting"
-    ensure
-      @log.close if Oxidized.config.input.debug?
-      (@ssh.close rescue true) unless @ssh.closed? # rubocop:disable Style/RedundantParentheses
-    end
-
     def shell_open(ssh)
       @ses = ssh.open_channel do |ch|
         ch.on_data do |_ch, data|
@@ -137,48 +117,5 @@ def expect(*regexps)
         end
       end
     end
-
-    def make_ssh_opts
-      secure = Oxidized.config.input.ssh.secure?
-      ssh_opts = {
-        number_of_password_prompts:      0,
-        keepalive:                       vars(:ssh_no_keepalive) ? false : true,
-        verify_host_key:                 secure ? :always : :never,
-        append_all_supported_algorithms: true,
-        password:                        @node.auth[:password],
-        timeout:                         @node.timeout,
-        port:                            (vars(:ssh_port) || 22).to_i,
-        forward_agent:                   false
-      }
-
-      auth_methods = vars(:auth_methods) || %w[none publickey password]
-      ssh_opts[:auth_methods] = auth_methods
-      logger.debug "AUTH METHODS::#{auth_methods}"
-
-      ssh_opts[:proxy] = make_ssh_proxy_command(vars(:ssh_proxy), vars(:ssh_proxy_port), secure) if vars(:ssh_proxy)
-
-      ssh_opts[:keys]       = [vars(:ssh_keys)].flatten           if vars(:ssh_keys)
-      ssh_opts[:kex]        = vars(:ssh_kex).split(/,\s*/)        if vars(:ssh_kex)
-      ssh_opts[:encryption] = vars(:ssh_encryption).split(/,\s*/) if vars(:ssh_encryption)
-      ssh_opts[:host_key]   = vars(:ssh_host_key).split(/,\s*/)   if vars(:ssh_host_key)
-      ssh_opts[:hmac]       = vars(:ssh_hmac).split(/,\s*/)       if vars(:ssh_hmac)
-
-      # Use our logger for Net::SSH
-      ssh_logger = SemanticLogger[Net::SSH]
-      ssh_logger.level = Oxidized.config.input.debug? ? :debug : :fatal
-      ssh_opts[:logger] = ssh_logger
-
-      ssh_opts
-    end
-
-    def make_ssh_proxy_command(proxy_host, proxy_port, secure)
-      return nil unless !proxy_host.nil? && !proxy_host.empty?
-
-      proxy_command =  "ssh "
-      proxy_command += "-o StrictHostKeyChecking=no " unless secure
-      proxy_command += "-p #{proxy_port} "            if proxy_port
-      proxy_command += "#{proxy_host} -W [%h]:%p"
-      Net::SSH::Proxy::Command.new(proxy_command)
-    end
   end
 end