hybrid_platforms_conductor 32.3.6

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

@@ -0,0 +1,43 @@
+describe HybridPlatformsConductor::ActionsExecutor do
+
+  context 'checking actions\' plugin bash' do
+
+    it 'executes local Bash code' do
+      with_test_platform_for_action_plugins do |repository|
+        expect(test_actions_executor.execute_actions('node' => {
+          bash: "echo TestContent >#{repository}/test_file ; echo TestStdout ; echo TestStderr 1>&2"
+        })['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 |repository|
+        expect(test_actions_executor.execute_actions(
+          { 'node' => {
+            bash: 'sleep 2 ; echo ShouldNotReach'
+          } },
+          timeout: 1
+        )['node']).to eq [:timeout, '', '']
+      end
+    end
+
+    it 'logs local Bash code' do
+      with_repository 'logs' do |logs_dir|
+        with_test_platform_for_action_plugins do |repository|
+          test_actions_executor.execute_actions({
+            'node' => {
+              bash: 'echo TestStdout ; sleep 1 ; echo TestStderr 1>&2'
+            } },
+            log_to_dir: logs_dir
+          )
+          expect(File.exist?("#{logs_dir}/node.stdout")).to eq true
+          expect(File.read("#{logs_dir}/node.stdout")).to eq "TestStdout\nTestStderr\n"
+        end
+      end
+    end
+
+  end
+
+end
+

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

@@ -0,0 +1,18 @@
+describe HybridPlatformsConductor::ActionsExecutor do
+
+  context 'checking actions\' plugin interactive' do
+
+    it 'executes remote interactive session' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions('node' => { interactive: true })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_interactive]
+        ]
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,102 @@
+describe HybridPlatformsConductor::ActionsExecutor do
+
+  context 'checking actions\' plugin remote_bash' do
+
+    it 'executes remote Bash code' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions('node' => { remote_bash: 'remote_bash_cmd.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|
+          expect(connector.timeout).to eq 1
+        end
+        test_actions_executor.execute_actions(
+          { 'node' => { remote_bash: 'remote_bash_cmd.bash' } },
+          timeout: 1
+        )
+        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 in several lines' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions('node' => { remote_bash: ['bash_cmd1.bash', 'bash_cmd2.bash', 'bash_cmd3.bash'] })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_bash, "bash_cmd1.bash\nbash_cmd2.bash\nbash_cmd3.bash"]
+        ]
+      end
+    end
+
+    it 'executes remote Bash code using the commands syntax' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions('node' => { remote_bash: { commands: 'bash_cmd.bash' } })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_bash, 'bash_cmd.bash']
+        ]
+      end
+    end
+
+    it 'executes remote Bash code from a file' do
+      with_test_platform_for_action_plugins do |repository|
+        File.write("#{repository}/commands.txt", "bash_cmd1.bash\nbash_cmd2.bash")
+        test_actions_executor.execute_actions('node' => { remote_bash: { file: "#{repository}/commands.txt" } })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_bash, "bash_cmd1.bash\nbash_cmd2.bash"]
+        ]
+      end
+    end
+
+    it 'executes remote Bash code both from commands and a file' do
+      with_test_platform_for_action_plugins do |repository|
+        File.write("#{repository}/commands.txt", "bash_cmd3.bash\nbash_cmd4.bash")
+        test_actions_executor.execute_actions('node' => { remote_bash: {
+          commands: ['bash_cmd1.bash', 'bash_cmd2.bash'],
+          file: "#{repository}/commands.txt"
+        } })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_bash, "bash_cmd1.bash\nbash_cmd2.bash\nbash_cmd3.bash\nbash_cmd4.bash"]
+        ]
+      end
+    end
+
+    it 'executes remote Bash code with environment variables set' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions('node' => { remote_bash: {
+          commands: 'bash_cmd.bash',
+          env: {
+            'var1' => 'value1',
+            '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/actions/ruby_spec.rb

@@ -0,0 +1,108 @@
+describe HybridPlatformsConductor::ActionsExecutor do
+
+  context 'checking actions\' plugin ruby' do
+
+    it 'executes local Ruby code' do
+      with_test_platform_for_action_plugins do
+        executed = false
+        expect(test_actions_executor.execute_actions('node' => {
+          ruby: proc do |stdout, stderr, action|
+            stdout << 'TestStdout'
+            stderr << 'TestStderr'
+            executed = true
+          end
+        })['node']).to eq [0, 'TestStdout', 'TestStderr']
+        expect(executed).to eq true
+      end
+    end
+
+    it 'executes local Ruby code with timeout' do
+      pending 'Implement timeout for Ruby actions'
+      with_test_platform_for_action_plugins do
+        executed = false
+        expect(test_actions_executor.execute_actions(
+          { 'node' => {
+            ruby: proc do |stdout, stderr, action|
+              sleep 2
+              stdout << 'ShouldNotReach'
+              executed = true
+            end
+          } },
+          timeout: 1
+        )['node']).to eq [:timeout, '', '']
+        expect(executed).to eq false
+      end
+    end
+
+    it 'logs local Ruby code' do
+      with_repository 'logs' do |logs_dir|
+        with_test_platform_for_action_plugins do
+          test_actions_executor.execute_actions(
+            { 'node' => {
+              ruby: proc do |stdout, stderr, action|
+                stdout << "TestStdout\n"
+                stderr << "TestStderr\n"
+              end
+            } },
+            log_to_dir: logs_dir
+          )
+          expect(File.exist?("#{logs_dir}/node.stdout")).to eq true
+          expect(File.read("#{logs_dir}/node.stdout")).to eq "TestStdout\nTestStderr\n"
+        end
+      end
+    end
+
+    it 'executes local Ruby code that needs an action' do
+      with_test_platform_for_action_plugins do
+        executed = false
+        expect(test_actions_executor.execute_actions('node' => {
+          ruby: proc do |stdout, stderr, action|
+            expect(action.is_a?(HybridPlatformsConductor::HpcPlugins::Action::Ruby)).to eq true
+            stdout << 'TestStdout'
+            stderr << 'TestStderr'
+            executed = true
+          end
+        })['node']).to eq [0, 'TestStdout', 'TestStderr']
+        expect(executed).to eq true
+      end
+    end
+
+    it 'executes local Ruby code that needs a connector' do
+      with_test_platform_for_action_plugins do
+        executed = false
+        expect(test_actions_executor.execute_actions('node' => {
+          ruby: {
+            code: proc do |stdout, stderr, action, connector|
+              expect(connector.is_a?(HybridPlatformsConductorTest::TestConnector)).to eq true
+              stdout << 'TestStdout'
+              stderr << 'TestStderr'
+              executed = true
+            end,
+            need_remote: true
+          }
+        })['node']).to eq [0, 'TestStdout', 'TestStderr']
+        expect(executed).to eq true
+      end
+    end
+
+    it 'executes local Ruby code that does not need a connector' do
+      with_test_platform_for_action_plugins do
+        executed = false
+        expect(test_actions_executor.execute_actions('node' => {
+          ruby: {
+            code: proc do |stdout, stderr, action, connector|
+              expect(connector).to be_nil
+              stdout << 'TestStdout'
+              stderr << 'TestStderr'
+              executed = true
+            end,
+            need_remote: false
+          }
+        })['node']).to eq [0, 'TestStdout', 'TestStderr']
+        expect(executed).to eq true
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,79 @@
+describe HybridPlatformsConductor::ActionsExecutor do
+
+  context 'checking actions\' plugin scp' do
+
+    it 'executes remote SCP' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions('node' => { scp: { 'from' => 'to' } })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_copy, 'from', 'to']
+        ]
+      end
+    end
+
+    it 'executes remote SCP with timeout' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.connector(:test_connector).remote_copy_code = proc do |_stdout, _stderr, connector|
+          expect(connector.timeout).to eq 1
+        end
+        test_actions_executor.execute_actions(
+          { 'node' => { scp: { 'from' => 'to' } } },
+          timeout: 1
+        )
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_copy, 'from', 'to']
+        ]
+      end
+    end
+
+    it 'executes remote SCP on several files' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions('node' => { scp: {
+          'from1' => 'to1',
+          'from2' => 'to2'
+        } })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_copy, 'from1', 'to1'],
+          [:remote_copy, 'from2', 'to2']
+        ]
+      end
+    end
+
+    it 'executes remote SCP with sudo' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions('node' => { scp: {
+          'from' => 'to',
+          sudo: true
+        } })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_copy, 'from', 'to', { sudo: true }]
+        ]
+      end
+    end
+
+    it 'executes remote SCP with different owner and group' do
+      with_test_platform_for_action_plugins do
+        test_actions_executor.execute_actions('node' => { scp: {
+          'from' => 'to',
+          owner: 'new_owner',
+          group: 'new_group'
+        } })
+        expect(test_actions_executor.connector(:test_connector).calls).to eq [
+          [:connectable_nodes_from, ['node']],
+          [:with_connection_to, ['node'], { no_exception: true }],
+          [:remote_copy, 'from', 'to', { owner: 'new_owner', group: 'new_group' }]
+        ]
+      end
+    end
+
+  end
+
+end

data/spec/hybrid_platforms_conductor_test/api/actions_executor/actions_spec.rb

@@ -0,0 +1,199 @@
+describe HybridPlatformsConductor::ActionsExecutor do
+
+  context 'checking actions handling' do
+
+    # Instantiate a test platform, with the test action registered in Actions Executor.
+    #
+    # Parameters::
+    # * Proc: Code called with the environment ready
+    #   * Parameters::
+    #     * *repository* (String): Path to the repository
+    def with_test_platform_for_actions
+      with_test_platform_for_executor(nodes: { 'node1' => {}, 'node2' => {}, 'node3' => {} }) do |repository|
+        yield repository
+      end
+    end
+
+    it 'executes a simple action on 1 node' do
+      with_test_platform_for_actions do
+        test_actions_executor.execute_actions('node1' => { test_action: 'Action executed' })
+        expect(action_executions).to eq [{ node: 'node1', message: 'Action executed' }]
+      end
+    end
+
+    it 'fails to execute an unknown action' do
+      with_test_platform_for_actions do
+        expect { test_actions_executor.execute_actions('node1' => { unknown_action: 'Action executed' }) }.to raise_error(/Unknown action type unknown_action/)
+      end
+    end
+
+    it 'executes a simple action on several nodes' do
+      with_test_platform_for_actions do
+        test_actions_executor.execute_actions(%w[node1 node2 node3] => { test_action: 'Action executed' })
+        expect(action_executions).to eq [
+          { node: 'node1', message: 'Action executed' },
+          { node: 'node2', message: 'Action executed' },
+          { node: 'node3', message: 'Action executed' }
+        ]
+      end
+    end
+
+    it 'executes several actions on 1 node' do
+      with_test_platform_for_actions do
+        test_actions_executor.execute_actions('node1' => [
+          { test_action: 'Action 1 executed' },
+          { test_action: 'Action 2 executed' },
+          { test_action: 'Action 3 executed' }
+        ])
+        expect(action_executions).to eq [
+          { node: 'node1', message: 'Action 1 executed' },
+          { node: 'node1', message: 'Action 2 executed' },
+          { node: 'node1', message: 'Action 3 executed' }
+        ]
+      end
+    end
+
+    it 'executes different actions on several nodes' do
+      with_test_platform_for_actions do
+        test_actions_executor.execute_actions(
+          'node1' => { test_action: 'Action 1 executed' },
+          'node2' => { test_action: 'Action 2 executed' },
+          'node3' => { test_action: 'Action 3 executed' }
+        )
+        expect(action_executions).to eq [
+          { node: 'node1', message: 'Action 1 executed' },
+          { node: 'node2', message: 'Action 2 executed' },
+          { node: 'node3', message: 'Action 3 executed' }
+        ]
+      end
+    end
+
+    it 'executes several actions of different types' do
+      with_test_platform_for_actions do
+        actions_executed = []
+        expect(test_actions_executor.execute_actions('node1' => [
+          { ruby: proc do |stdout, stderr|
+            stdout << 'action1_stdout '
+            stderr << 'action1_stderr '
+            actions_executed << 'action1'
+          end },
+          { bash: 'echo action2_stdout' },
+          { ruby: proc do |stdout, stderr|
+            stdout << 'action3_stdout'
+            stderr << 'action3_stderr'
+            actions_executed << 'action3'
+          end }
+        ])).to eq('node1' => [0, "action1_stdout action2_stdout\naction3_stdout", 'action1_stderr action3_stderr'])
+        expect(actions_executed).to eq %w[action1 action3]
+      end
+    end
+
+    it 'executes several actions on 1 node specified using different selectors' do
+      with_test_platform_for_actions do
+        actions_executed = []
+        test_actions_executor.execute_actions(
+          'node1' => { test_action: 'Action 1 executed' },
+          '/node1/' => { test_action: 'Action 2 executed' }
+        )
+        expect(action_executions).to eq [
+          { node: 'node1', message: 'Action 1 executed' },
+          { node: 'node1', message: 'Action 2 executed' }
+        ]
+      end
+    end
+
+    it 'fails to execute an action on an unknown node' do
+      with_test_platform_for_actions do
+        expect { test_actions_executor.execute_actions('unknown_node' => { test_action: 'Action executed' }) }.to raise_error(RuntimeError, 'Unknown nodes: unknown_node')
+        expect(action_executions).to eq []
+      end
+    end
+
+    it 'fails to execute actions being interactive in parallel' do
+      with_test_platform_for_actions do
+        expect do
+          test_actions_executor.execute_actions(
+            {
+              'node1' => { test_action: 'Action executed' },
+              'node2' => { interactive: true }
+            },
+            concurrent: true
+          )
+        end.to raise_error(RuntimeError, 'Cannot have concurrent executions for interactive sessions')
+      end
+    end
+
+    it 'returns errors without failing for actions having command issues' do
+      with_test_platform_for_actions do
+        expect(test_actions_executor.execute_actions(
+          'node1' => { test_action: { code: proc { |stdout| stdout << 'Action 1' } } },
+          'node2' => { test_action: { code: proc { raise HybridPlatformsConductor::CmdRunner::UnexpectedExitCodeError, 'Command returned 1' } } },
+          'node3' => { test_action: { code: proc { |stdout| stdout << 'Action 3' } } }
+        )).to eq(
+          'node1' => [0, 'Action 1', ''],
+          'node2' => [:failed_command, '', "Command returned 1\n"],
+          'node3' => [0, 'Action 3', '']
+        )
+      end
+    end
+
+    it 'returns errors without failing for actions having timeout issues' do
+      with_test_platform_for_actions do
+        expect(test_actions_executor.execute_actions(
+          'node1' => { test_action: { code: proc { |stdout| stdout << 'Action 1' } } },
+          'node2' => { test_action: { code: proc { raise HybridPlatformsConductor::CmdRunner::TimeoutError } } },
+          'node3' => { test_action: { code: proc { |stdout| stdout << 'Action 3' } } }
+        )).to eq(
+          'node1' => [0, 'Action 1', ''],
+          'node2' => [:timeout, '', ''],
+          'node3' => [0, 'Action 3', '']
+        )
+      end
+    end
+
+    it 'returns errors without failing for actions having connection issues' do
+      with_test_platform_for_actions do
+        expect(test_actions_executor.execute_actions(
+          'node1' => { test_action: { code: proc { |stdout| stdout << 'Action 1' } } },
+          'node2' => { test_action: { code: proc { raise HybridPlatformsConductor::ActionsExecutor::ConnectionError, 'Can\'t connect' } } },
+          'node3' => { test_action: { code: proc { |stdout| stdout << 'Action 3' } } }
+        )).to eq(
+          'node1' => [0, 'Action 1', ''],
+          'node2' => [:connection_error, '', "Can't connect\n"],
+          'node3' => [0, 'Action 3', '']
+        )
+      end
+    end
+
+    it 'returns errors without failing for actions having unhandled exceptions' do
+      with_test_platform_for_actions do
+        expect(test_actions_executor.execute_actions(
+          'node1' => { test_action: { code: proc { |stdout| stdout << 'Action 1' } } },
+          'node2' => { test_action: { code: proc { raise 'Strange error' } } },
+          'node3' => { test_action: { code: proc { |stdout| stdout << 'Action 3' } } }
+        )).to eq(
+          'node1' => [0, 'Action 1', ''],
+          'node2' => [:failed_action, '', "Strange error\n"],
+          'node3' => [0, 'Action 3', '']
+        )
+      end
+    end
+
+    it 'returns errors without failing for actions on nodes having no connectors' do
+      with_test_platform_for_actions do
+        test_actions_executor.connector(:test_connector).accept_nodes = %w[node1 node3]
+        expect(test_actions_executor.execute_actions(
+          'node1' => { test_action: { need_connector: true, code: proc { |stdout| stdout << 'Action 1' } } },
+          'node2' => { test_action: { need_connector: true, code: proc { |stdout| stdout << 'Action 2' } } },
+          'node3' => { test_action: { need_connector: true, code: proc { |stdout| stdout << 'Action 3' } } }
+        )).to eq(
+          'node1' => [0, 'Action 1', ''],
+          'node2' => [:no_connector, '', 'Unable to get a connector to node2'],
+          'node3' => [0, 'Action 3', '']
+        )
+      end
+    end
+
+  end
+
+end