3scale_toolbox 0.15.0 → 0.18.2

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

@@ -0,0 +1,82 @@
+require '3scale_toolbox/commands/product_command/copy_command/delete_target_backend_usages_task'
+require '3scale_toolbox/commands/product_command/copy_command/copy_backends_task'
+
+module ThreeScaleToolbox
+  module Commands
+    module ProductCommand
+      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-product>'
+            summary     'Copy product'
+            description <<-HEREDOC
+            This command makes a copy of the referenced product.
+            Target product will be searched by source product system name. System name can be overriden with `--target-system-name` option.
+            If a product with the selected `system_name` is not found, it will be created.
+            \n Components of the product being copied:
+            \nproduct configuration
+            \nproduct settings
+            \nproduct methods&metrics: Only missing metrics&methods will be created.
+            \nproduct mapping rules: Only missing mapping rules will be created.
+            \nproduct application plans & pricing rules & limits: Only missing application plans & pricing rules & limits will be created.
+            \nproduct application usage rules
+            \nproduct policies
+            \nproduct backends: Only missing backends will be created.
+            \nproduct activedocs: Only missing activedocs 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_product
+
+            runner CopySubcommand
+          end
+        end
+
+        def self.workflow(context)
+          tasks = []
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CreateOrUpdateTargetServiceTask.new(context)
+          tasks << CopyCommand::DeleteExistingTargetBackendUsagesTask.new(context)
+          tasks << CopyCommand::CopyBackendsTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CopyServiceProxyTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CopyMethodsTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CopyMetricsTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::DestroyMappingRulesTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CopyMappingRulesTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CopyApplicationPlansTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CopyLimitsTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CopyPoliciesTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CopyPricingRulesTask.new(context)
+          tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CopyActiveDocsTask.new(context)
+          tasks.each(&:call)
+
+          # This should be the last step
+          ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::BumpProxyVersionTask.new(service: context[:target]).call
+        end
+
+        def run
+          self.class.workflow(context)
+        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_product],
+            option_target_system_name: options[:'target-system-name']
+          }
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/product_command/copy_command/copy_backends_task.rb

@@ -0,0 +1,88 @@
+module ThreeScaleToolbox
+  module Commands
+    module ProductCommand
+      module CopyCommand
+        class CopyBackendsTask
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+
+          # entrypoint
+          def call
+            backend_list = source.backend_usage_list
+            backend_list.each(&method(:create_backend))
+            logger.info "created/upated #{backend_list.size} backends"
+          end
+
+          private
+
+          def create_backend(backend_usage)
+            source_backend = Entities::Backend.new(id: backend_usage.backend_id, remote: source_remote)
+            backend_context = create_backend_context(source_backend)
+
+            tasks = []
+            tasks << Commands::BackendCommand::CopyCommand::CreateOrUpdateTargetBackendTask.new(backend_context)
+            # First metrics as methods need 'hits' metric in target backend
+            tasks << Commands::BackendCommand::CopyCommand::CopyMetricsTask.new(backend_context)
+            tasks << Commands::BackendCommand::CopyCommand::CopyMethodsTask.new(backend_context)
+            tasks << Commands::BackendCommand::CopyCommand::CopyMappingRulesTask.new(backend_context)
+            tasks.each(&:call)
+
+            # CreateOrUpdate task will keep reference of the target backend in
+            # backend_context[:target_backend]
+            target_backend = backend_context[:target_backend]
+            attrs = {
+              'backend_api_id' => target_backend.id,
+              'path' => backend_usage.path
+            }
+            # It is assumed there is no target backend usage with this backend_source's path
+            # DeleteExistingTargetBackendUsagesTask should provide that
+            Entities::BackendUsage.create(product: target, attrs: attrs)
+
+            backends_report.merge!(target_backend.system_name => backend_context.fetch(:report))
+          end
+
+          def source
+            context[:source]
+          end
+
+          def target
+            context[:target]
+          end
+
+          def source_remote
+            context[:source_remote]
+          end
+
+          def target_remote
+            context[:target_remote]
+          end
+
+          def backends_report
+            report['backends'] ||= {}
+          end
+
+          def report
+            context.fetch(:report)
+          end
+
+          def logger
+            context.fetch(:logger)
+          end
+
+          def create_backend_context(source_backend)
+            {
+              source_remote: source_remote,
+              target_remote: target_remote,
+              source_backend: source_backend,
+              source_backend_ref: source_backend.id,
+              logger: logger
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/product_command/copy_command/delete_target_backend_usages_task.rb

@@ -0,0 +1,48 @@
+module ThreeScaleToolbox
+  module Commands
+    module ProductCommand
+      module CopyCommand
+        class DeleteExistingTargetBackendUsagesTask
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+
+          # entrypoint
+          def call
+            conflicting_target_backend_usage_list.each(&:delete)
+          end
+
+          private
+
+          # List of target backend usage items that match source backend usage paths
+          def conflicting_target_backend_usage_list
+            # Compute array intersection
+            target_backend_usage_list.select do |target_usage|
+              source_backend_usage_list.find do |source_usage|
+                target_usage.path == source_usage.path
+              end
+            end
+          end
+
+          def source_backend_usage_list
+            @source_backend_usage_list ||= source.backend_usage_list
+          end
+
+          def target_backend_usage_list
+            @target_backend_usage_list ||= target.backend_usage_list
+          end
+
+          def target
+            context[:target]
+          end
+
+          def source
+            context[:source]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module ThreeScaleToolbox
+  module Commands
+    module ProductCommand
+      class ExportSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        def self.command
+          Cri::Command.define do
+            name        'export'
+            usage       'export [opts] <remote> <product>'
+            summary     'Export product to serialized format'
+            description 'This command serializes the referenced product and associated backends into a yaml format'
+
+            option      :f, :file, 'Write to file instead of stdout', argument: :required
+            param       :remote
+            param       :product_ref
+
+            runner ExportSubcommand
+          end
+        end
+
+        def run
+          select_output do |output|
+            output.write(serialized_object.to_yaml)
+          end
+        end
+
+        private
+
+        def remote
+          @remote ||= threescale_client(arguments[:remote])
+        end
+
+        def serialized_object
+          {
+            'apiVersion' => 'v1',
+            'kind' => 'List',
+            'items' => [product.to_cr] + product_backends.map(&:to_cr)
+          }
+        end
+
+        def select_output
+          ios = if file
+                  File.open(file, 'w')
+                else
+                  $stdout
+                end
+          begin
+            yield(ios)
+          ensure
+            ios.close
+          end
+        end
+
+        def product
+          @product ||= find_product
+        end
+
+        def product_backends
+          product.backend_usage_list.map do |backend_usage|
+            Entities::Backend.new(id: backend_usage.backend_id, remote: remote)
+          end
+        end
+
+        def product_ref
+          arguments[:product_ref]
+        end
+
+        def find_product
+          Entities::Service.find(remote: remote, ref: product_ref).tap do |prd|
+            raise ThreeScaleToolbox::Error, "Product #{product_ref} does not exist" if prd.nil?
+          end
+        end
+
+        def file
+          options[:file]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+module ThreeScaleToolbox
+  module Commands
+    module ProductCommand
+      class ImportSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+        include ThreeScaleToolbox::ResourceReader
+
+        def self.command
+          Cri::Command.define do
+            name        'import'
+            usage       'import [opts] <remote>'
+            summary     'Import product from serialized format'
+            description 'This command deserializes one product and associated backends'
+
+            option      :f, :file, 'Read from file instead of stdin', argument: :required
+            ThreeScaleToolbox::CLI.output_flag(self)
+            param       :remote
+
+            runner ImportSubcommand
+          end
+        end
+
+        def run
+          validate_artifacts_resource!
+
+          product_list.each do |product|
+            context = {
+                target_remote: remote,
+                source_remote: crd_remote,
+                source_service_ref: product.system_name,
+                logger: Logger.new(File::NULL)
+            }
+
+            Commands::ProductCommand::CopySubcommand.workflow(context)
+
+            report[product.system_name] = context.fetch(:report)
+          end
+
+          printer.print_collection report
+        end
+
+        private
+
+        def crd_remote
+          @crd_remote ||= CRD::Remote.new(product_list, backend_list)
+        end
+
+        def product_list
+          @product_list ||= product_resources.map do |product_cr|
+            CRD::ProductParser.new product_cr
+          end
+        end
+
+        def backend_list
+          @backend_list ||= backend_resources.map do |backend_cr|
+            CRD::BackendParser.new backend_cr
+          end
+        end
+
+        def validate_artifacts_resource!
+          # TODO: Add openapiV3 validation
+          # https://github.com/3scale/3scale-operator/blob/3scale-2.10.0-CR2/deploy/crds/capabilities.3scale.net_backends_crd.yaml
+          # https://github.com/3scale/3scale-operator/blob/3scale-2.10.0-CR2/deploy/crds/capabilities.3scale.net_products_crd.yaml
+          validate_api_version!
+
+          validate_kind!
+        end
+
+        def validate_api_version!
+          artifacts_resource.fetch('apiVersion') do
+            raise ThreeScaleToolbox::Error, 'Invalid content. apiVersion not found'
+          end
+
+          raise ThreeScaleToolbox::Error, 'Invalid content. apiVersion wrong value ' unless artifacts_resource.fetch('apiVersion') == 'v1'
+        end
+
+        def validate_kind!
+          artifacts_resource.fetch('kind') do
+            raise ThreeScaleToolbox::Error, 'Invalid content. kind not found'
+          end
+
+          raise ThreeScaleToolbox::Error, 'Invalid content. kind wrong value ' unless artifacts_resource.fetch('kind') == 'List'
+        end
+
+        def artifacts_resource_items
+          artifacts_resource.fetch('items') do
+            raise ThreeScaleToolbox::Error, 'Invalid content. items not found'
+          end
+        end
+
+        def product_resources
+          artifacts_resource_items.select do |item|
+            item.respond_to?(:has_key?) &&
+              item.fetch('apiVersion', '').include?('capabilities.3scale.net') &&
+              item['kind'] == 'Product'
+          end
+        end
+
+        def backend_resources
+          artifacts_resource_items.select do |item|
+            item.respond_to?(:has_key?) &&
+              item.fetch('apiVersion', '').include?('capabilities.3scale.net') &&
+              item['kind'] == 'Backend'
+          end
+        end
+
+        def artifacts_resource
+          @artifacts_resource ||= load_resource(options[:file] || '-')
+        end
+
+        def report
+          @report ||= {}
+        end
+
+        def remote
+          @remote ||= threescale_client(arguments[:remote])
+        end
+
+        def printer
+          options.fetch(:output, CLI::JsonPrinter.new)
+        end
+      end
+    end
+  end
+end

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