3scale_toolbox 0.17.1 → 0.19.0

data/lib/3scale_toolbox/commands/service_command/copy_command/copy_activedocs_task.rb

@@ -6,35 +6,38 @@ module ThreeScaleToolbox
           include Task
 
           def call
-            puts 'copying all service ActiveDocs'
+            logger.info 'copying all service ActiveDocs'
 
             source.activedocs.each(&method(:apply_target_activedoc))
           end
 
           private
 
-          def apply_target_activedoc(attrs)
+          def apply_target_activedoc(source_activedoc)
             activedocs = Entities::ActiveDocs.find_by_system_name(remote: target.remote,
-                                                                  system_name: attrs['system_name'])
+                                                                  system_name: source_activedoc.system_name)
             if activedocs.nil?
-              Entities::ActiveDocs.create(remote: target.remote, attrs: create_attrs(attrs))
+              activedocs = Entities::ActiveDocs.create(remote: target.remote, attrs: create_attrs(source_activedoc))
+              activedocs_report[activedocs.system_name] = { 'id' => activedocs.id, 'status' => 'created' }
             elsif activedocs.attrs.fetch('service_id') == target.id
-              activedocs.update(update_attrs(attrs))
+              activedocs.update(update_attrs(source_activedoc))
+              activedocs_report[activedocs.system_name] = { 'id' => activedocs.id, 'status' => 'updated' }
             else
               # activedocs with same system_name exists, but now owned by target service
-              new_attrs = create_attrs(attrs)
-              new_attrs['system_name'] = "#{attrs['system_name']}#{target.id}"
-              Entities::ActiveDocs.create(remote: target.remote, attrs: new_attrs)
+              new_attrs = create_attrs(source_activedoc)
+              new_attrs['system_name'] = "#{source_activedoc.system_name}#{target.id}"
+              activedocs = Entities::ActiveDocs.create(remote: target.remote, attrs: new_attrs)
+              activedocs_report[activedocs.system_name] = { 'id' => activedocs.id, 'status' => 'created' }
             end
           end
 
-          def update_attrs(old_attrs)
-            create_attrs(old_attrs)
+          def update_attrs(activedoc)
+            create_attrs(activedoc)
           end
 
-          def create_attrs(old_attrs)
+          def create_attrs(activedoc)
             # keep same system_name
-            new_attrs = old_attrs.reject { |key, _| %w[id created_at updated_at].include? key }
+            new_attrs = activedoc.attrs.reject { |key, _| %w[id created_at updated_at].include? key }
             new_attrs.tap do |attrs|
               attrs['service_id'] = target.id
             end

data/lib/3scale_toolbox/commands/service_command/copy_command/copy_app_plans_task.rb

@@ -6,26 +6,26 @@ module ThreeScaleToolbox
           include Task
 
           def call
-            source_plans = source.plans
-            target_plans = target.plans
-            missing_plans = missing_app_plans(source_plans, target_plans)
-            missing_plans.each do |plan|
-              plan.delete('links')
-              plan.delete('default') # TODO: handle default plan
-              if plan.delete('custom') # TODO: what to do with custom plans?
-                puts "skipping custom plan #{plan}"
-              else
-                ThreeScaleToolbox::Entities::ApplicationPlan.create(service: target, plan_attrs: plan)
-              end
+            missing_regular_plans.each do |plan|
+              plan_attrs = plan.attrs.clone
+              plan_attrs.delete('links')
+              plan_attrs.delete('default') # TODO: handle default plan
+              ThreeScaleToolbox::Entities::ApplicationPlan.create(service: target, plan_attrs: plan_attrs)
             end
-            puts "target service missing #{missing_plans.size} application plans"
+
+            logger.info "target service missing #{missing_regular_plans.size} application plans"
+            report['missing_application_plans_created'] = missing_regular_plans.size
           end
 
           private
 
-          def missing_app_plans(source_plans, target_plans)
-            ThreeScaleToolbox::Helper.array_difference(source_plans, target_plans) do |src, target|
-              ThreeScaleToolbox::Helper.compare_hashes(src, target, ['system_name'])
+          def missing_regular_plans
+            missing_plans.reject(&:custom)
+          end
+
+          def missing_plans
+            @missing_plans ||= ThreeScaleToolbox::Helper.array_difference(source.plans, target.plans) do |src, target|
+              src.system_name == target.system_name
             end
           end
         end

data/lib/3scale_toolbox/commands/service_command/copy_command/copy_limits_task.rb

@@ -7,29 +7,28 @@ module ThreeScaleToolbox
 
           def call
             plan_mapping = Helper.application_plan_mapping(source.plans, target.plans)
-            plan_mapping.each do |plan_id, target_plan|
-              source_plan = ThreeScaleToolbox::Entities::ApplicationPlan.new(id: plan_id, service: source)
-              target_plan = ThreeScaleToolbox::Entities::ApplicationPlan.new(id: target_plan['id'], service: target)
-              missing_limits = missing_limits(source_plan.limits, target_plan.limits, metrics_map)
+            plan_mapping.each do |source_plan, target_plan|
+              missing_limits = compute_missing_limits(source_plan.limits, target_plan.limits)
               missing_limits.each do |limit|
-                limit.delete('links')
-                target_plan.create_limit(metrics_map.fetch(limit.fetch('metric_id')), limit)
+                target_plan.create_limit(metrics_map.fetch(limit.metric_id), limit.attrs)
               end
-              puts "Missing #{missing_limits.size} plan limits from target application plan " \
-                "#{target_plan.id}. Source plan #{plan_id}"
+              logger.info "Missing #{missing_limits.size} plan limits from target application plan " \
+                "#{target_plan.id}. Source plan #{source_plan.id}"
+
+              plans_report[target_plan.system_name] = {'application_plan_id' => target_plan.id} unless plans_report.has_key? target_plan.system_name
+              plans_report[target_plan.system_name].merge!({'missing_limits_created' => missing_limits.size})
             end
           end
 
           private
 
           def metrics_map
-            @metrics_map ||= Helper.metrics_mapping(source_metrics_and_methods, target_metrics_and_methods)
+            @metrics_map ||= source.metrics_mapping(target)
           end
 
-          def missing_limits(source_limits, target_limits, metrics_map)
-            ThreeScaleToolbox::Helper.array_difference(source_limits, target_limits) do |limit, target|
-              ThreeScaleToolbox::Helper.compare_hashes(limit, target, ['period']) &&
-                metrics_map.fetch(limit.fetch('metric_id')) == target.fetch('metric_id')
+          def compute_missing_limits(source_limits, target_limits)
+            ThreeScaleToolbox::Helper.array_difference(source_limits, target_limits) do |limit, target_limit|
+              limit.period == target_limit.period && metrics_map.fetch(limit.metric_id) == target_limit.metric_id
             end
           end
         end

data/lib/3scale_toolbox/commands/service_command/copy_command/copy_mapping_rules_task.rb

@@ -6,26 +6,26 @@ module ThreeScaleToolbox
           include Task
 
           def call
-            missing_rules = missing_mapping_rules(source.mapping_rules,
-                                                  target.mapping_rules, metrics_map)
             missing_rules.each do |mapping_rule|
-              mapping_rule.delete('links')
-              mapping_rule['metric_id'] = metrics_map.fetch(mapping_rule.delete('metric_id'))
-              target.create_mapping_rule mapping_rule
+              mr_attrs = mapping_rule.attrs.merge('metric_id' => metrics_map.fetch(mapping_rule.metric_id))
+              Entities::MappingRule.create(service: target, attrs: mr_attrs)
             end
-            puts "created #{missing_rules.size} mapping rules"
+            logger.info "created #{missing_rules.size} mapping rules"
+            report['missing_mapping_rules_created'] = missing_rules.size
           end
 
           private
 
           def metrics_map
-            @metrics_map ||= Helper.metrics_mapping(source_metrics_and_methods, target_metrics_and_methods)
+            @metrics_map ||= source.metrics_mapping(target)
           end
 
-          def missing_mapping_rules(source_rules, target_rules, metrics_map)
-            ThreeScaleToolbox::Helper.array_difference(source_rules, target_rules) do |source_rule, target_rule|
-              ThreeScaleToolbox::Helper.compare_hashes(source_rule, target_rule, %w[pattern http_method delta]) &&
-                metrics_map.fetch(source_rule.fetch('metric_id')) == target_rule.fetch('metric_id')
+          def missing_rules
+            @missing_rules ||= ThreeScaleToolbox::Helper.array_difference(source.mapping_rules, target.mapping_rules) do |source_rule, target_rule|
+              source_rule.pattern == target_rule.pattern &&
+                source_rule.http_method == target_rule.http_method &&
+                source_rule.delta == target_rule.delta &&
+                metrics_map.fetch(source_rule.metric_id) == target_rule.metric_id
             end
           end
         end

data/lib/3scale_toolbox/commands/service_command/copy_command/copy_methods_task.rb

@@ -6,31 +6,28 @@ module ThreeScaleToolbox
           include Task
 
           def call
-            puts "original service hits metric #{source_hits.fetch('id')} has #{source_methods.size} methods"
-            puts "target service hits metric #{target_hits.fetch('id')} has #{target_methods.size} methods"
+            logger.info "original service hits metric #{source.hits.id} has #{source.methods.size} methods"
+            logger.info "target service hits metric #{target.hits.id} has #{target.methods.size} methods"
             missing_methods.each(&method(:create_method))
-            puts "created #{missing_methods.size} missing methods on target service"
-            invalidate_target_methods if missing_methods.size.positive?
+            logger.info "created #{missing_methods.size} missing methods on target service"
+            report['missing_methods_created'] = missing_methods.size
           end
 
           private
 
           def create_method(method)
-            Entities::Method.create(
-              service: target,
-              parent_id: target_hits.fetch('id'),
-              attrs: ThreeScaleToolbox::Helper.filter_params(%w[friendly_name system_name], method)
-            )
+            new_method = method.attrs.reject { |key, _| %w[id links].include? key }
+            Entities::Method.create(service: target, attrs: new_method)
           rescue ThreeScaleToolbox::ThreeScaleApiError => e
             raise e unless ThreeScaleToolbox::Helper.system_name_already_taken_error?(e.apierrors)
 
-            warn "[WARN] method #{method.fetch('system_name')} not created. " \
+            warn "[WARN] method #{method.system_name} not created. " \
               'Metric with the same system_name exists.'
           end
 
           def missing_methods
-            @missing_methods ||= ThreeScaleToolbox::Helper.array_difference(source_methods, target_methods) do |method, target|
-              ThreeScaleToolbox::Helper.compare_hashes(method, target, ['system_name'])
+            @missing_methods ||= ThreeScaleToolbox::Helper.array_difference(source.methods, target.methods) do |method, target|
+              method.system_name == target.system_name
             end
           end
         end

data/lib/3scale_toolbox/commands/service_command/copy_command/copy_metrics_task.rb

@@ -6,28 +6,28 @@ module ThreeScaleToolbox
           include Task
 
           def call
-            puts "original service has #{source_metrics.size} metrics"
-            puts "target service has #{target_metrics.size} metrics"
+            logger.info "original service has #{source.metrics.size} metrics"
+            logger.info "target service has #{target.metrics.size} metrics"
             missing_metrics.each(&method(:create_metric))
-            puts "created #{missing_metrics.size} metrics on the target service"
-            invalidate_target_metrics if missing_metrics.size.positive?
+            logger.info "created #{missing_metrics.size} metrics on the target service"
+            report['missing_metrics_created'] = missing_metrics.size
           end
 
           private
 
           def create_metric(metric)
-            new_metric = metric.reject { |key, _| %w[id links].include? key }
+            new_metric = metric.attrs.reject { |key, _| %w[id links].include? key }
             Entities::Metric.create(service: target, attrs: new_metric)
           rescue ThreeScaleToolbox::ThreeScaleApiError => e
             raise e unless ThreeScaleToolbox::Helper.system_name_already_taken_error?(e.apierrors)
 
-            warn "[WARN] metric #{metric.fetch('system_name')} not created. " \
+            warn "[WARN] metric #{metric.system_name} not created. " \
               'Method with the same system_name exists.'
           end
 
           def missing_metrics
-            @missing_metrics ||= ThreeScaleToolbox::Helper.array_difference(source_metrics, target_metrics) do |source, target|
-              ThreeScaleToolbox::Helper.compare_hashes(source, target, ['system_name'])
+            @missing_metrics ||= ThreeScaleToolbox::Helper.array_difference(source.metrics, target.metrics) do |s_m, t_m|
+              s_m.system_name == t_m.system_name
             end
           end
         end

data/lib/3scale_toolbox/commands/service_command/copy_command/copy_policies_task.rb

@@ -6,7 +6,7 @@ module ThreeScaleToolbox
           include Task
 
           def call
-            puts 'copy proxy policies'
+            logger.info 'copy proxy policies'
             source_policies = source.policies
             target.update_policies('policies_config' => source_policies)
           end

data/lib/3scale_toolbox/commands/service_command/copy_command/copy_pricingrules_task.rb

@@ -7,34 +7,31 @@ module ThreeScaleToolbox
 
           def call
             plan_mapping = Helper.application_plan_mapping(source.plans, target.plans)
-            plan_mapping.each do |plan_id, target_plan|
-              pricing_rules_source = source.remote.list_pricingrules_per_application_plan(plan_id)
-              pricing_rules_target = target.remote.list_pricingrules_per_application_plan(target_plan['id'])
-              missing_pricing_rules = missing_pricing_rules(pricing_rules_source, pricing_rules_target,
-                                                            metrics_map)
+            plan_mapping.each do |source_plan, target_plan|
+              missing_pricing_rules = compute_missing_pricing_rules(source_plan.pricing_rules, target_plan.pricing_rules)
               missing_pricing_rules.each do |pricing_rule|
-                pricing_rule.delete('links')
-                target.remote.create_pricingrule(
-                  target_plan['id'],
-                  metrics_map.fetch(pricing_rule['metric_id']),
-                  pricing_rule
-                )
+                target_plan.create_pricing_rule(metrics_map.fetch(pricing_rule.metric_id), pricing_rule.attrs)
               end
-              puts "Missing #{missing_pricing_rules.size} pricing rules from target application plan " \
-                "#{target_plan['id']}. Source plan #{plan_id}"
+              logger.info "Missing #{missing_pricing_rules.size} pricing rules from target application plan " \
+                "#{target_plan.id}. Source plan #{source_plan.id}"
+
+              plans_report[target_plan.system_name] = {'application_plan_id' => target_plan.id} unless plans_report.has_key? target_plan.system_name
+              plans_report[target_plan.system_name].merge!({'missing_pricing_rules_created' => missing_pricing_rules.size})
             end
           end
 
           private
 
           def metrics_map
-            @metrics_map ||= Helper.metrics_mapping(source_metrics_and_methods, target_metrics_and_methods)
+            @metrics_map ||= source.metrics_mapping(target)
           end
 
-          def missing_pricing_rules(source_pricing_rules, target_pricing_rules, metrics_map)
-            ThreeScaleToolbox::Helper.array_difference(source_pricing_rules, target_pricing_rules) do |src, target|
-              ThreeScaleToolbox::Helper.compare_hashes(src, target, %w[cost_per_unit min max]) &&
-                metrics_map.fetch(src.fetch('metric_id')) == target.fetch('metric_id')
+          def compute_missing_pricing_rules(source_pricing_rules, target_pricing_rules)
+            ThreeScaleToolbox::Helper.array_difference(source_pricing_rules, target_pricing_rules) do |src, target_pr|
+              src.cost_per_unit == target_pr.cost_per_unit &&
+                src.min == target_pr.min &&
+                src.max == target_pr.max &&
+                metrics_map.fetch(src.metric_id) == target_pr.metric_id
             end
           end
         end

data/lib/3scale_toolbox/commands/service_command/copy_command/copy_service_proxy_task.rb

@@ -8,12 +8,12 @@ module ThreeScaleToolbox
           def call
             target.update_proxy target_proxy_attrs
             target.update_oidc source.oidc if source.attrs['backend_version'] == 'oidc'
-            puts "updated proxy of #{target.id} to match the original"
+            logger.info "updated proxy of #{target.id} to match the original"
           end
 
           def target_proxy_attrs
             if source.attrs['deployment_option'] == 'hosted'
-              # For services with "hosted" deployment config, 
+              # For services with "hosted" deployment config,
               # "Public Base URL" should not be copied, mainly because public base URL is self-assigned.
               # Two 3scale products (aka services) cannot be served using the same public base URL.
               source_proxy.dup.delete_if { |key, _v| %w[endpoint sandbox_endpoint].include? key }

data/lib/3scale_toolbox/commands/service_command/copy_command/create_or_update_service_task.rb

@@ -25,7 +25,8 @@ module ThreeScaleToolbox
             # assign target service for other tasks to have it available
             self.target = service
 
-            puts "new service id #{service.id}"
+            logger.info "new service id #{service.id}"
+            report['product_id'] = service.id
           end
 
           private

data/lib/3scale_toolbox/commands/service_command/copy_command/destroy_mapping_rules_task.rb

@@ -12,10 +12,8 @@ module ThreeScaleToolbox
           def call
             return unless delete_mapping_rules
 
-            puts 'destroying all mapping rules'
-            target.mapping_rules.each do |mapping_rule|
-              target.delete_mapping_rule mapping_rule['id']
-            end
+            logger.info 'destroying all mapping rules'
+            target.mapping_rules.each(&:delete)
           end
 
           private
@@ -25,7 +23,13 @@ module ThreeScaleToolbox
           end
 
           def target
-            context[:target]
+            context.fetch(:target)
+          end
+
+          def logger
+            context[:logger] ||= Logger.new($stdout).tap do |logger|
+              logger.formatter = proc { |severity, datetime, progname, msg| "#{msg}\n" }
+            end
           end
         end
       end

data/lib/3scale_toolbox/commands/service_command/copy_command/task.rb

@@ -36,44 +36,12 @@ module ThreeScaleToolbox
             context[:delete_mapping_rules] = true
           end
 
-          def source_metrics
-            context[:source_metrics] ||= source.metrics
-          end
-
-          def source_hits
-            context[:source_hits] ||= source.hits
-          end
-
-          def source_methods
-            context[:source_methods] ||= source.methods(source_hits.fetch('id'))
-          end
-
           def source_metrics_and_methods
-            source_metrics + source_methods
-          end
-
-          def target_metrics
-            context[:target_metrics] ||= target.metrics
-          end
-
-          def target_hits
-            context[:target_hits] ||= target.hits
-          end
-
-          def target_methods
-            context[:target_methods] ||= target.methods(target_hits.fetch('id'))
+            source.metrics + source.methods
           end
 
           def target_metrics_and_methods
-            target_metrics + target_methods
-          end
-
-          def invalidate_target_methods
-            context[:target_methods] = nil
-          end
-
-          def invalidate_target_metrics
-            context[:target_metrics] = nil
+            target.metrics + target.methods
           end
 
           def source_remote
@@ -92,6 +60,24 @@ module ThreeScaleToolbox
           def option_target_system_name
             context[:option_target_system_name]
           end
+
+          def logger
+            context[:logger] ||= Logger.new($stdout).tap do |logger|
+              logger.formatter = proc { |severity, datetime, progname, msg| "#{msg}\n" }
+            end
+          end
+
+          def plans_report
+            report['application_plans'] ||= {}
+          end
+
+          def activedocs_report
+            report['activedocs'] ||= {}
+          end
+
+          def report
+            context[:report] ||= {}
+          end
         end
       end
     end

data/lib/3scale_toolbox/commands/update_command/service_command/delete_activedocs_task.rb

@@ -11,9 +11,7 @@ module ThreeScaleToolbox
 
           def call
             puts 'deleting all target service ActiveDocs'
-            target.activedocs.each do |activedoc|
-              target.remote.delete_activedocs(activedoc['id'])
-            end
+            target.activedocs.each(&:delete)
           end
 
           def target