gooddata 1.1.0 → 1.2.0

data/lib/gooddata/bricks/release_brick.rb

@@ -0,0 +1,18 @@
+require_relative 'brick'
+
+module GoodData::Bricks
+  class ReleaseBrick < GoodData::Bricks::Brick
+    def version
+      '0.0.1'
+    end
+
+    # Provisioning brick entry-point
+    #
+    # @param [Hash] params Parameters
+    # @option [String] 'associate' ('true') Do association - true, false
+    # @option [String] 'provision' ('true') Do provision - true, false
+    def call(params)
+      GoodData::LCM2.perform('release', params)
+    end
+  end
+end

data/lib/gooddata/bricks/rollout_brick.rb

@@ -0,0 +1,14 @@
+require_relative 'brick'
+
+module GoodData::Bricks
+  class RolloutBrick < GoodData::Bricks::Brick
+    def version
+      '0.0.1'
+    end
+
+    # Rollout brick entry-point
+    def call(params)
+      GoodData::LCM2.perform('rollout', params)
+    end
+  end
+end

data/lib/gooddata/bricks/user_filters_brick.rb

@@ -0,0 +1,13 @@
+require_relative 'brick'
+
+module GoodData::Bricks
+  class UserFiltersBrick < GoodData::Bricks::Brick
+    def version
+      "0.0.1"
+    end
+
+    def call(params)
+      GoodData::LCM2.perform('user_filters', params)
+    end
+  end
+end

data/lib/gooddata/bricks/users_brick.rb

@@ -0,0 +1,13 @@
+require_relative 'brick'
+
+module GoodData::Bricks
+  class UsersBrick < GoodData::Bricks::Brick
+    def version
+      '0.0.1'
+    end
+
+    def call(params)
+      GoodData::LCM2.perform('users', params)
+    end
+  end
+end

data/lib/gooddata/core/logging.rb

@@ -93,7 +93,7 @@ module GoodData
     end
 
     # Initial setup of logger
-    GoodData.logger = GoodData.logging_on
+    GoodData.logger = GoodData.logging_on(ENV['GD_LOG_LEVEL'] || DEFAULT_LOG_LEVEL)
 
     # Initial setup of rest logger
     GoodData.rest_logger = GoodData.logging_http_on(

data/lib/gooddata/exceptions/maql_execution.rb

@@ -8,7 +8,7 @@ module GoodData
   class MaqlExecutionError < RuntimeError
     attr_accessor :data
 
-    def initialize(message, data)
+    def initialize(message, data = nil)
       super(message || 'Execution of maql failed')
       @data = data
     end

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

@@ -22,10 +22,13 @@ module GoodData
         param :domain, instance_of(Type::StringType), required: false
 
         description 'Delete Extra Clients'
-        param :delete_extra, instance_of(Type::BooleanType), required: false, default: false
+        param :delete_extra, instance_of(Type::BooleanType), required: false, default: false, deprecated: true, replacement: :delete_mode
 
         description 'Physically Delete Client Projects'
-        param :delete_projects, instance_of(Type::BooleanType), required: false, default: false
+        param :delete_projects, instance_of(Type::BooleanType), required: false, default: false, deprecated: true, replacement: :delete_mode
+
+        description 'Physically Delete Client Projects'
+        param :delete_mode, instance_of(Type::StringType), required: false, default: 'none'
 
         description 'Clients'
         param :clients, array_of(instance_of(Type::HashType)), required: true, generated: true
@@ -46,7 +49,33 @@ module GoodData
       ]
 
       class << self
+        DELETE_MODES = %w(
+          none
+          delete_projects
+          delete_extra
+        )
         def call(params)
+          unless DELETE_MODES.include?(params.delete_mode) || params.delete_mode.nil?
+            fail "The parameter \"delete_mode\" has to have one of the values #{DELETE_MODES.map(&:to_s).join(', ')} or has to be empty."
+          end
+
+          case params.delete_mode
+          when 'delete_projects'
+            delete_projects = true
+            delete_extra = true
+          when 'delete_extra'
+            delete_projects = false
+            delete_extra = true
+          else
+            # Usage of the depracated params
+            delete_projects = GoodData::Helpers.to_boolean(params.delete_projects)
+            delete_extra = GoodData::Helpers.to_boolean(params.delete_extra)
+          end
+
+          if delete_projects && !delete_extra
+            GoodData.logger.warn("Parameter `delete_projects` is set to true and parameter `delete_extra` is set to false (which is default) this action will not delete anything!")
+          end
+
           client = params.gdc_gd_client
 
           domain_name = params.organization || params.domain
@@ -70,22 +99,19 @@ module GoodData
           end
 
           domain.update_clients_settings(params.clients)
-
-          delete_projects = GoodData::Helpers.to_boolean(params.delete_projects)
-          delete_extra = GoodData::Helpers.to_boolean(params.delete_extra)
           options = { delete_projects: delete_projects }
-          options.merge!(delete_extra_option(params)) if delete_extra
+          options.merge!(delete_extra_option(params, delete_extra)) if delete_extra
 
           domain.update_clients(params.clients, options)
         end
 
         private
 
-        def delete_extra_option(params)
+        def delete_extra_option(params, delete_extra)
           if params.segments_filter && params.segments_filter.any?
             { delete_extra_in_segments: params.segments_filter }
           else
-            { delete_extra: GoodData::Helpers.to_boolean(params.delete_extra) }
+            { delete_extra: GoodData::Helpers.to_boolean(delete_extra) }
           end
         end
       end

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

@@ -45,7 +45,14 @@ module GoodData
             params.gdc_logger.info "Using data product 'default' since none was specified in brick parameters"
             data_product_id = 'default'
           end
-          data_product = domain.data_products(data_product_id)
+
+          begin
+            data_product = domain.data_products(data_product_id)
+          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
+
           results = [
             {
               data_product: data_product_id

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

@@ -15,12 +15,6 @@ module GoodData
         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: false
-
-        description 'Domain'
-        param :domain, instance_of(Type::StringType), required: false
-
         description 'ADS Client'
         param :ads_client, instance_of(Type::AdsClientType), required: true
 
@@ -47,20 +41,9 @@ module GoodData
         def call(params)
           client = params.gdc_gd_client
 
-          domain_name = params.organization || params.domain
-          fail "Either organisation or domain has to be specified in params" unless domain_name
-          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 = []
-          synchronize_clients = segments.map do |segment|
+          synchronize_clients = params[:segments].map do |segment_hash|
+            segment = segment_hash[:segment]
             segment_clients = segment.clients
             missing_project_clients = segment_clients.reject(&:project?).map(&:client_id)
 
@@ -75,15 +58,21 @@ module GoodData
             query = GoodData::Helpers::ErbHelper.template_file(path, replacements)
 
             res = params.ads_client.execute_select(query)
+            latest_master_id = res.max_by { |row| row[:version] }[:master_project_id]
+            latest_master = client.projects(latest_master_id)
 
             # 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
+            master_pid = latest_master.pid
+            master_name = latest_master.title
+
+            previous_master = segment_hash[:segment_master] if
+              segment_hash[:segment_master] &&
+              segment_hash[:segment_master].pid != latest_master.pid
 
             sync_info = {
               segment_id: segment.segment_id,
               from: master_pid,
+              previous_master: previous_master,
               to: segment_clients.map do |segment_client|
                 client_project = segment_client.project
                 to_pid = client_project.pid
@@ -91,7 +80,8 @@ module GoodData
                   from_name: master_name,
                   from_pid: master_pid,
                   to_name: client_project.title,
-                  to_pid: to_pid
+                  to_pid: to_pid,
+                  previous_master: previous_master
                 }
 
                 {

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

@@ -23,6 +23,14 @@ module GoodData
         param :gdc_logger, instance_of(Type::GdLogger), required: true
       end
 
+      RESULT_HEADER = [
+        :segment_id,
+        :development_pid,
+        :driver,
+        :master_name,
+        :uri
+      ]
+
       class << self
         def call(params)
           data_product = params.data_product
@@ -50,9 +58,11 @@ module GoodData
 
             {
               segment_id: segment.segment_id,
+              segment: segment,
               development_pid: project.pid,
               driver: project.driver.downcase,
               master_name: project.title,
+              segment_master: project,
               uri: segment.uri
             }
           end

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

@@ -72,9 +72,11 @@ module GoodData
             query = GoodData::Helpers::ErbHelper.template_file(path, replacements)
 
             res = params.ads_client.execute_select(query)
+            sorted = res.sort_by { |row| row[:version] }
+            current_master = sorted.last[:master_project_id]
 
             # TODO: Check res.first.nil? || res.first[:master_project_id].nil?
-            master = client.projects(res.first[:master_project_id])
+            master = client.projects(current_master)
 
             segment.master_project = master
             segment.save

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

@@ -35,57 +35,84 @@ module GoodData
 
         description 'Allows to have facts with higher precision decimals'
         param :exclude_fact_rule, instance_of(Type::BooleanType), required: false, default: false
+
+        description 'Specifies how to synchronize LDM and resolve possible conflicts'
+        param :synchronize_ldm, instance_of(Type::SynchronizeLDM), required: false, default: 'diff_against_master_with_fallback'
       end
 
       class << self
         def call(params)
-          include_ca = params.include_computed_attributes.to_b
-          exclude_fact_rule = params.exclude_fact_rule.to_b
-
           results = []
+          synchronize = []
+          params.synchronize.map do |segment_info|
+            new_segment_info, segment_results = sync_segment_ldm(params, segment_info)
+            results.concat(segment_results)
+            synchronize << new_segment_info
+          end
 
-          client = params.gdc_gd_client
-          development_client = params.development_client
+          {
+            results: results,
+            params: {
+              synchronize: synchronize
+            }
+          }
+        end
 
-          synchronize = params.synchronize.map do |info|
-            from_project = info.from
-            to_projects = info.to
+        private
 
-            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}"
+        def sync_segment_ldm(params, segment_info)
+          results = []
+          client = params.gdc_gd_client
+          exclude_fact_rule = params.exclude_fact_rule.to_b
+          from_pid = segment_info[:from]
+          from = params.development_client.projects(from_pid) || fail("Invalid 'from' project specified - '#{from_pid}'")
+
+          GoodData.logger.info "Creating Blueprint, project: '#{from.title}', PID: #{from_pid}"
+          blueprint = from.blueprint(include_ca: params.include_computed_attributes.to_b)
+          maql_diff = nil
+          previous_master = segment_info[:previous_master]
+          diff_against_master = %w(diff_against_master_with_fallback diff_against_master)
+            .include?(params[:synchronize_ldm].downcase)
+          if previous_master && diff_against_master
+            maql_diff_params = [:includeGrain]
+            maql_diff_params << :excludeFactRule if exclude_fact_rule
+            maql_diff = previous_master.maql_diff(blueprint: blueprint, params: maql_diff_params)
+          end
 
-            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}'")
+          segment_info[:to] = segment_info[:to].pmap do |entry|
+            pid = entry[:pid]
+            to_project = client.projects(pid) || fail("Invalid 'to' project specified - '#{pid}'")
 
-              params.gdc_logger.info "Updating from Blueprint, project: '#{to_project.title}', PID: #{pid}"
-              ca_scripts = to_project.update_from_blueprint(
+            GoodData.logger.info "Updating from Blueprint, project: '#{to_project.title}', PID: #{pid}"
+            begin
+              entry[:ca_scripts] = to_project.update_from_blueprint(
                 blueprint,
-                update_preference: params.update_preference,
+                update_preference: params[:update_preference],
+                exclude_fact_rule: exclude_fact_rule,
                 execute_ca_scripts: false,
-                exclude_fact_rule: exclude_fact_rule
+                maql_diff: maql_diff
+              )
+            rescue MaqlExecutionError => e
+              GoodData.logger.info("Applying MAQL to project #{to_project.title} - #{pid} failed. Reason: #{e}")
+              fail e unless previous_master && params[:synchronize_ldm] == 'diff_against_master_with_fallback'
+              GoodData.logger.info("Restoring the client project #{to_project.title} from master.")
+              entry[:ca_scripts] = to_project.update_from_blueprint(
+                blueprint,
+                update_preference: params[:update_preference],
+                exclude_fact_rule: exclude_fact_rule,
+                execute_ca_scripts: false
               )
-
-              entry[:ca_scripts] = ca_scripts
-
-              results << {
-                from: from_project,
-                to: pid,
-                status: 'ok'
-              }
-              entry
             end
 
-            info
+            results << {
+              from: from_pid,
+              to: pid,
+              status: 'ok'
+            }
+            entry
           end
 
-          {
-            results: results,
-            params: {
-              synchronize: synchronize
-            }
-          }
+          [segment_info, results]
         end
       end
     end

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

@@ -127,7 +127,7 @@ module GoodData
             ignore_missing_values: params.ignore_missing_values == 'true',
             do_not_touch_filters_that_are_not_mentioned: params.do_not_touch_filters_that_are_not_mentioned == 'true',
             domain: domain,
-            dry_run: params[:dry_run],
+            dry_run: params[:dry_run].to_b,
             users_brick_input: params.users_brick_users
           }
 
@@ -220,6 +220,7 @@ module GoodData
 
             working_client_ids = []
 
+            results = []
             filters.group_by { |u| u[multiple_projects_column] }.flat_map do |client_id, new_filters|
               fail "Client id cannot be empty" if client_id.blank?
               c = domain.clients(client_id, data_product)
@@ -232,10 +233,10 @@ module GoodData
               working_client_ids << client_id
               filters_to_load = GoodData::UserFilterBuilder.get_filters(new_filters, symbolized_config)
               puts "Synchronizing #{filters_to_load.count} filters in project #{project.pid} of client #{client_id}"
-              project.add_data_permissions(filters_to_load, run_params)
+              partial_results = project.add_data_permissions(filters_to_load, run_params)
+              results.concat(partial_results[:results])
             end
 
-            results = []
             unless run_params[:do_not_touch_filters_that_are_not_mentioned]
               domain_clients.each do |c|
                 next if working_client_ids.include?(c.client_id)
@@ -255,7 +256,8 @@ module GoodData
                 end
 
                 puts "Delete all filters in project #{project.pid} of client #{c.client_id}"
-                results << project.add_data_permissions([], run_params)
+                delete_results = project.add_data_permissions([], run_params)
+                results.concat(delete_results[:results])
               end
             end
 

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

@@ -75,18 +75,10 @@ module GoodData
         end
 
         def update_release_table(params, placeholders)
-          query = if placeholders[:version] > 1
-                    path = File.expand_path('../../data/update_lcm_release.sql.erb', __FILE__)
-                    default_query = GoodData::Helpers::ErbHelper.template_file(path, placeholders)
-
-                    temp_query = (params.query && params.query[:update]) || default_query
-                    replace_placeholders(temp_query, placeholders)
-                  else
-                    path = File.expand_path('../../data/insert_into_lcm_release.sql.erb', __FILE__)
-                    default_query = GoodData::Helpers::ErbHelper.template_file(path, placeholders)
-                    temp_query = (params.query && params.query.insert) || default_query
-                    replace_placeholders(temp_query, placeholders)
-                  end
+          path = File.expand_path('../../data/insert_into_lcm_release.sql.erb', __FILE__)
+          default_query = GoodData::Helpers::ErbHelper.template_file(path, placeholders)
+          temp_query = (params.query && params.query.insert) || default_query
+          query = replace_placeholders(temp_query, placeholders)
 
           params.ads_client.execute(query)
         end