gooddata 2.2.0-java → 2.3.0-java

data/gooddata.gemspec

@@ -1,13 +1,11 @@
 # encoding: utf-8
 $LOAD_PATH.push File.expand_path('../lib/', __FILE__)
 require 'gooddata/version'
-
 Gem::Specification.new do |s|
   s.name = 'gooddata'
   s.version = GoodData::VERSION
   s.licenses = ['BSD-3-Clause']
   s.platform = 'java' if RUBY_PLATFORM =~ /java/
-
   s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
   s.authors = [
     'Pavel Kolesnikov',
@@ -18,27 +16,27 @@ Gem::Specification.new do |s|
     'Petr Gadorek',
     'Jakub Mahnert'
   ]
-
   s.summary = 'A convenient Ruby wrapper around the GoodData RESTful API'
   s.description = 'Use the GoodData::Client class to integrate GoodData into your own application or use the CLI to work with GoodData directly from the command line.'
   s.email = 'lcm@gooddata.com'
   s.extra_rdoc_files = %w(LICENSE README.md)
-
   s.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR).map { |f| f unless %w(NOTICES.txt LICENSE_FOR_RUBY_SDK_COMPONENT.txt).include?(f) }
   s.files.reject! { |fn| fn.start_with? 'spec/' }
   s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-
   s.homepage = 'http://github.com/gooddata/gooddata-ruby'
   s.require_paths = ['lib']
-
   # s.add_development_dependency 'bundler', "~> 1.14"
   s.add_development_dependency 'license_finder', '~> 2.0'
-  s.add_development_dependency 'rake', '~> 11.1'
+  s.add_development_dependency 'rake', '~> 13.0'
   s.add_development_dependency 'redcarpet', '~> 3.1' if RUBY_PLATFORM != 'java'
-  s.add_development_dependency 'rspec', '~> 3.5.0'
-  s.add_development_dependency 'rspec-expectations', '~> 3.5'
-  s.add_development_dependency 'rspec_junit_formatter', '~> 0.3.0'
-  s.add_development_dependency 'rubocop', '~> 0.59.1'
+  s.add_development_dependency 'rspec', '~> 3.12.0'
+  s.add_development_dependency 'rspec-expectations', '~> 3.12'
+  s.add_development_dependency 'rspec_junit_formatter', '~> 0.6.0'
+  if RUBY_VERSION >= '2.6'
+    s.add_development_dependency 'rubocop', '>= 1.28'
+  else
+    s.add_development_dependency 'rubocop', '~> 0.81'
+  end
   s.add_development_dependency 'simplecov', '~> 0.12'
   s.add_development_dependency 'webmock', '~> 2.3.1'
   s.add_development_dependency 'yard', '~> 0.9.11'
@@ -46,16 +44,16 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'pry'
   s.add_development_dependency 'pry-byebug', '~> 3.6' if RUBY_PLATFORM != 'java'
 
-  s.add_development_dependency 'pronto', '~> 0.10' if RUBY_PLATFORM != 'java'
-  s.add_development_dependency 'pronto-rubocop', '~> 0.9' if RUBY_PLATFORM != 'java'
-  s.add_development_dependency 'pronto-reek', '~> 0.9' if RUBY_PLATFORM != 'java'
+  s.add_development_dependency 'pronto', '>= 0.10' if RUBY_PLATFORM != 'java'
+  s.add_development_dependency 'pronto-rubocop', '>= 0.9' if RUBY_PLATFORM != 'java'
+  s.add_development_dependency 'pronto-reek', '>= 0.9' if RUBY_PLATFORM != 'java'
   s.add_development_dependency 'vcr', '5.0.0'
   s.add_development_dependency 'hashdiff', '~> 0.4'
 
   s.add_development_dependency 'sqlite3' if RUBY_PLATFORM != 'java'
 
-  if RUBY_VERSION >= '2.5'
-    s.add_dependency 'activesupport', '>= 6.0.3.1', '< 6.2'
+if RUBY_VERSION >= '2.5'
+      s.add_dependency 'activesupport', '< 7.0.0'
   else
     s.add_dependency 'activesupport', '>= 5.2.4.3', '< 6.0'
   end
@@ -66,19 +64,20 @@ Gem::Specification.new do |s|
   else
     s.add_dependency 'docile', '> 1.1', '< 1.4.0'
   end
-  s.add_dependency 'azure-storage-blob', '~> 1.1.0'
-  s.add_dependency 'nokogiri', '~> 1.10.0'
+  s.add_dependency 'azure-storage-blob', '~> 2.0'
+  s.add_dependency 'nokogiri', '~> 1', '>= 1.10.8'
   s.add_dependency 'gli', '~> 2.15'
-  s.add_dependency 'gooddata_datawarehouse', '~> 0.0.10' if RUBY_PLATFORM == 'java'
+  s.add_dependency 'gooddata_datawarehouse', '~> 0.0.11' if RUBY_PLATFORM == 'java'
   s.add_dependency 'highline', '= 2.0.0.pre.develop.14'
-  s.add_dependency 'json_pure', '~> 1.8'
+  s.add_dependency 'json_pure', '~> 2.6'
   s.add_dependency 'multi_json', '~> 1.12'
   s.add_dependency 'parseconfig', '~> 1.0'
   s.add_dependency 'pmap', '~> 1.1'
+  s.add_dependency 'sequel', '< 5.72.0'
   s.add_dependency 'remote_syslog_logger', '~> 1.0.3'
-  s.add_dependency 'restforce', '>= 2.4', '< 4.0'
+  s.add_dependency 'restforce', '>= 2.4'
   s.add_dependency 'rest-client', '~> 2.0'
-  s.add_dependency 'rubyzip', '~> 1.2', '>= 1.2.1'
+  s.add_dependency 'rubyzip'
   s.add_dependency 'terminal-table', '~> 1.7'
   s.add_dependency 'thread_safe'
   s.add_dependency 'backports'

data/lcm.rake

@@ -138,6 +138,15 @@ namespace :maven do
 
     system('mvn -f ci/redshift/pom.xml clean install -P binary-packaging')
     system('cp -rf ci/redshift/target/*.jar lib/gooddata/cloud_resources/redshift/drivers/')
+
+    system('mvn -f ci/postgresql/pom.xml clean install -P binary-packaging')
+    system('cp -rf ci/postgresql/target/*.jar lib/gooddata/cloud_resources/postgresql/drivers/')
+
+    system('mvn -f ci/mssql/pom.xml clean install -P binary-packaging')
+    system('cp -rf ci/mssql/target/*.jar lib/gooddata/cloud_resources/mssql/drivers/')
+
+    system('mvn -f ci/mysql/pom.xml clean install -P binary-packaging')
+    system('cp -rf ci/mysql/target/*.jar lib/gooddata/cloud_resources/mysql/drivers/')
   end
 end
 

data/lib/gooddata/bricks/base_pipeline.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+#
+# Copyright (c) 2010-2022 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module Bricks
+    class BasePipeline
+      # Pipeline preparation code
+      def self.prepare(pipeline)
+        pipeline.reverse.reduce(nil) do |memo, app|
+          if memo.nil?
+            app.respond_to?(:new) ? app.new : app
+          elsif app.respond_to?(:new)
+            app.new(app: memo)
+          else
+            app.app = memo
+            app
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/bricks/brick.rb

@@ -5,7 +5,6 @@
 # LICENSE file in the root directory of this source tree.
 
 require_relative 'utils'
-require_relative 'middleware/middleware'
 
 module GoodData
   module Bricks

data/lib/gooddata/bricks/middleware/execution_result_middleware.rb

@@ -39,7 +39,7 @@ module GoodData
             message: message
           }
         }
-        update_result(result)
+        update_result(result, status)
       end
 
       private
@@ -52,9 +52,9 @@ module GoodData
         @@result_log_path = result_log_path
       end
 
-      def self.update_result(result)
+      def self.update_result(result, status = ExecutionStatus::ERROR)
         if @@result_log_path.nil?
-          GoodData.gd_logger.warn("action=update_execution_result status=error Not found execution result logger file.") unless GoodData.gd_logger.nil?
+          GoodData.gd_logger&.warn("action=update_execution_result status=#{status} Not found execution result logger file.")
           return
         end
 

data/lib/gooddata/bricks/pipeline.rb

@@ -10,23 +10,11 @@ require_relative 'release_brick'
 require_relative 'provisioning_brick'
 require_relative 'rollout_brick'
 require_relative 'hello_world_brick'
+require_relative 'base_pipeline'
 
 module GoodData
   module Bricks
-    class Pipeline
-      # Pipeline preparation code
-      def self.prepare(pipeline)
-        pipeline.reverse.reduce(nil) do |memo, app|
-          if memo.nil?
-            app.respond_to?(:new) ? app.new : app
-          elsif app.respond_to?(:new)
-            app.new(app: memo)
-          else
-            app.app = memo
-            app
-          end
-        end
-      end
+    class Pipeline < GoodData::Bricks::BasePipeline
 
       def self.users_brick_pipeline
         prepare([

data/lib/gooddata/cloud_resources/mysql/mysql_client.rb

@@ -21,10 +21,12 @@ module GoodData
       JDBC_MYSQL_PATTERN = %r{jdbc:mysql:\/\/([^:^\/]+)(:([0-9]+))?(\/)?}
       MYSQL_DEFAULT_PORT = 3306
       JDBC_MYSQL_PROTOCOL = 'jdbc:mysql://'
-      VERIFY_FULL = 'VERIFY_IDENTITY'
-      PREFER = 'PREFERRED'
-      REQUIRE = 'REQUIRED'
+      VERIFY_FULL = '&useSSL=true&verifyServerCertificate=true'
+      PREFER = '&useSSL=true&requireSSL=false&verifyServerCertificate=false'
+      REQUIRE = '&useSSL=true&requireSSL=true&verifyServerCertificate=false'
       MYSQL_FETCH_SIZE = 1000
+      MONGO_BI_FETCH_SIZE = 1
+      MONGO_BI_TYPE = 'MongoDBConnector'
 
       class << self
         def accept?(type)
@@ -39,6 +41,7 @@ module GoodData
           @database = options['mysql_client']['connection']['database']
           @authentication = options['mysql_client']['connection']['authentication']
           @ssl_mode = options['mysql_client']['connection']['sslMode']
+          @database_type = options['mysql_client']['connection']['databaseType']
           raise "SSL Mode should be prefer, require and verify-full" unless @ssl_mode == 'prefer' || @ssl_mode == 'require' || @ssl_mode == 'verify-full'
 
           @url = build_url(options['mysql_client']['connection']['url'])
@@ -46,7 +49,7 @@ module GoodData
           raise('Missing connection info for Mysql client')
         end
 
-        Java.com.mysql.cj.jdbc.Driver
+        Java.com.mysql.jdbc.Driver
       end
 
       def realize_query(query, _params)
@@ -56,7 +59,7 @@ module GoodData
         filename = "#{SecureRandom.urlsafe_base64(6)}_#{Time.now.to_i}.csv"
         measure = Benchmark.measure do
           statement = @connection.create_statement
-          statement.set_fetch_size(MYSQL_FETCH_SIZE)
+          statement.set_fetch_size(fetch_size)
           has_result = statement.execute(query)
           if has_result
             result = statement.get_result_set
@@ -76,12 +79,11 @@ module GoodData
       end
 
       def connect
-        GoodData.logger.info "Setting up connection to Mysql #{@url}"
+        GoodData.logger.info "Setting up connection to Mysql #{@database_type} #{@url} "
 
         prop = java.util.Properties.new
         prop.setProperty('user', @authentication['basic']['userName'])
         prop.setProperty('password', @authentication['basic']['password'])
-
         @connection = java.sql.DriverManager.getConnection(@url, prop)
         @connection.set_auto_commit(false)
       end
@@ -93,7 +95,11 @@ module GoodData
         host = matches[0][0]
         port = matches[0][2]&.to_i || MYSQL_DEFAULT_PORT
 
-        "#{JDBC_MYSQL_PROTOCOL}#{host}:#{port}/#{@database}?sslmode=#{get_ssl_mode(@ssl_mode)}&useCursorFetch=true&enabledTLSProtocols=TLSv1.2"
+        "#{JDBC_MYSQL_PROTOCOL}#{host}:#{port}/#{@database}?#{get_ssl_mode(@ssl_mode)}#{add_extended}&useCursorFetch=true&enabledTLSProtocols=TLSv1.2"
+      end
+
+      def fetch_size
+        @database_type == MONGO_BI_TYPE ? MONGO_BI_FETCH_SIZE : MYSQL_FETCH_SIZE
       end
 
       def get_ssl_mode(ssl_mode)
@@ -106,6 +112,10 @@ module GoodData
 
         mode
       end
+
+      def add_extended
+        @database_type == MONGO_BI_TYPE ? '&authenticationPlugins=org.mongodb.mongosql.auth.plugin.MongoSqlAuthenticationPlugin&useLocalTransactionState=true' : ''
+      end
     end
   end
 end

data/lib/gooddata/cloud_resources/redshift/redshift_client.rb

@@ -39,8 +39,6 @@ module GoodData
         @debug = options['debug'] == true || options['debug'] == 'true'
 
         Java.com.amazon.redshift.jdbc42.Driver
-        base = Pathname(__FILE__).dirname
-        org.apache.log4j.PropertyConfigurator.configure("#{base}/drivers/log4j.properties")
       end
 
       def realize_query(query, _params)

data/lib/gooddata/cloud_resources/snowflake/snowflake_client.rb

@@ -18,7 +18,7 @@ end
 module GoodData
   module CloudResources
     class SnowflakeClient < CloudResourceClient
-      SNOWFLAKE_GDC_APPLICATION_PARAMETER = 'application=GoodData_Platform'
+      SNOWFLAKE_GDC_APPLICATION_PARAMETER = 'application=gooddata_platform'
       SNOWFLAKE_SEPARATOR_PARAM = '?'
 
       class << self

data/lib/gooddata/lcm/actions/base_action.rb

@@ -18,6 +18,11 @@ module GoodData
       class << self
         include Dsl::Dsl
 
+        SYNC_FAILED_LIST = 'sync_failed_list'.to_sym
+        FAILED_PROJECTS = 'failed_projects'.to_sym
+        FAILED_CLIENTS = 'failed_clients'.to_sym
+        FAILED_SEGMENTS = 'failed_segments'.to_sym
+
         def check_params(specification, params)
           Helpers.check_params(specification, params)
         end
@@ -31,6 +36,158 @@ module GoodData
           params.setup_filters(specification) # enables params validation
           result
         end
+
+        def print_result(_params)
+          true
+        end
+
+        def continue_on_error(params)
+          Helpers.continue_on_error(params)
+        end
+
+        def collect_synced_status(params)
+          Helpers.collect_synced_status(params)
+        end
+
+        def add_failed_project(project_id, message, failed_action, params)
+          if collect_synced_status(params) && !sync_failed_project(project_id, params)
+            sync_failed_list = sync_failed_list(params)
+            project_client_mappings = sync_failed_list[:project_client_mappings]
+            project_client_mapping = project_client_mappings ? project_client_mappings[project_id.to_sym] : nil
+            client_id = project_client_mapping ? project_client_mapping[:client_id] : nil
+            segment_id = project_client_mapping ? project_client_mapping[:segment_id] : nil
+
+            failed_detailed_project = {
+              project_id: project_id,
+              client_id: client_id,
+              segment: segment_id,
+              message: message,
+              action: failed_action
+            }
+            add_failed_detail(params, failed_detailed_project, sync_failed_list)
+          end
+        end
+
+        def add_failed_client(client_id, message, error_action, params)
+          if collect_synced_status(params) && !sync_failed_client(client_id, params)
+            sync_failed_list = sync_failed_list(params)
+            client_project_mappings = sync_failed_list[:client_project_mappings]
+            client_project_mapping = client_project_mappings ? client_project_mappings[client_id.to_sym] : nil
+            project_id = client_project_mapping ? client_project_mapping[:project_id] : nil
+            segment_id = client_project_mapping ? client_project_mapping[:segment_id] : nil
+
+            failed_detailed_client = {
+              project_id: project_id,
+              client_id: client_id,
+              segment: segment_id,
+              message: message,
+              action: error_action
+            }
+            add_failed_detail(params, failed_detailed_client, sync_failed_list)
+          end
+        end
+
+        def add_failed_segment(segment_id, message, error_action, params)
+          if collect_synced_status(params) && !sync_failed_segment(segment_id, params)
+            sync_failed_list = sync_failed_list(params)
+            failed_detailed_segment = {
+              project_id: nil,
+              client_id: nil,
+              segment: segment_id,
+              message: message,
+              action: error_action
+            }
+            add_failed_detail(params, failed_detailed_segment, sync_failed_list, true)
+          end
+        end
+
+        # Add new clients to project client mapping
+        #
+        # @param [String] project_id project identify will be added to mapping
+        # @param [String] client_id client identify will be added to mapping
+        # @param [String] segment_id segment identify will be added to mapping
+        # @param [Hash] params the hash contains list of parameters and values
+        def add_new_clients_to_project_client_mapping(project_id, client_id, segment_id, params)
+          if collect_synced_status(params)
+            sync_failed_list = sync_failed_list(params)
+            client_project_mappings = sync_failed_list[:client_project_mappings]
+            project_client_mappings = sync_failed_list[:project_client_mappings]
+            client_project_mappings[client_id.to_sym] = {
+              project_id: project_id,
+              segment_id: segment_id
+            } if client_project_mappings
+
+            project_client_mappings[project_id.to_sym] = {
+              client_id: client_id,
+              segment_id: segment_id
+            } if project_client_mappings
+          end
+        end
+
+        def process_failed_project(project_id, failed_message, failed_projects, continue_on_error)
+          fail(failed_message) unless continue_on_error
+
+          failed_projects << {
+            project_id: project_id,
+            message: failed_message
+          }
+        end
+
+        def process_failed_projects(failed_projects, failed_action, params)
+          failed_projects.each do |failed_project|
+            add_failed_project(failed_project[:project_id], failed_project[:message], failed_action, params)
+          end
+        end
+
+        def sync_failed_project(project_id, params)
+          collect_synced_status(params) && params[SYNC_FAILED_LIST][FAILED_PROJECTS].include?(project_id)
+        end
+
+        def sync_failed_client(client_id, params)
+          collect_synced_status(params) && params[SYNC_FAILED_LIST][FAILED_CLIENTS].include?(client_id)
+        end
+
+        def sync_failed_segment(segment_id, params)
+          collect_synced_status(params) && params[SYNC_FAILED_LIST][FAILED_SEGMENTS].include?(segment_id)
+        end
+
+        private
+
+        def add_failed_detail(params, failed_detailed_project, sync_failed_list, ignore_segment = false)
+          params.gdc_logger&.warn failed_detailed_project[:message]
+          sync_failed_list[:failed_detailed_projects] << failed_detailed_project
+
+          if ignore_segment
+            add_failed_detail_segment(failed_detailed_project[:segment_id], sync_failed_list)
+          else
+            add_failed_detail_client(failed_detailed_project[:client_id], failed_detailed_project[:project_id], sync_failed_list)
+          end
+        end
+
+        def sync_failed_list(params)
+          if params.include?(SYNC_FAILED_LIST)
+            params[SYNC_FAILED_LIST]
+          else
+            nil
+          end
+        end
+
+        def add_failed_detail_client(client_id, project_id, sync_failed_list)
+          sync_failed_list[FAILED_CLIENTS] << client_id if client_id
+
+          sync_failed_list[FAILED_PROJECTS] << project_id if project_id
+        end
+
+        def add_failed_detail_segment(segment_id, sync_failed_list)
+          if segment_id
+            sync_failed_list[FAILED_SEGMENTS] << segment_id
+
+            client_project_mappings = sync_failed_list[:client_project_mappings]
+            client_project_mappings.each do |client_id, client_project_mapping|
+              add_failed_detail_client(client_id, client_project_mapping[:project_id], sync_failed_list) if client_project_mapping[:segment_id] == segment_id
+            end
+          end
+        end
       end
     end
   end

data/lib/gooddata/lcm/actions/collect_data_product.rb

@@ -47,8 +47,9 @@ module GoodData
           end
 
           begin
+            params.gdc_logger.info "Starting to find DataProduct ID: #{data_product_id}"
             data_product = domain.data_products(data_product_id)
-          rescue RestClient::BadRequest
+          rescue RestClient::BadRequest, RestClient::NotFound
             params.gdc_logger.info "Can not find DataProduct #{params.data_product}, creating it instead"
             data_product = domain.create_data_product(id: params.data_product)
           end

data/lib/gooddata/lcm/actions/collect_projects_warning_status.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# (C) 2019-2022 GoodData Corporation
+require_relative 'base_action'
+
+module GoodData
+  module LCM2
+    class CollectProjectsWarningStatus < BaseAction
+      DESCRIPTION = 'Collect synced projects status'
+
+      PARAMS = define_params(self) do
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), required: false
+
+        description 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), required: false
+
+        description 'Collect synced status'
+        param :collect_synced_status, instance_of(Type::BooleanType), required: false
+
+        description 'Sync failed list'
+        param :sync_failed_list, instance_of(Type::HashType), required: false
+      end
+
+      RESULT_HEADER = %i[segment client project_pid failed_action]
+
+      class << self
+        def call(params)
+          results = []
+          return results unless collect_synced_status(params)
+
+          sync_failed_list = params[SYNC_FAILED_LIST]
+          if sync_failed_list
+            failed_detailed_projects = sync_failed_list[:failed_detailed_projects]
+            failed_detailed_projects.each do |failed_detailed_project|
+              results << {
+                segment: failed_detailed_project[:segment],
+                client: failed_detailed_project[:client_id],
+                project_pid: failed_detailed_project[:project_id],
+                failed_action: failed_detailed_project[:action]
+              }
+            end
+          end
+
+          results
+        end
+
+        def print_result(params)
+          collect_synced_status(params)
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/collect_segment_clients.rb

@@ -32,9 +32,22 @@ module GoodData
 
         description 'Domain'
         param :domain, instance_of(Type::StringType), required: false
+
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), required: false
+
+        description 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), required: false
+
+        description 'Collect synced status'
+        param :collect_synced_status, instance_of(Type::BooleanType), required: false
+
+        description 'Sync failed list'
+        param :sync_failed_list, instance_of(Type::HashType), required: false
       end
 
       RESULT_HEADER = [
+        :segment,
         :from_name,
         :from_pid,
         :to_name,
@@ -89,6 +102,7 @@ module GoodData
                 client_project = segment_client.project
                 to_pid = client_project.pid
                 results << {
+                  segment: segment.segment_id,
                   from_name: master_name,
                   from_pid: master_pid,
                   to_name: client_project.title,

data/lib/gooddata/lcm/actions/initialize_continue_on_error_option.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+# (C) 2019-2022 GoodData Corporation
+require_relative 'base_action'
+
+module GoodData
+  module LCM2
+    class InitializeContinueOnErrorOption < BaseAction
+      DESCRIPTION = 'Initialize continue on error option'
+
+      PARAMS = define_params(self) do
+        description 'Organization Name'
+        param :organization, instance_of(Type::StringType), required: false
+
+        description 'Domain'
+        param :domain, instance_of(Type::StringType), required: false
+
+        description 'DataProduct'
+        param :data_product, instance_of(Type::GDDataProductType), required: false
+
+        description 'Restricts synchronization to specified segments'
+        param :segments_filter, array_of(instance_of(Type::StringType)), required: false
+
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), required: false
+
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+      end
+
+      class << self
+        def call(params)
+          project_mappings = ThreadSafe::Hash.new
+          client_mappings = ThreadSafe::Hash.new
+          continue_on_error = continue_on_error(params)
+
+          if continue_on_error
+            client = params.gdc_gd_client
+            domain_name = params.organization || params.domain
+            domain = client.domain(domain_name)
+            data_product = params.data_product
+            data_product_segments = domain.segments(:all, data_product)
+
+            if params.segments_filter
+              data_product_segments.select! do |segment|
+                params.segments_filter.include?(segment.segment_id)
+              end
+            end
+
+            data_product_segments.pmap do |segment|
+              segment.clients.map do |segment_client|
+                project = segment_client.project
+                next unless project
+
+                project_mappings[project.pid.to_sym] = {
+                  client_id: segment_client.client_id,
+                  segment_id: segment.segment_id
+                }
+                client_mappings[segment_client.client_id.to_sym] = {
+                  project_id: project.pid,
+                  segment_id: segment.segment_id
+                }
+              end
+            end
+          end
+
+          {
+            params: {
+              collect_synced_status: continue_on_error,
+              sync_failed_list: {
+                project_client_mappings: project_mappings,
+                client_project_mappings: client_mappings,
+                failed_detailed_projects: [],
+                failed_projects: [],
+                failed_clients: [],
+                failed_segments: []
+              }
+            }
+          }
+        end
+
+        def print_result(_params)
+          false
+        end
+      end
+    end
+  end
+end