hybrid_platforms_conductor 32.16.3 → 33.0.0

data/spec/hybrid_platforms_conductor_test/helpers/connector_ssh_helpers.rb

@@ -136,7 +136,7 @@ module HybridPlatformsConductorTest
         session_exec: true
       )
         with_test_platform(
-          { nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: session_exec ? 'true' : 'false' } } } },
+          { nodes: { 'node' => { meta: { host_ip: '192.168.42.42', ssh_session_exec: session_exec } } } },
           false,
           additional_config
         ) do

data/spec/hybrid_platforms_conductor_test/helpers/deployer_helpers.rb

@@ -68,71 +68,21 @@ module HybridPlatformsConductorTest
         Hash[nodes.map { |node| [node, [0, 'Release mutex successful', '']] }]
       end
 
-      # Expect a given set of actions to upload log files on a list of nodes
+      # Expect a given set of actions to upload log files on a list of nodes (using the test_log log plugin)
       #
       # Parameters::
       # * *actions* (Object): Actions
       # * *nodes* (String or Array<String>): Node (or list of nodes) that should be checked
-      # * *sudo* (String or nil): sudo supposed to be used, or nil if none [default: 'sudo -u root']
-      def expect_actions_to_upload_logs(actions, nodes, sudo: 'sudo -u root')
+      def expect_actions_to_upload_logs(actions, nodes)
         nodes = [nodes] if nodes.is_a?(String)
         expect(actions.size).to eq nodes.size
         nodes.each do |node|
           expect(actions.key?(node)).to eq true
-          expect(actions[node][:remote_bash]).to eq "#{sudo ? "#{sudo} " : ''}mkdir -p /var/log/deployments"
-          expect(actions[node][:scp].first[1]).to eq '/var/log/deployments'
-          expect(actions[node][:scp][:group]).to eq 'root'
-          expect(actions[node][:scp][:owner]).to eq 'root'
-          expect(actions[node][:scp][:sudo]).to eq (!sudo.nil?)
+          expect(actions[node]).to eq [{ bash: "echo Save test logs to #{node}" }]
         end
         Hash[nodes.map { |node| [node, [0, 'Logs uploaded', '']] }]
       end
 
-      # Expect some logs to have the following information.
-      # Expected logs format:
-      #
-      # date: 2019-08-14 17:02:57
-      # user: muriel
-      # debug: Yes
-      # repo_name: my_remote_platform
-      # commit_id: c0d16b1b7ae286ae4a059185957e08f0ddc95517
-      # commit_message: Test commit
-      # diff_files: 
-      # ===== STDOUT =====
-      # Deploy successful
-      # ===== STDERR =====
-      #
-      # Parameters::
-      # * *logs* (String): The logs content
-      # * *stdout* (String): Expected STDOUT
-      # * *stderr* (String): Expected STDERR
-      # * *properties* (Hash<Symbol, String or Regexp>): Expected properties values, per name. Values can be exact strings or regexps.
-      def expect_logs_to_be(logs, stdout, stderr, properties)
-        lines = logs.split("\n")
-        idx_stdout = lines.index('===== STDOUT =====')
-        expect(idx_stdout).not_to eq nil
-        idx_stderr = lines.index('===== STDERR =====')
-        expect(idx_stderr).not_to eq nil
-        logs_properties = Hash[lines[0..idx_stdout - 1].map do |property_line|
-          property_fields = property_line.split(': ')
-          [
-            property_fields.first.to_sym,
-            property_fields[1..-1].join(': ')
-          ]
-        end]
-        expect(logs_properties.size).to eq properties.size
-        properties.each do |expected_property, expected_property_value|
-          expect(logs_properties.key?(expected_property)).to eq true
-          if expected_property_value.is_a?(String)
-            expect(logs_properties[expected_property]).to eq expected_property_value
-          else
-            expect(logs_properties[expected_property]).to match expected_property_value
-          end
-        end
-        expect(lines[idx_stdout + 1..idx_stderr - 1].join("\n")).to eq stdout
-        expect(lines[idx_stderr + 1..-1].join("\n")).to eq stderr
-      end
-
       # Get a test Deployer
       #
       # Result::
@@ -142,6 +92,43 @@ module HybridPlatformsConductorTest
         @deployer
       end
 
+      # Expect the test services handler to be called to deploy a given list of services
+      #
+      # Parameters::
+      # * *services* (Hash<String, Array<String> >): List of services to be expected, per node name
+      def expect_services_handler_to_deploy(services)
+        expect(test_services_handler).to receive(:deploy_allowed?).with(
+          services: services,
+          secrets: {},
+          local_environment: false
+        ) do
+          nil
+        end
+        expect(test_services_handler).to receive(:package).with(
+          services: services,
+          secrets: {},
+          local_environment: false
+        )
+        expect(test_services_handler).to receive(:prepare_for_deploy).with(
+          services: services,
+          secrets: {},
+          local_environment: false,
+          why_run: false
+        )
+        services.each do |node, services|
+          expect(test_services_handler).to receive(:actions_to_deploy_on).with(node, services, false) do
+            [{ bash: "echo \"Deploying on #{node}\"" }]
+          end
+          expect(test_services_handler).to receive(:log_info_for).with(node, services) do
+            {
+              repo_name_0: 'platform',
+              commit_id_0: '123456',
+              commit_message_0: "Test commit for #{node}: #{services.join(', ')}"
+            }
+          end
+        end
+      end
+
     end
 
   end

data/spec/hybrid_platforms_conductor_test/helpers/deployer_test_helpers.rb

@@ -69,7 +69,7 @@ module HybridPlatformsConductorTest
                   }
                 end
               end
-              actions << proc { |actions_per_nodes| expect_actions_to_upload_logs(actions_per_nodes, services.keys, sudo: sudo) }
+              actions << proc { |actions_per_nodes| expect_actions_to_upload_logs(actions_per_nodes, services.keys) }
             end
             actions
           end
@@ -78,6 +78,8 @@ module HybridPlatformsConductorTest
           #
           # Parameters::
           # * *nodes_info* (Hash): Node info to give the platform [default: 1 node having 1 service]
+          # * *expect_services_to_deploy* (Hash<String,Array<String>>): Expected services to be deployed [default: all services from nodes_info]
+          # * *expect_deploy_allowed* (Boolean): Should we expect the call to deploy_allowed? [default: true]
           # * *expect_package* (Boolean): Should we expect packaging? [default: true]
           # * *expect_prepare_for_deploy* (Boolean): Should we expect calls to prepare for deploy? [default: true]
           # * *expect_connections_to_nodes* (Boolean): Should we expect connections to nodes? [default: true]
@@ -95,6 +97,8 @@ module HybridPlatformsConductorTest
           #     * *repository* (String): Path to the repository
           def with_platform_to_deploy(
             nodes_info: { nodes: { 'node' => { services: %w[service] } } },
+            expect_services_to_deploy: Hash[nodes_info[:nodes].map { |node, node_info| [node, node_info[:services]] }],
+            expect_deploy_allowed: true,
             expect_package: true,
             expect_prepare_for_deploy: true,
             expect_connections_to_nodes: true,
@@ -109,12 +113,9 @@ module HybridPlatformsConductorTest
             additional_config: ''
           )
             platform_name = check_mode ? 'platform' : 'my_remote_platform'
-            with_test_platform(nodes_info, !check_mode, additional_config) do |repository|
+            with_test_platform(nodes_info, !check_mode, additional_config + "\nsend_logs_to :test_log") do |repository|
               # Mock the ServicesHandler accesses
-              expect_services_to_deploy = Hash[nodes_info[:nodes].map do |node, node_info|
-                [node, node_info[:services]]
-              end]
-              unless check_mode
+              if !check_mode && expect_deploy_allowed
                 expect(test_services_handler).to receive(:deploy_allowed?).with(
                   services: expect_services_to_deploy,
                   secrets: expect_secrets,
@@ -144,7 +145,7 @@ module HybridPlatformsConductorTest
               end
               test_deployer.use_why_run = true if check_mode
               if expect_connections_to_nodes
-                with_connections_mocked_on(nodes_info[:nodes].keys) do
+                with_connections_mocked_on(expect_services_to_deploy.keys) do
                   expect_actions_executor_runs(expected_actions_for_deploy_on(
                     services: expect_services_to_deploy,
                     check_mode: check_mode,
@@ -218,14 +219,7 @@ module HybridPlatformsConductorTest
 
           it 'deploys on 1 node using 1 secret' do
             with_platform_to_deploy(expect_secrets: { 'secret1' => 'password1' }) do
-              test_deployer.secrets = [{ 'secret1' => 'password1' }]
-              expect(test_deployer.deploy_on('node')).to eq('node' => expected_deploy_result)
-            end
-          end
-
-          it 'deploys on 1 node using several secrets' do
-            with_platform_to_deploy(expect_secrets: { 'secret1' => 'password1', 'secret2' => 'password2' }) do
-              test_deployer.secrets = [{ 'secret1' => 'password1' }, { 'secret2' => 'password2' }]
+              test_deployer.override_secrets('secret1' => 'password1')
               expect(test_deployer.deploy_on('node')).to eq('node' => expected_deploy_result)
             end
           end
@@ -901,6 +895,248 @@ module HybridPlatformsConductorTest
 
           end
 
+          context 'checking secrets handling' do
+
+            it 'calls secrets readers only for nodes and services to be deployed and merges their secrets' do
+              register_plugins(
+                :secrets_reader,
+                {
+                  secrets_reader1: HybridPlatformsConductorTest::TestSecretsReaderPlugin,
+                  secrets_reader2: HybridPlatformsConductorTest::TestSecretsReaderPlugin,
+                  secrets_reader3: HybridPlatformsConductorTest::TestSecretsReaderPlugin
+                }
+              )
+              with_platform_to_deploy(
+                nodes_info: {
+                  nodes: {
+                    'node1' => { services: %w[service1 service2] },
+                    'node2' => { services: %w[service2 service3] },
+                    'node3' => { services: %w[service3] },
+                    'node4' => { services: %w[service1 service3] }
+                  }
+                },
+                expect_services_to_deploy: {
+                  'node1' => %w[service1 service2],
+                  'node2' => %w[service2 service3],
+                  'node3' => %w[service3]
+                },
+                expect_secrets: {
+                  'node1' => {
+                    'service1' => {
+                      'secrets_reader1' => 'Secret value',
+                      'secrets_reader2' => 'Secret value'
+                    },
+                    'service2' => {
+                      'secrets_reader1' => 'Secret value',
+                      'secrets_reader2' => 'Secret value'
+                    }
+                  },
+                  'node2' => {
+                    'service2' => {
+                      'secrets_reader1' => 'Secret value',
+                      'secrets_reader2' => 'Secret value',
+                      'secrets_reader3' => 'Secret value'
+                    },
+                    'service3' => {
+                      'secrets_reader1' => 'Secret value',
+                      'secrets_reader2' => 'Secret value',
+                      'secrets_reader3' => 'Secret value'
+                    }
+                  },
+                  'node3' => {
+                    'service3' => {
+                      'secrets_reader1' => 'Secret value',
+                      'secrets_reader2' => 'Secret value'
+                    }
+                  }
+                },
+                additional_config: <<~EOS
+                  read_secrets_from %i[secrets_reader1 secrets_reader2]
+                  for_nodes('node2') { read_secrets_from :secrets_reader3 }
+                EOS
+              ) do
+                TestSecretsReaderPlugin.deployer = test_deployer
+                expect(test_deployer.deploy_on(%w[node1 node2 node3])).to eq(
+                  'node1' => expected_deploy_result,
+                  'node2' => expected_deploy_result,
+                  'node3' => expected_deploy_result
+                )
+                expect(HybridPlatformsConductorTest::TestSecretsReaderPlugin.calls).to eq [
+                  { instance: :secrets_reader1, node: 'node1', service: 'service1' },
+                  { instance: :secrets_reader1, node: 'node1', service: 'service2' },
+                  { instance: :secrets_reader2, node: 'node1', service: 'service1' },
+                  { instance: :secrets_reader2, node: 'node1', service: 'service2' },
+                  { instance: :secrets_reader1, node: 'node2', service: 'service2' },
+                  { instance: :secrets_reader1, node: 'node2', service: 'service3' },
+                  { instance: :secrets_reader2, node: 'node2', service: 'service2' },
+                  { instance: :secrets_reader2, node: 'node2', service: 'service3' },
+                  { instance: :secrets_reader3, node: 'node2', service: 'service2' },
+                  { instance: :secrets_reader3, node: 'node2', service: 'service3' },
+                  { instance: :secrets_reader1, node: 'node3', service: 'service3' },
+                  { instance: :secrets_reader2, node: 'node3', service: 'service3' }
+                ]
+              end
+            end
+
+            it 'merges secrets having same values' do
+              register_plugins(
+                :secrets_reader,
+                {
+                  secrets_reader1: HybridPlatformsConductorTest::TestSecretsReaderPlugin,
+                  secrets_reader2: HybridPlatformsConductorTest::TestSecretsReaderPlugin
+                }
+              )
+              with_platform_to_deploy(
+                nodes_info: {
+                  nodes: {
+                    'node1' => { services: %w[service1] },
+                    'node2' => { services: %w[service2] }
+                  }
+                },
+                expect_secrets: {
+                  'global1' => 'value1',
+                  'global2' => 'value2',
+                  'global3' => 'value3',
+                  'global4' => 'value4'
+                },
+                additional_config: <<~EOS
+                  read_secrets_from :secrets_reader1
+                  for_nodes('node2') { read_secrets_from :secrets_reader2 }
+                EOS
+              ) do
+                TestSecretsReaderPlugin.deployer = test_deployer
+                TestSecretsReaderPlugin.mocked_secrets = {
+                  'node1' => {
+                    'service1' => {
+                      secrets_reader1: {
+                        'global1' => 'value1',
+                        'global2' => 'value2'
+                      }
+                    }
+                  },
+                  'node2' => {
+                    'service2' => {
+                      secrets_reader1: {
+                        'global2' => 'value2',
+                        'global3' => 'value3'
+                      },
+                      secrets_reader2: {
+                        'global3' => 'value3',
+                        'global4' => 'value4'
+                      }
+                    }
+                  }
+                }
+                expect(test_deployer.deploy_on(%w[node1 node2])).to eq(
+                  'node1' => expected_deploy_result,
+                  'node2' => expected_deploy_result
+                )
+                expect(HybridPlatformsConductorTest::TestSecretsReaderPlugin.calls).to eq [
+                  { instance: :secrets_reader1, node: 'node1', service: 'service1' },
+                  { instance: :secrets_reader1, node: 'node2', service: 'service2' },
+                  { instance: :secrets_reader2, node: 'node2', service: 'service2' }
+                ]
+              end
+            end
+
+            it 'fails when merging secrets having different values' do
+              register_plugins(
+                :secrets_reader,
+                {
+                  secrets_reader1: HybridPlatformsConductorTest::TestSecretsReaderPlugin,
+                  secrets_reader2: HybridPlatformsConductorTest::TestSecretsReaderPlugin
+                }
+              )
+              with_platform_to_deploy(
+                nodes_info: {
+                  nodes: {
+                    'node1' => { services: %w[service1] },
+                    'node2' => { services: %w[service2] }
+                  }
+                },
+                expect_deploy_allowed: false,
+                expect_package: false,
+                expect_prepare_for_deploy: false,
+                expect_connections_to_nodes: false,
+                additional_config: <<~EOS
+                  read_secrets_from :secrets_reader1
+                  for_nodes('node2') { read_secrets_from :secrets_reader2 }
+                EOS
+              ) do
+                TestSecretsReaderPlugin.deployer = test_deployer
+                TestSecretsReaderPlugin.mocked_secrets = {
+                  'node1' => {
+                    'service1' => {
+                      secrets_reader1: {
+                        'global1' => 'value1',
+                        'global2' => 'value2'
+                      }
+                    }
+                  },
+                  'node2' => {
+                    'service2' => {
+                      secrets_reader1: {
+                        'global2' => 'value2',
+                        'global3' => {
+                          'sub_key' => 'value3'
+                        }
+                      },
+                      secrets_reader2: {
+                        'global3' => {
+                          'sub_key' => 'Other value'
+                        },
+                        'global4' => 'value4'
+                      }
+                    }
+                  }
+                }
+                expect { test_deployer.deploy_on(%w[node1 node2]) }.to raise_error 'Secret set at path global3->sub_key by secrets_reader2 for service service2 on node node2 has conflicting values (set debug for value details).'
+                expect(HybridPlatformsConductorTest::TestSecretsReaderPlugin.calls).to eq [
+                  { instance: :secrets_reader1, node: 'node1', service: 'service1' },
+                  { instance: :secrets_reader1, node: 'node2', service: 'service2' },
+                  { instance: :secrets_reader2, node: 'node2', service: 'service2' }
+                ]
+              end
+            end
+
+            it 'does not call secrets readers when secrets are overridden' do
+              register_plugins(
+                :secrets_reader,
+                {
+                  secrets_reader1: HybridPlatformsConductorTest::TestSecretsReaderPlugin,
+                  secrets_reader2: HybridPlatformsConductorTest::TestSecretsReaderPlugin,
+                  secrets_reader3: HybridPlatformsConductorTest::TestSecretsReaderPlugin
+                }
+              )
+              with_platform_to_deploy(
+                nodes_info: {
+                  nodes: {
+                    'node1' => { services: %w[service1] },
+                    'node2' => { services: %w[service2] },
+                    'node3' => { services: %w[service3] }
+                  }
+                },
+                expect_secrets: {
+                  'overridden_secrets' => 'value'
+                },
+                additional_config: <<~EOS
+                  read_secrets_from %i[secrets_reader1 secrets_reader2]
+                  for_nodes('node2') { read_secrets_from :secrets_reader3 }
+                EOS
+              ) do
+                TestSecretsReaderPlugin.deployer = test_deployer
+                test_deployer.override_secrets('overridden_secrets' => 'value')
+                expect(test_deployer.deploy_on(%w[node1 node2 node3])).to eq(
+                  'node1' => expected_deploy_result,
+                  'node2' => expected_deploy_result,
+                  'node3' => expected_deploy_result
+                )
+                expect(HybridPlatformsConductorTest::TestSecretsReaderPlugin.calls).to eq []
+              end
+            end
+
+          end
+
         end
 
       end

data/spec/hybrid_platforms_conductor_test/test_log_no_read_plugin.rb

@@ -0,0 +1,82 @@
+module HybridPlatformsConductorTest
+
+  # Test log without reading actions
+  class TestLogNoReadPlugin < HybridPlatformsConductor::Log
+
+    class << self
+      attr_accessor :calls
+    end
+
+    # Get actions to save logs
+    # [API] - This method is mandatory.
+    # [API] - The following API components are accessible:
+    # * *@config* (Config): Main configuration API.
+    # * *@nodes_handler* (NodesHandler): Nodes handler API.
+    # * *@actions_executor* (ActionsExecutor): Actions executor API.
+    #
+    # Parameters::
+    # * *node* (String): Node for which logs are being saved
+    # * *services* (Array<String>): The list of services that have been deployed on this node
+    # * *deployment_info* (Hash<Symbol,Object>): Additional information to attach to the logs
+    # * *exit_status* (Integer or Symbol): Exit status of the deployment
+    # * *stdout* (String): Deployment's stdout
+    # * *stderr* (String): Deployment's stderr
+    # Result::
+    # * Array< Hash<Symbol,Object> >: List of actions to be done
+    def actions_to_save_logs(node, services, deployment_info, exit_status, stdout, stderr)
+      TestLogNoReadPlugin.calls << {
+        method: :actions_to_save_logs,
+        node: node,
+        services: services,
+        # Don't store the date
+        deployment_info: deployment_info.select { |k, _v| k != :date },
+        exit_status: exit_status,
+        stdout: stdout,
+        stderr: stderr
+      }
+      [{ bash: "echo Save test logs to #{node}" }]
+    end
+
+    # Get deployment logs from a node.
+    # This method can use the result of actions previously run to read logs, as returned by the actions_to_read_logs method.
+    # [API] - This method is mandatory.
+    # [API] - The following API components are accessible:
+    # * *@config* (Config): Main configuration API.
+    # * *@nodes_handler* (NodesHandler): Nodes handler API.
+    # * *@actions_executor* (ActionsExecutor): Actions executor API.
+    #
+    # Parameters::
+    # * *node* (String): The node we want deployment logs from
+    # * *exit_status* (Integer, Symbol or nil): Exit status of actions to read logs, or nil if no action was returned by actions_to_read_logs
+    # * *stdout* (String or nil): stdout of actions to read logs, or nil if no action was returned by actions_to_read_logs
+    # * *stderr* (String or nil): stderr of actions to read logs, or nil if no action was returned by actions_to_read_logs
+    # Result::
+    # * Hash<Symbol,Object>: Deployment log information:
+    #   * *error* (String): Error string in case deployment logs could not be retrieved. If set then further properties will be ignored. [optional]
+    #   * *services* (Array<String>): List of services deployed on the node
+    #   * *deployment_info* (Hash<Symbol,Object>): Deployment metadata
+    #   * *exit_status* (Integer or Symbol): Deployment exit status
+    #   * *stdout* (String): Deployment stdout
+    #   * *stderr* (String): Deployment stderr
+    def logs_for(node, exit_status, stdout, stderr)
+      TestLogNoReadPlugin.calls << {
+        method: :logs_for,
+        node: node,
+        exit_status: exit_status,
+        stdout: stdout,
+        stderr: stderr
+      }
+      {
+        services: %w[unknown],
+        deployment_info: {
+          user: 'test_user'
+        },
+        exit_status: 666,
+        stdout: 'Deployment test stdout',
+        stderr: 'Deployment test stderr'
+      }
+    end
+
+  end
+
+end