gooddata 0.6.53 → 0.6.54

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

@@ -5,6 +5,7 @@
 # LICENSE file in the root directory of this source tree.
 
 require_relative 'base_action'
+require_relative 'purge_clients'
 
 module GoodData
   module LCM2
@@ -32,34 +33,44 @@ module GoodData
 
       class << self
         def call(params)
+          synchronize_projects = []
+          data_product = params.data_product
           client = params.gdc_gd_client
-
           domain_name = params.organization || params.domain
           domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
 
-          synchronize_projects = []
-          results = params.segments.pmap do |segment|
-            tmp = domain.provision_client_projects(segment.segment_id).pmap do |m|
-              Hash[m.each_pair.to_a].merge(type: :provision_result)
-            end
+          begin
+            results = params.segments.map do |segment|
+              segment_object = domain.segments(segment.segment_id, data_product)
+              tmp = segment_object.provision_client_projects.map do |m|
+                Hash[m.each_pair.to_a].merge(type: :provision_result)
+              end
 
-            unless tmp.empty?
-              synchronize_projects << {
-                segment_id: segment.segment_id,
-                from: segment.development_pid,
-                to: tmp.map do |entry|
-                  unless entry[:project_uri]
-                    raise "Provisioning project for client id #{entry[:id]} has error: #{entry[:error]}"
+              unless tmp.empty?
+                synchronize_projects << {
+                  segment_id: segment.segment_id,
+                  from: segment.development_pid,
+                  to: tmp.map do |entry|
+                    unless entry[:project_uri]
+                      raise "Provisioning project for client id #{entry[:id]} has error: #{entry[:error]}"
+                    end
+                    {
+                      pid: entry[:project_uri].split('/').last,
+                      client_id: entry[:id]
+                    }
                   end
-                  {
-                    pid: entry[:project_uri].split('/').last,
-                    client_id: entry[:id]
-                  }
-                end
-              }
-            end
+                }
+              end
 
-            tmp
+              tmp
+            end
+          rescue => e
+            params.gdc_logger.error "Problem occurs when provisioning clients. Purge all invalid clients now ..."
+            res = PurgeClients.send(:call, params)
+            params.gdc_logger.debug "Purge clients result: #{res}"
+            deleted_client_ids = res[:results].select { |r| r[:status] == 'purged' }.map { |r| r[:client_id] }
+            params.gdc_logger.error "Deleted clients: #{deleted_client_ids.join(', ')}"
+            raise e
           end
 
           results.flatten!

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

@@ -12,14 +12,6 @@ module GoodData
       DESCRIPTION = 'Purge LCM Clients'
 
       PARAMS = define_params(self) do
-        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: true
-
-        description 'Segments to manage'
-        param :segments, array_of(instance_of(Type::SegmentType)), required: true
       end
 
       RESULT_HEADER = [
@@ -30,41 +22,35 @@ module GoodData
 
       class << self
         def call(params)
-          client = params.gdc_gd_client
-
-          domain_name = params.organization || params.domain
-          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
-          all_segments = domain.segments
-
-          segment_names = params.segments.map do |segment|
-            segment.segment_id.downcase
-          end
+          client_projects = params.client_projects
+
+          results = client_projects.pmap do |_, info|
+            client = info[:segment_client]
+            project = info[:project]
+
+            res = {
+              client_id: client.client_id,
+              project: project && project.pid
+            }
+
+            if project.nil? || project.deleted?
+              client.delete
+              res[:status] = 'purged'
+            else
+              res[:status] = 'ok - not purged'
+            end
 
-          segments = all_segments.select do |segment|
-            segment_names.include?(segment.segment_id.downcase)
+            res
           end
 
-          results = segments.pmap do |segment|
-            segment.clients.map do |segment_client|
-              project = segment_client.project
-              res = {
-                client_id: segment_client.client_id,
-                project: project && project.pid
-              }
-
-              if project.nil? || project.deleted?
-                segment_client.delete
-                res[:status] = 'purged'
-              else
-                res[:status] = 'ok - not purged'
-              end
-
-              res
-            end
-          end
+          results.pselect { |res| res[:status] == 'purged' }.pmap { |res| res[:client_id] }.each { |id| client_projects.delete(id) }
 
-          # Return results
-          results.flatten
+          {
+            results: results,
+            params: {
+              client_projects: client_projects
+            }
+          }
         end
       end
     end

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

@@ -0,0 +1,70 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2017 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 RenameExistingClientProjects < BaseAction
+      DESCRIPTION = 'Rename Existing Client Projects'
+
+      PARAMS = define_params(self) do
+        description 'Clients'
+        param :clients, array_of(instance_of(Type::HashType)), required: true, generated: true
+      end
+
+      RESULT_HEADER = [
+        :id,
+        :pid,
+        :old_title,
+        :new_title
+      ]
+
+      class << self
+        def call(params)
+          client_projects = params.client_projects
+
+          results = []
+          params.clients.each do |c|
+            info = client_projects[c[:id]]
+            next unless info
+
+            segment_client = info[:segment_client]
+            project = info[:project]
+
+            # If he is an existing client but has no project, he will be purged and then re-created again
+            # so his project absolutely does not need to be updated title
+            next unless project
+
+            # If his project is existing, we do not know this is a correct project or not because user
+            # can associate this client with another project and we need to check and update its title.
+            # If this is a new project, we do not need to verify its status because we already did it in
+            # CollectClients action
+            project = segment_client.project
+
+            new_title = c[:settings].find { |setting| setting[:name] == 'lcm.title' }[:value]
+            next unless new_title
+
+            old_title = project.title
+            next if new_title == old_title
+
+            project.title = new_title
+            project.save
+
+            results << {
+              id: c[:id],
+              pid: project.pid,
+              old_title: old_title,
+              new_title: new_title
+            }
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -22,6 +22,12 @@ module GoodData
       class << self
         def call(params)
           filtered_segments = params.segments
+
+          segment_ids = filtered_segments.map(&:segment_id)
+          downcase_segment_ids = segment_ids.map(&:downcase)
+          duplicated_segment_ids = segment_ids.select { |e| downcase_segment_ids.count(e.downcase) > 1 }.uniq
+          fail "Parameter 'segments' contains duplicate segment id(s): #{duplicated_segment_ids.join(', ')}" if duplicated_segment_ids.any?
+
           if params.segments_filter
             segments_filter = params.segments_filter.map(&:downcase)
 

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

@@ -17,11 +17,22 @@ module GoodData
 
         description 'Synchronization Info'
         param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+
+        description 'Specifies whether to transfer computed attributes'
+        param :include_computed_attributes, instance_of(Type::BooleanType), required: false, default: true
       end
 
       class << self
         def call(params)
+          # set default value for include_computed_attributes
+          # (we won't have to do this after TMA-690)
+          include_ca = params.include_computed_attributes
+          include_ca = true if include_ca.nil?
+          include_ca = include_ca.to_b
+
           results = []
+          return results unless include_ca
+
           client = params.gdc_gd_client
 
           params.synchronize.each do |info|

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

@@ -45,7 +45,8 @@ module GoodData
 
           domain_name = params.organization || params.domain
           domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
-          domain_segments = domain.segments
+          data_product = params.data_product
+          domain_segments = domain.segments(:all, data_product)
 
           segments = params.segments.map do |seg|
             domain_segments.find do |s|

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

@@ -40,14 +40,13 @@ module GoodData
       class << self
         def call(params)
           client = params.gdc_gd_client
-          domain_name = params.organization || params.domain
-          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+          data_product = params.data_product
           synchronize_segments = params.synchronize.group_by do |info|
             info[:segment_id]
           end
 
           results = synchronize_segments.pmap do |segment_id, synchronize|
-            segment = domain.segments(segment_id)
+            segment = data_product.segments.find { |s| s.segment_id == segment_id }
             res = segment.synchronize_processes(
               synchronize.flat_map do |info|
                 info[:to].flat_map do |to|
@@ -80,15 +79,12 @@ module GoodData
           end
 
           delete_extra_process_schedule = GoodData::Helpers.to_boolean(params.delete_extra_process_schedule)
+          schedule_params = params.schedule_params || {}
+          params_for_all_projects = schedule_params[:all_clients] || {}
+          params_for_all_schedules_in_all_projects = params_for_all_projects[:all_schedules]
 
           params.synchronize.peach do |info|
-            if delete_extra_process_schedule
-              from_project = client.projects(info.from) || fail("Invalid 'from' project specified - '#{info.from}'")
-              from_project_processes = from_project.processes
-              from_project_process_id_names = Hash[from_project_processes.map { |process| [process.process_id, process.name] }]
-              from_project_process_names = from_project_processes.map(&:name)
-              from_project_schedule_names = from_project.schedules.map { |schedule| [schedule.name, from_project_process_id_names[schedule.process_id]] }
-            end
+            from_project_etl_names = get_process_n_schedule_names(client, info.from) if delete_extra_process_schedule
 
             to_projects = info.to
             to_projects.peach do |entry|
@@ -98,7 +94,7 @@ module GoodData
               if delete_extra_process_schedule
                 to_project_process_id_names = {}
                 to_project.processes.each do |process|
-                  if from_project_process_names.include?(process.name)
+                  if from_project_etl_names[:processes].include?(process.name)
                     to_project_process_id_names[process.process_id] = process.name
                   else
                     process.delete
@@ -106,21 +102,31 @@ module GoodData
                 end
               end
 
+              client_id = entry[:client_id]
+              params_for_this_client = schedule_params[client_id] || {}
+              params_for_all_schedules_in_this_client = params_for_this_client[nil]
+
+              to_project.set_metadata('GOODOT_CUSTOM_PROJECT_ID', client_id) # TMA-210
+
               to_project.schedules.each do |schedule|
                 if delete_extra_process_schedule
-                  unless from_project_schedule_names.include?([schedule.name, to_project_process_id_names[schedule.process_id]])
+                  unless from_project_etl_names[:schedules].include?([schedule.name, to_project_process_id_names[schedule.process_id]])
                     schedule.delete
                     next
                   end
                 end
 
                 schedule.update_params(params.additional_params) if params.additional_params
-
                 schedule.update_params(
-                  CLIENT_ID: entry[:client_id], # needed for ADD and CloudConnect ETL
-                  GOODOT_CUSTOM_PROJECT_ID: entry[:client_id] # TMA-210
+                  CLIENT_ID: client_id, # needed for ADD and CloudConnect ETL
+                  GOODOT_CUSTOM_PROJECT_ID: client_id # TMA-210
                 )
 
+                schedule.update_params(params_for_all_schedules_in_all_projects) if params_for_all_schedules_in_all_projects
+                schedule.update_params(params_for_all_projects[schedule.name]) if params_for_all_projects[schedule.name]
+                schedule.update_params(params_for_all_schedules_in_this_client) if params_for_all_schedules_in_this_client
+                schedule.update_params(params_for_this_client[schedule.name]) if params_for_this_client[schedule.name]
+
                 schedule.update_hidden_params(params.additional_hidden_params) if params.additional_hidden_params
                 schedule.enable
                 schedule.save
@@ -130,6 +136,19 @@ module GoodData
 
           results.flatten
         end
+
+        private
+
+        def get_process_n_schedule_names(client, project_id)
+          project = client.projects(project_id) || fail("Invalid 'from' project specified - '#{project_id}'")
+          processes = project.processes
+          process_id_names = Hash[processes.map { |process| [process.process_id, process.name] }]
+
+          {
+            processes: processes.map(&:name),
+            schedules: project.schedules.map { |schedule| [schedule.name, process_id_names[schedule.process_id]] }
+          }
+        end
       end
     end
   end

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

@@ -23,10 +23,19 @@ module GoodData
 
         description 'LDM Update Preference'
         param :update_preference, instance_of(Type::UpdatePreferenceType), required: false
+
+        description 'Specifies whether to transfer computed attributes'
+        param :include_computed_attributes, instance_of(Type::BooleanType), required: false, default: true
       end
 
       class << self
         def call(params)
+          # set default value for include_computed_attributes
+          # (we won't have to do this after TMA-690)
+          include_ca = params.include_computed_attributes
+          include_ca = true if include_ca.nil?
+          include_ca = include_ca.to_b
+
           results = []
 
           client = params.gdc_gd_client
@@ -39,7 +48,7 @@ module GoodData
             from = development_client.projects(from_project) || fail("Invalid 'from' project specified - '#{from_project}'")
             params.gdc_logger.info "Creating Blueprint, project: '#{from.title}', PID: #{from.pid}"
 
-            blueprint = from.blueprint
+            blueprint = from.blueprint(include_ca: include_ca)
             info[:to] = to_projects.pmap do |entry|
               pid = entry[:pid]
               to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")

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

@@ -28,7 +28,8 @@ module GoodData
 
           domain_name = params.organization || params.domain
           domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
-          domain_segments = domain.segments
+          data_product = params.data_product
+          domain_segments = domain.segments(:all, data_product)
 
           params.segments.pmap do |segment_in|
             segment_id = segment_in.segment_id

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

@@ -25,6 +25,7 @@ module GoodData
       RESULT_HEADER = [
         :from,
         :to,
+        :name,
         :status
       ]
 
@@ -48,20 +49,16 @@ module GoodData
               to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
 
               params.gdc_logger.info "Transferring processes, from project: '#{from.title}', PID: '#{from.pid}', to project: '#{to_project.title}', PID: '#{to_project.pid}'"
-              GoodData::Project.transfer_processes(from, to_project, ads_output_stage_uri: info.ads_output_stage_uri)
+              res = GoodData::Project.transfer_processes(from, to_project, ads_output_stage_uri: info.ads_output_stage_uri)
 
               to_project.add.output_stage.client_id = client_id if client_id && to_project.add.output_stage
 
-              results << {
-                from: from.pid,
-                to: to_project.pid,
-                status: 'ok'
-              }
+              results << res
             end
           end
 
           # Return results
-          results
+          results.flatten
         end
       end
     end

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

@@ -19,13 +19,16 @@ module GoodData
         description 'Synchronization Info'
         param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
 
-        description 'Tag Name'
-        param :production_tag, instance_of(Type::StringType), required: false
+        description 'Production Tag Names'
+        param :production_tags, array_of(instance_of(Type::StringType)), required: false
+
+        description 'Production Tag Names'
+        param :production_tag, instance_of(Type::StringType), required: false, deprecated: true, replacement: :production_tags
       end
 
       class << self
         def call(params)
-          return [] unless params.production_tag
+          return [] unless params.production_tags || params.production_tag
 
           results = []
 
@@ -42,12 +45,12 @@ module GoodData
               pid = entry[:pid]
               to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
 
-              GoodData::Project.transfer_tagged_stuff(from, to_project, params.production_tag)
+              GoodData::Project.transfer_tagged_stuff(from, to_project, params.production_tags || params.production_tag)
 
               results << {
                 from: from_project,
                 to: pid,
-                tag: params.production_tag,
+                tag: params.production_tags || params.production_tag,
                 status: 'ok'
               }
             end