3scale_toolbox 0.8.0 → 0.9.0

data/lib/3scale_toolbox/commands/plans_command/import/import_plan_limits_step.rb

@@ -0,0 +1,41 @@
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      module Import
+        class ImportMetricLimitsStep
+          include Step
+          ##
+          # Writes Plan limits
+          def call
+            missing_limits.each do |limit|
+              metric_id = limit.delete('metric_id')
+              limit_obj = plan.create_limit(metric_id, limit)
+              if (errors = limit_obj['errors'])
+                raise ThreeScaleToolbox::Error, "Plan limit has not been created. #{errors}"
+              end
+
+              puts "Created plan limit: [metric: #{metric_id}, #{limit}]"
+            end
+          end
+
+          private
+
+          def missing_limits
+            ThreeScaleToolbox::Helper.array_difference(resource_limits_processed, plan.limits) do |a, b|
+              ThreeScaleToolbox::Helper.compare_hashes(a, b, %w[metric_id period])
+            end
+          end
+
+          def resource_limits_processed
+            resource_limits.map do |limit|
+              metric = find_metric_by_system_name(limit.delete('metric_system_name'))
+              # this ImportMetricLimitsStep step is assuming all metrics/methods have been created
+              # in previous step, so finding metric should always succeed.
+              limit.merge('metric_id' => metric.fetch('id'))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/plans_command/import/import_plan_metrics_step.rb

@@ -0,0 +1,57 @@
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      module Import
+        class ImportMetricsStep
+          include Step
+          ##
+          # Writes Plan metrics and methods
+          def call
+            missing_metrics.each(&method(:create_metric))
+            missing_methods.each(&method(:create_method))
+
+            # invalidate memoized methods and metrics
+            invalidate_service_methods
+            invalidate_service_metrics
+          end
+
+          private
+
+          def missing_metrics
+            # service metrics list includes methods
+            # this array_difference method computes elements in resource_metrics not included in service_metrics
+            # So methods will not be in the "missing_metrics" list, as long as array diff semantics are kept.
+            ThreeScaleToolbox::Helper.array_difference(resource_metrics, service_metrics) do |a, b|
+              ThreeScaleToolbox::Helper.compare_hashes(a, b, ['system_name'])
+            end
+          end
+
+          def missing_methods
+            ThreeScaleToolbox::Helper.array_difference(resource_methods, service_methods) do |a, b|
+              ThreeScaleToolbox::Helper.compare_hashes(a, b, ['system_name'])
+            end
+          end
+
+          def create_metric(metric_attrs)
+            metric = service.create_metric(metric_attrs)
+            if (errors = metric['errors'])
+              raise ThreeScaleToolbox::Error, "Metric has not been created. #{errors}"
+            end
+
+            puts "Created metric: #{metric['system_name']}"
+          end
+
+          def create_method(method_attrs)
+            method = service.create_method(service_hits['id'], method_attrs)
+            if (errors = method['errors'])
+              raise ThreeScaleToolbox::Error, "Method has not been created. #{errors}" \
+
+            end
+
+            puts "Created method: #{method_attrs['system_name']}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/plans_command/import/import_plan_pricing_rules_step.rb

@@ -0,0 +1,39 @@
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      module Import
+        class ImportPricingRulesStep
+          include Step
+          ##
+          # Writes Plan pricing rules
+          def call
+            missing_pricing_rules.each do |pr|
+              metric_id = pr.delete('metric_id')
+              resp = plan.create_pricing_rule(metric_id, pr)
+              if (errors = resp['errors'])
+                raise ThreeScaleToolbox::Error, "Plan pricing rule has not been created. #{errors}"
+              end
+
+              puts "Created plan pricing rule: [metric: #{metric_id}, #{pr}]"
+            end
+          end
+
+          private
+
+          def missing_pricing_rules
+            ThreeScaleToolbox::Helper.array_difference(resource_pr_processed, plan.pricing_rules) do |a, b|
+              ThreeScaleToolbox::Helper.compare_hashes(a, b, %w[metric_id cost_per_unit min max])
+            end
+          end
+
+          def resource_pr_processed
+            resource_pricing_rules.map do |pr|
+              metric = find_metric_by_system_name(pr.delete('metric_system_name'))
+              pr.merge('metric_id' => metric.fetch('id'))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/plans_command/import/step.rb

@@ -0,0 +1,129 @@
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      module Import
+        module Step
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+
+          def service
+            context[:service] ||= find_service
+          end
+
+          def file
+            context[:file]
+          end
+
+          def threescale_client
+            context[:threescale_client]
+          end
+
+          # can be id or system_name
+          def service_system_name
+            context[:service_system_name]
+          end
+
+          # can be id or system_name
+          def plan_system_name
+            context[:plan_system_name] || artifacts_resource.dig('plan', 'system_name')
+          end
+
+          def result
+            context[:result] ||= {}
+          end
+
+          def plan
+            context[:plan] ||= find_plan
+          end
+
+          def resource_plan
+            artifacts_resource.fetch('plan') do
+              raise ThreeScaleToolbox::Error, 'Invalid content. Plan not found'
+            end
+          end
+
+          def resource_metrics
+            artifacts_resource['metrics'] || []
+          end
+
+          def resource_methods
+            artifacts_resource['methods'] || []
+          end
+
+          def resource_limits
+            artifacts_resource['limits'] || []
+          end
+
+          def resource_pricing_rules
+            artifacts_resource['pricingrules'] || []
+          end
+
+          def resource_features
+            artifacts_resource['plan_features'] || []
+          end
+
+          def service_metrics
+            context[:service_metrics] ||= service.metrics
+          end
+
+          def invalidate_service_metrics
+            context[:service_metrics] = nil
+          end
+
+          def service_hits
+            context[:service_hits] ||= find_service_hits
+          end
+
+          def service_methods
+            context[:service_methods] ||= service.methods
+          end
+
+          def invalidate_service_methods
+            context[:service_methods] = nil
+          end
+
+          def service_features
+            context[:service_features] ||= service.features
+          end
+
+          # deserialized artifacts content
+          def artifacts_resource
+            context[:artifacts_resource]
+          end
+
+          def find_feature_by_system_name(system_name)
+            service_features.find { |feature| feature['system_name'] == system_name }
+          end
+
+          def find_metric_by_system_name(system_name)
+            service_metrics.find { |metric| metric['system_name'] == system_name }
+          end
+
+          private
+
+          def find_service
+            Entities::Service.find(remote: threescale_client,
+                                   ref: service_system_name).tap do |svc|
+              raise ThreeScaleToolbox::Error, "Service #{service_system_name} does not exist" if svc.nil?
+            end
+          end
+
+          def find_plan
+            Entities::ApplicationPlan.find(service: service, ref: plan_system_name).tap do |p|
+              raise ThreeScaleToolbox::Error, "Application plan #{plan_system_name} does not exist" if p.nil?
+            end
+          end
+
+          def find_service_hits
+            find_metric_by_system_name('hits').tap do |hits_metric|
+              raise ThreeScaleToolbox::Error, 'missing hits metric' if hits_metric.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/plans_command/import_command.rb

@@ -0,0 +1,62 @@
+require '3scale_toolbox/commands/plans_command/import/step'
+require '3scale_toolbox/commands/plans_command/import/create_or_update_app_plan_step'
+require '3scale_toolbox/commands/plans_command/import/import_plan_features_step'
+require '3scale_toolbox/commands/plans_command/import/import_plan_metrics_step'
+require '3scale_toolbox/commands/plans_command/import/import_plan_limits_step'
+require '3scale_toolbox/commands/plans_command/import/import_plan_pricing_rules_step'
+
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      module Import
+        class ImportSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+          include ThreeScaleToolbox::ResourceReader
+
+          def self.command
+            Cri::Command.define do
+              name        'import'
+              usage       'import [opts] <remote> <service_system_name>'
+              summary     'import application plan'
+              description 'Import application plan, limits, pricing rules and features'
+
+              option      :f, :file, 'Read from file or url instead of stdin', argument: :required
+              option      :p, :plan, 'Override application plan reference', argument: :required
+              param       :remote
+              param       :service_system_name
+
+              runner ImportSubcommand
+            end
+          end
+
+          def run
+            tasks = []
+            tasks << CreateOrUpdateAppPlanStep.new(context)
+            tasks << ImportMetricsStep.new(context)
+            tasks << ImportMetricLimitsStep.new(context)
+            tasks << ImportPricingRulesStep.new(context)
+            tasks << ImportPlanFeaturesStep.new(context)
+
+            # run tasks
+            tasks.each(&:call)
+          end
+
+          private
+
+          def context
+            @context ||= create_context
+          end
+
+          def create_context
+            {
+              artifacts_resource: load_resource(options[:file] || '-'),
+              threescale_client: threescale_client(arguments[:remote]),
+              service_system_name: arguments[:service_system_name],
+              plan_system_name: options[:plan],
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/plans_command/list_command.rb

@@ -0,0 +1,63 @@
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      module List
+        class ListSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          FIELDS_TO_SHOW = %w[id name system_name].freeze
+
+          def self.command
+            Cri::Command.define do
+              name        'list'
+              usage       'list [opts] <remote> <service>'
+              summary     'list application plans'
+              description 'List application plans'
+
+              param       :remote
+              param       :service_ref
+
+              runner ListSubcommand
+            end
+          end
+
+          def run
+            print_header
+            print_data
+          end
+
+          private
+
+          def print_header
+            puts FIELDS_TO_SHOW.map(&:upcase).join("\t")
+          end
+
+          def print_data
+            service.plans.each do |plan|
+              puts FIELDS_TO_SHOW.map { |field| plan.fetch(field, '(empty)') }.join("\t")
+            end
+          end
+
+          def service
+            @service ||= find_service
+          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 remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def service_ref
+            arguments[:service_ref]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/plans_command/show_command.rb

@@ -0,0 +1,81 @@
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      module Show
+        class ShowSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          FIELDS_TO_SHOW = %w[id name system_name approval_required end_user_required
+                              cost_per_month setup_fee trial_period_days].freeze
+
+          def self.command
+            Cri::Command.define do
+              name        'show'
+              usage       'show [opts] <remote> <service> <plan>'
+              summary     'show application plan'
+              description 'show application plan'
+
+              param       :remote
+              param       :service_ref
+              param       :plan_ref
+
+              runner ShowSubcommand
+            end
+          end
+
+          def run
+            print_header
+            print_data
+          end
+
+          private
+
+          def print_header
+            puts FIELDS_TO_SHOW.map(&:upcase).join("\t")
+          end
+
+          def print_data
+            puts FIELDS_TO_SHOW.map { |field| plan_attrs.fetch(field, '(empty)') }.join("\t")
+          end
+
+          def service
+            @service ||= find_service
+          end
+
+          def plan_attrs
+            @plan_attrs ||= plan.show
+          end
+
+          def plan
+            @plan ||= find_plan
+          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 find_plan
+            Entities::ApplicationPlan.find(service: service, ref: plan_ref).tap do |p|
+              raise ThreeScaleToolbox::Error, "Application plan #{plan_ref} does not exist" if p.nil?
+            end
+          end
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def service_ref
+            arguments[:service_ref]
+          end
+
+          def plan_ref
+            arguments[:plan_ref]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require '3scale_toolbox/commands/plans_command/export_command'
+require '3scale_toolbox/commands/plans_command/import_command'
+require '3scale_toolbox/commands/plans_command/create_command'
+require '3scale_toolbox/commands/plans_command/apply_command'
+require '3scale_toolbox/commands/plans_command/list_command'
+require '3scale_toolbox/commands/plans_command/show_command'
+require '3scale_toolbox/commands/plans_command/delete_command'
+
+module ThreeScaleToolbox
+  module Commands
+    module PlansCommand
+      include ThreeScaleToolbox::Command
+      def self.command
+        Cri::Command.define do
+          name        'application-plan'
+          usage       'application-plan <sub-command> [options]'
+          summary     'application-plan super command'
+          description 'Application plan commands'
+
+          run do |_opts, _args, cmd|
+            puts cmd.help
+          end
+        end
+      end
+      add_subcommand(Export::ExportSubcommand)
+      add_subcommand(Import::ImportSubcommand)
+      add_subcommand(Create::CreateSubcommand)
+      add_subcommand(Apply::ApplySubcommand)
+      add_subcommand(List::ListSubcommand)
+      add_subcommand(Show::ShowSubcommand)
+      add_subcommand(Delete::DeleteSubcommand)
+    end
+  end
+end

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

@@ -1,6 +1,3 @@
-require 'cri'
-require '3scale_toolbox/base_command'
-require '3scale_toolbox/remotes'
 require '3scale_toolbox/commands/remote_command/remote_add'
 require '3scale_toolbox/commands/remote_command/remote_remove'
 require '3scale_toolbox/commands/remote_command/remote_rename'

data/lib/3scale_toolbox/commands/update_command/update_service.rb

@@ -1,6 +1,3 @@
-require 'cri'
-require '3scale_toolbox/base_command'
-
 module ThreeScaleToolbox
   module Commands
     module UpdateCommand
@@ -41,7 +38,6 @@ module ThreeScaleToolbox
           tasks = []
           unless options[:'rules-only']
             tasks << Tasks::UpdateServiceSettingsTask.new(context.merge(target_name: system_name))
-            tasks << Tasks::CopyServiceProxyTask.new(context)
             tasks << Tasks::CopyMethodsTask.new(context)
             tasks << Tasks::CopyMetricsTask.new(context)
             tasks << Tasks::CopyApplicationPlansTask.new(context)
@@ -50,6 +46,11 @@ module ThreeScaleToolbox
             tasks << Tasks::CopyPricingRulesTask.new(context)
             tasks << Tasks::DeleteActiveDocsTask.new(context)
             tasks << Tasks::CopyActiveDocsTask.new(context)
+            # Copy proxy must be the last task
+            # 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.
+            tasks << Tasks::CopyServiceProxyTask.new(context)
           end
           tasks << Tasks::DestroyMappingRulesTask.new(context) if options[:force]
           tasks << Tasks::CopyMappingRulesTask.new(context)

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

@@ -1,5 +1,3 @@
-require 'cri'
-require '3scale_toolbox/base_command'
 require '3scale_toolbox/commands/update_command/update_service'
 
 module ThreeScaleToolbox

data/lib/3scale_toolbox/commands.rb

@@ -4,6 +4,7 @@ require '3scale_toolbox/commands/copy_command'
 require '3scale_toolbox/commands/import_command'
 require '3scale_toolbox/commands/update_command'
 require '3scale_toolbox/commands/remote_command'
+require '3scale_toolbox/commands/plans_command'
 
 module ThreeScaleToolbox
   module Commands
@@ -12,7 +13,8 @@ module ThreeScaleToolbox
       ThreeScaleToolbox::Commands::CopyCommand,
       ThreeScaleToolbox::Commands::ImportCommand,
       ThreeScaleToolbox::Commands::UpdateCommand,
-      ThreeScaleToolbox::Commands::RemoteCommand::RemoteCommand
+      ThreeScaleToolbox::Commands::RemoteCommand::RemoteCommand,
+      ThreeScaleToolbox::Commands::PlansCommand,
     ].freeze
   end
 end