hybrid_platforms_conductor 32.7.0 → 32.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34ae09b6107332c4f51418677736cabed358f01c3e5c47ff2f5752f6c597a809
-  data.tar.gz: 99358ffeb3d2f70819c5408c18b5b8d8e5531331da0c96073e5577f02cebcb72
+  metadata.gz: 04d2e323c123bfaa35c0fb61f95dcc7a9ade67b19f184eff75c61419e249ac8e
+  data.tar.gz: 25afb265a466103db73b891c62ec9a9ee32e5529bf8d9f0df71df379bab5ec7a
 SHA512:
-  metadata.gz: 873851a3e54538b2915df041e9dca3decde7cbfe4f7e8b82ea7102bbe5e75668ef5d7adb828979f4eab8493245f982b3e5da0bb492c116688b9151d10bc979a2
-  data.tar.gz: 72418b66806746d05589f08f773eb065b0811d760e35908410405f1cbd9a6fadc94aa2ec85a83ac7f314f53d6a7ebc6396460894c4f595aee9c9b0ffd65625c0
+  metadata.gz: d8112983393928123c7f8f35395506c4ec5e401e84577e3ab1e24380ab0cd92affd90b6be0cb75645314d06cc8350cd8c478e1d1b9e3c600143296bdec73af47
+  data.tar.gz: 6177c45b5489b077ee2d3e6d7535d6c07e94715c755c282ea8dc424e54d35ac1603c4be9d2e2d9b4cbfc4f450463c792a3e449f6dbbc5eb6bba4a0161c695c65

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

@@ -574,28 +574,33 @@ module HybridPlatformsConductor
                     end
                   end
                 end
+              else
+                # We have not created any ControlMaster, but still consider the nodes to be ready to connect
+                user_locks = Hash[nodes.map { |node| [node, nil]} ]
               end
               yield user_locks.keys
             ensure
-              user_locks_mutex.synchronize do
-                user_locks.each do |node, user_id|
-                  with_lock_on_control_master_for(node, user_id: user_id) do |current_users, user_id|
-                    ssh_url = "hpc.#{node}"
-                    log_warn "[ ControlMaster - #{ssh_url} ] - Current process/thread was not part of the ControlMaster users anymore whereas it should have been" unless current_users.include?(user_id)
-                    remaining_users = current_users - [user_id]
-                    if remaining_users.empty?
-                      # Stop the ControlMaster
-                      log_debug "[ ControlMaster - #{ssh_url} ] - Stopping ControlMaster..."
-                      # Dumb verbose ssh! Tricky trick to just silence what is useless.
-                      # Don't fail if the connection close fails (but still log the error), as it can be seen as only a warning: it means the connection was closed anyway.
-                      @cmd_runner.run_cmd "#{ssh_exec_for(node)} -O exit #{ssh_url} 2>&1 | grep -v 'Exit request sent.'", log_to_stdout: log_debug?, expected_code: 1, timeout: timeout, no_exception: true
-                      log_debug "[ ControlMaster - #{ssh_url} ] - ControlMaster stopped"
-                      # Uncomment if you want to test that the connection has been closed
-                      # @cmd_runner.run_cmd "#{ssh_exec_for(node)} -O check #{ssh_url}", log_to_stdout: log_debug?, expected_code: 255, timeout: timeout
-                    else
-                      log_debug "[ ControlMaster - #{ssh_url} ] - Leaving ControlMaster started as #{remaining_users.size} processes/threads are still using it."
+              if @ssh_use_control_master
+                user_locks_mutex.synchronize do
+                  user_locks.each do |node, user_id|
+                    with_lock_on_control_master_for(node, user_id: user_id) do |current_users, user_id|
+                      ssh_url = "hpc.#{node}"
+                      log_warn "[ ControlMaster - #{ssh_url} ] - Current process/thread was not part of the ControlMaster users anymore whereas it should have been" unless current_users.include?(user_id)
+                      remaining_users = current_users - [user_id]
+                      if remaining_users.empty?
+                        # Stop the ControlMaster
+                        log_debug "[ ControlMaster - #{ssh_url} ] - Stopping ControlMaster..."
+                        # Dumb verbose ssh! Tricky trick to just silence what is useless.
+                        # Don't fail if the connection close fails (but still log the error), as it can be seen as only a warning: it means the connection was closed anyway.
+                        @cmd_runner.run_cmd "#{ssh_exec_for(node)} -O exit #{ssh_url} 2>&1 | grep -v 'Exit request sent.'", log_to_stdout: log_debug?, expected_code: 1, timeout: timeout, no_exception: true
+                        log_debug "[ ControlMaster - #{ssh_url} ] - ControlMaster stopped"
+                        # Uncomment if you want to test that the connection has been closed
+                        # @cmd_runner.run_cmd "#{ssh_exec_for(node)} -O check #{ssh_url}", log_to_stdout: log_debug?, expected_code: 255, timeout: timeout
+                      else
+                        log_debug "[ ControlMaster - #{ssh_url} ] - Leaving ControlMaster started as #{remaining_users.size} processes/threads are still using it."
+                      end
+                      false
                     end
-                    false
                   end
                 end
               end

data/lib/hybrid_platforms_conductor/version.rb

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

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

@@ -118,8 +118,12 @@ describe HybridPlatformsConductor::ActionsExecutor do
               ['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(
-              'node1' => { connection: '192.168.42.1', user: 'test_user' },
-              'node3' => { connection: '192.168.42.3', user: 'test_user' }
+              {
+                'node1' => { connection: '192.168.42.1', user: 'test_user' },
+                'node3' => { connection: '192.168.42.3', user: 'test_user' }
+              },
+              # Here the threads for node1's and node3's ControlMasters might not trigger before the one for node2, so they will not destroy it.
+              with_control_master_destroy_optional: true
             ) + ssh_expected_commands_for(
               {
                 'node2' => { connection: '192.168.42.2', user: 'test_user', control_master_create_error: 'Can\'t connect to 192.168.42.2' }
@@ -294,7 +298,8 @@ describe HybridPlatformsConductor::ActionsExecutor do
           ) do
             test_connector.ssh_use_control_master = false
             test_connector.ssh_user = 'test_user'
-            test_connector.with_connection_to(['node']) do
+            test_connector.with_connection_to(['node']) do |connected_nodes|
+              expect(connected_nodes).to eq %w[node]
             end
           end
         end

data/spec/hybrid_platforms_conductor_test/executables/options/common_spec.rb

@@ -50,7 +50,8 @@ describe 'executables\' common options' do
         with_test_platform_for_common_options do
           exit_code, stdout, stderr = run executable, *(['--debug'] + default_options)
           expect(exit_code).to eq 0
-          expect(stderr).to eq ''
+          # Make sure to ignore the deployment markers from stderr.
+          expect(stderr.gsub("===== [ node1 / node1_service ] - HPC Service Check ===== Begin\n===== [ node1 / node1_service ] - HPC Service Check ===== End\n", '')).to eq ''
         end
       end
 

data/spec/hybrid_platforms_conductor_test/helpers/cmd_runner_helpers.rb

@@ -8,13 +8,27 @@ module HybridPlatformsConductorTest
       # Run expectations on the expected commands to be called.
       #
       # Parameters::
-      # * *commands* (Array< [String or Regexp, Proc] >): Expected commands that should be called on CmdRunner: the command name or regexp and the corresponding mocked code
-      #   * Parameters::
-      #     * Same parameters as CmdRunner@run_cmd
+      # * *commands* (Array<Array>): List of expected commands that should be called on CmdRunner. Each specification is a list containing those items:
+      #   * *0* (String or Regexp): The command name or regexp matching the command name
+      #   * *1* (Proc): The mocking code to be called in place of the real command:
+      #     * Parameters::
+      #       * Same parameters as CmdRunner@run_cmd
+      #     * Result::
+      #       * Same results as CmdRunner@run_cmd
+      #   * *2* (Hash): Optional hash of options. Can be ommited. [default = {}]
+      #     * *optional* (Boolean): If true then don't fail if the command to be mocked has not been called [default: false]
       # * *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)
-        remaining_expected_commands = commands.clone
+        remaining_expected_commands = commands.map do |(expected_command, command_code, options)|
+          [
+            expected_command,
+            command_code,
+            {
+              optional: false
+            }.merge(options || {})
+          ]
+        end
         # 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
         allow(cmd_runner).to receive(:run_cmd) do |cmd, log_to_file: nil, log_to_stdout: true, log_stdout_to_io: nil, log_stderr_to_io: nil, expected_code: 0, timeout: nil, no_exception: false|
@@ -22,7 +36,7 @@ module HybridPlatformsConductorTest
           found_command = nil
           found_command_code = nil
           remaining_expected_commands_mutex.synchronize do
-            remaining_expected_commands.delete_if do |(expected_command, command_code)|
+            remaining_expected_commands.delete_if do |(expected_command, command_code, _options)|
               break unless found_command.nil?
               if (expected_command.is_a?(String) && expected_command == cmd) || (expected_command.is_a?(Regexp) && cmd =~ expected_command)
                 found_command = expected_command
@@ -67,7 +81,11 @@ module HybridPlatformsConductorTest
           end
         end
         yield
-        expect(remaining_expected_commands).to eq([]), "Expected CmdRunner commands were not run:\n#{remaining_expected_commands.map(&:first).join("\n")}"
+        expect(
+          remaining_expected_commands.select do |(_expected_command, _command_code, options)|
+            !options[:optional]
+          end
+        ).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
       end

data/spec/hybrid_platforms_conductor_test/helpers/connector_ssh_helpers.rb

@@ -17,16 +17,18 @@ module HybridPlatformsConductorTest
       # * *with_control_master_create* (Boolean): Do we create the control master? [default: true]
       # * *with_control_master_check* (Boolean): Do we check the control master? [default: false]
       # * *with_control_master_destroy* (Boolean): Do we destroy the control master? [default: true]
+      # * *with_control_master_destroy_optional* (Boolean): If true, then consider the ControlMaster destruction to be optional [default: false]
       # * *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
+      # * Array<Array>: The expected commands that should be used, and their corresponding mocked code and options
       def ssh_expected_commands_for(
         nodes_connections,
         with_control_master_create: true,
         with_control_master_check: false,
         with_control_master_destroy: true,
+        with_control_master_destroy_optional: false,
         with_strict_host_key_checking: true,
         with_batch_mode: true,
         with_session_exec: true
@@ -45,12 +47,19 @@ module HybridPlatformsConductorTest
             ])
           end
           if with_control_master_create
+            control_master_created = false
             ssh_commands_per_connection << [
               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" }
+                # 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) do
+                  # We have to wait for the Control Master creation thread to actually create the Control Master before hitting Enter.
+                  while !control_master_created do
+                    sleep 0.1
+                  end
+                  "\n"
+                end
                 /^xterm -e '.+\/ssh -o ControlMaster=yes -o ControlPersist=yes hpc\.#{Regexp.escape(node)}'$/
               end,
               proc do
@@ -61,6 +70,7 @@ 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, '')
+                  control_master_created = true
                   # 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
@@ -84,7 +94,8 @@ module HybridPlatformsConductorTest
                 # Really mock the control file deletion
                 File.unlink(test_actions_executor.connector(:ssh).send(:control_master_file, node_connection_info[:connection], '22', node_connection_info[:user]))
                 [1, '', '']
-              end
+              end,
+              { optional: with_control_master_destroy_optional }
             ]
           end
           ssh_commands_once + ssh_commands_per_connection * node_connection_info[:times]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hybrid_platforms_conductor
 version: !ruby/object:Gem::Version
-  version: 32.7.0
+  version: 32.7.1
 platform: ruby
 authors:
 - Muriel Salvan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-11 00:00:00.000000000 Z
+date: 2021-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: range_operators