gooddata 0.6.49 → 0.6.50

data/lib/gooddata/lcm/actions/associate_clients.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 AssociateClients < BaseAction
+      DESCRIPTION = 'Associate LCM Clients'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+      end
+
+      RESULT_HEADER = [
+        :id,
+        :status,
+        :originalProject,
+        :client,
+        :type
+      ]
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          client = params.gdc_gd_client
+
+          delete_projects = GoodData::Helpers.to_boolean(params.delete_projects)
+          delete_extra = GoodData::Helpers.to_boolean(params.delete_extra)
+
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+
+          domain.update_clients_settings(params.clients)
+          domain.update_clients(params.clients, delete_extra: delete_extra, delete_projects: delete_projects)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# 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 '../dsl/dsl'
+require_relative '../helpers/helpers'
+require_relative '../types/types'
+
+module GoodData
+  module LCM2
+    class BaseAction
+      class << self
+        include Dsl::Dsl
+
+        def check_params(specification, params)
+          Helpers.check_params(specification, params)
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/collect_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'
+
+module GoodData
+  module LCM2
+    class CollectClients < BaseAction
+      DESCRIPTION = 'Collect Clients'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+      end
+
+      RESULT_HEADER = [
+        :client,
+        :segment_id,
+        :title
+      ]
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          segment_names = params.segments.map(&:segment_id)
+
+          clients = collect_clients(params, segment_names)
+
+          results = clients.map do |client|
+            {
+              client: client[:id],
+              segment_id: client[:segment],
+              title: client[:project_title]
+            }
+          end
+
+          # Return results
+          {
+            results: results,
+            params: {
+              clients: clients
+            }
+          }
+        end
+
+        def collect_clients(params, segment_names = nil)
+          client_id_column = params.client_id_column || 'client_id'
+          segment_id_column = params.segment_id_column || 'segment_id'
+          project_id_column = params.project_id_column || 'project_id'
+          project_title_column = params.project_title_column || 'project_title'
+          project_token_column = params.project_token_column || 'project_token'
+
+          clients = []
+          data_source = GoodData::Helpers::DataSource.new(params.input_source)
+          input_data = File.open(data_source.realize(params), 'r:UTF-8')
+          CSV.foreach(input_data, :headers => true, :return_headers => false, encoding: 'utf-8') do |row|
+            segment_name = row[segment_id_column]
+            if segment_names.nil? || segment_names.include?(segment_name)
+              clients << {
+                id: row[client_id_column],
+                segment: segment_name,
+                project: row[project_id_column],
+                project_title: row[project_title_column],
+                settings: [
+                  {
+                    name: 'lcm.token',
+                    value: row[project_token_column]
+                  }
+                ]
+              }.compact
+            end
+          end
+
+          if clients.empty?
+            fail "No segments or clients qualify for provisioning. \
+            Please check the input source data, platform segments, and the SEGMENTS_FILTER parameter. \
+            The intersection of these three elements is empty set."
+          end
+          clients
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# 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 CollectSegmentClients < BaseAction
+      DESCRIPTION = 'Collect 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 'ADS Client'
+        param :ads_client, instance_of(Type::AdsClientType), required: true
+      end
+
+      RESULT_HEADER = [
+        :from_name,
+        :from_pid,
+        :to_name,
+        :to_pid
+      ]
+
+      DEFAULT_TABLE_NAME = 'LCM_RELEASE'
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          client = params.gdc_gd_client
+
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+          domain_segments = domain.segments
+
+          segments = params.segments.map do |seg|
+            domain_segments.find do |s|
+              s.segment_id == seg.segment_id
+            end
+          end
+
+          results = []
+          synchronize_clients = 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])
+            master_pid = master.pid
+            master_name = master.title
+
+            sync_info = {
+              from: master_pid,
+              to: segment.clients.map do |segment_client|
+                client_project = segment_client.project
+                to_pid = client_project.pid
+                results << {
+                  from_name: master_name,
+                  from_pid: master_pid,
+                  to_name: client_project.title,
+                  to_pid: to_pid
+                }
+
+                {
+                  pid: to_pid,
+                  client_id: segment_client.client_id
+                }
+              end
+            }
+
+            sync_info
+          end
+
+          results.flatten!
+
+          # Return results
+          {
+            results: results,
+            params: {
+              synchronize: synchronize_clients
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# 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 CollectSegments < BaseAction
+      DESCRIPTION = 'Collect Segments from API'
+
+      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
+      end
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, params)
+
+          client = params.gdc_gd_client
+
+          domain_name = params.organization || params.domain
+          domain = client.domain(domain_name) || fail("Invalid domain name specified - #{domain_name}")
+          domain_segments = domain.segments
+
+          segments = domain_segments.map do |segment|
+            project = segment.master_project
+
+            # TODO: Check if project exists!
+
+            {
+              segment_id: segment.segment_id,
+              development_pid: project.pid,
+              driver: project.driver.downcase,
+              master_name: project.title
+            }
+          end
+
+          segments.compact!
+
+          # Return results
+          {
+            results: segments,
+            params: {
+              segments: segments
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+# 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 'Organization Name'
+        param :organization, instance_of(Type::StringType), required: true
+
+        description 'ADS Client'
+        param :ads_client, instance_of(Type::AdsClientType), required: true
+
+        description 'Queries Used'
+        param :query, instance_of(Type::ReleaseQueryType), required: false
+
+        description 'Segments to manage'
+        param :segments, array_of(instance_of(Type::SegmentType)), required: true
+
+        description 'Tokens'
+        param :tokens, instance_of(Type::TokensType), required: true
+      end
+
+      DEFAULT_TABLE_NAME = 'LCM_RELEASE'
+
+      class << self
+        def call(params)
+          # Check if all required parameters were passed
+          BaseAction.check_params(PARAMS, 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}")
+          domain_segments = domain.segments
+
+          # TODO: Support for 'per segment' provisioning
+          segments = params.segments
+
+          # Output param with info about which projects should be synchronized
+          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")
+
+            # 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')
+
+            # Do we have hash with synchronization info for current development project?
+            synchronize_info = synchronize_projects.find do |info|
+              info[:from] == development_pid
+            end
+
+            # If not, create new one
+            unless synchronize_info
+              synchronize_info = {
+                segment: segment_id,
+                from: development_pid,
+                to: []
+              }
+              synchronize_projects << synchronize_info
+            end
+
+            # Add target project (new master for segment) into synchronization info
+            synchronize_info[:to] << { pid: project.pid }
+
+            # Does segment exists? If not, create new one and set initial master
+            if segment
+              segment_in[:is_new] = false
+            else
+              params.gdc_logger.info "Creating segment #{segment_id}, master #{project.pid}"
+              segment = domain.create_segment(segment_id: segment_id, master_project: project)
+              segment.synchronize_clients
+              segment_in[:is_new] = true
+            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
+            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,
+              driver: driver,
+              status: 'created'
+            }
+
+            project
+          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