3scale_toolbox 0.17.1 → 0.18.0

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

@@ -1,4 +1,6 @@
 require '3scale_toolbox/commands/product_command/copy_command'
+require '3scale_toolbox/commands/product_command/export_command'
+require '3scale_toolbox/commands/product_command/import_command'
 
 module ThreeScaleToolbox
   module Commands
@@ -17,6 +19,8 @@ module ThreeScaleToolbox
         end
       end
       add_subcommand(CopySubcommand)
+      add_subcommand(ExportSubcommand)
+      add_subcommand(ImportSubcommand)
     end
   end
 end

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

@@ -22,8 +22,8 @@ module ThreeScaleToolbox
             \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 application usage rules
+            \nproduct policies
             \nproduct backends: Only missing backends will be created.
             \nproduct activedocs: Only missing activedocs will be created.
             HEREDOC
@@ -37,7 +37,7 @@ module ThreeScaleToolbox
           end
         end
 
-        def run
+        def self.workflow(context)
           tasks = []
           tasks << ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::CreateOrUpdateTargetServiceTask.new(context)
           tasks << CopyCommand::DeleteExistingTargetBackendUsagesTask.new(context)
@@ -58,6 +58,10 @@ module ThreeScaleToolbox
           ThreeScaleToolbox::Commands::ServiceCommand::CopyCommand::BumpProxyVersionTask.new(service: context[:target]).call
         end
 
+        def run
+          self.class.workflow(context)
+        end
+
         private
 
         def context

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

@@ -13,14 +13,14 @@ module ThreeScaleToolbox
           def call
             backend_list = source.backend_usage_list
             backend_list.each(&method(:create_backend))
-            puts "created/upated #{backend_list.size} backends"
+            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.system_name)
+            backend_context = create_backend_context(source_backend)
 
             tasks = []
             tasks << Commands::BackendCommand::CopyCommand::CreateOrUpdateTargetBackendTask.new(backend_context)
@@ -32,13 +32,16 @@ module ThreeScaleToolbox
 
             # CreateOrUpdate task will keep reference of the target backend in
             # backend_context[:target_backend]
+            target_backend = backend_context[:target_backend]
             attrs = {
-              'backend_api_id' => backend_context[:target_backend].id,
+              '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
@@ -57,11 +60,25 @@ module ThreeScaleToolbox
             context[:target_remote]
           end
 
-          def create_backend_context(source_backend_system_name)
+          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_ref: source_backend_system_name
+              source_backend: source_backend,
+              source_backend_ref: source_backend.id,
+              logger: logger
             }
           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('/dev/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

@@ -5,6 +5,7 @@ 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
@@ -28,6 +29,7 @@ module ThreeScaleToolbox
       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/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