gooddata 1.0.0-java

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

@@ -0,0 +1,89 @@
+# 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'
+require_relative 'purge_clients'
+
+module GoodData
+  module LCM2
+    class ProvisionClients < BaseAction
+      DESCRIPTION = 'Provisions 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 = [
+        :id,
+        :status,
+        :project_uri,
+        :error,
+        :type
+      ]
+
+      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}")
+
+          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]}"
+                    end
+                    {
+                      pid: entry[:project_uri].split('/').last,
+                      client_id: entry[:id]
+                    }
+                  end
+                }
+              end
+
+              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!
+
+          # Return results
+          {
+            results: results,
+            params: {
+              synchronize: synchronize_projects
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# 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 PurgeClients < BaseAction
+      DESCRIPTION = 'Purge LCM Clients'
+
+      PARAMS = define_params(self) do
+      end
+
+      RESULT_HEADER = [
+        :client_id,
+        :project,
+        :status
+      ]
+
+      class << self
+        def call(params)
+          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
+
+            res
+          end
+
+          results.pselect { |res| res[:status] == 'purged' }.pmap { |res| res[:client_id] }.each { |id| client_projects.delete(id) }
+
+          {
+            results: results,
+            params: {
+              client_projects: client_projects
+            }
+          }
+        end
+      end
+    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

@@ -0,0 +1,50 @@
+# 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 SegmentsFilter < BaseAction
+      DESCRIPTION = 'Filter Segments'
+
+      PARAMS = define_params(self) do
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+
+        description 'Segments to provision'
+        param :segments_filter, array_of(instance_of(Type::StringType)), required: false
+      end
+
+      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)
+
+            filtered_segments = params.segments.select do |segment|
+              segments_filter.include?(segment.segment_id.downcase)
+            end
+          end
+
+          # Return results
+          {
+            results: filtered_segments,
+            params: {
+              segments: filtered_segments
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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 SynchronizeAttributeDrillpath < BaseAction
+      DESCRIPTION = 'Synchronize Attribute Drillpath'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Development Client Used for Connecting to GD'
+        param :development_client, instance_of(Type::GdClientType), required: true
+
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+      end
+
+      RESULT_HEADER = [
+        :from,
+        :to,
+        :status
+      ]
+
+      class << self
+        def call(params)
+          results = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_client
+
+          params.synchronize.peach do |info|
+            from = info.from
+            to = info.to
+
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+            to_projects = to.pmap do |entry|
+              pid = entry[:pid]
+              client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+            end
+
+            GoodData::LCM.transfer_attribute_drillpaths(from_project, to_projects)
+
+            to_projects.each do |project|
+              results << {
+                from: from,
+                to: project.pid,
+                status: 'ok'
+              }
+            end
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# 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 SynchronizeComputedAttributes < BaseAction
+      DESCRIPTION = 'Synchronize Computed Attributes'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        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|
+            from = info.from
+            to_projects = info.to
+
+            params.gdc_logger.info "Synchronize Computed Attributes from project pid: #{from}"
+
+            to_projects.peach do |entry|
+              ca_scripts = entry[:ca_scripts]
+              next unless ca_scripts
+
+              pid = entry[:pid]
+              ca_chunks = ca_scripts['maqlDdlChunks']
+              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+              params.gdc_logger.info "Synchronizing Computed Attributes to project: '#{to_project.title}', PID: #{pid}"
+
+              begin
+                ca_chunks.each { |chunk| to_project.execute_maql(chunk) }
+              rescue => e
+                raise "Error occured when executing MAQL, project: \"#{to_project.title}\" reason: \"#{e.message}\", chunks: #{ca_chunks.inspect}"
+              end
+
+              results << {
+                from: from,
+                to: pid,
+                status: 'ok'
+              }
+            end
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# 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 SynchronizeClients < BaseAction
+      DESCRIPTION = 'Synchronize 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
+
+        description 'Table Name'
+        param :release_table_name, instance_of(Type::StringType), required: false
+
+        description 'ADS Client'
+        param :ads_client, instance_of(Type::AdsClientType), required: true
+      end
+
+      RESULT_HEADER = [
+        :segment,
+        :successful_count,
+        :failed_count,
+        :master_name,
+        :master_pid,
+        # :details
+      ]
+
+      DEFAULT_TABLE_NAME = 'LCM_RELEASE'
+
+      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
+          domain_segments = domain.segments(:all, data_product)
+
+          segments = params.segments.map do |seg|
+            domain_segments.find do |s|
+              s.segment_id == seg.segment_id
+            end
+          end
+
+          results = segments.map do |segment|
+            replacements = {
+              table_name: params.release_table_name || DEFAULT_TABLE_NAME,
+              segment_id: segment.segment_id
+            }
+
+            path = File.expand_path('../../data/select_from_lcm_release.sql.erb', __FILE__)
+            query = GoodData::Helpers::ErbHelper.template_file(path, replacements)
+
+            res = params.ads_client.execute_select(query)
+
+            # TODO: Check res.first.nil? || res.first[:master_project_id].nil?
+            master = client.projects(res.first[:master_project_id])
+
+            segment.master_project = master
+            segment.save
+
+            res = segment.synchronize_clients
+
+            sync_result = res.json['synchronizationResult']
+
+            {
+              segment: segment.id,
+              master_pid: master.pid,
+              master_name: master.title,
+              successful_count: sync_result['successfulClients']['count'],
+              failed_count: sync_result['failedClients']['count'],
+              # details: sync_result['links']['details']
+            }
+          end
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end