gooddata 0.6.49 → 0.6.50

data/lib/gooddata/lcm/data/create_lcm_release.sql.erb

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS "<%= table_name || 'LCM_RELEASE' %>" (
+  segment_id        VARCHAR(255) NOT NULL,
+  master_project_id VARCHAR(255) NOT NULL,
+  version           INTEGER NOT NULL
+);

data/lib/gooddata/lcm/data/insert_into_lcm_release.sql.erb

@@ -0,0 +1,11 @@
+INSERT INTO "<%= table_name || 'LCM_RELEASE' %>"
+(
+  segment_id,
+  master_project_id,
+  version
+)
+VALUES (
+  '<%= segment_id %>',
+  '<%= master_project_id %>',
+  <%= version %>
+);

data/lib/gooddata/lcm/data/select_from_lcm_release.sql.erb

@@ -0,0 +1,8 @@
+SELECT
+  segment_id,
+  master_project_id,
+  version
+FROM "<%= table_name || 'LCM_RELEASE' %>"
+WHERE
+  segment_id = '<%= segment_id %>'
+;

data/lib/gooddata/lcm/data/update_lcm_release.sql.erb

@@ -0,0 +1,7 @@
+UPDATE "<%= table_name || 'LCM_RELEASE' %>"
+SET
+  master_project_id = '<%= master_project_id %>',
+  version = <%= version %>
+WHERE
+  segment_id = '<%= segment_id %>'
+;

data/lib/gooddata/lcm/dsl/dsl.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 'json'
+
+require_relative 'params_dsl'
+require_relative 'type_dsl'
+
+require_relative '../../helpers/global_helpers'
+
+module GoodData
+  module LCM2
+    module Dsl
+      module Dsl
+        DEFAULT_OPTS = {
+          required: false,
+          default: nil
+        }
+
+        PARAMS = {}
+        TYPES = {}
+
+        def process(_klass, type, _caption, &block)
+          dsl = type.new
+          dsl.instance_eval(&block)
+
+          # puts "#{caption}: #{klass.name}"
+          # puts JSON.pretty_generate(dsl.params)
+          # puts
+
+          # yield if block_given?
+
+          # Return params
+          dsl.params
+        end
+
+        def define_params(klass, &block)
+          PARAMS[klass] = process(klass, GoodData::LCM2::Dsl::ParamsDsl, 'PARAMS', &block)
+        end
+
+        def define_type(klass, &block)
+          TYPES[klass] = process(klass, GoodData::LCM2::Dsl::TypeDsl, 'TYPE', &block)
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/dsl/params_dsl.rb

@@ -0,0 +1,61 @@
+# 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 '../types/param'
+
+module GoodData
+  module LCM2
+    module Dsl
+      class ParamsDsl
+        def initialize
+          @params = {}
+
+          new_param
+        end
+
+        attr_reader :params
+
+        def array_of(type)
+          Type::ArrayType.new(type)
+        end
+
+        def instance_of(type)
+          type.new
+        end
+
+        def one_of(_type)
+          Type::EnumType.new
+        end
+
+        def new_param
+          @param = Type::Param.new
+        end
+
+        def description(desc)
+          @param.description = desc
+        end
+
+        def param(name, type, opts = {})
+          @param.name = name
+          @param.type = type
+          @param.opts = opts
+
+          @params[name] = {
+            name: @param.name,
+            type: @param.type,
+            opts: @param.opts,
+            description: @param.description,
+            category: @param.type.class.const_get(:CATEGORY)
+          }
+
+          # Create new instance of param
+          new_param
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/dsl/type_dsl.rb

@@ -0,0 +1,61 @@
+# 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 '../types/param'
+
+module GoodData
+  module LCM2
+    module Dsl
+      class TypeDsl
+        def initialize
+          @params = {}
+
+          new_param
+        end
+
+        attr_reader :params
+
+        def array_of(type)
+          Type::ArrayType.new(type)
+        end
+
+        def instance_of(type)
+          type.new
+        end
+
+        def one_of(_type)
+          Type::EnumType.new
+        end
+
+        def new_param
+          @param = Type::Param.new
+        end
+
+        def description(desc)
+          @param.description = desc
+        end
+
+        def param(name, type, opts = {})
+          @param.name = name
+          @param.type = type
+          @param.opts = opts
+
+          @params[name] = {
+            name: @param.name,
+            type: @param.type,
+            opts: @param.opts,
+            description: @param.description,
+            category: @param.type.class.const_get(:CATEGORY)
+          }
+
+          # Create new instance of param
+          new_param
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/helpers/check_helper.rb

@@ -0,0 +1,37 @@
+# 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 'json'
+
+module GoodData
+  module LCM2
+    class Helpers
+      class << self
+        def check_params(specification, params)
+          specification.keys.each do |param_name|
+            value = params[param_name]
+            type = specification[param_name][:type]
+
+            if value.nil?
+              if specification[param_name][:opts][:required]
+                fail("Mandatory parameter '#{param_name}' of type '#{type}' is not specified")
+              end
+            else
+              if type.class.const_get(:CATEGORY) == :complex && !value.is_a?(Hash)
+                puts JSON.pretty_generate(params)
+                fail "Expected parameter '#{param_name}' to be kind of '#{type}', got '#{value.class.name}'"
+              end
+
+              unless type.check(value)
+                fail "Parameter '#{param_name}' has invalid type, expected: #{type}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/lcm/helpers/helpers.rb

@@ -0,0 +1,12 @@
+# 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 'pathname'
+
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + '*.rb').each do |file|
+  require file
+end

data/lib/gooddata/lcm/lcm.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 #
-# Copyright (c) 2010-2016 GoodData Corporation. All rights reserved.
+# 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.
 
@@ -27,7 +27,9 @@ module GoodData
         messages
       end
 
-      def transfer_everything(client, domain, migration_spec, filter_on_segment = [], opts = {})
+      def transfer_everything(client, domain, migration_spec, opts = {})
+        filter_on_segment = migration_spec[:segments] || migration_spec['segments'] || []
+
         puts 'Ensuring Users - warning: works across whole domain not just provided segment(s)'
         ensure_users(domain, migration_spec, filter_on_segment)
 
@@ -38,15 +40,53 @@ module GoodData
           maql_replacements: opts[:maql_replacements] || opts['maql_replacements']
         }
 
-        tags = opts[:production_tag] || opts['production_tag']
+        #########################################################
+        # New Architecture of Transfer Everything Functionality #
+        #########################################################
+        #
+        # modes = {
+        #   release: [
+        #     self.synchronize_ldm,
+        #     self.synchronize_label_types,
+        #     self.synchronize_meta, # Tag specified? If yes, transfer only tagged stuff. If not transfer all meta.
+        #     self.synchronize_etl, # Processes, Schedules, Additional Params
+        #   ],
+        #   provisioning: [
+        #     # self.ensure_titles # Handled by Provisioning Brick?
+        #     self.ensure_users,
+        #     self.delete_clients,
+        #     self.provision_clients, # LCM API
+        #     self.synchronize_label_types,
+        #     self.synchronize_etl # Processes, Schedules, Additional Params
+        #   ],
+        #   rollout: [ # Works on segments only, not using collect_clients
+        #     self.ensure_users,
+        #     self.synchronize_ldm,
+        #     self.synchronize_label_types,
+        #     self.synchronize_etl, # Processes, Schedules, Additional Params
+        #     self.synchronize_clients
+        #   ]
+        # }
+        #
+        # mode_name = param['mode']
+        # mode_actions = modes[mode_name] || fail("Invalid mode specified: '#{mode_name}'")
+        # messages = mode_actions.map do |action|
+        #   action(params)
+        # end
 
         domain.segments.peach do |segment|
           next if !filter_on_segment.empty? && !(filter_on_segment.include?(segment.id))
+
           bp = segment.master_project.blueprint
           segment.clients.each do |c|
             p = c.project
             p.update_from_blueprint(bp, bp_opts)
           end
+
+          # target_projects = segment.clients.map(&:project)
+
+          # Transfer metadata objects
+          # GoodData::LCM.transfer_meta(segment.master_project, target_projects)
         end
 
         puts 'Migrating Processes and Schedules'
@@ -55,12 +95,16 @@ module GoodData
         domain.clients.peach do |c|
           segment = c.segment
           next if !filter_on_segment.empty? && !(filter_on_segment.include?(segment.id))
+
           segment_master = segment.master_project
           project = c.project
+
           # set metadata
+          # TODO: Review this and remove if not required or duplicate
+          # FIXME: TMA-210
           project.set_metadata('GOODOT_CUSTOM_PROJECT_ID', c.id)
-          # copy processes
 
+          # copy processes
           deployment_client_segment_master = deployment_client.projects(segment_master.pid)
           deployment_client_project = deployment_client.projects(project.pid)
           GoodData::Project.transfer_processes(deployment_client_segment_master, deployment_client_project)
@@ -69,6 +113,7 @@ module GoodData
 
           # Set up unique parameters
           deployment_client_project.schedules.peach do |s|
+            # TODO: Review this and remove if not required or duplicate (GOODOT_CUSTOM_PROJECT_ID vs CLIENT_ID)
             s.update_params('GOODOT_CUSTOM_PROJECT_ID' => c.id)
             s.update_params('CLIENT_ID' => c.id)
             s.update_params('SEGMENT_ID' => segment.id)
@@ -77,24 +122,35 @@ module GoodData
             s.save
           end
 
-          GoodData::Project.transfer_tagged_stuff(segment_master, project, tags) if tags
+          # Transfer label types
+          begin
+            GoodData::LCM.transfer_label_types(segment_master, project)
+          rescue => e
+            puts "Unable to transfer label_types, reason: #{e.message}"
+          end
+
+          # Transfer tagged objects
+          # FIXME: Make sure it is not duplicate functionality mentioned in TMA-171
+          tag = migration_spec[:production_tag]
+          GoodData::Project.transfer_tagged_stuff(segment_master, project, tag) if tag
         end
 
-        puts 'Migrating Dashboards'
-        if filter_on_segment.empty?
-          domain.synchronize_clients
-        else
-          filter_on_segment.map { |s| domain.segments(s).synchronize_clients }
+        do_not_synchronize_clients = migration_spec[:do_not_synchronize_clients]
+        if do_not_synchronize_clients.nil? || !do_not_synchronize_clients
+          puts 'Migrating Dashboards'
+          if filter_on_segment.empty?
+            domain.synchronize_clients
+          else
+            filter_on_segment.map do |s|
+              domain.segments(s).synchronize_clients
+            end
+          end
         end
       end
 
       def transfer_label_types(source_project, targets)
         semaphore = Mutex.new
 
-        synchronized_puts = proc do |*args|
-          semaphore.synchronize { puts args }
-        end
-
         # Convert to array
         targets = [targets] unless targets.is_a?(Array)
 
@@ -118,8 +174,8 @@ module GoodData
         transfer = {}
         display_forms.each { |display_form| transfer[display_form['meta']['identifier']] = display_form['content']['type'] }
 
-        puts 'Transferring label types'
-        puts JSON.pretty_generate(transfer)
+        GoodData.logger.info 'Transferring label types'
+        GoodData.logger.info JSON.pretty_generate(transfer)
 
         # Transfer to target projects
         targets.peach do |target|
@@ -131,16 +187,101 @@ module GoodData
 
             if obj
               if obj.content['type'] != type
-                synchronized_puts.call "Updating #{identifier} -> #{type} in '#{target.title}'"
+                semaphore.synchronize do
+                  GoodData.logger.info "Updating #{identifier} -> #{type} in '#{target.title}'"
+                end
+
                 obj.content['type'] = type
                 obj.save
-              else
-                synchronized_puts.call "Identifier #{identifier} in '#{target.title}' already has desired type - #{type}"
               end
             else
-              synchronized_puts.call "Unable to find #{identifier} in '#{target.title}'"
+              semaphore.synchronize do
+                GoodData.logger.warn "Unable to find #{identifier} in '#{target.title}'"
+              end
+            end
+
+            nil
+          end
+
+          nil
+        end
+      end
+
+      # Synchronizes the dashboards tagged with the +$PRODUCTION_TAG+ from development project to master projects
+      # Params:
+      # +source_workspace+:: workspace with the tagged dashboards that are going to be synchronized to the target workspaces
+      # +target_workspaces+:: array of target workspaces where the tagged dashboards are going be synchronized to
+      def transfer_meta(source_workspace, target_workspaces, tag = nil)
+        objects = get_dashboards(source_workspace, tag)
+        begin
+          token = source_workspace.objects_export(objects)
+          GoodData.logger.info "Export token: '#{token}'"
+        rescue => e
+          GoodData.logger.error "Export failed, reason: #{e.message}"
+        end
+        target_workspaces.each do |target_workspace|
+          begin
+            target_workspace.objects_import(token)
+          rescue => e
+            GoodData.logger.error "Import failed, reason: #{e.message}"
+          end
+        end
+      end
+
+      # Retrieves all dashboards tagged with the +$PRODUCTION_TAG+ from the +workspace+
+      # Params:
+      # +workspace+:: workspace with the tagged dashboards
+      # Returns enumeration of the tagged dashboards URIs
+      def get_dashboards(workspace, tag = nil)
+        if tag
+          GoodData::Dashboard.find_by_tag(tag, project: workspace, client: workspace.client).map(&:uri)
+        else
+          GoodData::Dashboard.all(project: workspace, client: workspace.client).map(&:uri)
+        end
+      end
+
+      def transfer_attribute_drillpaths(source_project, targets)
+        semaphore = Mutex.new
+
+        # Convert to array
+        targets = [targets] unless targets.is_a?(Array)
+
+        # Get attributes from source project
+        attributes = source_project.attributes
+
+        # Generate transfer table
+        drill_paths = attributes.map do |attribute|
+          [attribute.meta['identifier'], attribute.content['drillDownStepAttributeDF']]
+        end
+        transfer = Hash[*drill_paths.flatten].compact
+
+        # Transfer to target projects
+        targets.peach do |target|
+          transfer.peach do |identifier, drill_path|
+            uri = GoodData::MdObject.identifier_to_uri({ project: target, client: target.client }, identifier)
+            next unless uri
+
+            obj = GoodData::MdObject[uri, { project: target, client: target.client }]
+
+            if obj
+              if !obj.content['drillDownStepAttributeDF'] || obj.content['drillDownStepAttributeDF'] != drill_path
+                semaphore.synchronize do
+                  GoodData.logger.info "Updating drill path of #{identifier} -> #{drill_path} in '#{target.title}'"
+                end
+
+                obj.content['drillDownStepAttributeDF'] = drill_path
+                obj.save
+              end
+            else
+              semaphore.synchronize do
+                GoodData.logger.warn "Unable to find #{identifier} in '#{target.title}'"
+              end
             end
+
+            nil
           end
+
+          nil
         end
       end
     end