3scale_toolbox 0.17.1 → 0.18.0

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,11 +6,11 @@ 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
@@ -18,19 +18,18 @@ module ThreeScaleToolbox
           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)
+              attrs: ThreeScaleToolbox::Helper.filter_params(%w[friendly_name system_name], method.attrs)
             )
           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

data/lib/3scale_toolbox/crds.rb

@@ -0,0 +1,16 @@
+require '3scale_toolbox/crds/application_plan_dump'
+require '3scale_toolbox/crds/backend_method_dump'
+require '3scale_toolbox/crds/backend_mapping_rule_dump'
+require '3scale_toolbox/crds/backend_metric_dump'
+require '3scale_toolbox/crds/backend_dump'
+require '3scale_toolbox/crds/backend_usage_dump'
+require '3scale_toolbox/crds/limit_dump'
+require '3scale_toolbox/crds/mapping_rule_dump'
+require '3scale_toolbox/crds/method_dump'
+require '3scale_toolbox/crds/metric_dump'
+require '3scale_toolbox/crds/pricing_rule_dump'
+require '3scale_toolbox/crds/product_dump'
+require '3scale_toolbox/crds/product_deployment_parser'
+require '3scale_toolbox/crds/backend_parser'
+require '3scale_toolbox/crds/product_parser'
+require '3scale_toolbox/crds/remote'

data/lib/3scale_toolbox/crds/application_plan_dump.rb

@@ -0,0 +1,19 @@
+module ThreeScaleToolbox
+  module CRD
+    module ApplicationPlanSerializer
+      def to_cr
+        {
+          'name' => name,
+          'appsRequireApproval' => approval_required?,
+          'trialPeriod' => trial_period_days,
+          'setupFee' => setup_fee,
+          'custom' => custom,
+          'state' => state,
+          'costMonth' => cost_per_month,
+          'pricingRules' => pricing_rules.map(&:to_cr),
+          'limits' => limits.map(&:to_cr)
+        }
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/crds/backend_dump.rb

@@ -0,0 +1,39 @@
+module ThreeScaleToolbox
+  module CRD
+    module BackendSerializer
+      def to_cr
+        {
+          'apiVersion' => 'capabilities.3scale.net/v1beta1',
+          'kind' => 'Backend',
+          'metadata' => {
+            'annotations' => {
+              '3scale_toolbox_created_at' => Time.now.utc.iso8601,
+              '3scale_toolbox_version' => ThreeScaleToolbox::VERSION
+            },
+            'name' => cr_name
+          },
+          'spec' => {
+            'name' => name,
+            'systemName' => system_name,
+            'privateBaseURL' => private_endpoint,
+            'description' => description,
+            'mappingRules' => mapping_rules.map(&:to_cr),
+            'metrics' => metrics.each_with_object({}) do |metric, hash|
+              hash[metric.system_name] = metric.to_cr
+            end,
+            'methods' => methods.each_with_object({}) do |method, hash|
+              hash[method.system_name] = method.to_cr
+            end
+          }
+        }
+      end
+
+      def cr_name
+        # Should be DNS1123 subdomain name
+        # TODO run validation for DNS1123
+        # https://kubernetes.io/docs/concepts/overview/working-with-objects/names/
+        "#{system_name.gsub(/[^[a-zA-Z0-9\-\.]]/, '.')}.#{Helper.random_lowercase_name}"
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/crds/backend_mapping_rule_dump.rb

@@ -0,0 +1,26 @@
+module ThreeScaleToolbox
+  module CRD
+    module BackendMappingRuleSerializer
+      def to_cr
+        {
+          'httpMethod' => http_method,
+          'pattern' => pattern,
+          'metricMethodRef' => metric_method_ref,
+          'increment' => delta,
+          'last' => last,
+        }
+      end
+
+      def metric_method_ref
+        if (method = backend.methods.find { |m| m.id == metric_id })
+          method.system_name
+        elsif (metric = backend.metrics.find { |m| m.id == metric_id })
+          metric.system_name
+        else
+          raise ThreeScaleToolbox::Error, "Unexpected error. Backend #{backend.system_name} " \
+            "mapping rule #{id} referencing to metric id #{metric_id} which has not been found"
+        end
+      end
+    end
+  end
+end