3scale_toolbox 0.15.0 → 0.18.2

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,49 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyActiveDocsTask
+          include Task
+
+          def call
+            logger.info 'copying all service ActiveDocs'
+
+            source.activedocs.each(&method(:apply_target_activedoc))
+          end
+
+          private
+
+          def apply_target_activedoc(source_activedoc)
+            activedocs = Entities::ActiveDocs.find_by_system_name(remote: target.remote,
+                                                                  system_name: source_activedoc.system_name)
+            if activedocs.nil?
+              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(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(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(activedoc)
+            create_attrs(activedoc)
+          end
+
+          def create_attrs(activedoc)
+            # keep same system_name
+            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
+          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
+            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
+
+            logger.info "target service missing #{missing_regular_plans.size} application plans"
+            report['missing_application_plans_created'] = missing_regular_plans.size
+          end
+
+          private
+
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+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 |source_plan, target_plan|
+              missing_limits = compute_missing_limits(source_plan.limits, target_plan.limits)
+              missing_limits.each do |limit|
+                target_plan.create_limit(metrics_map.fetch(limit.metric_id), limit.attrs)
+              end
+              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 ||= source.metrics_mapping(target)
+          end
+
+          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
+      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.each do |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
+            logger.info "created #{missing_rules.size} mapping rules"
+            report['missing_mapping_rules_created'] = missing_rules.size
+          end
+
+          private
+
+          def metrics_map
+            @metrics_map ||= source.metrics_mapping(target)
+          end
+
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyMethodsTask
+          include Task
+
+          def call
+            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))
+            logger.info "created #{missing_methods.size} missing methods on target service"
+            report['missing_methods_created'] = missing_methods.size
+          end
+
+          private
+
+          def create_method(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.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|
+              method.system_name == 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
+            logger.info "original service has #{source.metrics.size} metrics"
+            logger.info "target service has #{target.metrics.size} metrics"
+            missing_metrics.each(&method(:create_metric))
+            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.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.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 |s_m, t_m|
+              s_m.system_name == t_m.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
+            logger.info '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,41 @@
+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 |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|
+                target_plan.create_pricing_rule(metrics_map.fetch(pricing_rule.metric_id), pricing_rule.attrs)
+              end
+              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 ||= source.metrics_mapping(target)
+          end
+
+          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
+      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'
+            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,
+              # "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