3scale_toolbox 0.16.0 → 0.18.3

data/lib/3scale_toolbox/commands/proxy_config_command.rb

@@ -1,8 +1,11 @@
 require 'cri'
 require '3scale_toolbox/base_command'
+require '3scale_toolbox/commands/proxy_config_command/helper'
 require '3scale_toolbox/commands/proxy_config_command/list_command'
 require '3scale_toolbox/commands/proxy_config_command/show_command'
 require '3scale_toolbox/commands/proxy_config_command/promote_command'
+require '3scale_toolbox/commands/proxy_config_command/export_command'
+require '3scale_toolbox/commands/proxy_config_command/deploy_command'
 
 module ThreeScaleToolbox
   module Commands
@@ -25,6 +28,8 @@ module ThreeScaleToolbox
       add_subcommand(List::ListSubcommand)
       add_subcommand(Show::ShowSubcommand)
       add_subcommand(Promote::PromoteSubcommand)
+      add_subcommand(Export::ExportSubcommand)
+      add_subcommand(DeploySubcommand)
     end
   end
 end

data/lib/3scale_toolbox/commands/proxy_config_command/deploy_command.rb

@@ -0,0 +1,54 @@
+module ThreeScaleToolbox
+  module Commands
+    module ProxyConfigCommand
+      class DeploySubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        def self.command
+          Cri::Command.define do
+            name        'deploy'
+            usage       'deploy <remote> <service>'
+            summary     'Promotes the APIcast configuration to the Staging Environment'
+            description 'Promotes the APIcast configuration to the Staging Environment (Production Environment in case of Service Mesh).'
+
+            param :remote
+            param :service_ref
+
+            ThreeScaleToolbox::CLI.output_flag(self)
+
+            runner DeploySubcommand
+          end
+        end
+
+        def run
+          printer.print_record service.proxy_deploy
+        end
+
+        private
+
+        def remote
+          @remote ||= threescale_client(arguments[:remote])
+        end
+
+        def service_ref
+          arguments[:service_ref]
+        end
+
+        def find_service
+          Entities::Service.find(remote: remote,
+                                 ref: service_ref).tap do |svc|
+            raise ThreeScaleToolbox::Error, "Service #{service_ref} does not exist" if svc.nil?
+          end
+        end
+
+        def service
+          @service ||= find_service
+        end
+
+        def printer
+          options.fetch(:output, CLI::JsonPrinter.new)
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/proxy_config_command/export_command.rb

@@ -0,0 +1,74 @@
+module ThreeScaleToolbox
+  module Commands
+    module ProxyConfigCommand
+      module Export
+        class ExportSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          def self.command
+            Cri::Command.define do
+              name        'export'
+              usage       'export <remote>'
+              summary     'Export proxy configuration for the entire provider account'
+              description <<-HEREDOC
+              Export proxy configuration for the entire provider account
+              \n Can be used as 3scale apicast configuration file
+              \n https://github.com/3scale/apicast/blob/master/doc/parameters.md#threescale_config_file
+              HEREDOC
+
+              param :remote
+
+              ThreeScaleToolbox::CLI.output_flag(self)
+              option nil, :environment, "Gateway environment. Must be 'sandbox' or 'production'", default: 'sandbox', argument: :required, transform: ProxyConfigCommand::EnvironmentTransformer.new
+
+              runner ExportSubcommand
+            end
+          end
+
+          def run
+            printer.print_record proxy_config_list_obj
+          end
+
+          private
+
+          def proxy_config_list_obj
+            {
+              'services' => proxy_config_list
+            }
+          end
+
+          def proxy_config_list
+            service_list.map do |service|
+              pc = Entities::ProxyConfig.find_latest(service: service, environment: environment)
+              pc.attrs['content'] unless pc.nil?
+            end.compact
+          end
+
+          def service_list
+            tmp_list = remote.list_services
+
+            if tmp_list.respond_to?(:has_key?) && (errors = tmp_list['errors'])
+              raise ThreeScaleToolbox::ThreeScaleApiError.new('Service list not read', errors)
+            end
+
+            tmp_list.map do |svc_attrs|
+              Entities::Service.new(id: svc_attrs.fetch('id'), remote: remote, attrs: svc_attrs)
+            end
+          end
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def environment
+            options[:environment]
+          end
+
+          def printer
+            options.fetch(:output, CLI::JsonPrinter.new)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/proxy_config_command/helper.rb

@@ -0,0 +1,15 @@
+module ThreeScaleToolbox
+  module Commands
+    module ProxyConfigCommand
+      class EnvironmentTransformer
+        def call(param_str)
+          raise ArgumentError unless param_str.is_a?(String)
+
+          raise ArgumentError unless %w[production sandbox].include? param_str
+
+          param_str
+        end
+      end
+    end
+  end
+end

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