3scale_toolbox 0.15.0 → 0.16.0

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,17 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CopyServiceProxyTask
+          include Task
+
+          def call
+            target.update_proxy source.proxy
+            target.update_oidc source.oidc if source.attrs['backend_version'] == 'oidc'
+            puts "updated proxy of #{target.id} to match the original"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class CreateOrUpdateTargetServiceTask
+          include Task
+
+          def call
+            service = Entities::Service.find(remote: target_remote,
+                                             ref: target_service_ref)
+            if service == source
+              raise ThreeScaleToolbox::Error, 'Source and destination services are the same: ' \
+                "ID: #{source.id} system_name: #{source.attrs['system_name']}"
+            end
+
+            if service.nil?
+              service = Entities::Service.create(remote: target_remote,
+                                                 service_params: create_attrs)
+              # Notify that mapping rules should be deleted before being copied
+              force_delete_mapping_rules
+            else
+              service.update update_attrs
+            end
+
+            # assign target service for other tasks to have it available
+            self.target = service
+
+            puts "new service id #{service.id}"
+          end
+
+          private
+
+          def target_service_ref
+            option_target_system_name || source.attrs.fetch('system_name')
+          end
+
+          def create_attrs
+            source.attrs.merge('system_name' => target_service_ref)
+          end
+
+          def update_attrs
+            source.attrs.merge('system_name' => target_service_ref)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        class DestroyMappingRulesTask
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+
+          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
+          end
+
+          private
+
+          def delete_mapping_rules
+            context.fetch(:delete_mapping_rules, false)
+          end
+
+          def target
+            context[:target]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module ThreeScaleToolbox
+  module Commands
+    module ServiceCommand
+      module CopyCommand
+        module Task
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+
+          def source
+            context[:source] ||= find_source_service
+          end
+
+          def find_source_service
+            Entities::Service.find(remote: source_remote, ref: source_service_ref).tap do |svc|
+              raise ThreeScaleToolbox::Error, "Service #{source_service_ref} does not exist" if svc.nil?
+            end
+          end
+
+          def target
+            context[:target] ||= raise ThreeScaleToolbox::Error, 'Unexpected error. ' \
+              'Target service should have been created or updated'
+          end
+
+          def target=(target)
+            context[:target] = target
+          end
+
+          def delete_mapping_rules
+            context.fetch(:delete_mapping_rules, false)
+          end
+
+          def force_delete_mapping_rules
+            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'))
+          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
+          end
+
+          def source_remote
+            context[:source_remote]
+          end
+
+          def target_remote
+            context[:target_remote]
+          end
+
+          def source_service_ref
+            context[:source_service_ref] ||= raise ThreeScaleToolbox::Error, 'Unexpected error. ' \
+              'source_service_ref not found'
+          end
+
+          def option_target_system_name
+            context[:option_target_system_name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,58 +1,72 @@
 module ThreeScaleToolbox
   module Commands
     module ServiceCommand
-      module Create
-        class CreateSubcommand < Cri::CommandRunner
-          include ThreeScaleToolbox::Command
-
-          def self.command
-            Cri::Command.define do
-              name        'create'
-              usage       'create [options] <remote> <service-name>'
-              summary     'Create a service'
-              description 'Create a service'
-              runner CreateSubcommand
-
-              param   :remote
-              param   :service_name
-
-              option :d, :'deployment-mode', "Specify the deployment mode of the service", argument: :required
-              option :s, :'system-name', "Specify the system-name of the service", argument: :required
-              option :a, :'authentication-mode', "Specify authentication mode of the service ('1' for API key, '2' for App Id / App Key, 'oauth' for OAuth mode, 'oidc' for OpenID Connect)", argument: :required
-              option nil, :description, "Specify the description of the service", argument: :required
-              option nil, :'support-email', "Specify the support email of the service", argument: :required
-            end
-          end
+      class CreateSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        class CustomPrinter
+          attr_reader :option_default, :option_disabled
 
-          def run
-            create_service_params = service_attrs
-            result = Entities::Service.create(remote: remote, service_params: create_service_params)
-            puts "Service '#{arguments[:service_name]}' has been created with ID: #{result.id}"
+          def print_record(service)
+            puts "Service '#{service['name']}' has been created with ID: #{service['id']}"
           end
 
-          private
+          def print_collection(collection) end
+        end
 
-          def remote
-            @remote ||= threescale_client(arguments[:remote])
-          end
+        def self.command
+          Cri::Command.define do
+            name        'create'
+            usage       'create [options] <remote> <service-name>'
+            summary     'Create a service'
+            description 'Create a service'
 
-          def parse_options
-            {
-              "deployment_option" => options[:'deployment-mode'],
-              "system_name" => options[:'system-name'],
-              "backend_version" => options[:'authentication-mode'],
-              "description" => options[:description],
-              "support_email" => options[:'support-email'],
-            }.compact
-          end
+            param   :remote
+            param   :service_name
 
-          def service_attrs
-            service_name = arguments[:service_name]
-            create_service_attrs = parse_options
-            create_service_attrs["name"] = service_name
-            create_service_attrs
+            ThreeScaleToolbox::CLI.output_flag(self)
+            option :d, :'deployment-mode', "Specify the deployment mode of the service", argument: :required
+            option :s, :'system-name', "Specify the system-name of the service", argument: :required
+            option :a, :'authentication-mode', "Specify authentication mode of the service ('1' for API key, '2' for App Id / App Key, 'oauth' for OAuth mode, 'oidc' for OpenID Connect)", argument: :required
+            option nil, :description, "Specify the description of the service", argument: :required
+            option nil, :'support-email', "Specify the support email of the service", argument: :required
+
+            runner CreateSubcommand
           end
         end
+
+        def run
+          service = Entities::Service.create(remote: remote, service_params: create_params)
+          printer.print_record service.attrs
+        end
+
+        private
+
+        def remote
+          @remote ||= threescale_client(arguments[:remote])
+        end
+
+        def parse_options
+          {
+            "deployment_option" => options[:'deployment-mode'],
+            "system_name" => options[:'system-name'],
+            "backend_version" => options[:'authentication-mode'],
+            "description" => options[:description],
+            "support_email" => options[:'support-email'],
+          }.compact
+        end
+
+        def create_params
+          service_name = arguments[:service_name]
+          create_service_attrs = parse_options
+          create_service_attrs['name'] = service_name
+          create_service_attrs
+        end
+
+        def printer
+          # keep backwards compatibility
+          options.fetch(:output, CustomPrinter.new)
+        end
       end
     end
   end