gooddata 2.1.19 → 2.3.0

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

@@ -121,9 +121,10 @@ module GoodData
             users_brick_input: params.users_brick_users
           }
           all_clients = domain.clients(:all, data_product).to_a
-          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, number_of_clients=#{all_clients.size}, data_rows=#{user_filters.size}")
+          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, number_of_clients=#{all_clients.size}, data_rows=#{user_filters.size} ,")
 
           GoodData.logger.info("Synchronizing in mode \"#{mode}\"")
+          results = []
           case mode
           when 'sync_project', 'sync_one_project_based_on_pid', 'sync_one_project_based_on_custom_id'
             if mode == 'sync_one_project_based_on_pid'
@@ -133,8 +134,10 @@ module GoodData
             end
             user_filters = user_filters.select { |f| f[:pid] == filter } if filter
 
-            GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{user_filters.size}")
-            sync_user_filters(project, user_filters, run_params, symbolized_config)
+            GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{user_filters.size} ,")
+            current_results = sync_user_filters(project, user_filters, run_params, symbolized_config)
+
+            results.concat(current_results[:results]) unless current_results.nil? || current_results[:results].empty?
           when 'sync_multiple_projects_based_on_pid', 'sync_multiple_projects_based_on_custom_id'
             users_by_project = run_params[:users_brick_input].group_by { |u| u[:pid] }
             user_filters.group_by { |u| u[:pid] }.flat_map.pmap do |id, new_filters|
@@ -148,8 +151,10 @@ module GoodData
                 current_project = client.projects(id)
               end
 
-              GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{id}, data_rows=#{new_filters.size}")
-              sync_user_filters(current_project, new_filters, run_params.merge(users_brick_input: users), symbolized_config)
+              GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{id}, data_rows=#{new_filters.size} ,")
+              current_results = sync_user_filters(current_project, new_filters, run_params.merge(users_brick_input: users), symbolized_config)
+
+              results.concat(current_results[:results]) unless current_results.nil? || current_results[:results].empty?
             end
           when 'sync_domain_client_workspaces'
             domain_clients = all_clients
@@ -159,9 +164,9 @@ module GoodData
             end
 
             working_client_ids = []
+            semaphore = Mutex.new
 
             users_by_project = run_params[:users_brick_input].group_by { |u| u[:pid] }
-            results = []
             user_filters.group_by { |u| u[multiple_projects_column] }.flat_map.pmap do |client_id, new_filters|
               users = users_by_project[client_id]
               fail "Client id cannot be empty" if client_id.blank?
@@ -178,36 +183,39 @@ module GoodData
               current_project = c.project
               fail "Client #{client_id} does not have project." unless current_project
 
-              working_client_ids << client_id
+              semaphore.synchronize do
+                working_client_ids << client_id.to_s
+              end
 
-              GoodData.gd_logger.info("Synchronizing in mode=#{mode}, client_id=#{client_id}, data_rows=#{new_filters.size}")
+              GoodData.gd_logger.info("Synchronizing in mode=#{mode}, client_id=#{client_id}, data_rows=#{new_filters.size} ,")
               partial_results = sync_user_filters(current_project, new_filters, run_params.merge(users_brick_input: users), symbolized_config)
-              results.concat(partial_results[:results])
+              results.concat(partial_results[:results]) unless partial_results.nil? || partial_results[:results].empty?
             end
 
-            unless run_params[:do_not_touch_filters_that_are_not_mentioned]
-              domain_clients.peach do |c|
-                next if working_client_ids.include?(c.client_id)
+            GoodData.gd_logger.info("Synchronizing in mode=#{mode}, working_client_ids=#{working_client_ids.join(', ')} ,") if working_client_ids.size < 50
 
+            unless run_params[:do_not_touch_filters_that_are_not_mentioned]
+              to_be_deleted_clients = UserBricksHelper.non_working_clients(domain_clients, working_client_ids)
+              to_be_deleted_clients.peach do |c|
                 begin
                   current_project = c.project
                   users = users_by_project[c.client_id]
                   params.gdc_logger.info "Delete all filters in project #{current_project.pid} of client #{c.client_id}"
 
-                  GoodData.gd_logger.info("Delete all filters in project_id=#{current_project.pid}, client_id=#{c.client_id}")
+                  GoodData.gd_logger.info("Delete all filters in project_id=#{current_project.pid}, client_id=#{c.client_id} ,")
                   current_results = sync_user_filters(current_project, [], run_params.merge(users_brick_input: users), symbolized_config)
 
-                  results.concat(current_results[:results])
+                  results.concat(current_results[:results]) unless current_results.nil? || current_results[:results].empty?
                 rescue StandardError => e
                   params.gdc_logger.error "Failed to clear filters of  #{c.client_id} due to: #{e.inspect}"
                 end
               end
             end
-
-            {
-              results: results
-            }
           end
+
+          {
+            results: results
+          }
         end
 
         def sync_user_filters(project, filters, params, filters_config)

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

@@ -27,11 +27,22 @@ module GoodData
 
         description 'Additional Hidden Parameters'
         param :additional_hidden_params, instance_of(Type::HashType), required: false
+
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), 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
 
       class << self
         def call(params)
           results = ThreadSafe::Array.new
+          collect_synced_status = collect_synced_status(params)
+          failed_projects = ThreadSafe::Array.new
 
           client = params.gdc_gd_client
           development_client = params.development_client
@@ -40,17 +51,32 @@ module GoodData
             from_project = info.from
             to_projects = info.to
 
-            from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
+            from = development_client.projects(from_project)
+            unless from
+              process_failed_project(from_project, "Invalid 'from' project specified - '#{from_project}'", failed_projects, collect_synced_status)
+              next
+            end
 
             to_projects.peach do |entry|
               pid = entry[:pid]
-              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+              next if sync_failed_project(pid, params)
+
+              to_project = client.projects(pid)
+              unless to_project
+                process_failed_project(pid, "Invalid 'to' project specified - '#{pid}'", failed_projects, collect_synced_status)
+                next
+              end
 
-              params.gdc_logger.info "Transferring User Groups, from project: '#{from.title}', PID: '#{from.pid}', to project: '#{to_project.title}', PID: '#{to_project.pid}'"
-              results += GoodData::Project.transfer_user_groups(from, to_project)
+              begin
+                params.gdc_logger.info "Transferring User Groups, from project: '#{from.title}', PID: '#{from.pid}', to project: '#{to_project.title}', PID: '#{to_project.pid}'"
+                results += GoodData::Project.transfer_user_groups(from, to_project)
+              rescue StandardError => err
+                process_failed_project(pid, err.message, failed_projects, collect_synced_status)
+              end
             end
           end
 
+          process_failed_projects(failed_projects, short_name, params) if collect_synced_status
           results.uniq
         end
       end

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

@@ -190,7 +190,7 @@ module GoodData
             create_non_existing_user_groups: create_non_existing_user_groups,
             user_groups_cache: nil
           }
-          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, data_rows=#{new_users.size}")
+          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, data_rows=#{new_users.size} ,")
 
           GoodData.logger.info("Synchronizing in mode \"#{mode}\"")
           results = case mode
@@ -202,7 +202,7 @@ module GoodData
                       params.gdc_logger.info "#{user_ids.count - users.count} users were not found (or were deleted) in domain #{domain_name}" if user_ids.count > users.count
                       params.gdc_logger.warn "Deleting #{users.count} users from domain #{domain_name}"
 
-                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, domain=#{domain_name}, data_rows=#{users.count}")
+                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, domain=#{domain_name}, data_rows=#{users.count} ,")
                       users.map(&:delete)
                     when 'sync_project'
                       project.import_users(new_users, common_params)
@@ -211,7 +211,7 @@ module GoodData
                         begin
                           project = client.projects(project_id)
 
-                          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project_id}, data_rows=#{users.count}")
+                          GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project_id}, data_rows=#{users.count} ,")
                           project.import_users(users, common_params)
                         rescue RestClient::ResourceNotFound
                           fail "Project \"#{project_id}\" was not found. Please check your project ids in the source file"
@@ -224,7 +224,7 @@ module GoodData
                     when 'sync_one_project_based_on_pid'
                       filtered_users = new_users.select { |u| u[:pid] == project.pid }
 
-                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, data_rows=#{filtered_users.count}")
+                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, data_rows=#{filtered_users.count} ,")
                       project.import_users(filtered_users, common_params)
                     when 'sync_one_project_based_on_custom_id'
                       filter_value = UserBricksHelper.resolve_client_id(domain, project, data_product)
@@ -245,7 +245,7 @@ module GoodData
                       end
 
                       GoodData.logger.info("Project #{project.pid} will receive #{filtered_users.count} from #{new_users.count} users")
-                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, filtered_users=#{filtered_users.count}, data_rows=#{new_users.count}")
+                      GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, filtered_users=#{filtered_users.count}, data_rows=#{new_users.count} ,")
                       project.import_users(filtered_users, common_params)
                     when 'sync_multiple_projects_based_on_custom_id'
                       all_clients = domain.clients(:all, data_product).to_a
@@ -260,7 +260,7 @@ module GoodData
 
                         GoodData.logger.info("Project #{project.pid} of client #{client_id} will receive #{users.count} users")
 
-                        GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{users.count}")
+                        GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{users.count} ,")
                         project.import_users(users, common_params)
                       end
                     when 'sync_domain_client_workspaces'
@@ -294,7 +294,7 @@ module GoodData
                         working_client_ids << client_id.to_s
                         GoodData.logger.info("Project #{project.pid} of client #{client_id} will receive #{users.count} users")
 
-                        GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{users.count}")
+                        GoodData.gd_logger.info("Synchronizing in mode=#{mode}, project_id=#{project.pid}, data_rows=#{users.count} ,")
                         project.import_users(users, common_params)
                       end
 
@@ -319,17 +319,17 @@ module GoodData
                           end
                           GoodData.logger.info("Synchronizing all users in project #{project.pid} of client #{c.client_id}")
 
-                          GoodData.gd_logger.info("Synchronizing all users in project_id=#{project.pid}, client_id=#{c.client_id}")
+                          GoodData.gd_logger.info("Synchronizing all users in project_id=#{project.pid}, client_id=#{c.client_id} ,")
                           res += project.import_users([], common_params)
                         end
                       end
 
                       res
                     when 'sync_domain_and_project'
-                      GoodData.gd_logger.info("Create users in mode=#{mode}, data_rows=#{new_users.count}")
+                      GoodData.gd_logger.info("Create users in mode=#{mode}, data_rows=#{new_users.count} ,")
                       domain.create_users(new_users, ignore_failures: ignore_failures)
 
-                      GoodData.gd_logger.info("Import users in mode=#{mode}, data_rows=#{new_users.count}")
+                      GoodData.gd_logger.info("Import users in mode=#{mode}, data_rows=#{new_users.count} ,")
                       project.import_users(new_users, common_params)
                     end
 
@@ -390,6 +390,7 @@ module GoodData
 
             user_group = row[user_groups_column] || row[user_groups_column.to_sym]
             user_group = user_group.split(',').map(&:strip) if user_group
+            user_group = [] if row.headers.include?(user_groups_column) && !user_group
 
             ip_whitelist = row[ip_whitelist_column] || row[ip_whitelist_column.to_sym]
             ip_whitelist = ip_whitelist.split(',').map(&:strip) if ip_whitelist

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

@@ -0,0 +1,202 @@
+# 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 UpdateMetricFormats < BaseAction
+      DESCRIPTION = 'Localize Metric Formats'
+
+      PARAMS = define_params(self) do
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Organization Name'
+        param :organization, instance_of(Type::StringType), required: false
+
+        description 'DataProduct to manage'
+        param :data_product, instance_of(Type::GDDataProductType), required: false
+
+        description 'Logger'
+        param :gdc_logger, instance_of(Type::GdLogger), required: true
+
+        description 'ADS Client'
+        param :ads_client, instance_of(Type::AdsClientType), required: false
+
+        description 'Input Source'
+        param :input_source, instance_of(Type::HashType), required: false
+
+        description 'Localization query'
+        param :localization_query, instance_of(Type::StringType), required: false
+
+        description 'Abort on error'
+        param :abort_on_error, instance_of(Type::StringType), 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[action ok_clients error_clients]
+
+      class << self
+        def load_metric_data(params)
+          collect_synced_status = collect_synced_status(params)
+
+          if params&.dig(:input_source, :metric_format) && params[:input_source][:metric_format].present?
+            metric_input_source = validate_input_source(params[:input_source], collect_synced_status)
+            return nil unless metric_input_source
+          else
+            return nil
+          end
+
+          metric_data_source = GoodData::Helpers::DataSource.new(metric_input_source)
+          begin
+            temp_csv = without_check(PARAMS, params) do
+              File.open(metric_data_source.realize(params), 'r:UTF-8')
+            end
+          rescue StandardError => e
+            GoodData.logger.warn("Unable to get metric input source, skip updating metric formats. Error: #{e.message} - #{e}")
+            return nil
+          end
+
+          metrics_hash = GoodData::Helpers::Csv.read_as_hash temp_csv
+          return nil if metrics_hash.empty?
+
+          expected_keys = %w[tag client_id format]
+          unless expected_keys.map(&:to_sym).all? { |s| metrics_hash.first.key? s }
+            GoodData.logger.warn("The input metric data is incorrect, expecting the following fields: #{expected_keys}")
+            return nil
+          end
+          metrics_hash
+        end
+
+        def validate_input_source(input_source, continue_on_error)
+          type = input_source[:type] if input_source&.dig(:type)
+          metric_format = input_source[:metric_format]
+          if type.blank?
+            raise "Incorrect configuration: 'type' of 'input_source' is required" unless continue_on_error
+
+            return nil
+          end
+
+          modified_input_source = input_source
+          case type
+          when 'ads', 'redshift', 'snowflake', 'bigquery', 'postgresql', 'mssql', 'mysql'
+            if metric_format[:query].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'query'")
+              return nil
+            end
+
+            modified_input_source[:query] = metric_format[:query]
+            return modified_input_source
+          when 's3'
+            if metric_format[:file].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'file'")
+              return nil
+            end
+
+            if modified_input_source.key?(:key)
+              modified_input_source[:key] = metric_format[:file]
+            else
+              modified_input_source[:file] = metric_format[:file]
+            end
+            return modified_input_source
+          when 'blobStorage'
+            if metric_format[:file].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'file'")
+              return nil
+            end
+
+            modified_input_source[:file] = metric_format[:file]
+            return modified_input_source
+          when 'staging'
+            if metric_format[:file].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'file'")
+              return nil
+            end
+
+            modified_input_source[:path] = metric_format[:file]
+            return modified_input_source
+          when 'web'
+            if metric_format[:url].blank?
+              GoodData.logger.warn("The metric input_source '#{type}' is missing property 'url'")
+              return nil
+            end
+
+            modified_input_source[:url] = metric_format[:url]
+            return modified_input_source
+          else
+            return nil
+          end
+        end
+
+        def get_clients_metrics(metric_data)
+          return {} if metric_data.nil?
+
+          metric_groups = {}
+          clients = metric_data.map { |row| row[:client_id] }.uniq
+          clients.each do |client|
+            next if client.blank?
+
+            formats = {}
+            metric_data.select { |row| row[:client_id] == client && row[:tag].present? && row[:format].present? }.each { |row| formats[row[:tag]] = row[:format] }
+            metric_groups[client.to_s] ||= formats
+          end
+          metric_groups
+        end
+
+        def call(params)
+          data = load_metric_data(params)
+          result = []
+          return result if data.nil?
+
+          metric_group = get_clients_metrics(data)
+          return result if metric_group.empty?
+
+          GoodData.logger.debug("Clients have metrics which will be modified: #{metric_group.keys}")
+          updated_clients = params.synchronize.map { |segment| segment.to.map { |client| client[:client_id] } }.flatten.uniq
+          GoodData.logger.debug("Updating clients: #{updated_clients}")
+          data_product = params.data_product
+          data_product_clients = data_product.clients
+          number_client_ok = 0
+          number_client_error = 0
+          collect_synced_status = collect_synced_status(params)
+          metric_group.each do |client_id, formats|
+            next if !updated_clients.include?(client_id) || (collect_synced_status && sync_failed_client(client_id, params))
+
+            client = data_product_clients.find { |c| c.id == client_id }
+            begin
+              GoodData.logger.info("Start updating metric format for client: '#{client_id}'")
+              metrics = client.project.metrics.to_a
+              formats.each do |tag, format|
+                next if tag.blank? || format.blank?
+
+                metrics_to_be_updated = metrics.select { |metric| metric.tags.include?(tag) }
+                metrics_to_be_updated.each do |metric|
+                  metric.format = format
+                  metric.save
+                end
+              end
+              number_client_ok += 1
+              GoodData.logger.info("Finished updating metric format for client: '#{client_id}'")
+            rescue StandardError => e
+              number_client_error += 1
+              GoodData.logger.warn("Failed to update metric format for client: '#{client_id}'. Error: #{e.message} - #{e}")
+            end
+          end
+          [{ :action => 'Update metric format', :ok_clients => number_client_ok, :error_clients => number_client_error }]
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/data/delete_from_lcm_release.sql.erb

@@ -0,0 +1,5 @@
+DELETE FROM "<%= table_name || 'LCM_RELEASE' %>"
+WHERE
+  segment_id = '<%= segment_id %>'
+  AND master_project_id IN (<%= master_project_ids %>)
+;

data/lib/gooddata/lcm/exceptions/lcm_execution_warning.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+# (C) 2019-2022 GoodData Corporation
+
+module GoodData
+  class LcmExecutionWarning < RuntimeError
+    DEFAULT_MSG = 'Existing errors during lcm execution'
+
+    attr_reader :summary_error
+
+    def initialize(summary_error, message = DEFAULT_MSG)
+      super(message)
+      @summary_error = summary_error
+    end
+  end
+end

data/lib/gooddata/lcm/helpers/check_helper.rb

@@ -10,6 +10,9 @@ module GoodData
   module LCM2
     class Helpers
       class << self
+        ABORT_ON_ERROR_PARAM = 'abort_on_error'.to_sym
+        COLLECT_SYNCED_STATUS = 'collect_synced_status'.to_sym
+
         def check_params(specification, params)
           specification.keys.each do |param_name|
             value = params.send(param_name)
@@ -39,6 +42,22 @@ module GoodData
             end
           end
         end
+
+        def continue_on_error(params)
+          params.include?(ABORT_ON_ERROR_PARAM) && !to_bool(ABORT_ON_ERROR_PARAM, params[ABORT_ON_ERROR_PARAM])
+        end
+
+        def collect_synced_status(params)
+          params.include?(COLLECT_SYNCED_STATUS) && to_bool(COLLECT_SYNCED_STATUS, params[COLLECT_SYNCED_STATUS])
+        end
+
+        def to_bool(key, value)
+          return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          return true if value =~ /^(true|t|yes|y|1)$/i
+          return false if value == '' || value =~ /^(false|f|no|n|0)$/i
+
+          raise ArgumentError, "Invalid '#{value}' boolean value for '#{key}' parameter"
+        end
       end
     end
   end

data/lib/gooddata/lcm/helpers/release_table_helper.rb

@@ -12,6 +12,21 @@ module GoodData
 
       class << self
         def latest_master_project_from_ads(release_table_name, ads_client, segment_id)
+          sorted = get_master_project_list_from_ads(release_table_name, ads_client, segment_id)
+          sorted.last
+        end
+
+        def latest_master_project_from_nfs(domain_id, data_product_id, segment_id)
+          file_path = path_to_release_table_file(domain_id, data_product_id, segment_id)
+          sorted = get_master_project_list_from_nfs(domain_id, data_product_id, segment_id)
+          latest_master_project = sorted.last
+
+          version_info = latest_master_project ? "master_pid=#{latest_master_project[:master_project_id]} version=#{latest_master_project[:version]}" : ""
+          GoodData.gd_logger.info "Getting latest master project: file=#{file_path} domain=#{domain_id} data_product=#{data_product_id} segment=#{segment_id} #{version_info}"
+          latest_master_project
+        end
+
+        def get_master_project_list_from_ads(release_table_name, ads_client, segment_id)
           replacements = {
             table_name: release_table_name || DEFAULT_TABLE_NAME,
             segment_id: segment_id
@@ -22,18 +37,27 @@ module GoodData
 
           res = ads_client.execute_select(query)
           sorted = res.sort_by { |row| row[:version] }
-          sorted.last
+          sorted
         end
 
-        def latest_master_project_from_nfs(domain_id, data_product_id, segment_id)
+        def delete_master_project_from_ads(release_table_name, ads_client, segment_id, removal_master_project_ids)
+          replacements = {
+            table_name: release_table_name || DEFAULT_TABLE_NAME,
+            segment_id: segment_id,
+            master_project_ids: removal_master_project_ids.map { |x| "'#{x}'" } * ', '
+          }
+
+          path = File.expand_path('../data/delete_from_lcm_release.sql.erb', __dir__)
+          query = GoodData::Helpers::ErbHelper.template_file(path, replacements)
+
+          ads_client.execute(query)
+        end
+
+        def get_master_project_list_from_nfs(domain_id, data_product_id, segment_id)
           file_path = path_to_release_table_file(domain_id, data_product_id, segment_id)
           data = GoodData::Helpers::Csv.read_as_hash(file_path)
-          latest_master_project = data.sort_by { |master| master[:version] }
-              .reverse.first
-
-          version_info = latest_master_project ? "master_pid=#{latest_master_project[:master_project_id]} version=#{latest_master_project[:version]}" : ""
-          GoodData.gd_logger.info "Getting latest master project: file=#{file_path} domain=#{domain_id} data_product=#{data_product_id} segment=#{segment_id} #{version_info}"
-          latest_master_project
+          sorted = data.sort_by { |master| master[:version] }
+          sorted
         end
 
         def update_latest_master_to_nfs(domain_id, data_product_id, segment_id, master_pid, version)
@@ -46,6 +70,16 @@ module GoodData
           )
         end
 
+        def update_master_project_to_nfs(domain_id, data_product_id, segment_id, data)
+          file_path = path_to_release_table_file(domain_id, data_product_id, segment_id)
+          FileUtils.mkpath(file_path.split('/')[0...-1].join('/'))
+          CSV.open(file_path, 'w', write_headers: true, headers: data.first.keys) do |csv|
+            data.each do |r|
+              csv << r.values
+            end
+          end
+        end
+
         def path_to_release_table_file(domain_id, data_prod_id, segment_id)
           nsf_directory = ENV['RELEASE_TABLE_NFS_DIRECTORY'] || DEFAULT_NFS_DIRECTORY
           [nsf_directory, domain_id, data_prod_id + '-' + segment_id + '.csv'].join('/')