gooddata 1.0.0-java

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

@@ -0,0 +1,83 @@
+# 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 EnsureTechnicalUsersProject < BaseAction
+      DESCRIPTION = 'Ensure Technical Users in Project'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), 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
+
+        description 'Synchronization Info'
+        param :synchronize, array_of(instance_of(Type::SynchronizationInfoType)), required: true, generated: true
+      end
+
+      RESULT_HEADER = [
+        :project,
+        :pid,
+        :login,
+        :role,
+        :result,
+        :message,
+        :url
+      ]
+
+      class << self
+        def call(params)
+          client = params.gdc_gd_client
+
+          technical_users = params.technical_users || params.technical_user || []
+          new_users = technical_users.map do |technical_user|
+            {
+              login: technical_user,
+              role: 'admin'
+            }
+          end
+
+          results = params.synchronize.pmap do |synchronize_info|
+            synchronize_info[:to].pmap do |entry|
+              ensure_users(client, entry[:pid], new_users)
+            end
+          end.flatten
+
+          results += params.clients.pmap { |input_client| input_client[:project] }.compact.pmap { |pid| ensure_users(client, pid, new_users) }.flatten if params.clients
+
+          results
+        end
+
+        private
+
+        def ensure_users(client, project_id, new_users)
+          project = client.projects(project_id)
+          res = project.create_users(new_users)
+
+          new_users.zip(res).map do |f, s|
+            {
+              project: project.title,
+              pid: project.pid,
+              login: f[:login],
+              role: f[:role],
+              result: s[:type],
+              message: s[:message],
+              url: s[:user]
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# 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 ExecuteSchedules < BaseAction
+      DESCRIPTION = 'Execute schedules'
+
+      PARAMS = define_params(self) do
+        description 'Client Used for Connecting to GD'
+        param :gdc_gd_client, instance_of(Type::GdClientType), required: true
+
+        description 'List Of Modes'
+        param :list_of_modes, instance_of(Type::StringType), required: true
+
+        description 'Work Done Identificator'
+        param :work_done_identificator, instance_of(Type::StringType), required: true
+
+        description 'Number Of Schedules In Batch'
+        param :number_of_schedules_in_batch, instance_of(Type::StringType), required: false, default: '1000'
+
+        description 'Delay Between Batches'
+        param :delay_between_batches, instance_of(Type::StringType), required: false, default: '0'
+
+        description 'Control Parameter'
+        param :control_parameter, instance_of(Type::StringType), required: false, default: 'MODE'
+
+        description 'Wait For Schedule'
+        param :wait_for_schedule, instance_of(Type::StringType), required: false, default: 'false'
+
+        description 'Segment List'
+        param :segment_list, instance_of(Type::StringType), required: false
+
+        description 'Domain'
+        param :domain, instance_of(Type::StringType), required: false
+
+        description 'Number Of Threads'
+        param :number_of_threads, instance_of(Type::StringType), required: false, default: '5'
+      end
+
+      class << self
+        def call(params)
+          logger = params.gdc_logger
+
+          client = params.gdc_gd_client
+          project = client.projects(params.gdc_project) || client.projects(params.gdc_project_id)
+
+          list_of_modes = params.list_of_modes.split('|').map(&:strip)
+          work_done_identificator = params.work_done_identificator
+          number_of_schedules_in_batch = Integer(params.number_of_schedules_in_batch || "1000")
+          delay_between_batches = Integer(params.delay_between_batches || "0")
+          control_parameter = params.control_parameter || "MODE"
+          wait = GoodData::Helpers.to_boolean(params.wait_for_schedule)
+
+          segment_list = params.segment_list
+          domain_name  = params.domain
+          fail "In case that you are using SEGMENT_LIST parameter, you need to fill out DOMAIN parameter" if !segment_list.nil? && domain_name.nil?
+
+          number_of_threads = Integer(params.number_of_threads || '5')
+
+          # The WORK_DONE_IDENTIFICATOR is flag which tells the executor to execute the schedules
+          # It could have special value IGNORE. In this case all corresponding schedules will be started during every run of this brick
+
+          start_schedules = work_done_identificator == 'IGNORE' || GoodData::Helpers.to_boolean(project.metadata[work_done_identificator])
+
+          project_list = []
+          if !segment_list.nil? && segment_list != ''
+            domain = client.domain(domain_name)
+            segment_list.split('|').each do |segment_identification|
+              segment = domain.segments(segment_identification)
+              project_list += segment.clients.map { |c| !c.project.nil? ? c.project.obj_id : nil }.compact
+            end
+            project_list.uniq!
+          end
+
+          if start_schedules
+            schedules_to_filter = client.projects.pmapcat do |p|
+              begin
+                p.schedules
+              rescue => e
+                logger.info "The retrieval of project schedules, for project #{p.obj_id} has failed. Message: #{e.message}."
+                []
+              end
+            end
+
+            schedules_to_start = schedules_to_filter.select { |schedule| list_of_modes.include?(schedule.params[control_parameter]) }
+
+            if !segment_list.nil? && segment_list != ''
+              schedules_to_start.delete_if { |schedule| !project_list.include?(schedule.project.obj_id) }
+            end
+
+            logger.info "Found #{schedules_to_start.count} schedules to execute"
+
+            schedules_to_start.each_slice(number_of_schedules_in_batch).each_with_index do |batch_schedules, batch_index|
+              batch_number = batch_index + 1
+              logger.info "Starting batch number #{batch_number}. Number of schedules in batch #{batch_schedules.count}."
+              batch_schedules.peach(number_of_threads) do |schedule|
+                begin
+                  tries ||= 5
+                  logger.info "Starting schedule for project #{schedule.project.pid} - #{schedule.project.title}. Schedule ID is #{schedule.obj_id}"
+                  schedule.execute(wait: wait)
+                rescue => e
+                  if (tries -= 1) > 0
+                    logger.warn "There was error during operation: #{e.message}. Retrying"
+                    sleep(5)
+                    retry
+                  else
+                    logger.info "We could not start schedule for project #{schedule.project.pid} - #{schedule.project.title} - #{e.message}"
+                  end
+                else
+                  logger.info "Operation finished"
+                end
+              end
+              logger.info "Entering sleep mode for #{delay_between_batches} seconds"
+              sleep(delay_between_batches)
+            end
+            project.set_metadata(work_done_identificator, 'false') unless work_done_identificator == 'IGNORE'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# 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 HelloWorld < BaseAction
+      DESCRIPTION = 'Print Hello World Message'
+
+      PARAMS = define_params(self) do
+        description 'Message to be printed'
+        param :message, instance_of(Type::StringType), required: true
+
+        description 'Number of Iterations'
+        param :iterations, instance_of(Type::IntegerType), required: false, default: 1
+      end
+
+      class << self
+        def say(msg)
+          puts "#{name}#say - #{msg}"
+        end
+
+        def call(params)
+          say(params.message)
+
+          msg = {
+            message: params.message
+          }
+          results = [msg]
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# 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 ImportObjectCollections < BaseAction
+      DESCRIPTION = 'Import all objects in CollectXXX action to master projects'
+
+      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
+
+      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_projects = info.to
+            transfer_uris = info.transfer_uris
+
+            from_project = development_client.projects(from) || fail("Invalid 'from' project specified - '#{from}'")
+
+            to_projects.peach do |entry|
+              pid = entry[:pid]
+              to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
+
+              if transfer_uris.any?
+                from_project.partial_md_export(transfer_uris, project: to_project)
+              end
+
+              results << {
+                from: from,
+                to: pid,
+                status: 'ok'
+              }
+            end
+          end
+
+          results
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/actions/print_actions.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 PrintActions < BaseAction
+      DESCRIPTION = 'Print Information About Actions'
+
+      PARAMS = {
+      }
+
+      class << self
+        def call(params)
+          results = []
+
+          actions = GoodData::LCM2::BaseAction.descendants
+
+          actions.each do |action|
+            action_params = action.const_get(:PARAMS)
+            action_params_keys = action_params.keys
+            params = action_params_keys.map do |param|
+              param
+            end
+
+            types = action_params.map do |_k, param|
+              param[:type].class.short_name
+            end
+
+            required = action_params.map do |_k, param|
+              param[:opts][:required]
+            end
+
+            defaults = action_params.map do |_k, param|
+              param[:opts][:default]
+            end
+
+            results << {
+              name: action.short_name,
+              description: action.const_get(:DESCRIPTION),
+              params: params.join("\n"),
+              types: types.join("\n"),
+              required: required.join("\n"),
+              default: defaults.join("\n")
+            }
+          end
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# 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 PrintModes < BaseAction
+      DESCRIPTION = 'Print Modes'
+
+      PARAMS = {
+      }
+
+      class << self
+        def call(params)
+          results = []
+          GoodData::LCM2::MODES.keys.each_with_index do |mode, index|
+            actions = GoodData::LCM2::MODES[mode]
+            action_names = actions.map do |k, _action|
+              params_length = k.const_get(:PARAMS).keys.length
+              k.short_name + ("\n" * (params_length > 1 ? params_length - 1 : 0))
+            end
+
+            params = actions.map do |action|
+              action.const_get(:PARAMS).map do |_k, param|
+                param[:name]
+              end
+            end
+
+            types = actions.map do |action|
+              action.const_get(:PARAMS).map do |_k, param|
+                param[:type]
+                # param[:type].class.short_name
+              end
+            end
+
+            required = actions.map do |action|
+              action.const_get(:PARAMS).map do |_k, param|
+                param[:opts][:required]
+              end
+            end
+
+            defaults = actions.map do |action|
+              action.const_get(:PARAMS).map do |_k, param|
+                param[:opts][:default]
+              end
+            end
+
+            results << {
+              '#' => index,
+              mode: mode,
+              actions: action_names.join("\n"),
+              params: params.join("\n"),
+              types: types.join("\n"),
+              required: required.join("\n"),
+              default: defaults.join("\n")
+            }
+          end
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# 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 PrintTypes < BaseAction
+      DESCRIPTION = 'Print Information About Defined Types'
+
+      PARAMS = {
+      }
+
+      class << self
+        def call(_params)
+          results = []
+
+          GoodData::LCM2::Dsl::Dsl::TYPES.each_pair do |k, v|
+            vals = []
+            v.each_pair do |_name, val|
+              vals << val[:type]
+            end
+
+            required = []
+            v.each_pair do |_name, val|
+              required << val[:opts][:required]
+            end
+
+            defaults = []
+            v.each_pair do |_name, val|
+              defaults << val[:opts][:default]
+            end
+
+            results << {
+              class: k.short_name,
+              param: v.keys.join("\n"),
+              type: vals.join("\n"),
+              required: required.join("\n"),
+              default: defaults.join("\n")
+            }
+          end
+
+          # Return results
+          results
+        end
+      end
+    end
+  end
+end