hybrid_platforms_conductor 32.11.1 → 32.13.2

data/examples/tutorial/05_extend_with_plugins/my_hpc_plugins/lib/my_hpc_plugins/hpc_plugins/test/root_space.rb

@@ -0,0 +1,44 @@
+module MyHpcPlugins
+
+  module HpcPlugins
+
+    module Test
+
+      # Check root space
+      class RootSpace < HybridPlatformsConductor::Test
+
+        # Run test using SSH commands on the node.
+        # Instead of executing the SSH commands directly on each node for each test, this method returns the list of commands to run and the test framework then groups them in 1 SSH connection.
+        # [API] - @node can be used to adapt the command with the node.
+        #
+        # Result::
+        # * Hash<String,Object>: For each command to execute, information regarding the assertion.
+        #   * Values can be:
+        #     * Proc: The code block making the test given the stdout of the command. Here is the Proc description:
+        #       * Parameters::
+        #         * *stdout* (Array<String>): List of lines of the stdout of the command.
+        #         * *stderr* (Array<String>): List of lines of the stderr of the command.
+        #         * *return_code* (Integer): The return code of the command.
+        #     * Hash<Symbol,Object>: More complete information, that can contain the following keys:
+        #       * *validator* (Proc): The proc containing the assertions to perform (as described above). This key is mandatory.
+        #       * *timeout* (Integer): Timeout to wait for this command to execute.
+        def test_on_node
+          # If this method is defined, it will be used to execute SSH commands on each node that is being tested.
+          # For each SSH command, a validator code block will be called with the stdout of the command run remotely on the node.
+          # In place of a simple validator code block, a more complex structure can be used to give more info (for example timeout).
+          {
+            'du -sk /root' => proc do |stdout|
+              # stdout contains the output of our du command
+              used_kb = stdout.first.split.first.to_i
+              error "Root space used is #{used_kb}KB - too much!" if used_kb > 1024
+            end
+          }
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/examples/tutorial/05_extend_with_plugins/my_hpc_plugins/my_hpc_plugins.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name = 'my_hpc_plugins'
+  s.version = '0.0.1'
+  s.date = '2021-04-29'
+  s.authors = ['Me myself!']
+  s.email = ['me-myself@my-domain.com']
+  s.summary = 'My awesome plugins for Hybrid Platforms Conductor'
+  s.files = Dir['{bin,lib,spec}/**/*']
+  Dir['bin/**/*'].each do |exec_name|
+    s.executables << File.basename(exec_name)
+  end
+  # Dependencies
+  # Make sure we use a compatible version of hybrid_platforms_conductor
+  s.add_dependency 'hybrid_platforms_conductor', '~> 32.12'
+end

data/examples/tutorial/05_extend_with_plugins/node/my-service.conf

@@ -0,0 +1,4 @@
+service-port: 1107
+service-timeout: 60
+service-logs: stdout
+

data/examples/tutorial/05_extend_with_plugins/web_docker_image/Dockerfile

@@ -0,0 +1,33 @@
+# syntax=docker/dockerfile:1
+# Pull the image containing Go
+FROM golang:1.16.3-buster
+
+# Install the web server
+# Create the message file to be displayed by the web server
+COPY hello_world.txt /root/hello_world.txt
+# Copy the code
+COPY main.go /codebase/src/main.go
+# Build the binary
+RUN cd /codebase && go build -v -o /codebase/bin/server ./src/main.go
+# Set the env which will be available at runtime
+ENV PORT=80
+EXPOSE 80
+
+# Install sshd
+RUN apt-get update && apt-get install -y openssh-server
+RUN mkdir /var/run/sshd
+# Activate root login
+RUN sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config
+# Speed-up considerably ssh performance and avoid huge lags and timeouts without DNS
+RUN sed -i 's/#UseDNS yes/UseDNS no/' /etc/ssh/sshd_config
+EXPOSE 22
+
+# Upload our root key for key authentication of root
+COPY hpc_root.key.pub /root/.ssh/authorized_keys
+RUN chmod 700 /root/.ssh
+RUN chmod 400 /root/.ssh/authorized_keys
+
+# Startup script
+COPY start.sh /start.sh
+RUN chmod +x /start.sh
+CMD ["/start.sh"]

data/examples/tutorial/05_extend_with_plugins/web_docker_image/hello_world.txt

@@ -0,0 +1 @@
+Hello World!

data/examples/tutorial/05_extend_with_plugins/web_docker_image/hpc_root.key

@@ -0,0 +1,27 @@
+-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABFwAAAAdzc2gtcn
+NhAAAAAwEAAQAAAQEAu5oVFddWtHFKA8+PnRssWieXrnMUPM8+qTdQrxoMaNacFWN+pBv3
+Nj61GphCANoEPBvgcm7ltgZa1EumAZh4NJFi7AqM4Z2AFsqsvzRS1HNFRClEwr576iRkMc
+ECIr0JmxeOscVcDMx0/9uFSfON7DiuStOOpIJIiQfjtFBsLFpzdfsVfZ3zc18Hxugqsbq0
+t0bsTZdjRKnIYeKTSXKbF2n9b/dAf2tBtpywpun1WXQul7w1z20m9zv955k4kq3rAhSIPH
+aOSE+QCXlICYqwmP2KVKCG6XEqSWjF4ujzcE7PlKIK1gsXdfum6GL23X8k8njBIjRzq6a0
+Uabp65tvVQAAA8hgF2y/YBdsvwAAAAdzc2gtcnNhAAABAQC7mhUV11a0cUoDz4+dGyxaJ5
+eucxQ8zz6pN1CvGgxo1pwVY36kG/c2PrUamEIA2gQ8G+BybuW2BlrUS6YBmHg0kWLsCozh
+nYAWyqy/NFLUc0VEKUTCvnvqJGQxwQIivQmbF46xxVwMzHT/24VJ843sOK5K046kgkiJB+
+O0UGwsWnN1+xV9nfNzXwfG6CqxurS3RuxNl2NEqchh4pNJcpsXaf1v90B/a0G2nLCm6fVZ
+dC6XvDXPbSb3O/3nmTiSresCFIg8do5IT5AJeUgJirCY/YpUoIbpcSpJaMXi6PNwTs+Uog
+rWCxd1+6boYvbdfyTyeMEiNHOrprRRpunrm29VAAAAAwEAAQAAAQEAj5IE7vkkvuUweqgf
+RWGlWL2SJIyngT4tuzy8/7SUqKsNOoUxRxCr6ZSl7tt1L8eplALVi135aIuGeZAHVJNF8x
+0Mso4EcSmi/E5RU+cMONCawuY+XDeBB5igIT+PjdxT/KBTsRLUNmtGYwSyBf1hsNVT9ang
+MWAPeOdTyQv/LRUe+O/ZKQ/h/X51BEwSXqz32RmlmZdMnDacIJ0NWdbcbAEtB4JT83S20d
+bycQNOxGVmyevOGjyTXfUX6FhtYT7A7zzqNUL8UstSdajWeTZvVGd0C7Ob1kxaU3tnAwFr
+0sHTPHX7FQQFGhiU8gBZHOJ/PQzo+qqcCSsM3FcJlpVw5QAAAIAPYGXt7diWFYEhZVfj3n
+KA0lX7LjQms0en4CoSkN4BELQJnaaqlTkrqN7PNL/WbmeavzDqQMk1jb9Q2+gra826THX5
+GGtbFPFb9TSwBNi+zsyVURKEzqNYSw28ytKIdj98VW1qqQoolgTc5qoXG1JW5f5bEPbzUT
+LXPP5j+YvuCgAAAIEA8NVJc5vXzJxbdgBxOPPHaPCAZ28V15Ggy+Bj1K/9G6FHqa/SFhy0
+tCpBDNB/POX2UXCQDLteTIDodj9h2Yat6PJP9RKYCC9F5+/fU/0Y/tvD/p/uNhwEuqToex
+gBUoL+r7/G3qYK13n8AKwrvb2wiYgP3aUVW7AyOier1MKt4OsAAACBAMdqmcj+5fNSTuOg
+iPgGylUSIYnJ0w2jjZIaX96aat/w+SgciLhenbwpcf/9E8MDYKbXyhArdQvOgkEVogEI4s
+PrFG66ogawPuRUUsuZBhm/b535EEvNAlkC8fMPVuKfOIsHJs8Cwcy7QPZSZu5pyKznpnCT
+UlYGT6aB0GGoeeC/AAAAEWFkbWluQGV4YW1wbGUuY29tAQ==
+-----END OPENSSH PRIVATE KEY-----

data/examples/tutorial/05_extend_with_plugins/web_docker_image/hpc_root.key.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC7mhUV11a0cUoDz4+dGyxaJ5eucxQ8zz6pN1CvGgxo1pwVY36kG/c2PrUamEIA2gQ8G+BybuW2BlrUS6YBmHg0kWLsCozhnYAWyqy/NFLUc0VEKUTCvnvqJGQxwQIivQmbF46xxVwMzHT/24VJ843sOK5K046kgkiJB+O0UGwsWnN1+xV9nfNzXwfG6CqxurS3RuxNl2NEqchh4pNJcpsXaf1v90B/a0G2nLCm6fVZdC6XvDXPbSb3O/3nmTiSresCFIg8do5IT5AJeUgJirCY/YpUoIbpcSpJaMXi6PNwTs+UogrWCxd1+6boYvbdfyTyeMEiNHOrprRRpunrm29V admin@example.com

data/examples/tutorial/05_extend_with_plugins/web_docker_image/main.go

@@ -0,0 +1,43 @@
+package main
+
+import (
+    "fmt"
+    "io/ioutil"
+    "log"
+    "net/http"
+    "os"
+)
+
+const homepageEndPoint = "/"
+
+// StartWebServer the webserver
+func StartWebServer() {
+    http.HandleFunc(homepageEndPoint, handleHomepage)
+    port := os.Getenv("PORT")
+    if len(port) == 0 {
+        panic("Environment variable PORT is not set")
+    }
+
+    log.Printf("Starting web server to listen on endpoints [%s] and port %s",
+        homepageEndPoint, port)
+    if err := http.ListenAndServe(":"+port, nil); err != nil {
+        panic(err)
+    }
+}
+
+func handleHomepage(w http.ResponseWriter, r *http.Request) {
+    urlPath := r.URL.Path
+    log.Printf("Web request received on url path %s", urlPath)
+    content, content_err := ioutil.ReadFile("/root/hello_world.txt")
+    if content_err != nil {
+        fmt.Printf("Failed to read message to display, err: %s", content_err)
+    }
+    _, write_err := w.Write(content)
+    if write_err != nil {
+        fmt.Printf("Failed to write response, err: %s", write_err)
+    }
+}
+
+func main() {
+    StartWebServer()
+}

data/examples/tutorial/05_extend_with_plugins/web_docker_image/start.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+# Start sshd as a daemon
+/usr/sbin/sshd
+
+# Start web server
+sh -c /codebase/bin/server

data/examples/tutorial/05_extend_with_plugins/web_docker_image/test.bash

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+for ((i=1;i<=10;i++));
+do 
+   echo "Container web$i: $(curl http://web$i.hpc_tutorial.org 2>/dev/null)"
+done

data/lib/hybrid_platforms_conductor/actions_executor.rb

@@ -5,6 +5,7 @@ require 'securerandom'
 require 'tmpdir'
 require 'hybrid_platforms_conductor/action'
 require 'hybrid_platforms_conductor/cmd_runner'
+require 'hybrid_platforms_conductor/config'
 require 'hybrid_platforms_conductor/connector'
 require 'hybrid_platforms_conductor/io_router'
 require 'hybrid_platforms_conductor/logger_helpers'

data/lib/hybrid_platforms_conductor/deployer.rb

@@ -41,7 +41,7 @@ module HybridPlatformsConductor
 
     include LoggerHelpers
 
-    Config.extend_config_dsl_with ConfigDSLExtension, :init_nodes_handler_config
+    Config.extend_config_dsl_with ConfigDSLExtension, :init_deployer_config
 
     # Do we use why-run mode while deploying? [default = false]
     #   Boolean
@@ -336,7 +336,8 @@ module HybridPlatformsConductor
           actions_executor.connector(:ssh).passwords[node] = 'root_pwd'
           deployer.local_environment = true
           # Ignore secrets that might have been given: in Docker containers we always use dummy secrets
-          deployer.secrets = [JSON.parse(File.read("#{@config.hybrid_platforms_dir}/dummy_secrets.json"))]
+          dummy_secrets_file = "#{@config.hybrid_platforms_dir}/dummy_secrets.json"
+          deployer.secrets = File.exist?(dummy_secrets_file) ? [JSON.parse(File.read(dummy_secrets_file))] : []
           yield deployer, instance
         end
       rescue

data/lib/hybrid_platforms_conductor/hpc_plugins/action/remote_bash.rb

@@ -14,16 +14,33 @@ module HybridPlatformsConductor
         # [API] - @actions_executor is accessible
         #
         # Parameters::
-        # * *remote_bash* (Array< Hash<Symbol, Object> or Array<String> or String>): List of bash actions to execute. Each action can have the following properties:
-        #   * *commands* (Array<String> or String): List of bash commands to execute (can be a single one). This is the default property also that allows to not use the Hash form for brevity.
-        #   * *file* (String): Name of file from which commands should be taken.
-        #   * *env* (Hash<String, String>): Environment variables to be set before executing those commands.
+        # * *remote_bash* (Array or Object): List of commands (or single command) to be executed. Each command can be the following:
+        #   * String: Simple bash command.
+        #   * Hash<Symbol, Object>: Information about the commands to execute. Can have the following properties:
+        #     * *commands* (Array<String> or String): List of bash commands to execute (can be a single one) [default: ''].
+        #     * *file* (String): Name of file from which commands should be taken [optional].
+        #     * *env* (Hash<String, String>): Environment variables to be set before executing those commands [default: {}].
         def setup(remote_bash)
-          @remote_bash = remote_bash
-          # Normalize the parameters
-          @remote_bash = [@remote_bash] if @remote_bash.is_a?(String)
-          @remote_bash = { commands: @remote_bash } if @remote_bash.is_a?(Array)
-          @remote_bash[:commands] = [@remote_bash[:commands]] if @remote_bash[:commands].is_a?(String)
+          # Normalize the parameters.
+          # Array< Hash<Symbol,Object> >: Simple array of info:
+          # * *commands* (Array<String>): List of bash commands to execute.
+          # * *env* (Hash<String, String>): Environment variables to be set before executing those commands.
+          @remote_bash = (remote_bash.is_a?(Array) ? remote_bash : [remote_bash]).map do |cmd_info|
+            if cmd_info.is_a?(String)
+              {
+                commands: [cmd_info],
+                env: {}
+              }
+            else
+              commands = []
+              commands.concat(cmd_info[:commands].is_a?(String) ? [cmd_info[:commands]] : cmd_info[:commands]) if cmd_info[:commands]
+              commands << File.read(cmd_info[:file]) if cmd_info[:file]
+              {
+                commands: commands,
+                env: cmd_info[:env] || {}
+              }
+            end
+          end
         end
 
         # Do we need a connector to execute this action on a node?
@@ -46,10 +63,9 @@ module HybridPlatformsConductor
         # [API] - @stderr_io can be used to log stderr messages
         # [API] - run_cmd(String) method can be used to execute a command. See CmdRunner#run_cmd to know about the result's signature.
         def execute
-          bash_commands = (@remote_bash[:env] || {}).map { |var_name, var_value| "export #{var_name}='#{var_value}'" }
-          bash_commands.concat(@remote_bash[:commands].clone) if @remote_bash.key?(:commands)
-          bash_commands << File.read(@remote_bash[:file]) if @remote_bash.key?(:file)
-          bash_str = bash_commands.join("\n")
+          bash_str = @remote_bash.map do |cmd_info|
+            (cmd_info[:env].map { |var_name, var_value| "export #{var_name}='#{var_value}'" } + cmd_info[:commands]).join("\n")
+          end.join("\n")
           log_debug "[#{@node}] - Execute remote Bash commands \"#{bash_str}\"..."
           @connector.remote_bash bash_str
         end

data/lib/hybrid_platforms_conductor/hpc_plugins/action/scp.rb

@@ -16,7 +16,7 @@ module HybridPlatformsConductor
         # Parameters::
         # * *mappings* (Hash<String or Symbol, Object>): Set of couples source => destination_dir to copy files or directories from the local file system to the remote file system.
         #   The following properties can also be used:
-        #   * *sudo* (Boolean): Do we use sudo to make the copy? [default: false]
+        #   * *sudo* (Boolean): Do we use sudo on the remote to make the copy? [default: false]
         #   * *owner* (String or nil): Owner to use for files, or nil to use current one [default: nil]
         #   * *group* (String or nil): Group to use for files, or nil to use current one [default: nil]
         def setup(mappings)

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

@@ -0,0 +1,98 @@
+require 'fileutils'
+require 'tmpdir'
+
+module HybridPlatformsConductor
+
+  module HpcPlugins
+
+    module Connector
+
+      # Connector executing remote commands on the local environment in dedicated workspaces (/tmp/hpc_local_workspaces)
+      class Local < HybridPlatformsConductor::Connector
+
+        # Select nodes where this connector can connect.
+        # [API] - This method is mandatory
+        # [API] - @cmd_runner can be used
+        # [API] - @nodes_handler can be used
+        #
+        # Parameters::
+        # * *nodes* (Array<String>): List of candidate nodes
+        # Result::
+        # * Array<String>: List of nodes we can connect to from the candidates
+        def connectable_nodes_from(nodes)
+          @nodes_handler.prefetch_metadata_of nodes, :local_node
+          nodes.select { |node| @nodes_handler.get_local_node_of(node) }
+        end
+
+        # Run bash commands on a given node.
+        # [API] - This method is mandatory
+        # [API] - If defined, then with_connection_to has been called before this method.
+        # [API] - @cmd_runner can be used
+        # [API] - @nodes_handler can be used
+        # [API] - @node can be used to access the node on which we execute the remote bash
+        # [API] - @timeout can be used to know when the action should fail
+        # [API] - @stdout_io can be used to send stdout output
+        # [API] - @stderr_io can be used to send stderr output
+        #
+        # Parameters::
+        # * *bash_cmds* (String): Bash commands to execute
+        def remote_bash(bash_cmds)
+          run_cmd "cd #{workspace_for(@node)} ; #{bash_cmds}"
+        end
+
+        # Execute an interactive shell on the remote node
+        # [API] - This method is mandatory
+        # [API] - If defined, then with_connection_to has been called before this method.
+        # [API] - @cmd_runner can be used
+        # [API] - @nodes_handler can be used
+        # [API] - @node can be used to access the node on which we execute the remote bash
+        # [API] - @timeout can be used to know when the action should fail
+        # [API] - @stdout_io can be used to send stdout output
+        # [API] - @stderr_io can be used to send stderr output
+        def remote_interactive
+          system "cd #{workspace_for(@node)} ; /bin/bash"
+        end
+
+        # Copy a file to the remote node in a directory
+        # [API] - This method is mandatory
+        # [API] - If defined, then with_connection_to has been called before this method.
+        # [API] - @cmd_runner can be used
+        # [API] - @nodes_handler can be used
+        # [API] - @node can be used to access the node on which we execute the remote bash
+        # [API] - @timeout can be used to know when the action should fail
+        # [API] - @stdout_io can be used to send stdout output
+        # [API] - @stderr_io can be used to send stderr output
+        #
+        # Parameters::
+        # * *from* (String): Local file to copy
+        # * *to* (String): Remote directory to copy to
+        # * *sudo* (Boolean): Do we use sudo to copy? [default: false]
+        # * *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)
+          # If the destination is a relative path, prepend the workspace dir to it.
+          to = "#{workspace_for(@node)}/#{to}" unless to.start_with?('/')
+          FileUtils.cp_r from, to
+        end
+
+        private
+
+        # Create or reuse a dedicated workspace for a node
+        #
+        # Parameters::
+        # * *node* (String): Node for which we want a dedicated workspace
+        # Result::
+        # * String: Dedicated workspace path
+        def workspace_for(node)
+          workspace = "#{Dir.tmpdir}/hpc_local_workspaces/#{node}"
+          FileUtils.mkdir_p workspace
+          workspace
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/hybrid_platforms_conductor/hpc_plugins/connector/my_connector.rb.sample

@@ -73,7 +73,7 @@ module HybridPlatformsConductor
         # Result::
         # * Array<String>: List of nodes we can connect to from the candidates
         def connectable_nodes_from(nodes)
-          nodes.select { |node| @nodes_handler.get_ip_of(node) =~ /^192\.168\..+$/ }
+          nodes.select { |node| @nodes_handler.get_host_ip_of(node) =~ /^192\.168\..+$/ }
         end
 
         # Prepare connections to a given set of nodes.
@@ -135,7 +135,7 @@ module HybridPlatformsConductor
         # Parameters::
         # * *from* (String): Local file to copy
         # * *to* (String): Remote directory to copy to
-        # * *sudo* (Boolean): Do we use sudo to copy? [default: false]
+        # * *sudo* (Boolean): Do we use sudo on the remote to copy? [default: false]
         # * *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)

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

@@ -131,6 +131,10 @@ module HybridPlatformsConductor
           # Default values
           @ssh_user = ENV['hpc_ssh_user']
           @ssh_user = ENV['USER'] if @ssh_user.nil? || @ssh_user.empty?
+          if @ssh_user.nil? || @ssh_user.empty?
+            _exit_status, stdout = @cmd_runner.run_cmd 'whoami', log_to_stdout: log_debug?
+            @ssh_user = stdout.strip
+          end
           @ssh_use_control_master = true
           @ssh_strict_host_key_checking = true
           @passwords = {}
@@ -236,9 +240,9 @@ module HybridPlatformsConductor
           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"
+              "{ cat | #{ssh_exec} #{ssh_url} -T; } <<'HPC_EOF'\n#{bash_cmds}\nHPC_EOF"
             else
-              "#{ssh_exec} #{ssh_url} /bin/bash <<'EOF'\n#{bash_cmds}\nEOF"
+              "#{ssh_exec} #{ssh_url} /bin/bash <<'HPC_EOF'\n#{bash_cmds}\nHPC_EOF"
             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.
@@ -292,13 +296,20 @@ module HybridPlatformsConductor
         # Parameters::
         # * *from* (String): Local file to copy
         # * *to* (String): Remote directory to copy to
-        # * *sudo* (Boolean): Do we use sudo to copy? [default: false]
+        # * *sudo* (Boolean): Do we use sudo on the remote to copy? [default: false]
         # * *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)
           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}"
+            if sudo
+              # We need to first copy the file in an accessible directory, and then sudo mv
+              remote_bash('mkdir -p hpc_tmp_scp')
+              run_cmd "scp -S #{ssh_exec} #{from} #{ssh_url}:./hpc_tmp_scp"
+              remote_bash("#{@nodes_handler.sudo_on(@node)} mv ./hpc_tmp_scp/#{File.basename(from)} #{to}")
+            else
+              run_cmd "scp -S #{ssh_exec} #{from} #{ssh_url}:#{to}"
+            end
           else
             run_cmd <<~EOS
               cd #{File.dirname(from)} && \