3scale_toolbox 0.15.0 → 0.16.0

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

@@ -11,41 +11,39 @@ module ThreeScaleToolbox
               usage       'show <remote> <service> <environment>'
               summary     'Show Proxy Configuration'
               description 'Show a Proxy Configuration'
-              runner ShowSubcommand
 
               param   :remote
               param   :service_ref
               param   :environment
 
-              option nil, :'config-version', "Specify the Proxy Configuration version. If not specified it gets the latest version", argument: :required
+              ThreeScaleToolbox::CLI.output_flag(self)
+              option nil, :'config-version', "Specify the Proxy Configuration version. If not specified it gets the latest version", default: 'latest', argument: :required
+
+              runner ShowSubcommand
             end
           end
 
-          def run      
-            print_proxy_config
+          def run
+            printer.print_record proxy_config.attrs
           end
 
           private
 
           def proxy_config
-            @proxy_config ||= find_proxy_config 
-          end
-
-          def find_proxy_config
-            if proxy_config_version == "latest"
-              find_proxy_config_latest
+            if proxy_config_version_option == 'latest'
+              proxy_config_latest
             else
-              find_proxy_config_version
+              proxy_config_version
             end
           end
 
-          def find_proxy_config_version
-            Entities::ProxyConfig.find(service: service, environment: proxy_config_environment, version: proxy_config_version).tap do |pc|
+          def proxy_config_version
+            Entities::ProxyConfig.find(service: service, environment: proxy_config_environment, version: proxy_config_version_option).tap do |pc|
               raise ThreeScaleToolbox::Error, "ProxyConfig #{proxy_config_environment} in service #{service.id} does not exist" if pc.nil?
             end
           end
 
-          def find_proxy_config_latest
+          def proxy_config_latest
             Entities::ProxyConfig.find_latest(service: service, environment: proxy_config_environment).tap do |pc|
               raise ThreeScaleToolbox::Error, "ProxyConfig #{proxy_config_environment} in service #{service.id} does not exist" if pc.nil?
             end
@@ -55,25 +53,20 @@ module ThreeScaleToolbox
             @remote ||= threescale_client(arguments[:remote])
           end
 
-          def proxy_config_version
-            options[:'config-version'] || "latest"
+          def proxy_config_version_option
+            options[:'config-version']
           end
 
           def proxy_config_environment
             arguments[:environment]
           end
 
-          def print_proxy_config
-            puts JSON.pretty_generate(proxy_config.attrs)    
-          end
-
           def service_ref
             arguments[:service_ref]
           end
 
           def find_service
-            Entities::Service.find(remote: remote,
-                                   ref: service_ref).tap do |svc|
+            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
@@ -81,8 +74,12 @@ module ThreeScaleToolbox
           def service
             @service ||= find_service
           end
+
+          def printer
+            options.fetch(:output, CLI::JsonPrinter.new)
+          end
         end
       end
     end
   end
-end
+end

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

@@ -5,6 +5,7 @@ require '3scale_toolbox/commands/service_command/show_command'
 require '3scale_toolbox/commands/service_command/delete_command'
 require '3scale_toolbox/commands/service_command/create_command'
 require '3scale_toolbox/commands/service_command/apply_command'
+require '3scale_toolbox/commands/service_command/copy_command'
 
 module ThreeScaleToolbox
   module Commands
@@ -24,11 +25,12 @@ module ThreeScaleToolbox
         end
       end
 
-      add_subcommand(List::ListSubcommand)
-      add_subcommand(Show::ShowSubcommand)
-      add_subcommand(Delete::DeleteSubcommand)
-      add_subcommand(Create::CreateSubcommand)
-      add_subcommand(Apply::ApplySubcommand)
+      add_subcommand(ListSubcommand)
+      add_subcommand(ShowSubcommand)
+      add_subcommand(DeleteSubcommand)
+      add_subcommand(CreateSubcommand)
+      add_subcommand(ApplySubcommand)
+      add_subcommand(CopySubcommand)
     end
   end
 end

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

@@ -1,75 +1,86 @@
 module ThreeScaleToolbox
   module Commands
     module ServiceCommand
-      module Apply
-        class ApplySubcommand < Cri::CommandRunner
-          include ThreeScaleToolbox::Command
-
-          def self.command
-            Cri::Command.define do
-              name        'apply'
-              usage       'apply <remote> <service-id_or_system-name>'
-              summary     'Update service'
-              description "Update (create if it does not exist) service"
-              runner ApplySubcommand
-
-              param   :remote
-              param   :service_id_or_system_name
-
-              option :d, :'deployment-mode', "Specify the deployment mode of the service", argument: :required
-              option :n, :name, "Specify the name of the metric", 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 CustomPrinter
+        attr_reader :option_default, :option_disabled
 
-          def run
-            res = service
-            if res.nil?
-              res = Entities::Service.create(remote: remote, service_params: create_service_attrs)
-            else
-              res.update(service_attrs) unless service_attrs.empty?
-            end
+        def print_record(service)
+          puts "Applied Service id: #{service['id']}"
+        end
 
-            output_msg_array = ["Applied Service id: #{res.id}"]
-            puts output_msg_array
-          end
+        def print_collection(collection) end
+      end
 
-          private
+      class ApplySubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
 
-          def remote
-            @remote ||= threescale_client(arguments[:remote])
-          end
+        def self.command
+          Cri::Command.define do
+            name        'apply'
+            usage       'apply <remote> <service-id_or_system-name>'
+            summary     'Update service'
+            description "Update (create if it does not exist) service"
 
-          def ref
-            @ref ||= arguments[:service_id_or_system_name]
-          end
+            param   :remote
+            param   :service_id_or_system_name
 
-          def service
-            @service ||= find_service
-          end
+            ThreeScaleToolbox::CLI.output_flag(self)
+            option :d, :'deployment-mode', "Specify the deployment mode of the service", argument: :required
+            option :n, :name, "Specify the name of the metric", 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
 
-          def find_service
-            Entities::Service::find(remote: remote, ref: ref)
+            runner ApplySubcommand
           end
+        end
 
-          def service_attrs
-            {
-              "deployment_option" => options[:'deployment-mode'],
-              "backend_version" => options[:'authentication-mode'],
-              "description" => options[:description],
-              "support_email" => options[:'support-email'],
-              "name" => options[:name],
-            }.compact
+        def run
+          service = Entities::Service.find(remote: remote, ref: ref)
+          if service.nil?
+            service = Entities::Service.create(remote: remote,
+                                               service_params: create_attrs)
+          else
+            service.update(update_attrs) unless update_attrs.empty?
           end
 
-          def create_service_attrs
-            service_attrs.merge(
-              "system_name" => ref,
-              "name" => ref
-            ) { |_key, oldval, _newval| oldval } # receiver of the merge message has key priority
-          end
+          printer.print_record service.attrs
+        end
+
+        private
+
+        def remote
+          @remote ||= threescale_client(arguments[:remote])
+        end
+
+        def ref
+          @ref ||= arguments[:service_id_or_system_name]
+        end
+
+        def base_service_attrs
+          {
+            "deployment_option" => options[:'deployment-mode'],
+            "backend_version" => options[:'authentication-mode'],
+            "description" => options[:description],
+            "support_email" => options[:'support-email'],
+            "name" => options[:name],
+          }.compact
+        end
+
+        def update_attrs
+          base_service_attrs
+        end
+
+        def create_attrs
+          base_service_attrs.merge(
+            "system_name" => ref,
+            "name" => ref
+          ) { |_key, oldval, _newval| oldval } # receiver of the merge message has key priority
+        end
+
+        def printer
+          # keep backwards compatibility
+          options.fetch(:output, CustomPrinter.new)
         end
       end
     end

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