3scale_toolbox 0.15.0 → 0.16.0

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

@@ -14,10 +14,12 @@ module ThreeScaleToolbox
               summary     'list applications'
               description 'List applications'
 
-              param       :remote
               option      nil, :account, 'Filter by account', argument: :required
               option      nil, :service, 'Filter by service', argument: :required
               option      nil, :plan, 'Filter by application plan. Service option required', argument: :required
+              ThreeScaleToolbox::CLI.output_flag(self)
+
+              param       :remote
 
               runner ListSubcommand
             end
@@ -35,8 +37,8 @@ module ThreeScaleToolbox
                            else
                              provider_account_applications
                            end
-            print_header
-            print_data(applications)
+
+            printer.print_collection applications.map(&:attrs)
           end
 
           private
@@ -72,16 +74,6 @@ module ThreeScaleToolbox
             options[:plan]
           end
 
-          def print_header
-            puts FIELDS_TO_SHOW.map(&:upcase).join("\t")
-          end
-
-          def print_data(applications)
-            applications.each do |app|
-              puts FIELDS_TO_SHOW.map { |field| app.attrs.fetch(field, '(empty)') }.join("\t")
-            end
-          end
-
           def service
             @service ||= find_service
           end
@@ -117,6 +109,11 @@ module ThreeScaleToolbox
           def remote
             @remote ||= threescale_client(arguments[:remote])
           end
+
+          def printer
+            # keep backwards compatibility
+            options.fetch(:output, CLI::CustomTablePrinter.new(FIELDS_TO_SHOW))
+          end
         end
       end
     end

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

@@ -21,6 +21,8 @@ module ThreeScaleToolbox
               \n * Application internal id
               HEREDOC
 
+              ThreeScaleToolbox::CLI.output_flag(self)
+
               param       :remote
               param       :application
 
@@ -29,24 +31,11 @@ module ThreeScaleToolbox
           end
 
           def run
-            print_header
-            print_data
+            printer.print_record application.attrs
           end
 
           private
 
-          def print_header
-            puts FIELDS_TO_SHOW.map(&:upcase).join("\t")
-          end
-
-          def print_data
-            puts FIELDS_TO_SHOW.map { |field| app_attrs.fetch(field, '(empty)') }.join("\t")
-          end
-
-          def app_attrs
-            @app_attrs ||= application.attrs
-          end
-
           def application
             @application ||= find_application
           end
@@ -64,6 +53,11 @@ module ThreeScaleToolbox
           def remote
             @remote ||= threescale_client(arguments[:remote])
           end
+
+          def printer
+            # keep backwards compatibility
+            options.fetch(:output, CLI::CustomTablePrinter.new(FIELDS_TO_SHOW))
+          end
         end
       end
     end

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

@@ -0,0 +1,22 @@
+require '3scale_toolbox/commands/backend_command/copy_command'
+
+module ThreeScaleToolbox
+  module Commands
+    module BackendCommand
+      include ThreeScaleToolbox::Command
+      def self.command
+        Cri::Command.define do
+          name        'backend'
+          usage       'backend <sub-command> [options]'
+          summary     'backend super command'
+          description 'Backend commands'
+
+          run do |_opts, _args, cmd|
+            puts cmd.help
+          end
+        end
+      end
+      add_subcommand(CopySubcommand)
+    end
+  end
+end

data/lib/3scale_toolbox/commands/backend_command/copy_command.rb

@@ -0,0 +1,65 @@
+require '3scale_toolbox/commands/backend_command/copy_command/task'
+require '3scale_toolbox/commands/backend_command/copy_command/create_or_update_target_backend_task'
+require '3scale_toolbox/commands/backend_command/copy_command/copy_metrics_task'
+require '3scale_toolbox/commands/backend_command/copy_command/copy_methods_task'
+require '3scale_toolbox/commands/backend_command/copy_command/copy_mapping_rules_task'
+
+module ThreeScaleToolbox
+  module Commands
+    module BackendCommand
+      class CopySubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        def self.command
+          Cri::Command.define do
+            name        'copy'
+            usage       'copy [opts] -s <source-remote> -d <target-remote> <source-backend>'
+            summary     'Copy backend'
+            description <<-HEREDOC
+            This command makes a copy of the referenced backend.
+            Target backend will be searched by source backend system name. System name can be overriden with `--target-system-name` option.
+            If a backend with the selected `system-name` is not found, it will be created.
+            \n Components of the backend being copied:
+            \nmetrics
+            \nmethods
+            \nmapping rules
+            \n\n If a backend with the selected `system-name` is found, it will be updated. Only missing metrics, methods and mapping rules will be created.
+            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
+            param   :source_backend
+
+            runner CopySubcommand
+          end
+        end
+
+        def run
+          tasks = []
+          tasks << CopyCommand::CreateOrUpdateTargetBackendTask.new(context)
+          # First metrics as methods need 'hits' metric in target backend
+          tasks << CopyCommand::CopyMetricsTask.new(context)
+          tasks << CopyCommand::CopyMethodsTask.new(context)
+          tasks << CopyCommand::CopyMappingRulesTask.new(context)
+          tasks.each(&: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_backend_ref: arguments[:source_backend],
+            option_target_system_name: options[:'target-system-name']
+          }
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/backend_command/copy_command/copy_mapping_rules_task.rb

@@ -0,0 +1,52 @@
+module ThreeScaleToolbox
+  module Commands
+    module BackendCommand
+      module CopyCommand
+        class CopyMappingRulesTask
+          include Task
+
+          # entrypoint
+          def run
+            missing_rules = missing_mapping_rules(source_backend.mapping_rules,
+                                                  target_backend.mapping_rules, metrics_map)
+            missing_rules.each do |mapping_rule|
+              mapping_rule.metric_id = metrics_map.fetch(mapping_rule.metric_id)
+              Entities::BackendMappingRule.create(backend: target_backend,
+                                                  attrs: mapping_rule.attrs)
+            end
+            puts "created #{missing_rules.size} mapping rules"
+          end
+
+          private
+
+          def metrics_map
+            @metrics_map ||= build_metrics_mapping
+          end
+
+          def build_metrics_mapping
+            target_mm = target_metrics + target_methods
+            source_mm = source_metrics + source_methods
+            target_mm.map do |target|
+              source = source_mm.find do |m|
+                m.system_name == target.system_name
+              end
+              next if source.nil?
+
+              [source.id, target.id]
+            end.compact.to_h
+          end
+
+          def missing_mapping_rules(source_rules, target_rules, metrics_map)
+            ThreeScaleToolbox::Helper.array_difference(source_rules, target_rules) do |source, target|
+              # map metric_id to the target backend domain
+              source_attrs = source.attrs.merge('metric_id' => metrics_map.fetch(source.metric_id))
+              ThreeScaleToolbox::Helper.compare_hashes(source_attrs,
+                                                       target.attrs,
+                                                       %w[pattern http_method delta metric_id])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module ThreeScaleToolbox
+  module Commands
+    module BackendCommand
+      module CopyCommand
+        class CopyMethodsTask
+          include Task
+
+          # entrypoint
+          def run
+            missing_methods.each(&method(:create_method))
+            puts "created #{missing_methods.size} missing methods"
+            invalidate_target_methods if missing_methods.size.positive?
+          end
+
+          private
+
+          def create_method(method)
+            # return silently if target metric hits does not exist
+            return if target_hits.nil?
+
+            Entities::BackendMethod.create(backend: target_backend,
+                                           parent_id: target_hits.id,
+                                           attrs:  method.attrs)
+          rescue ThreeScaleToolbox::ThreeScaleApiError => e
+            raise e unless ThreeScaleToolbox::Helper.system_name_already_taken_error?(e.apierrors)
+
+            warn "[WARN] backend method #{method.attrs.fetch('system_name')} not created. " \
+              'Backend metric with the same system_name exists.'
+          end
+
+          def missing_methods
+            @missing_methods ||= ThreeScaleToolbox::Helper.array_difference(source_methods, target_methods) do |source, target|
+              source.system_name == target.system_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/backend_command/copy_command/copy_metrics_task.rb

@@ -0,0 +1,30 @@
+module ThreeScaleToolbox
+  module Commands
+    module BackendCommand
+      module CopyCommand
+        class CopyMetricsTask
+          include Task
+
+          # entrypoint
+          def run
+            missing_metrics.each(&method(:create_metric))
+            puts "created #{missing_metrics.size} missing metrics"
+            invalidate_target_metrics if missing_metrics.size.positive?
+          end
+
+          private
+
+          def create_metric(metric)
+            Entities::BackendMetric.create(backend: target_backend, attrs: metric.attrs)
+          end
+
+          def missing_metrics
+            @missing_metrics ||= ThreeScaleToolbox::Helper.array_difference(source_metrics, target_metrics) do |source, target|
+              source.system_name == target.system_name
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/backend_command/copy_command/create_or_update_target_backend_task.rb

@@ -0,0 +1,45 @@
+module ThreeScaleToolbox
+  module Commands
+    module BackendCommand
+      module CopyCommand
+        class CreateOrUpdateTargetBackendTask
+          include Task
+
+          # entrypoint
+          def run
+            backend = Entities::Backend.find(remote: target_remote, ref: target_backend_ref)
+
+            if backend.nil?
+              backend = Entities::Backend.create(remote: target_remote,
+                                                 attrs: create_attrs)
+            elsif backend == source_backend
+              message = 'source and destination backends are the same: ' \
+                "ID: #{source_backend.id} system_name: #{source_backend.attrs['system_name']}"
+              warn "\e[1m\e[31mWarning: #{message}\e[0m"
+            else
+              backend.update update_attrs
+            end
+
+            # assign target backend for other tasks to have it available
+            self.target_backend = backend
+
+            puts "source backend ID: #{source_backend.id} system_name: #{source_backend.attrs['system_name']}"
+            puts "target backend ID: #{target_backend.id} system_name: #{target_backend.attrs['system_name']}"
+          end
+
+          def create_attrs
+            source_backend.attrs.merge('system_name' => target_backend_ref)
+          end
+
+          def update_attrs
+            source_backend.attrs.merge('system_name' => target_backend_ref)
+          end
+
+          def target_backend_ref
+            option_target_system_name || source_backend.attrs.fetch('system_name')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module ThreeScaleToolbox
+  module Commands
+    module BackendCommand
+      module CopyCommand
+        module Task
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+
+          def call
+            run
+          end
+
+          def target_backend=(target)
+            context[:target_backend] = target
+          end
+
+          def target_backend
+            context[:target_backend] ||= raise ThreeScaleToolbox::Error, 'Unexpected error. ' \
+              'Target backend should have been created or updated'
+          end
+
+          def source_backend
+            context[:source_backend] ||= find_source_backend
+          end
+
+          def source_methods
+            context[:source_methods] ||= source_backend.methods(source_hits)
+          end
+
+          def source_hits
+            context[:source_hits] ||= source_backend.hits
+          end
+
+          def source_metrics
+            context[:source_metrics] ||= source_backend.metrics
+          end
+
+          def target_metrics
+            context[:target_metrics] ||= target_backend.metrics
+          end
+
+          def target_hits
+            context[:target_hits] ||= target_backend.hits
+          end
+
+          def target_methods
+            context[:target_methods] ||= target_backend.methods(target_hits)
+          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_backend_ref
+            context[:source_backend_ref] ||= raise ThreeScaleToolbox::Error, 'Unexpected error. ' \
+              'source_backend_ref not found'
+          end
+
+          def option_target_system_name
+            context[:option_target_system_name]
+          end
+
+          private
+
+          def find_source_backend
+            Entities::Backend.find(remote: source_remote, ref: source_backend_ref).tap do |backend|
+              raise ThreeScaleToolbox::Error, "Backend #{source_backend_ref} does not exist" if backend.nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end