gooddata 1.0.0-java

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

@@ -0,0 +1,80 @@
+# 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 '../helpers/helpers'
+
+module GoodData
+  module LCM2
+    class CollectTaggedObjects < BaseAction
+      DESCRIPTION = 'Collect all objects tagged with the +$PRODUCTION_TAG+ from development projects'
+
+      PARAMS = define_params(self) do
+        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
+
+        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
+
+        description 'Segments to search for segment-specific production tags'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: false
+
+        description 'Flag to mark if we need to transfer all objects'
+        param :transfer_all, instance_of(Type::BooleanType), required: false, default: false
+      end
+
+      class << self
+        def call(params)
+          results = []
+          segments_to_tags = Helpers.segment_production_tags(params.segments)
+          transfer_all = GoodData::Helpers.to_boolean(params.transfer_all)
+          return results unless params.production_tags || params.production_tag || segments_to_tags.any? || transfer_all
+          development_client = params.development_client
+
+          synchronize = params.synchronize.pmap do |info|
+            from = info.from
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+
+            segment_tags = segments_to_tags[info.segment]
+            production_tags = Helpers.parse_production_tags(params.production_tags || params.production_tag, segment_tags)
+            objects = []
+            if transfer_all
+              vizs = MdObject.query('visualization', MdObject, client: development_client, project: from_project)
+              viz_widgets = MdObject.query('visualizationWidget', MdObject, client: development_client, project: from_project)
+              objects = (from_project.reports.to_a + from_project.metrics.to_a + from_project.variables.to_a + vizs.to_a + viz_widgets.to_a).map(&:uri)
+            elsif production_tags.any?
+              objects = from_project.find_by_tag(production_tags)
+            end
+
+            info[:transfer_uris] ||= []
+            info[:transfer_uris] += objects
+
+            results += objects.map do |uri|
+              {
+                project: from,
+                transfer_uri: uri
+              }
+            end
+
+            info
+          end
+          {
+            results: results,
+            params: {
+              synchronize: synchronize
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# 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 CollectUsersBrickUsers < BaseAction
+      DESCRIPTION = 'Enriches parameters with users from the Users Brick input.'
+
+      PARAMS = define_params(self) do
+        description 'Input source of the Users Brick. Needed to prevent ' \
+                    'deletion of filters for a user that is to be removed.'
+        param :users_brick_config, instance_of(Type::UsersBrickConfig), required: true
+      end
+
+      class << self
+        def call(params)
+          users_brick_users = []
+          login_column = params.users_brick_config.login_column || 'login'
+          users_brick_data_source = GoodData::Helpers::DataSource.new(params.users_brick_config.input_source)
+          users_brick_data_source_file = File.open(
+            users_brick_data_source.realize(params),
+            'r:UTF-8'
+          )
+          CSV.foreach(users_brick_data_source_file,
+                      headers: true,
+                      return_headers: false,
+                      encoding: 'utf-8') do |row|
+            users_brick_users << { login: row[login_column] }
+          end
+
+          {
+            results: users_brick_users,
+            params: {
+              users_brick_users: users_brick_users
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# 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 CreateSegmentMasters < BaseAction
+      DESCRIPTION = 'Create Master Projects for Segments'
+
+      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 'Organization Name'
+        param :organization, instance_of(Type::StringType), required: true
+
+        description 'ADS Client'
+        param :ads_client, instance_of(Type::AdsClientType), required: true
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+
+        description 'Tokens'
+        param :tokens, instance_of(Type::TokensType), required: true
+
+        description 'Table Name'
+        param :release_table_name, instance_of(Type::StringType), required: false
+
+        description 'Project Environment'
+        param :project_environment, instance_of(Type::StringType), required: false
+      end
+
+      DEFAULT_TABLE_NAME = 'LCM_RELEASE'
+
+      class << self
+        def call(params)
+          results = []
+
+          client = params.gdc_gd_client
+          development_client = params.development_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)
+
+          # TODO: Support for 'per segment' provisioning
+          segments = params.segments
+
+          synchronize_projects = segments.map do |segment_in| # rubocop:disable Metrics/BlockLength
+            segment_id = segment_in.segment_id
+            development_pid = segment_in.development_pid
+            driver = segment_in.driver.downcase
+            token = params.tokens[driver.to_sym] || fail("Token for driver '#{driver}' was not specified")
+            ads_output_stage_uri = segment_in.ads_output_stage_uri
+
+            # Create master project Postgres
+            version = get_project_version(params, segment_id) + 1
+
+            master_name = segment_in.master_name.gsub('#{version}', version.to_s)
+
+            # Get project instance based on PID. Fail if invalid one was specified.
+            # TODO: Use development client for getting project
+            development_client.projects(development_pid) || fail("Invalid Development PID specified - #{development_pid}")
+            segment = domain_segments.find do |ds|
+              ds.segment_id == segment_id
+            end
+
+            # Create new master project
+            params.gdc_logger.info "Creating master project - name: '#{master_name}' development_project: '#{development_pid}', segment: '#{segment_id}', driver: '#{driver}'"
+            project = client.create_project(title: master_name, auth_token: token, driver: driver == 'vertica' ? 'vertica' : 'Pg', environment: params.project_environment)
+
+            # Does segment exists? If not, create new one and set initial master
+            if segment
+              segment_in[:is_new] = false
+              status = 'untouched'
+            else
+              params.gdc_logger.info "Creating segment #{segment_id}, master #{project.pid}"
+              segment = data_product.create_segment(segment_id: segment_id, master_project: project)
+              segment.synchronize_clients
+              segment_in[:is_new] = true
+              status = 'created'
+            end
+
+            master_project = nil
+
+            begin
+              master_project = segment.master_project
+            rescue => e
+              GoodData.logger.warn "Unable to get segment master, reason: #{e.message}"
+            end
+
+            if master_project.nil? || master_project.deleted?
+              segment.master_project = project
+              segment.save
+              segment_in[:is_new] = true
+              status = 'modified'
+            end
+
+            segment_in[:master_pid] = project.pid
+            segment_in[:version] = version
+            segment_in[:timestamp] = Time.now.utc.iso8601
+
+            # Show new project
+            params.gdc_logger.info JSON.pretty_generate(project.json)
+
+            # Add new segment master project with additional info into output results
+            results << {
+              segment_id: segment_id,
+              name: master_name,
+              development_pid: development_pid,
+              master_pid: project.pid,
+              ads_output_stage_uri: ads_output_stage_uri,
+              driver: driver,
+              status: status
+            }
+
+            {
+              segment: segment_id,
+              from: development_pid,
+              to: [{ pid: project.pid }],
+              ads_output_stage_uri: ads_output_stage_uri
+            }
+          end
+
+          # Return results
+          {
+            results: results,
+            params: {
+              synchronize: synchronize_projects
+            }
+          }
+        end
+
+        def get_project_version(params, segment_id)
+          replacements = {
+            table_name: params.release_table_name || DEFAULT_TABLE_NAME,
+            segment_id: 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)
+
+          return 0 if res.empty?
+
+          res[0][:version].to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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 EnsureDataProduct < BaseAction
+      DESCRIPTION = 'Creates the DataProduct if it does not exist yet'
+
+      PARAMS = define_params(self) do
+        description 'client to connect to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'DataProduct to ensure'
+        param :data_product, instance_of(Type::StringType), required: false
+      end
+
+      RESULT_HEADER = [
+        :data_product
+      ]
+
+      class << self
+        def call(params)
+          params = params.to_hash
+          client = params.gdc_gd_client
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+
+          if params.key?(:data_product)
+            begin
+              data_product = domain.data_products(params.data_product)
+            rescue RestClient::BadRequest
+              params.gdc_logger.info "Can not find DataProduct #{params.data_product}, creating it instead"
+              data_product = domain.create_data_product(id: params.data_product)
+            end
+          end
+
+          {
+            results: [
+              {
+                data_product: data_product
+              }
+            ]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# 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 EnsureReleaseTable < BaseAction
+      DESCRIPTION = 'Ensures presence of LCM_RELEASE table'
+
+      PARAMS = define_params(self) do
+        description 'ADS Client'
+        param :ads_client, instance_of(Type::AdsClientType), required: true
+
+        description 'Table Name'
+        param :release_table_name, instance_of(Type::StringType), required: false
+      end
+
+      RESULT_HEADER = [
+        :table_name,
+        :status
+      ]
+
+      DEFAULT_TABLE_NAME = 'LCM_RELEASE'
+
+      class << self
+        def call(params)
+          replacements = {
+            table_name: params.release_table_name || DEFAULT_TABLE_NAME
+          }
+
+          path = File.expand_path('../../data/create_lcm_release.sql.erb', __FILE__)
+          query = GoodData::Helpers::ErbHelper.template_file(path, replacements)
+
+          sql_result = params.ads_client.execute(query)
+
+          # TODO: Format
+          GoodData.logger.info(JSON.pretty_generate(sql_result))
+
+          [
+            {
+              table_name: replacements[:table_name],
+              status: 'ok'
+            }
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# 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 EnsureSegments < BaseAction
+      DESCRIPTION = 'Ensure Segments Exist (LCM API)'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+      end
+
+      class << self
+        def call(_params)
+          results = []
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/ensure_technical_users_domain.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 EnsureTechnicalUsersDomain < BaseAction
+      DESCRIPTION = 'Ensure Technical Users in Domain'
+
+      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 'Technical users'
+        param :technical_user, array_of(instance_of(Type::StringType)),
+              required: false, deprecated: true, replacement: :technical_users
+
+        description 'Technical users'
+        param :technical_users, array_of(instance_of(Type::StringType)), required: false
+      end
+
+      RESULT_HEADER = [
+        :login,
+        :email,
+        :domain,
+        :status
+      ]
+
+      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}")
+
+          technical_users = (params.technical_users || params.technical_user || []).uniq
+          technical_users.pmap do |technical_user|
+            domain_user = domain.users.find do |du|
+              du.login == technical_user
+            end
+
+            if domain_user
+              {
+                login: domain_user.login,
+                email: domain_user.email,
+                domain: domain_name,
+                status: 'exists'
+              }
+            else
+              user = domain.add_user(login: technical_user, email: technical_user)
+              {
+                login: user.login,
+                email: user.email,
+                domain: domain_name,
+                status: 'added'
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end