gooddata 2.1.19-java → 2.2.0-java

data/lib/gooddata/cloud_resources/blobstorage/blobstorage_client.rb

@@ -0,0 +1,98 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+#
+# Copyright (c) 2021 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.
+
+require 'securerandom'
+require 'pathname'
+require "azure/storage/blob"
+
+module GoodData
+  class BlobStorageClient
+    SAS_URL_PATTERN = %r{(^https?:\/\/[^\/]*)\/.*\?(.*)}
+    INVALID_BLOB_GENERAL_MESSAGE = "The connection string is not valid."
+    INVALID_BLOB_SIG_WELL_FORMED_MESSAGE = "The signature format is not valid."
+    INVALID_BLOB_CONTAINER_MESSAGE = "ContainerNotFound"
+    INVALID_BLOB_CONTAINER_FORMED_MESSAGE = "The container with the specified name is not found."
+    INVALID_BLOB_EXPIRED_ORIGINAL_MESSAGE = "Signature not valid in the specified time frame"
+    INVALID_BLOB_EXPIRED_MESSAGE = "The signature expired."
+    INVALID_BLOB_INVALID_CONNECTION_STRING_MESSAGE = "The connection string is not valid."
+    INVALID_BLOB_PATH_MESSAGE = "BlobNotFound"
+    INVALID_BLOB_INVALID_PATH_MESSAGE = "The path to the data is not found."
+
+    attr_reader :use_sas
+
+    def initialize(options = {})
+      raise("Data Source needs a client to Blob Storage to be able to get blob file but 'blobStorage_client' is empty.") unless options['blobStorage_client']
+
+      if options['blobStorage_client']['connectionString'] && options['blobStorage_client']['container']
+        @connection_string = options['blobStorage_client']['connectionString']
+        @container = options['blobStorage_client']['container']
+        @path = options['blobStorage_client']['path']
+        @use_sas = false
+        build_sas(@connection_string)
+      else
+        raise('Missing connection info for Blob Storage client')
+      end
+    end
+
+    def realize_blob(file, _params)
+      GoodData.gd_logger.info("Realizing download from Blob Storage. Container #{@container}.")
+      filename = ''
+      begin
+        connect
+        filename = "#{SecureRandom.urlsafe_base64(6)}_#{Time.now.to_i}.csv"
+        blob_name = get_blob_name(@path, file)
+
+        measure = Benchmark.measure do
+          _blob, content = @client.get_blob(@container, blob_name)
+          File.open(filename, "wb") { |f| f.write(content) }
+        end
+      rescue  => e
+        raise_error(e)
+      end
+      GoodData.gd_logger.info("Done downloading file type=blobStorage status=finished duration=#{measure.real}")
+      filename
+    end
+
+    def connect
+      GoodData.logger.info "Setting up connection to Blob Storage"
+      if use_sas
+        @client = Azure::Storage::Blob::BlobService.create(:storage_blob_host => @host, :storage_sas_token => @sas_token)
+      else
+        @client = Azure::Storage::Blob::BlobService.create_from_connection_string(@connection_string)
+      end
+    end
+
+    def build_sas(url)
+      matches = url.scan(SAS_URL_PATTERN)
+      return unless matches && matches[0]
+
+      @use_sas = true
+      @host = matches[0][0]
+      @sas_token = matches[0][1]
+    end
+
+    def raise_error(e)
+      if e.message && e.message.include?(INVALID_BLOB_EXPIRED_ORIGINAL_MESSAGE)
+        raise INVALID_BLOB_EXPIRED_MESSAGE
+      elsif e.message && e.message.include?(INVALID_BLOB_SIG_WELL_FORMED_MESSAGE)
+        raise INVALID_BLOB_SIG_WELL_FORMED_MESSAGE
+      elsif e.message && e.message.include?(INVALID_BLOB_CONTAINER_MESSAGE)
+        raise INVALID_BLOB_CONTAINER_FORMED_MESSAGE
+      elsif e.message && e.message.include?(INVALID_BLOB_PATH_MESSAGE)
+        raise INVALID_BLOB_INVALID_PATH_MESSAGE
+      else
+        raise INVALID_BLOB_GENERAL_MESSAGE
+      end
+    end
+
+    def get_blob_name(path, file)
+      return file unless path
+
+      path.rindex('/') == path.length - 1 ? "#{path}#{file}" : "#{path}/#{file}"
+    end
+  end
+end

data/lib/gooddata/cloud_resources/mssql/mssql_client.rb

@@ -0,0 +1,122 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+#
+# Copyright (c) 2021 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.
+
+require 'securerandom'
+require 'java'
+require 'pathname'
+require_relative '../cloud_resource_client'
+
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + 'drivers/*.jar').each do |file|
+  require file unless file.start_with?('lcm-mssql-driver')
+end
+
+module GoodData
+  module CloudResources
+    class MSSQLClient < CloudResourceClient
+      MSSQL_SEPARATOR_PARAM = ";"
+      MSSQL_URL_PATTERN = %r{jdbc:sqlserver://([^:]+)(:([0-9]+))?(/)?}
+      MSSQL_DEFAULT_PORT = 1433
+      LOGIN_TIME_OUT = 30
+      MSSQL_FETCH_SIZE = 10_000
+      VERIFY_FULL = 'verify-full'
+      PREFER = 'prefer'
+      REQUIRE = 'require'
+
+      class << self
+        def accept?(type)
+          type == 'mssql'
+        end
+      end
+
+      def initialize(options = {})
+        raise("Data Source needs a client to MSSQL to be able to query the storage but 'mssql_client' is empty.") unless options['mssql_client']
+
+        connection = options['mssql_client']['connection']
+        if connection.is_a?(Hash)
+          @database = connection['database']
+          @schema = connection['schema']
+          @authentication = connection['authentication']
+          @ssl_mode = connection['sslMode']
+          @url = connection['url']
+
+          validate
+        else
+          raise('Missing connection info for MSSQL client')
+        end
+
+        Java.com.microsoft.sqlserver.jdbc.SQLServerDriver
+      end
+
+      def realize_query(query, _params)
+        GoodData.gd_logger.info("Realize SQL query: type=mssql status=started")
+
+        connect
+
+        filename = "#{SecureRandom.urlsafe_base64(6)}_#{Time.now.to_i}.csv"
+        measure = Benchmark.measure do
+          statement = @connection.create_statement
+          statement.set_fetch_size(MSSQL_FETCH_SIZE)
+          has_result = statement.execute(query)
+          if has_result
+            result = statement.get_result_set
+            metadata = result.get_meta_data
+            col_count = metadata.column_count
+            CSV.open(filename, 'wb') do |csv|
+              csv << Array(1..col_count).map { |i| metadata.get_column_name(i) } # build the header
+              csv << Array(1..col_count).map { |i| result.get_string(i)&.to_s } while result.next
+            end
+          end
+        end
+
+        GoodData.gd_logger.info("Realize SQL query: type=mssql status=finished duration=#{measure.real}")
+        filename
+      ensure
+        @connection&.close
+        @connection = nil
+      end
+
+      def connect
+        connection_string = build_connection_string
+        GoodData.logger.info "Setting up connection to MSSQL #{connection_string}"
+
+        authentication = @authentication['basic'] || @authentication['activeDirectoryPassword']
+
+        prop = java.util.Properties.new
+        prop.setProperty('userName', authentication['userName'])
+        prop.setProperty('password', authentication['password'])
+
+        @connection = java.sql.DriverManager.getConnection(connection_string, prop)
+      end
+
+      def validate
+        raise "SSL Mode should be prefer, require and verify-full" unless @ssl_mode == 'prefer' || @ssl_mode == 'require' || @ssl_mode == 'verify-full'
+
+        raise "Instance name is not supported" if @url !~ /^[^\\]*$/
+
+        raise "The connection url is invalid. Parameter is not supported." if @url.include? MSSQL_SEPARATOR_PARAM
+
+        url_matches = @url.scan(MSSQL_URL_PATTERN)
+        raise "Cannot reach the url" if url_matches.nil? || url_matches.length.zero?
+
+        raise "The authentication method is not supported." unless @authentication['basic'] || @authentication['activeDirectoryPassword']
+      end
+
+      def build_connection_string
+        encrypt = @ssl_mode != PREFER
+        trust_server_certificate = @ssl_mode == REQUIRE
+
+        "#{@url};" \
+          "database=#{@database};" \
+          "encrypt=#{encrypt};" \
+          "trustServerCertificate=#{trust_server_certificate};" \
+          "loginTimeout=#{LOGIN_TIME_OUT};" \
+          "#{'authentication=ActiveDirectoryPassword;' if @authentication['activeDirectoryPassword']}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+#
+# Copyright (c) 2021 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.
+
+require 'securerandom'
+require 'java'
+require 'pathname'
+require_relative '../cloud_resource_client'
+
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + 'drivers/*.jar').each do |file|
+  require file unless file.start_with?('lcm-mysql-driver')
+end
+
+module GoodData
+  module CloudResources
+    class MysqlClient < CloudResourceClient
+      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'
+      MYSQL_FETCH_SIZE = 1000
+
+      class << self
+        def accept?(type)
+          type == 'mysql'
+        end
+      end
+
+      def initialize(options = {})
+        raise("Data Source needs a client to Mysql to be able to query the storage but 'mysql_client' is empty.") unless options['mysql_client']
+
+        if options['mysql_client']['connection'].is_a?(Hash)
+          @database = options['mysql_client']['connection']['database']
+          @authentication = options['mysql_client']['connection']['authentication']
+          @ssl_mode = options['mysql_client']['connection']['sslMode']
+          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'])
+        else
+          raise('Missing connection info for Mysql client')
+        end
+
+        Java.com.mysql.cj.jdbc.Driver
+      end
+
+      def realize_query(query, _params)
+        GoodData.gd_logger.info("Realize SQL query: type=mysql status=started")
+
+        connect
+        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)
+          has_result = statement.execute(query)
+          if has_result
+            result = statement.get_result_set
+            metadata = result.get_meta_data
+            col_count = metadata.column_count
+            CSV.open(filename, 'wb') do |csv|
+              csv << Array(1..col_count).map { |i| metadata.get_column_name(i) } # build the header
+              csv << Array(1..col_count).map { |i| result.get_string(i)&.to_s } while result.next
+            end
+          end
+        end
+        GoodData.gd_logger.info("Realize SQL query: type=mysql status=finished duration=#{measure.real}")
+        filename
+      ensure
+        @connection&.close
+        @connection = nil
+      end
+
+      def connect
+        GoodData.logger.info "Setting up connection to Mysql #{@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
+
+      def build_url(url)
+        matches = url.scan(JDBC_MYSQL_PATTERN)
+        raise 'Cannot reach the url' unless matches
+
+        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"
+      end
+
+      def get_ssl_mode(ssl_mode)
+        mode = PREFER
+        if ssl_mode == 'verify-full'
+          mode =  VERIFY_FULL
+        elsif ssl_mode == 'require'
+          mode =  REQUIRE
+        end
+
+        mode
+      end
+    end
+  end
+end

data/lib/gooddata/cloud_resources/postgresql/postgresql_client.rb

@@ -98,7 +98,6 @@ module GoodData
 
         host = matches[0][0]
         port = matches[0][2]&.to_i || POSTGRES_DEFAULT_PORT
-        raise "Custom port #{port} is not supported. Remove it or use the default port '5432'" if POSTGRES_DEFAULT_PORT != port
 
         "#{JDBC_POSTGRES_PROTOCOL}#{host}:#{port}/#{@database}?sslmode=#{@ssl_mode}#{VERIFY_FULL == @ssl_mode ? SSL_JAVA_FACTORY : ''}"
       end

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

@@ -18,6 +18,9 @@ end
 module GoodData
   module CloudResources
     class SnowflakeClient < CloudResourceClient
+      SNOWFLAKE_GDC_APPLICATION_PARAMETER = 'application=GoodData_Platform'
+      SNOWFLAKE_SEPARATOR_PARAM = '?'
+
       class << self
         def accept?(type)
           type == 'snowflake'
@@ -31,7 +34,7 @@ module GoodData
           @database = options['snowflake_client']['connection']['database']
           @schema = options['snowflake_client']['connection']['schema'] || 'public'
           @warehouse = options['snowflake_client']['connection']['warehouse']
-          @url = options['snowflake_client']['connection']['url']
+          @url = build_url(options['snowflake_client']['connection']['url'])
           @authentication = options['snowflake_client']['connection']['authentication']
         else
           raise('Missing connection info for Snowflake client')
@@ -79,6 +82,20 @@ module GoodData
 
         @connection = java.sql.DriverManager.getConnection(@url, prop)
       end
+
+      def build_url(url)
+        is_contain = url.include?(SNOWFLAKE_GDC_APPLICATION_PARAMETER)
+        unless is_contain
+          if url.include?(SNOWFLAKE_SEPARATOR_PARAM)
+            url.concat("&")
+          else
+            url.concat(SNOWFLAKE_SEPARATOR_PARAM)
+          end
+          url.concat(SNOWFLAKE_GDC_APPLICATION_PARAMETER)
+        end
+
+        url
+      end
     end
   end
 end

data/lib/gooddata/helpers/data_helper.rb

@@ -44,10 +44,14 @@ module GoodData
           realize_link
         when 's3'
           realize_s3(params)
-        when 'redshift', 'snowflake', 'bigquery', 'postgresql'
+        when 'redshift', 'snowflake', 'bigquery', 'postgresql', 'mssql', 'mysql'
           raise GoodData::InvalidEnvError, "DataSource does not support type \"#{source}\" on the platform #{RUBY_PLATFORM}" unless RUBY_PLATFORM =~ /java/
           require_relative '../cloud_resources/cloud_resources'
           realize_cloud_resource(source, params)
+        when 'blobStorage'
+          require_relative '../cloud_resources/blobstorage/blobstorage_client'
+          blob_storage_client = GoodData::BlobStorageClient.new(params)
+          blob_storage_client.realize_blob(@options[:file], params)
         else
           raise "DataSource does not support type \"#{source}\""
         end
@@ -111,12 +115,13 @@ module GoodData
       end
 
       def realize_s3(params)
-        s3_client = params['aws_client'] && params['aws_client']['s3_client']
+        s3_client = params['s3_client'] && params['s3_client']['client']
         raise 'AWS client not present. Perhaps S3Middleware is missing in the brick definition?' if !s3_client || !s3_client.respond_to?(:bucket)
         bucket_name = @options[:bucket]
-        key = @options[:key]
+        key = @options[:key].present? ? @options[:key] : @options[:file]
         raise 'Key "bucket" is missing in S3 datasource' if bucket_name.blank?
-        raise 'Key "key" is missing in S3 datasource' if key.blank?
+        raise 'Key "key" or "file" is missing in S3 datasource' if key.blank?
+
         GoodData.logger.info("Realizing download from S3. Bucket #{bucket_name}, object with key #{key}.")
         filename = Digest::SHA256.new.hexdigest(@options.to_json)
         bucket = s3_client.bucket(bucket_name)

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

@@ -53,7 +53,9 @@ module GoodData
                 client: development_client
               )
               kpi_dashboards = MdObject.query('analyticalDashboard', MdObject, client: development_client, project: from_project)
-              objects = old_dashboards.to_a + kpi_dashboards.to_a
+              kpi_dashboard_plugin = MdObject.query('dashboardPlugin', MdObject, client: development_client, project: from_project)
+              kpi_date_filter_config = MdObject.query('dateFilterConfig', MdObject, client: development_client, project: from_project)
+              objects = old_dashboards.to_a + kpi_dashboards.to_a + kpi_dashboard_plugin.to_a + kpi_date_filter_config.to_a
             else
               objects = GoodData::Dashboard.find_by_tag(
                 production_tags,

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

@@ -50,6 +50,7 @@ module GoodData
             segment_info[:to].pmap do |entry|
               pid = entry[:pid]
               to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+              GoodData.logger.info "Migrating date dimension, project: '#{to_project.title}', PID: #{pid}"
               to_blueprint = to_project.blueprint
               upgrade_datasets = get_upgrade_dates(latest_blueprint, to_blueprint)
               next if upgrade_datasets.empty?
@@ -71,9 +72,9 @@ module GoodData
           dest_dates = get_date_dimensions(dest_blueprint) if dest_blueprint
           src_dates = get_date_dimensions(src_blueprint) if src_blueprint
 
-          return false if dest_dates.empty? || src_dates.empty?
-
           upgrade_datasets = []
+          return upgrade_datasets if dest_dates.empty? || src_dates.empty?
+
           dest_dates.each do |dest|
             src_dim = get_date_dimension(src_blueprint, dest[:id])
             next unless src_dim

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

@@ -33,6 +33,9 @@ module GoodData
         description 'ADS Client'
         param :ads_client, instance_of(Type::AdsClientType), required: false
 
+        description 'Keep number of old master workspace excluding the latest one'
+        param :keep_only_previous_masters_count, instance_of(Type::StringType), required: false, default: '-1'
+
         description 'Additional Hidden Parameters'
         param :additional_hidden_params, instance_of(Type::HashType), required: false
       end
@@ -53,6 +56,7 @@ module GoodData
           domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
           data_product = params.data_product
           domain_segments = domain.segments(:all, data_product)
+          keep_only_previous_masters_count = Integer(params.keep_only_previous_masters_count || "-1")
 
           segments = params.segments.map do |seg|
             domain_segments.find do |s|
@@ -62,18 +66,14 @@ module GoodData
 
           results = segments.map do |segment|
             if params.ads_client
-              current_master = GoodData::LCM2::Helpers.latest_master_project_from_ads(
-                params.release_table_name,
-                params.ads_client,
-                segment.segment_id
-              )
+              master_projects = GoodData::LCM2::Helpers.get_master_project_list_from_ads(params.release_table_name, params.ads_client, segment.segment_id)
             else
-              current_master = GoodData::LCM2::Helpers.latest_master_project_from_nfs(domain_name, data_product.data_product_id, segment.segment_id)
+              master_projects = GoodData::LCM2::Helpers.get_master_project_list_from_nfs(domain_name, data_product.data_product_id, segment.segment_id)
             end
 
+            current_master = master_projects.last
             # TODO: Check res.first.nil? || res.first[:master_project_id].nil?
             master = client.projects(current_master[:master_project_id])
-
             segment.master_project = master
             segment.save
 
@@ -87,6 +87,19 @@ module GoodData
                    "Details: #{sync_result['links']['details']}")
             end
 
+            if keep_only_previous_masters_count >= 0
+              number_of_deleted_projects = master_projects.count - (keep_only_previous_masters_count + 1)
+
+              if number_of_deleted_projects.positive?
+                begin
+                  removal_master_project_ids = remove_multiple_workspace(params, segment.segment_id, master_projects, number_of_deleted_projects)
+                  remove_old_workspaces_from_release_table(params, domain_name, data_product.data_product_id, segment.segment_id, master_projects, removal_master_project_ids)
+                rescue Exception => e # rubocop:disable RescueException
+                  GoodData.logger.error "Problem occurs when removing old master workspace, reason: #{e.message}"
+                end
+              end
+            end
+
             {
               segment: segment.id,
               master_pid: master.pid,
@@ -98,6 +111,42 @@ module GoodData
           # Return results
           results
         end
+
+        def remove_multiple_workspace(params, segment_id, master_projects, number_of_deleted_projects)
+          removal_master_project_ids = []
+          need_to_delete_projects = master_projects.take(number_of_deleted_projects)
+
+          need_to_delete_projects.each do |project_wrapper|
+            master_project_id = project_wrapper[:master_project_id]
+            next if master_project_id.to_s.empty?
+
+            begin
+              project = params.gdc_gd_client.projects(master_project_id)
+              if project && !%w[deleted archived].include?(project.state.to_s)
+                GoodData.logger.info "Segment #{segment_id}: Deleting old master workspace, project: '#{project.title}', PID: (#{project.pid})."
+                project.delete
+              end
+              removal_master_project_ids << master_project_id
+              master_projects.delete_if { |p| p[:master_project_id] == master_project_id }
+            rescue Exception => ex # rubocop:disable RescueException
+              GoodData.logger.error "Unable to remove master workspace: '#{master_project_id}', Error: #{ex.message}"
+            end
+          end
+          removal_master_project_ids
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def remove_old_workspaces_from_release_table(params, domain_id, data_product_id, segment_id, master_projects, removal_master_project_ids)
+          unless removal_master_project_ids.empty?
+            if params.ads_client
+              GoodData::LCM2::Helpers.delete_master_project_from_ads(params.release_table_name, params.ads_client, segment_id, removal_master_project_ids)
+            else
+              data = master_projects.sort_by { |master| master[:version] }
+              GoodData::LCM2::Helpers.update_master_project_to_nfs(domain_id, data_product_id, segment_id, data)
+            end
+          end
+        end
+        # rubocop:enable Metrics/ParameterLists
       end
     end
   end

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

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+#
+# Copyright (c) 2010-2021 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.
+
+require_relative 'base_action'
+
+module GoodData
+  module LCM2
+    class SynchronizeDataSetMapping < BaseAction
+      DESCRIPTION = 'Synchronize Dataset Mappings'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Client used to connecting to development domain'
+        param :development_client, instance_of(Type::GdClientType), required: true
+
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+
+        description 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), required: true
+      end
+
+      RESULT_HEADER = %i[from to count status]
+
+      class << self
+        def call(params)
+          results = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+
+          params.synchronize.peach do |info|
+            from_project = info.from
+            to_projects = info.to
+
+            from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
+            dataset_mapping = from.dataset_mapping
+            if dataset_mapping&.dig('datasetMappings', 'items').nil? || dataset_mapping['datasetMappings']['items'].empty?
+              params.gdc_logger.info "Project: '#{from.title}', PID: '#{from.pid}' has no model mapping, skip synchronizing model mapping."
+            else
+              to_projects.peach do |to|
+                pid = to[:pid]
+                to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+
+                params.gdc_logger.info "Transferring model mapping, from project: '#{from.title}', PID: '#{from.pid}', to project: '#{to_project.title}', PID: '#{to_project.pid}'"
+                res = to_project.update_dataset_mapping(dataset_mapping)
+                res[:from] = from.pid
+                results << res
+              end
+            end
+          end
+          # Return results
+          results.flatten
+        end
+      end
+    end
+  end
+end

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

@@ -83,18 +83,29 @@ module GoodData
           segment_info[:from_blueprint] = blueprint
           maql_diff = nil
           previous_master = segment_info[:previous_master]
+          synchronize_ldm_mode = params[:synchronize_ldm].downcase
           diff_against_master = %w(diff_against_master_with_fallback diff_against_master)
-            .include?(params[:synchronize_ldm].downcase)
-          GoodData.logger.info "Synchronize LDM mode: '#{params[:synchronize_ldm].downcase}'"
-          if previous_master && diff_against_master
-            maql_diff_params = [:includeGrain]
-            maql_diff_params << :excludeFactRule if exclude_fact_rule
-            maql_diff_params << :includeDeprecated if include_deprecated
-            maql_diff = previous_master.maql_diff(blueprint: blueprint, params: maql_diff_params)
+            .include?(synchronize_ldm_mode)
+          GoodData.logger.info "Synchronize LDM mode: '#{synchronize_ldm_mode}'"
+          if segment_info.key?(:previous_master) && diff_against_master
+            if previous_master
+              maql_diff_params = [:includeGrain]
+              maql_diff_params << :excludeFactRule if exclude_fact_rule
+              maql_diff_params << :includeDeprecated if include_deprecated
+              maql_diff = previous_master.maql_diff(blueprint: blueprint, params: maql_diff_params)
+            else
+              maql_diff = {
+                "projectModelDiff" =>
+                   {
+                     "updateOperations" => [],
+                     "updateScripts" => []
+                   }
+              }
+            end
             chunks = maql_diff['projectModelDiff']['updateScripts']
             if chunks.empty?
               GoodData.logger.info "Synchronize LDM to clients will not proceed in mode \
-'#{params[:synchronize_ldm].downcase}' due to no LDM changes in the new master project. \
+'#{synchronize_ldm_mode}' due to no LDM changes in the segment master project. \
 If you had changed LDM of clients manually, please use mode 'diff_against_clients' \
 to force synchronize LDM to clients"
             end