hybrid_platforms_conductor 33.3.0 → 33.7.0

data/lib/hybrid_platforms_conductor/test.rb

@@ -36,20 +36,34 @@ module HybridPlatformsConductor
     # Constructor
     #
     # Parameters::
-    # * *logger* (Logger): Logger to be used
-    # * *logger_stderr* (Logger): Logger to be used for stderr
-    # * *config* (Config): Config to be used.
-    # * *cmd_runner* (CmdRunner): CmdRunner that can be used by tests
-    # * *nodes_handler* (NodesHandler): Nodes handler that can be used by tests
-    # * *deployer* (Deployer): Deployer that can be used by tests
+    # * *logger* (Logger): Logger to be used [default: Logger.new($stdout)]
+    # * *logger_stderr* (Logger): Logger to be used for stderr [default: Logger.new($stderr)]
+    # * *config* (Config): Config to be used. [default: Config.new]
+    # * *cmd_runner* (CmdRunner): Command executor to be used. [default: CmdRunner.new]
+    # * *nodes_handler* (NodesHandler): Nodes handler to be used. [default: NodesHandler.new]
+    # * *actions_executor* (ActionsExecutor): Actions Executor to be used. [default: ActionsExecutor.new]
+    # * *deployer* (Deployer): Deployer that can be used by tests [default: Deployer.new]
     # * *name* (String): Name of the test being instantiated [default: 'unknown_test']
     # * *platform* (PlatformHandler): Platform handler for which the test is instantiated, or nil if global or node specific [default: nil]
     # * *node* (String): Node name for which the test is instantiated, or nil if global or platform specific [default: nil]
     # * *expected_failure* (String or nil): Expected failure, or nil if not expected to fail [default: nil]
-    def initialize(logger, logger_stderr, config, cmd_runner, nodes_handler, deployer, name: 'unknown_test', platform: nil, node: nil, expected_failure: nil)
+    def initialize(
+      logger: Logger.new($stdout),
+      logger_stderr: Logger.new($stderr),
+      config: Config.new,
+      cmd_runner: CmdRunner.new,
+      nodes_handler: NodesHandler.new,
+      actions_executor: ActionsExecutor.new,
+      deployer: Deployer.new,
+      name: 'unknown_test',
+      platform: nil,
+      node: nil,
+      expected_failure: nil
+    )
       super(logger: logger, logger_stderr: logger_stderr, config: config)
       @cmd_runner = cmd_runner
       @nodes_handler = nodes_handler
+      @actions_executor = actions_executor
       @deployer = deployer
       @name = name
       @platform = platform

data/lib/hybrid_platforms_conductor/tests_runner.rb

@@ -274,12 +274,13 @@ module HybridPlatformsConductor
     # * Test: Corresponding test
     def new_test(test_name, platform: nil, node: nil, ignore_expected_failure: false)
       (test_name.nil? ? Test : @tests_plugins[test_name]).new(
-        @logger,
-        @logger_stderr,
-        @config,
-        @cmd_runner,
-        @nodes_handler,
-        @deployer,
+        logger: @logger,
+        logger_stderr: @logger_stderr,
+        config: @config,
+        cmd_runner: @cmd_runner,
+        nodes_handler: @nodes_handler,
+        actions_executor: @actions_executor,
+        deployer: @deployer,
         name: test_name.nil? ? :global : test_name,
         platform: platform,
         node: node,

data/lib/hybrid_platforms_conductor/thycotic.rb

@@ -5,95 +5,100 @@ require 'hybrid_platforms_conductor/logger_helpers'
 
 module HybridPlatformsConductor
 
-  # Gives ways to query the Thycotic SOAP API at a given URL
-  class Thycotic
+  # Mixin giving ways to query the Thycotic SOAP API at a given URL
+  module Thycotic
 
-    include LoggerHelpers
+    include Credentials
 
     # Provide a Thycotic connector, and make sure the password is being cleaned when exiting.
     #
     # Parameters::
     # * *thycotic_url* (String): The Thycotic URL
-    # * *logger* (Logger): Logger to be used
-    # * *logger_stderr* (Logger): Logger to be used for stderr
     # * *domain* (String): Domain to use for authentication to Thycotic [default: ENV['hpc_domain_for_thycotic']]
     # * Proc: Code called with the Thyctotic instance.
-    #   * *thycotic* (Thyctotic): The Thyctotic instance to use.
-    def self.with_thycotic(thycotic_url, logger, logger_stderr, domain: ENV['hpc_domain_for_thycotic'])
-      Credentials.with_credentials_for(:thycotic, logger, logger_stderr, url: thycotic_url) do |thycotic_user, thycotic_password|
-        yield Thycotic.new(thycotic_url, thycotic_user, thycotic_password, domain: domain, logger: logger, logger_stderr: logger_stderr)
+    #   * *thycotic* (ThyctoticApi): The Thycotic instance to use.
+    def with_thycotic(thycotic_url, domain: ENV['hpc_domain_for_thycotic'])
+      with_credentials_for(:thycotic, resource: thycotic_url) do |thycotic_user, thycotic_password|
+        yield ThycoticApi.new(thycotic_url, thycotic_user, thycotic_password, domain: domain, logger: @logger, logger_stderr: @logger_stderr)
       end
     end
 
-    # Constructor
-    #
-    # Parameters::
-    # * *url* (String): URL of the Thycotic Secret Server
-    # * *user* (String): User name to be used to connect to Thycotic
-    # * *password* (String): Password to be used to connect to Thycotic
-    # * *domain* (String): Domain to use for authentication to Thycotic [default: ENV['hpc_domain_for_thycotic']]
-    # * *logger* (Logger): Logger to be used [default: Logger.new(STDOUT)]
-    # * *logger_stderr* (Logger): Logger to be used for stderr [default: Logger.new(STDERR)]
-    def initialize(
-      url,
-      user,
-      password,
-      domain: ENV['hpc_domain_for_thycotic'],
-      logger: Logger.new($stdout),
-      logger_stderr: Logger.new($stderr)
-    )
-      init_loggers(logger, logger_stderr)
-      # Get a token to this SOAP API
-      @client = Savon.client(
-        wsdl: "#{url}/webservices/SSWebservice.asmx?wsdl",
-        ssl_verify_mode: :none,
-        logger: @logger,
-        log: log_debug?
+    # Access to the Thycotic API
+    class ThycoticApi
+
+      include LoggerHelpers
+
+      # Constructor
+      #
+      # Parameters::
+      # * *url* (String): URL of the Thycotic Secret Server
+      # * *user* (String): User name to be used to connect to Thycotic
+      # * *password* (SecretString): Password to be used to connect to Thycotic
+      # * *domain* (String): Domain to use for authentication to Thycotic [default: ENV['hpc_domain_for_thycotic']]
+      # * *logger* (Logger): Logger to be used [default: Logger.new(STDOUT)]
+      # * *logger_stderr* (Logger): Logger to be used for stderr [default: Logger.new(STDERR)]
+      def initialize(
+        url,
+        user,
+        password,
+        domain: ENV['hpc_domain_for_thycotic'],
+        logger: Logger.new($stdout),
+        logger_stderr: Logger.new($stderr)
       )
-      @token = @client.call(
-        :authenticate,
-        message: {
-          username: user,
-          password: password,
-          domain: domain
-        }
-      ).to_hash.dig(:authenticate_response, :authenticate_result, :token)
-      raise "Unable to get token from SOAP authentication to #{url}" if @token.nil?
-    end
+        init_loggers(logger, logger_stderr)
+        # Get a token to this SOAP API
+        @client = Savon.client(
+          wsdl: "#{url}/webservices/SSWebservice.asmx?wsdl",
+          ssl_verify_mode: :none,
+          logger: @logger,
+          log: log_debug?
+        )
+        @token = @client.call(
+          :authenticate,
+          message: {
+            username: user,
+            password: password&.to_unprotected,
+            domain: domain
+          }
+        ).to_hash.dig(:authenticate_response, :authenticate_result, :token)
+        raise "Unable to get token from SOAP authentication to #{url}" if @token.nil?
+      end
 
-    # Return secret corresponding to a given secret ID
-    #
-    # Parameters::
-    # * *secret_id* (Object): The secret ID
-    # Result::
-    # * Hash: The corresponding API result
-    def get_secret(secret_id)
-      @client.call(
-        :get_secret,
-        message: {
-          token: @token,
-          secretId: secret_id
-        }
-      ).to_hash.dig(:get_secret_response, :get_secret_result)
-    end
+      # Return secret corresponding to a given secret ID
+      #
+      # Parameters::
+      # * *secret_id* (Object): The secret ID
+      # Result::
+      # * Hash: The corresponding API result
+      def get_secret(secret_id)
+        @client.call(
+          :get_secret,
+          message: {
+            token: @token,
+            secretId: secret_id
+          }
+        ).to_hash.dig(:get_secret_response, :get_secret_result)
+      end
+
+      # Get a file attached to a given secret
+      #
+      # Parameters::
+      # * *secret_id* (Object): The secret ID
+      # * *secret_item_id* (Object): The secret item id
+      # Result::
+      # * String or nil: The file content, or nil if none
+      def download_file_attachment_by_item_id(secret_id, secret_item_id)
+        encoded_file = @client.call(
+          :download_file_attachment_by_item_id,
+          message: {
+            token: @token,
+            secretId: secret_id,
+            secretItemId: secret_item_id
+          }
+        ).to_hash.dig(:download_file_attachment_by_item_id_response, :download_file_attachment_by_item_id_result, :file_attachment)
+        encoded_file.nil? ? nil : Base64.decode64(encoded_file)
+      end
 
-    # Get a file attached to a given secret
-    #
-    # Parameters::
-    # * *secret_id* (Object): The secret ID
-    # * *secret_item_id* (Object): The secret item id
-    # Result::
-    # * String or nil: The file content, or nil if none
-    def download_file_attachment_by_item_id(secret_id, secret_item_id)
-      encoded_file = @client.call(
-        :download_file_attachment_by_item_id,
-        message: {
-          token: @token,
-          secretId: secret_id,
-          secretItemId: secret_item_id
-        }
-      ).to_hash.dig(:download_file_attachment_by_item_id_response, :download_file_attachment_by_item_id_result, :file_attachment)
-      encoded_file.nil? ? nil : Base64.decode64(encoded_file)
     end
 
   end

data/lib/hybrid_platforms_conductor/version.rb

@@ -1,5 +1,5 @@
 module HybridPlatformsConductor
 
-  VERSION = '33.3.0'
+  VERSION = '33.7.0'
 
 end

data/spec/hybrid_platforms_conductor_test.rb

@@ -1,5 +1,6 @@
 require 'fileutils'
 require 'tmpdir'
+require 'webmock/rspec'
 require 'hybrid_platforms_conductor/config'
 require 'hybrid_platforms_conductor/platforms_handler'
 require 'hybrid_platforms_conductor/actions_executor'
@@ -83,6 +84,9 @@ module HybridPlatformsConductorTest
     # Make sure the tested components are being reset before each test case
     RSpec.configure do |config|
       config.before do
+        # We allow for connections by default.
+        # Tests that need to test specifically connections at a given point call WebMock.disable_net_connect!
+        WebMock.allow_net_connect!
         @actions_executor = nil
         @cmd_runner = nil
         @config = nil
@@ -95,6 +99,8 @@ module HybridPlatformsConductorTest
         ENV.delete 'hpc_platforms'
         ENV.delete 'hpc_ssh_gateways_conf'
         ENV.delete 'hpc_ssh_gateway_user'
+        ENV.delete 'hpc_user_for_github'
+        ENV.delete 'hpc_password_for_github'
         ENV.delete 'hpc_user_for_proxmox'
         ENV.delete 'hpc_password_for_proxmox'
         ENV.delete 'hpc_realm_for_proxmox'

data/spec/hybrid_platforms_conductor_test/api/actions_executor/actions/bash_spec.rb

@@ -17,6 +17,21 @@ describe HybridPlatformsConductor::ActionsExecutor do
       end
     end
 
+    it 'executes local Bash code from a SecretString' do
+      with_test_platform_for_action_plugins do |repository|
+        expect(
+          test_actions_executor.execute_actions(
+            {
+              'node' => {
+                bash: SecretString.new("echo TestContent >#{repository}/test_file ; echo TestStdout ; echo TestStderr 1>&2", silenced_str: '__INVALID_BASH__')
+              }
+            }
+          )['node']
+        ).to eq [0, "TestStdout\n", "TestStderr\n"]
+        expect(File.read("#{repository}/test_file")).to eq "TestContent\n"
+      end
+    end
+
     it 'executes local Bash code with timeout' do
       with_test_platform_for_action_plugins do
         expect(test_actions_executor.execute_actions(

data/spec/hybrid_platforms_conductor_test/api/actions_executor/actions/remote_bash_spec.rb

@@ -13,6 +13,17 @@ describe HybridPlatformsConductor::ActionsExecutor do
       end
     end
 
+    it 'executes remote Bash code from a SecretString' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions({ 'node' => { remote_bash: SecretString.new('remote_bash_cmd.bash', silenced_str: '__INVALID_BASH__') } })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_bash, 'remote_bash_cmd.bash']
+        ]
+      end
+    end
+
     it 'executes remote Bash code with timeout' do
       with_test_platform_for_action_plugins do
         test_actions_executor.connector(:test_connector).remote_bash_code = proc do |_stdout, _stderr, connector|
@@ -124,6 +135,27 @@ describe HybridPlatformsConductor::ActionsExecutor do
       end
     end
 
+    it 'executes remote Bash code with environment variables set using SecretStrings' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions(
+          {
+            'node' => { remote_bash: {
+              commands: 'bash_cmd.bash',
+              env: {
+                'var1' => SecretString.new('value1', silenced_str: 'SILENCED_VALUE'),
+                'var2' => 'value2'
+              }
+            } }
+          }
+        )
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_bash, "export var1='value1'\nexport var2='value2'\nbash_cmd.bash"]
+        ]
+      end
+    end
+
   end
 
 end

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

@@ -54,6 +54,15 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'executes bash commands remotely from a SecretString' do
+        with_test_platform_for_remote_testing(
+          expected_cmds: [['cd /tmp/hpc_local_workspaces/node ; bash_cmd.bash', proc { [0, 'Bash commands executed on node', ''] }]],
+          expected_stdout: 'Bash commands executed on node'
+        ) do
+          test_connector.remote_bash(SecretString.new('bash_cmd.bash', silenced_str: '__INVALID_BASH__'))
+        end
+      end
+
       it 'executes bash commands remotely with timeout' do
         with_test_platform_for_remote_testing(
           expected_cmds: [
@@ -98,6 +107,10 @@ describe HybridPlatformsConductor::ActionsExecutor do
       it 'copies files remotely with sudo' do
         with_test_platform_for_remote_testing(
           expected_cmds: [
+            [
+              'whoami',
+              proc { [0, 'test_user', ''] }
+            ],
             [
               'sudo -u root cp -r "/path/to/src.file" "/remote_path/to/dst.dir"',
               proc { [0, '', ''] }
@@ -108,9 +121,27 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'copies files remotely with sudo when being root' do
+        with_test_platform_for_remote_testing(
+          expected_cmds: [
+            [
+              'whoami',
+              proc { [0, 'root', ''] }
+            ]
+          ]
+        ) do
+          expect(FileUtils).to receive(:cp_r).with('/path/to/src.file', '/remote_path/to/dst.dir')
+          test_connector.remote_copy('/path/to/src.file', '/remote_path/to/dst.dir', sudo: true)
+        end
+      end
+
       it 'copies files remotely with a different sudo' do
         with_test_platform_for_remote_testing(
           expected_cmds: [
+            [
+              'whoami',
+              proc { [0, 'test_user', ''] }
+            ],
             [
               'other_sudo --user root cp -r "/path/to/src.file" "/remote_path/to/dst.dir"',
               proc { [0, '', ''] }
@@ -124,6 +155,23 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'copies files remotely with a different sudo when being root' do
+        with_test_platform_for_remote_testing(
+          expected_cmds: [
+            [
+              'whoami',
+              proc { [0, 'root', ''] }
+            ]
+          ],
+          additional_config: <<~'EO_CONFIG'
+            sudo_for { |user| "other_sudo --user #{user}" }
+          EO_CONFIG
+        ) do
+          expect(FileUtils).to receive(:cp_r).with('/path/to/src.file', '/remote_path/to/dst.dir')
+          test_connector.remote_copy('/path/to/src.file', '/remote_path/to/dst.dir', sudo: true)
+        end
+      end
+
       it 'copies files remotely with timeout' do
         with_test_platform_for_remote_testing(
           timeout: 5
@@ -143,6 +191,10 @@ describe HybridPlatformsConductor::ActionsExecutor do
       it 'copies relative files remotely with sudo' do
         with_test_platform_for_remote_testing(
           expected_cmds: [
+            [
+              'whoami',
+              proc { [0, 'test_user', ''] }
+            ],
             [
               'sudo -u root cp -r "/path/to/src.file" "/tmp/hpc_local_workspaces/node/to/dst.dir"',
               proc { [0, '', ''] }
@@ -153,9 +205,27 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'copies relative files remotely with sudo when being root' do
+        with_test_platform_for_remote_testing(
+          expected_cmds: [
+            [
+              'whoami',
+              proc { [0, 'root', ''] }
+            ]
+          ]
+        ) do
+          expect(FileUtils).to receive(:cp_r).with('/path/to/src.file', '/tmp/hpc_local_workspaces/node/to/dst.dir')
+          test_connector.remote_copy('/path/to/src.file', 'to/dst.dir', sudo: true)
+        end
+      end
+
       it 'copies relative files remotely with a different sudo' do
         with_test_platform_for_remote_testing(
           expected_cmds: [
+            [
+              'whoami',
+              proc { [0, 'test_user', ''] }
+            ],
             [
               'other_sudo --user root cp -r "/path/to/src.file" "/tmp/hpc_local_workspaces/node/to/dst.dir"',
               proc { [0, '', ''] }
@@ -169,6 +239,23 @@ describe HybridPlatformsConductor::ActionsExecutor do
         end
       end
 
+      it 'copies relative files remotely with a different sudo when being root' do
+        with_test_platform_for_remote_testing(
+          expected_cmds: [
+            [
+              'whoami',
+              proc { [0, 'root', ''] }
+            ]
+          ],
+          additional_config: <<~'EO_CONFIG'
+            sudo_for { |user| "other_sudo --user #{user}" }
+          EO_CONFIG
+        ) do
+          expect(FileUtils).to receive(:cp_r).with('/path/to/src.file', '/tmp/hpc_local_workspaces/node/to/dst.dir')
+          test_connector.remote_copy('/path/to/src.file', 'to/dst.dir', sudo: true)
+        end
+      end
+
     end
 
   end