3scale_toolbox 0.13.0 → 0.17.1

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

@@ -0,0 +1,95 @@
+require '3scale_toolbox/commands/service_command/copy_command/task'
+require '3scale_toolbox/commands/service_command/copy_command/create_or_update_service_task'
+require '3scale_toolbox/commands/service_command/copy_command/copy_limits_task'
+require '3scale_toolbox/commands/service_command/copy_command/copy_mapping_rules_task'
+require '3scale_toolbox/commands/service_command/copy_command/copy_activedocs_task'
+require '3scale_toolbox/commands/service_command/copy_command/copy_app_plans_task'
+require '3scale_toolbox/commands/service_command/copy_command/copy_methods_task'
+require '3scale_toolbox/commands/service_command/copy_command/copy_metrics_task'
+require '3scale_toolbox/commands/service_command/copy_command/copy_policies_task'
+require '3scale_toolbox/commands/service_command/copy_command/copy_pricingrules_task'
+require '3scale_toolbox/commands/service_command/copy_command/copy_service_proxy_task'
+require '3scale_toolbox/commands/service_command/copy_command/destroy_mapping_rules_task'
+require '3scale_toolbox/commands/service_command/copy_command/bump_proxy_version_task'
+
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      class CopySubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        def self.command
+          Cri::Command.define do
+            name        'copy'
+            usage       'copy [opts] -s <src> -d <dst> <source-service>'
+            summary     'Copy service'
+            description <<-HEREDOC
+            This command makes a copy of the referenced service.
+            Target service will be searched by source service system name. System name can be overriden with `--target_system_name` option.
+            If a service with the selected `system_name` is not found, it will be created.
+            \n Components of the service being copied:
+            \nservice settings
+            \nproxy settings
+            \npricing rules
+            \nactivedocs
+            \nmetrics
+            \nmethods
+            \napplication plans
+            \nmapping rules
+            HEREDOC
+
+            option  :s, :source, '3scale source instance. Url or remote name', argument: :required
+            option  :d, :destination, '3scale target instance. Url or remote name', argument: :required
+            option  :t, 'target_system_name', 'Target system name. Default to source system name', argument: :required
+            flag    :f, :force, 'Overwrites the mapping rules by deleting all rules from target service first'
+            flag    :r, 'rules-only', 'Only mapping rules are copied'
+            param   :source_service
+
+            runner CopySubcommand
+          end
+        end
+
+        def run
+          tasks = []
+          unless option_rules_only
+            tasks << CopyCommand::CreateOrUpdateTargetServiceTask.new(context)
+            tasks << CopyCommand::CopyServiceProxyTask.new(context)
+            tasks << CopyCommand::CopyMethodsTask.new(context)
+            tasks << CopyCommand::CopyMetricsTask.new(context)
+            tasks << CopyCommand::CopyApplicationPlansTask.new(context)
+            tasks << CopyCommand::CopyLimitsTask.new(context)
+            tasks << CopyCommand::CopyPoliciesTask.new(context)
+            tasks << CopyCommand::CopyPricingRulesTask.new(context)
+            tasks << CopyCommand::CopyActiveDocsTask.new(context)
+          end
+          tasks << CopyCommand::DestroyMappingRulesTask.new(context)
+          tasks << CopyCommand::CopyMappingRulesTask.new(context)
+          tasks.each(&:call)
+
+          # This should be the last step
+          CopyCommand::BumpProxyVersionTask.new(service: context[:target]).call
+        end
+
+        private
+
+        def context
+          @context ||= create_context
+        end
+
+        def create_context
+          {
+            source_remote: threescale_client(fetch_required_option(:source)),
+            target_remote: threescale_client(fetch_required_option(:destination)),
+            source_service_ref: arguments[:source_service],
+            option_target_system_name: options[:target_system_name],
+            delete_mapping_rules: options[:force]
+          }
+        end
+
+        def option_rules_only
+          options[:'rules-only']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class BumpProxyVersionTask
+          attr_reader :service
+
+          def initialize(service:)
+            @service = service
+          end
+
+          ##
+          # bumps proxy config version to propagate proxy settings updates
+          def call
+            # Proxy update is the mechanism to increase version of the proxy,
+            # Hence propagating (mapping rules, poicies, oidc, auth) update to
+            # latest proxy config, making available to gateway.
+
+            # Currently it is done always because mapping rules, at least, are always created
+            # So they need to be propagated
+            proxy_settings = {
+              # Adding harmless attribute to avoid empty body
+              # update_proxy cannot be done with empty body
+              # and must be done to increase proxy version
+              # If proxy settings have not been changed since last update,
+              # this request will not have effect and proxy config version will not be bumped.
+              service_id: service.id
+            }
+
+            service.update_proxy proxy_settings
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyActiveDocsTask
+          include Task
+
+          def call
+            puts 'copying all service ActiveDocs'
+
+            source.activedocs.each(&method(:apply_target_activedoc))
+          end
+
+          private
+
+          def apply_target_activedoc(attrs)
+            activedocs = Entities::ActiveDocs.find_by_system_name(remote: target.remote,
+                                                                  system_name: attrs['system_name'])
+            if activedocs.nil?
+              Entities::ActiveDocs.create(remote: target.remote, attrs: create_attrs(attrs))
+            elsif activedocs.attrs.fetch('service_id') == target.id
+              activedocs.update(update_attrs(attrs))
+            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)
+            end
+          end
+
+          def update_attrs(old_attrs)
+            create_attrs(old_attrs)
+          end
+
+          def create_attrs(old_attrs)
+            # keep same system_name
+            new_attrs = old_attrs.reject { |key, _| %w[id created_at updated_at].include? key }
+            new_attrs.tap do |attrs|
+              attrs['service_id'] = target.id
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyApplicationPlansTask
+          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
+            end
+            puts "target service missing #{missing_plans.size} application plans"
+          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'])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyLimitsTask
+          include Task
+
+          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)
+              missing_limits.each do |limit|
+                limit.delete('links')
+                target_plan.create_limit(metrics_map.fetch(limit.fetch('metric_id')), limit)
+              end
+              puts "Missing #{missing_limits.size} plan limits from target application plan " \
+                "#{target_plan.id}. Source plan #{plan_id}"
+            end
+          end
+
+          private
+
+          def metrics_map
+            @metrics_map ||= Helper.metrics_mapping(source_metrics_and_methods, target_metrics_and_methods)
+          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')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyMappingRulesTask
+          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
+            end
+            puts "created #{missing_rules.size} mapping rules"
+          end
+
+          private
+
+          def metrics_map
+            @metrics_map ||= Helper.metrics_mapping(source_metrics_and_methods, target_metrics_and_methods)
+          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')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyMethodsTask
+          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"
+            missing_methods.each(&method(:create_method))
+            puts "created #{missing_methods.size} missing methods on target service"
+            invalidate_target_methods if missing_methods.size.positive?
+          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)
+            )
+          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. " \
+              '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'])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyMetricsTask
+          include Task
+
+          def call
+            puts "original service has #{source_metrics.size} metrics"
+            puts "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?
+          end
+
+          private
+
+          def create_metric(metric)
+            new_metric = metric.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. " \
+              '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'])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyPoliciesTask
+          include Task
+
+          def call
+            puts 'copy proxy policies'
+            source_policies = source.policies
+            target.update_policies('policies_config' => source_policies)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyPricingRulesTask
+          include Task
+
+          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)
+              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
+                )
+              end
+              puts "Missing #{missing_pricing_rules.size} pricing rules from target application plan " \
+                "#{target_plan['id']}. Source plan #{plan_id}"
+            end
+          end
+
+          private
+
+          def metrics_map
+            @metrics_map ||= Helper.metrics_mapping(source_metrics_and_methods, target_metrics_and_methods)
+          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')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyServiceProxyTask
+          include Task
+
+          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"
+          end
+
+          def target_proxy_attrs
+            if source.attrs['deployment_option'] == 'hosted'
+              # 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 }
+            else
+              source_proxy
+            end
+          end
+
+          def source_proxy
+            @source_proxy ||= source.proxy
+          end
+        end
+      end
+    end
+  end
+end