hybrid_platforms_conductor 32.4.1 → 32.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e0dfe56d0297ba7c9c90dfbf4737cd6b4754b20a36f7dec0962d62a19b5bf2b
-  data.tar.gz: 3a0363efcb7dc771c9cf41911d3012fae0a764a465e4bd925f241a422d5f11b0
+  metadata.gz: 04d2e323c123bfaa35c0fb61f95dcc7a9ade67b19f184eff75c61419e249ac8e
+  data.tar.gz: 25afb265a466103db73b891c62ec9a9ee32e5529bf8d9f0df71df379bab5ec7a
 SHA512:
-  metadata.gz: e1dae403085c924a043dfee0185b46478eff9c99fa1d69848f5e92b571e4dfb1dc62ab1f80792d3b1928323eecf72a8f0904317b17facf3b92b6a07b82381112
-  data.tar.gz: 6156b57048a690c5bc6e91ffd61a8276b84b2a2196206a8b77779ee25fe559aa4a4ec21bf741f015736cb3796b9bf4c33d9ec0203b4e4ff7c44a77c1d06fbe83
+  metadata.gz: d8112983393928123c7f8f35395506c4ec5e401e84577e3ab1e24380ab0cd92affd90b6be0cb75645314d06cc8350cd8c478e1d1b9e3c600143296bdec73af47
+  data.tar.gz: 6177c45b5489b077ee2d3e6d7535d6c07e94715c755c282ea8dc424e54d35ac1603c4be9d2e2d9b4cbfc4f450463c792a3e449f6dbbc5eb6bba4a0161c695c65

data/lib/hybrid_platforms_conductor/deployer.rb

@@ -480,6 +480,7 @@ module HybridPlatformsConductor
       outputs = @actions_executor.execute_actions(
         Hash[services.map do |node, node_services|
           image_id = @nodes_handler.get_image_of(node)
+          sudo = (ssh_user == 'root' ? '' : "#{@nodes_handler.sudo_on(node)} ")
           # Install My_company corporate certificates if present
           certificate_actions =
             if @local_environment && ENV['hpc_certificates']
@@ -489,20 +490,20 @@ module HybridPlatformsConductor
                 when 'debian_9', 'debian_10'
                   [
                     {
-                      remote_bash: "#{ssh_user == 'root' ? '' : 'sudo '}apt update && #{ssh_user == 'root' ? '' : 'sudo '}apt install -y ca-certificates"
+                      remote_bash: "#{sudo}apt update && #{sudo}apt install -y ca-certificates"
                     },
                     {
                       scp: {
                         ENV['hpc_certificates'] => '/usr/local/share/ca-certificates',
                         :sudo => ssh_user != 'root'
                       },
-                      remote_bash: "#{ssh_user == 'root' ? '' : 'sudo '}update-ca-certificates"
+                      remote_bash: "#{sudo}update-ca-certificates"
                     }
                   ]
                 when 'centos_7'
                   [
                     {
-                      remote_bash: "#{ssh_user == 'root' ? '' : 'sudo '}yum install -y ca-certificates"
+                      remote_bash: "#{sudo}yum install -y ca-certificates"
                     },
                     {
                       scp: Hash[Dir.glob("#{ENV['hpc_certificates']}/*.crt").map do |cert_file|
@@ -512,8 +513,8 @@ module HybridPlatformsConductor
                         ]
                       end].merge(sudo: ssh_user != 'root'),
                       remote_bash: [
-                        "#{ssh_user == 'root' ? '' : 'sudo '}update-ca-trust enable",
-                        "#{ssh_user == 'root' ? '' : 'sudo '}update-ca-trust extract"
+                        "#{sudo}update-ca-trust enable",
+                        "#{sudo}update-ca-trust extract"
                       ]
                     }
                   ]
@@ -532,7 +533,7 @@ module HybridPlatformsConductor
               # Install the mutex lock and acquire it
               {
                 scp: { "#{__dir__}/mutex_dir" => '.' },
-                remote_bash: "while ! #{ssh_user == 'root' ? '' : 'sudo '}./mutex_dir lock /tmp/hybrid_platforms_conductor_deploy_lock \"$(ps -o ppid= -p $$)\"; do echo -e 'Another deployment is running on #{node}. Waiting for it to finish to continue...' ; sleep 5 ; done"
+                remote_bash: "while ! #{sudo}./mutex_dir lock /tmp/hybrid_platforms_conductor_deploy_lock \"$(ps -o ppid= -p $$)\"; do echo -e 'Another deployment is running on #{node}. Waiting for it to finish to continue...' ; sleep 5 ; done"
               }
             ] +
               certificate_actions +
@@ -548,7 +549,7 @@ module HybridPlatformsConductor
         Hash[services.keys.map do |node|
           [
             node,
-            { remote_bash: "#{ssh_user == 'root' ? '' : 'sudo '}./mutex_dir unlock /tmp/hybrid_platforms_conductor_deploy_lock" }
+            { remote_bash: "#{ssh_user == 'root' ? '' : "#{@nodes_handler.sudo_on(node)} "}./mutex_dir unlock /tmp/hybrid_platforms_conductor_deploy_lock" }
           ]
         end],
         timeout: 10,
@@ -595,7 +596,7 @@ module HybridPlatformsConductor
               [
                 node,
                 {
-                  remote_bash: "#{ssh_user == 'root' ? '' : 'sudo '}mkdir -p /var/log/deployments",
+                  remote_bash: "#{ssh_user == 'root' ? '' : "#{@nodes_handler.sudo_on(node)} "}mkdir -p /var/log/deployments",
                   scp: {
                     log_file => '/var/log/deployments',
                     :sudo => ssh_user != 'root',

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

@@ -10,13 +10,46 @@ module HybridPlatformsConductor
       # Connect to node using SSH
       class Ssh < HybridPlatformsConductor::Connector
 
+        # Exception raise when a node is not connectable using SSH
+        class NotConnectableError < RuntimeError
+        end
+
         module PlatformsDslSsh
 
+          # List of SSH connection transformations:
+          # * *nodes_selectors_stack* (Array<Object>): Stack of nodes selectors impacted by this rule
+          # * *transform* (Proc): Code called to transform SSH connection info:
+          #   Parameters::
+          #   * *node* (String): Node for which we transform the SSH connection
+          #   * *connection* (String or nil): The connection host or IP, or nil if none
+          #   * *connection_user* (String): The connection user
+          #   * *gateway* (String or nil): The gateway name, or nil if none
+          #   * *gateway_user* (String or nil): The gateway user, or nil if none
+          #   Result::
+          #   * String: The transformed connection host or IP, or nil if none
+          #   * String: The transformed connection user
+          #   * String or nil: The transformed gateway name, or nil if none
+          #   * String or nil: The transformed gateway user, or nil if none
+          # Array< Hash<Symbol, Object> >
+          attr_reader :ssh_connection_transforms
+
           # Initialize the DSL
           def init_ssh
             # List of gateway configurations, per gateway config name
             # Hash<Symbol, String>
             @gateways = {}
+            @ssh_connection_transforms = []
+          end
+
+          # Define a transformation of SSH connection.
+          #
+          # Parameters::
+          # * *transform* (Proc): Code to be called to transform an SSH connection (see ssh_connection_transforms signature for details)
+          def transform_ssh_connection(&transform)
+            @ssh_connection_transforms << {
+              nodes_selectors_stack: current_nodes_selectors_stack,
+              transform: transform
+            }
           end
 
           # Register a new gateway configuration
@@ -200,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
@@ -257,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 ? 'sudo ' : ''}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
@@ -291,7 +335,7 @@ module HybridPlatformsConductor
         # Result::
         # * String: The ssh URL connecting to the current node
         def ssh_url
-          "#{@ssh_user}@hpc.#{@node}"
+          "hpc.#{@node}"
         end
 
         # Get an SSH configuration content giving access to nodes of the platforms with the current configuration
@@ -314,14 +358,6 @@ module HybridPlatformsConductor
             # ENDPOINTS #
             #############
 
-            Host *
-              User #{@ssh_user}
-              # Default control socket path to be used when multiplexing SSH connections
-              ControlPath #{control_master_file('%h', '%p', '%r')}
-              #{open_ssh_major_version >= 7 ? 'PubkeyAcceptedKeyTypes +ssh-dss' : ''}
-              #{known_hosts_file.nil? ? '' : "UserKnownHostsFile #{known_hosts_file}"}
-              #{@ssh_strict_host_key_checking ? '' : 'StrictHostKeyChecking no'}
-
           EOS
 
           # Add each node
@@ -329,17 +365,37 @@ module HybridPlatformsConductor
           @nodes_handler.prefetch_metadata_of nodes, %i[private_ips hostname host_ip description]
           nodes.sort.each do |node|
             # Generate the conf for the node
-            connection, gateway, gateway_user = connection_info_for(node)
-            config_content << "# #{node} - #{connection} - #{@nodes_handler.get_description_of(node) || ''}\n"
-            config_content << "Host #{ssh_aliases_for(node).join(' ')}\n"
-            config_content << "  Hostname #{connection}\n"
-            config_content << "  ProxyCommand #{ssh_exec} -q -W %h:%p #{gateway_user}@#{gateway}\n" unless gateway.nil?
-            if @passwords.key?(node)
-              config_content << "  PreferredAuthentications password\n"
-              config_content << "  PubkeyAuthentication no\n"
+            connection, connection_user, gateway, gateway_user = connection_info_for(node, no_exception: true)
+            if connection.nil?
+              config_content << "# #{node} - Not connectable using SSH - #{@nodes_handler.get_description_of(node) || ''}\n"
+            else
+              config_content << "# #{node} - #{connection} - #{@nodes_handler.get_description_of(node) || ''}\n"
+              config_content << "Host #{ssh_aliases_for(node).join(' ')}\n"
+              config_content << "  Hostname #{connection}\n"
+              config_content << "  User \"#{connection_user}\"\n" if connection_user != @ssh_user
+              config_content << "  ProxyCommand #{ssh_exec} -q -W %h:%p #{gateway_user}@#{gateway}\n" unless gateway.nil?
+              if @passwords.key?(node)
+                config_content << "  PreferredAuthentications password\n"
+                config_content << "  PubkeyAuthentication no\n"
+              end
             end
             config_content << "\n"
           end
+          # Add global definitions at the end of the SSH config, as they might be overriden by previous ones, and first match wins.
+          config_content << <<~EOS
+            ###########
+            # GLOBALS #
+            ###########
+
+            Host *
+              User #{@ssh_user}
+              # Default control socket path to be used when multiplexing SSH connections
+              ControlPath #{control_master_file('%h', '%p', '%r')}
+              #{open_ssh_major_version >= 7 ? 'PubkeyAcceptedKeyTypes +ssh-dss' : ''}
+              #{known_hosts_file.nil? ? '' : "UserKnownHostsFile #{known_hosts_file}"}
+              #{@ssh_strict_host_key_checking ? '' : 'StrictHostKeyChecking no'}
+
+          EOS
           config_content
         end
 
@@ -442,34 +498,48 @@ module HybridPlatformsConductor
                   with_lock_on_control_master_for(node) do |current_users, user_id|
                     working_master = false
                     ssh_exec = ssh_exec_for(node)
-                    ssh_url = "#{@ssh_user}@hpc.#{node}"
+                    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
@@ -504,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 = "#{@ssh_user}@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
@@ -554,8 +629,9 @@ module HybridPlatformsConductor
             # TODO: Add test case when control file is missing ad when it is stale
             # Get the list of existing process/thread ids using this control master
             existing_users = File.exist?(control_master_users_file) ? File.read(control_master_users_file).split("\n") : []
-            ssh_url = "#{@ssh_user}@hpc.#{node}"
-            control_path_file = control_master_file(connection_info_for(node).first, '22', @ssh_user)
+            ssh_url = "hpc.#{node}"
+            connection, connection_user, _gateway, _gateway_user = connection_info_for(node)
+            control_path_file = control_master_file(connection, '22', connection_user)
             if existing_users.empty?
               # Make sure there is no stale one.
               if File.exist?(control_path_file)
@@ -587,7 +663,7 @@ module HybridPlatformsConductor
         # * *port* (String): The port. Can be a string as ssh config uses wildchars.
         # * *user* (String): The user
         def control_master_file(host, port, user)
-          "#{@tmp_dir}/hpc_actions_executor_mux_#{host}_#{port}_#{user}"
+          "#{@tmp_dir}/hpc_ssh_mux_#{host}_#{port}_#{user}"
         end
 
         # Provide a bootstrapped ssh executable that includes an SSH config allowing access to nodes.
@@ -619,7 +695,7 @@ module HybridPlatformsConductor
                 nodes.sort.each do |node|
                   host_keys = @nodes_handler.get_host_keys_of(node)
                   if host_keys && !host_keys.empty?
-                    connection, _gateway, _gateway_user = connection_info_for(node)
+                    connection, _connection_user, _gateway, _gateway_user = connection_info_for(node)
                     host_keys.each do |host_key|
                       file.puts "#{connection} #{host_key}"
                     end
@@ -652,11 +728,13 @@ module HybridPlatformsConductor
         #
         # Parameters::
         # * *node* (String): The node to access
+        # * *no_exception* (Boolean): Should we skip exceptions in case of no connection possible? [default: false]
         # Result::
-        # * String: The real hostname or IP to be used to connect
+        # * String: The real hostname or IP to be used to connect, or nil if none and no_exception is true
+        # * String: The real user to be used to connect, or nil if none and no_exception is true
         # * String or nil: The gateway name to be used (should be defined by the gateways configurations), or nil if no gateway to be used.
         # * String or nil: The gateway user to be used, or nil if none.
-        def connection_info_for(node)
+        def connection_info_for(node, no_exception: false)
           connection =
             if @nodes_handler.get_host_ip_of(node)
               @nodes_handler.get_host_ip_of(node)
@@ -665,12 +743,18 @@ module HybridPlatformsConductor
             elsif @nodes_handler.get_hostname_of(node)
               @nodes_handler.get_hostname_of(node)
             else
-              raise "No connection possible to #{node}"
+              nil
             end
+          connection_user = @ssh_user
           gateway = @nodes_handler.get_gateway_of node
           gateway_user = @nodes_handler.get_gateway_user_of node
           gateway_user = @ssh_gateway_user if !gateway.nil? && gateway_user.nil?
-          [connection, gateway, gateway_user]
+          # In case we want to transform the connection info, do it here.
+          @nodes_handler.select_confs_for_node(node, @config.ssh_connection_transforms).each do |transform_info|
+            connection, connection_user, gateway, gateway_user = transform_info[:transform].call(node, connection, connection_user, gateway, gateway_user)
+          end
+          raise NotConnectableError, "No connection possible to #{node}" if connection.nil? && !no_exception
+          [connection, connection_user, gateway, gateway_user]
         end
 
         # Get the possible SSH aliases for a given node.

data/lib/hybrid_platforms_conductor/hpc_plugins/platform_handler/platform_handler_plugin.rb.sample

@@ -173,7 +173,7 @@ module HybridPlatformsConductor
         # * *local_environment* (Boolean): Are we deploying to a local environment?
         def package(services:, secrets:, local_environment:)
           # This method should take all actions to prepare the repository to be deployed on nodes later.
-          File.write('temporary_secrets_to_be_deployed.json', secrets)
+          File.write("#{@repository_path}/temporary_secrets_to_be_deployed.json", secrets.to_json)
           # Usually it is meant to package the deployment scripts.
           @cmd_runner.run_cmd "cd #{@repository_path} && ./scripts/package_in_debian_format.sh"
         end