hybrid_platforms_conductor 32.6.0 → 32.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6b6259b1f05bb082b4f2c6820f74b6c90dad15f5868a311337429b80d233500
-  data.tar.gz: c5f58e3ba104ba2365addea64ab08c43a4fe9797430c950bf01258eb7bfcdc1b
+  metadata.gz: 34ae09b6107332c4f51418677736cabed358f01c3e5c47ff2f5752f6c597a809
+  data.tar.gz: 99358ffeb3d2f70819c5408c18b5b8d8e5531331da0c96073e5577f02cebcb72
 SHA512:
-  metadata.gz: b079e89a17630ed994614bc24e76ba2154ae52fcaf3712feaaef9e823487d933d6b33b87b3aa253e8d11270d5765d061349c4a37f467e81d729d994ed1f7b72e
-  data.tar.gz: 4a89e197bed2c87dbc10d66d8a3f6240c68deb7c2799962be282634c3c109b653c2a66725baa5ca44e38fd0bf1ec992148720047668c1c7786bd494a8e3836e7
+  metadata.gz: 873851a3e54538b2915df041e9dca3decde7cbfe4f7e8b82ea7102bbe5e75668ef5d7adb828979f4eab8493245f982b3e5da0bb492c116688b9151d10bc979a2
+  data.tar.gz: 72418b66806746d05589f08f773eb065b0811d760e35908410405f1cbd9a6fadc94aa2ec85a83ac7f314f53d6a7ebc6396460894c4f595aee9c9b0ffd65625c0

data/lib/hybrid_platforms_conductor/hpc_plugins/connector/ssh.rb

@@ -233,7 +233,13 @@ module HybridPlatformsConductor
         # Parameters::
         # * *bash_cmds* (String): Bash commands to execute
         def remote_bash(bash_cmds)
-          ssh_cmd = "#{ssh_exec} #{ssh_url} /bin/bash <<'EOF'\n#{bash_cmds}\nEOF"
+          ssh_cmd =
+            if @nodes_handler.get_ssh_session_exec_of(@node) == 'false'
+              # When ExecSession is disabled we need to use stdin directly
+              "{ cat | #{ssh_exec} #{ssh_url} -T; } <<'EOF'\n#{bash_cmds}\nEOF"
+            else
+              "#{ssh_exec} #{ssh_url} /bin/bash <<'EOF'\n#{bash_cmds}\nEOF"
+            end
           # Due to a limitation of Process.spawn, each individual argument is limited to 128KB of size.
           # Therefore we need to make sure that if bash_cmds exceeds MAX_CMD_ARG_LENGTH bytes (considering EOF chars) then we use an intermediary shell script to store the commands.
           if bash_cmds.size > MAX_CMD_ARG_LENGTH
@@ -290,25 +296,30 @@ module HybridPlatformsConductor
         # * *owner* (String or nil): Owner to be used when copying the files, or nil for current one [default: nil]
         # * *group* (String or nil): Group to be used when copying the files, or nil for current one [default: nil]
         def remote_copy(from, to, sudo: false, owner: nil, group: nil)
-          run_cmd <<~EOS
-            cd #{File.dirname(from)} && \
-            tar \
-              --create \
-              --gzip \
-              --file - \
-              #{owner.nil? ? '' : "--owner #{owner}"} \
-              #{group.nil? ? '' : "--group #{group}"} \
-              #{File.basename(from)} | \
-            #{ssh_exec} \
-              #{ssh_url} \
-              \"#{sudo ? "#{@nodes_handler.sudo_on(@node)} " : ''}tar \
-                --extract \
-                --gunzip \
+          if @nodes_handler.get_ssh_session_exec_of(@node) == 'false'
+            # We don't have ExecSession, so don't use ssh, but scp instead.
+            run_cmd "scp -S #{ssh_exec} #{from} #{ssh_url}:#{to}"
+          else
+            run_cmd <<~EOS
+              cd #{File.dirname(from)} && \
+              tar \
+                --create \
+                --gzip \
                 --file - \
-                --directory #{to} \
-                --owner root \
-              \"
-          EOS
+                #{owner.nil? ? '' : "--owner #{owner}"} \
+                #{group.nil? ? '' : "--group #{group}"} \
+                #{File.basename(from)} | \
+              #{ssh_exec} \
+                #{ssh_url} \
+                \"#{sudo ? "#{@nodes_handler.sudo_on(@node)} " : ''}tar \
+                  --extract \
+                  --gunzip \
+                  --file - \
+                  --directory #{to} \
+                  --owner root \
+                \"
+            EOS
+          end
         end
 
         # Get the ssh executable to be used when connecting to the current node
@@ -490,31 +501,45 @@ module HybridPlatformsConductor
                     ssh_url = "hpc.#{node}"
                     if current_users.empty?
                       log_debug "[ ControlMaster - #{ssh_url} ] - Creating SSH ControlMaster..."
-                      # Create the control master
-                      ssh_control_master_start_cmd = "#{ssh_exec}#{@passwords.key?(node) || @auth_password ? '' : ' -o BatchMode=yes'} -o ControlMaster=yes -o ControlPersist=yes #{ssh_url} true"
                       exit_status = nil
-                      idx_try = 0
-                      loop do
-                        stderr = nil
-                        exit_status, _stdout, stderr = @cmd_runner.run_cmd ssh_control_master_start_cmd, log_to_stdout: log_debug?, no_exception: true, timeout: timeout
-                        if exit_status == 0
-                          break
-                        elsif stderr =~ /System is booting up/
-                          if idx_try == MAX_RETRIES_FOR_BOOT
-                            if no_exception
-                              break
-                            else
-                              raise ActionsExecutor::ConnectionError, "Tried #{idx_try} times to create SSH Control Master with #{ssh_control_master_start_cmd} but system says it's booting up."
+                      if @nodes_handler.get_ssh_session_exec_of(node) == 'false'
+                        # Here we have to create a ControlMaster using an interactive session, as the SSH server prohibits ExecSession, and so command executions.
+                        # We'll do that using another terminal spawned in the background.
+                        Thread.new do
+                          log_debug "[ ControlMaster - #{ssh_url} ] - Spawn interactive ControlMaster in separate terminal"
+                          @cmd_runner.run_cmd "xterm -e '#{ssh_exec} -o ControlMaster=yes -o ControlPersist=yes #{ssh_url}'", log_to_stdout: log_debug?
+                          log_debug "[ ControlMaster - #{ssh_url} ] - Separate interactive ControlMaster closed"
+                        end
+                        out 'External ControlMaster has been spawned.'
+                        out 'Please login into it, keep its session opened and press enter here when done...'
+                        $stdin.gets
+                        exit_status = 0
+                      else
+                        # Create the control master
+                        ssh_control_master_start_cmd = "#{ssh_exec}#{@passwords.key?(node) || @auth_password ? '' : ' -o BatchMode=yes'} -o ControlMaster=yes -o ControlPersist=yes #{ssh_url} true"
+                        idx_try = 0
+                        loop do
+                          stderr = nil
+                          exit_status, _stdout, stderr = @cmd_runner.run_cmd ssh_control_master_start_cmd, log_to_stdout: log_debug?, no_exception: true, timeout: timeout
+                          if exit_status == 0
+                            break
+                          elsif stderr =~ /System is booting up/
+                            if idx_try == MAX_RETRIES_FOR_BOOT
+                              if no_exception
+                                break
+                              else
+                                raise ActionsExecutor::ConnectionError, "Tried #{idx_try} times to create SSH Control Master with #{ssh_control_master_start_cmd} but system says it's booting up."
+                              end
                             end
+                            # Wait a bit and try again
+                            idx_try += 1
+                            log_debug "[ ControlMaster - #{ssh_url} ] - System is booting up (try ##{idx_try}). Wait #{WAIT_TIME_FOR_BOOT} seconds before trying ControlMaster's creation again."
+                            sleep WAIT_TIME_FOR_BOOT
+                          elsif no_exception
+                            break
+                          else
+                            raise ActionsExecutor::ConnectionError, "Error while starting SSH Control Master with #{ssh_control_master_start_cmd}: #{stderr.strip}"
                           end
-                          # Wait a bit and try again
-                          idx_try += 1
-                          log_debug "[ ControlMaster - #{ssh_url} ] - System is booting up (try ##{idx_try}). Wait #{WAIT_TIME_FOR_BOOT} seconds before trying ControlMaster's creation again."
-                          sleep WAIT_TIME_FOR_BOOT
-                        elsif no_exception
-                          break
-                        else
-                          raise ActionsExecutor::ConnectionError, "Error while starting SSH Control Master with #{ssh_control_master_start_cmd}: #{stderr.strip}"
                         end
                       end
                       if exit_status == 0

data/lib/hybrid_platforms_conductor/version.rb

@@ -1,5 +1,5 @@
 module HybridPlatformsConductor
 
-  VERSION = '32.6.0'
+  VERSION = '32.7.0'
 
 end

data/spec/hybrid_platforms_conductor_test/api/actions_executor/connectors/ssh/connections_spec.rb

@@ -28,6 +28,22 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'creates an SSH master to 1 node not having Session Exec capabilities' do
+        with_test_platform(nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: 'false' } } }) do
+          with_cmd_runner_mocked(
+            [
+              ['which env', proc { [0, "/usr/bin/env\n", ''] }],
+              ['ssh -V 2>&1', proc { [0, "OpenSSH_7.4p1 Debian-10+deb9u7, OpenSSL 1.0.2u  20 Dec 2019\n", ''] }]
+            ] + ssh_expected_commands_for({ 'node' => { connection: '192.168.42.42', user: 'test_user' } }, with_session_exec: false)
+          ) do
+            test_connector.ssh_user = 'test_user'
+            test_connector.with_connection_to(['node']) do |connected_nodes|
+              expect(connected_nodes).to eq ['node']
+            end
+          end
+        end
+      end
+
       it 'creates SSH master to several nodes' do
         with_test_platform(nodes: {
           'node1' => { meta: { host_ip: '192.168.42.1' } },

data/spec/hybrid_platforms_conductor_test/api/actions_executor/connectors/ssh/remote_actions_spec.rb

@@ -141,6 +141,30 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'executes bash commands remotely without Session Exec capabilities' do
+        with_test_platform_for_remote_testing(
+          expected_cmds: [[/^\{ cat \| .+\/ssh hpc\.node -T; } <<'EOF'\nbash_cmd.bash\nEOF$/, proc { [0, 'Bash commands executed on node', ''] }]],
+          expected_stdout: 'Bash commands executed on node',
+          session_exec: false
+        ) do
+          test_connector.remote_bash('bash_cmd.bash')
+        end
+      end
+
+      it 'copies files remotely without Session Exec capabilities' do
+        with_test_platform_for_remote_testing(
+          expected_cmds: [
+            [
+              /^scp -S .+\/ssh \/path\/to\/src.file hpc\.node:\/remote_path\/to\/dst.dir$/,
+              proc { [0, '', ''] }
+            ]
+          ],
+          session_exec: false
+        ) do
+          test_connector.remote_copy('/path/to/src.file', '/remote_path/to/dst.dir')
+        end
+      end
+
     end
 
   end

data/spec/hybrid_platforms_conductor_test/helpers/cmd_runner_helpers.rb

@@ -14,7 +14,6 @@ module HybridPlatformsConductorTest
       # * *cmd_runner* (CmdRunner): The CmdRunner to mock [default: test_cmd_runner]
       # * Proc: Code called with the command runner mocked
       def with_cmd_runner_mocked(commands, cmd_runner: test_cmd_runner)
-        unexpected_commands = []
         remaining_expected_commands = commands.clone
         # We need to protect the access to this array as the mocked commands can be called by competing threads
         remaining_expected_commands_mutex = Mutex.new
@@ -64,13 +63,10 @@ module HybridPlatformsConductorTest
             log_stderr_to_io << mocked_stderr if !mocked_stderr.empty? && !log_stderr_to_io.nil?
             [mocked_exit_status, mocked_stdout, mocked_stderr]
           else
-            logger.error "[ Mocked CmdRunner ] - !!! Unexpected command run: #{cmd}"
-            unexpected_commands << cmd
-            [:unexpected_command_to_mock, '', "Could not mock unexpected command #{cmd}"]
+            raise "Unexpected command run: #{cmd}"
           end
         end
         yield
-        expect(unexpected_commands).to eq []
         expect(remaining_expected_commands).to eq([]), "Expected CmdRunner commands were not run:\n#{remaining_expected_commands.map(&:first).join("\n")}"
         # Un-mock the command runner
         allow(cmd_runner).to receive(:run_cmd).and_call_original

data/spec/hybrid_platforms_conductor_test/helpers/connector_ssh_helpers.rb

@@ -19,6 +19,7 @@ module HybridPlatformsConductorTest
       # * *with_control_master_destroy* (Boolean): Do we destroy the control master? [default: true]
       # * *with_strict_host_key_checking* (Boolean): Do we use strict host key checking? [default: true]
       # * *with_batch_mode* (Boolean): Do we use BatchMode when creating the control master? [default: true]
+      # * *with_session_exec* (Boolean): Do we use Sessien Exec capabilities when creating the control master? [default: true]
       # Result::
       # * Array< [String or Regexp, Proc] >: The expected commands that should be used, and their corresponding mocked code
       def ssh_expected_commands_for(
@@ -27,7 +28,8 @@ module HybridPlatformsConductorTest
         with_control_master_check: false,
         with_control_master_destroy: true,
         with_strict_host_key_checking: true,
-        with_batch_mode: true
+        with_batch_mode: true,
+        with_session_exec: true
       )
         nodes_connections.map do |node, node_connection_info|
           node_connection_info[:times] = 1 unless node_connection_info.key?(:times)
@@ -44,7 +46,13 @@ module HybridPlatformsConductorTest
           end
           if with_control_master_create
             ssh_commands_per_connection << [
-              /^.+\/ssh #{with_batch_mode ? '-o BatchMode=yes ' : ''}-o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)} true$/,
+              if with_session_exec
+                /^.+\/ssh #{with_batch_mode ? '-o BatchMode=yes ' : ''}-o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)} true$/
+              else
+                # Mock the user hitting enter as the Control MAster will be created in another thread and the main thread waits for user input.
+                expect($stdin).to receive(:gets) { "\n" }
+                /^xterm -e '.+\/ssh -o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)}'$/
+              end,
               proc do
                 control_file = test_actions_executor.connector(:ssh).send(:control_master_file, node_connection_info[:connection], '22', node_connection_info[:user])
                 # Fail if the ControlMaster file already exists, as would SSH do if the file is stalled
@@ -53,6 +61,9 @@ module HybridPlatformsConductorTest
                 elsif node_connection_info[:control_master_create_error].nil?
                   # Really touch a fake control file, as ssh connector checks for its existence
                   File.write(control_file, '')
+                  # If there is no Session Exec, this is done in a separate thread.
+                  # So keep it alive until the user wants to stop it (which is done using an ssh -O exit command).
+                  loop { sleep 0.1 } unless with_session_exec
                   [0, '', '']
                 else
                   [255, '', node_connection_info[:control_master_create_error]]
@@ -97,6 +108,7 @@ module HybridPlatformsConductorTest
       # * *timeout* (Integer or nil): Timeout to prepare the connector for [default: nil]
       # * *password* (String or nil): Password to set for the node, or nil for none [default: nil]
       # * *additional_config* (String): Additional config [default: '']
+      # * *session_exec* (Boolean): Do we mock a node having an SSH connection accepting Session Exec? [default: true]
       # * Proc: Client code to execute testing
       def with_test_platform_for_remote_testing(
         expected_cmds: [],
@@ -104,9 +116,14 @@ module HybridPlatformsConductorTest
         expected_stderr: '',
         timeout: nil,
         password: nil,
-        additional_config: ''
+        additional_config: '',
+        session_exec: true
       )
-        with_test_platform({ nodes: { 'node' => { meta: { host_ip: '192.168.42.42' } } } }, false, additional_config) do
+        with_test_platform(
+          { nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: session_exec ? 'true' : 'false' } } } },
+          false,
+          additional_config
+        ) do
           with_cmd_runner_mocked(
             [
               ['which env', proc { [0, "/usr/bin/env\n", ''] }],
@@ -115,7 +132,8 @@ module HybridPlatformsConductorTest
               (password ? [['sshpass -V', proc { [0, "sshpass 1.06\n", ''] }]] : []) +
               ssh_expected_commands_for(
                 { 'node' => { connection: '192.168.42.42', user: 'test_user' } },
-                with_batch_mode: password.nil?
+                with_batch_mode: password.nil?,
+                with_session_exec: session_exec
               ) +
               expected_cmds
           ) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hybrid_platforms_conductor
 version: !ruby/object:Gem::Version
-  version: 32.6.0
+  version: 32.7.0
 platform: ruby
 authors:
 - Muriel Salvan