3scale_toolbox 0.16.0 → 0.18.3

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

@@ -0,0 +1,98 @@
+module ThreeScaleToolbox
+  module Commands
+    module PoliciesCommand
+      class ExportSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        class JSONSerializer
+          def call(object)
+            JSON.pretty_generate(object)
+          end
+        end
+
+        class YAMLSerializer
+          def call(object)
+            YAML.dump(object)
+          end
+        end
+
+        class SerializerTransformer
+          def call(output_format)
+            raise unless %w[yaml json].include?(output_format)
+
+            case output_format
+            when 'yaml'
+              YAMLSerializer.new
+            when 'json'
+              JSONSerializer.new
+            end
+          end
+        end
+
+        def self.command
+          Cri::Command.define do
+            name        'export'
+            usage       'export [opts] <remote> <product>'
+            summary     'export product policy chain'
+            description 'export product policy chain'
+
+            option      :f, :file, 'Write to file instead of stdout', argument: :required
+            option      :o, :output, 'Output format. One of: json|yaml', argument: :required, transform: SerializerTransformer.new
+            param       :remote
+            param       :service_ref
+
+            runner ExportSubcommand
+          end
+        end
+
+        def run
+          select_output do |output|
+            output.write(serializer.call(product.policies))
+          end
+        end
+
+        private
+
+        def remote
+          @remote ||= threescale_client(arguments[:remote])
+        end
+
+        def product
+          @product ||= find_product
+        end
+
+        def service_ref
+          arguments[:service_ref]
+        end
+
+        def find_product
+          Entities::Service.find(remote: remote,
+                                 ref: service_ref).tap do |svc|
+            raise ThreeScaleToolbox::Error, "Product #{service_ref} does not exist" if svc.nil?
+          end
+        end
+
+        def file
+          options[:file]
+        end
+
+        def select_output
+          ios = if file
+                  File.open(file, 'w')
+                else
+                  $stdout
+                end
+          begin
+            yield(ios)
+          ensure
+            ios.close
+          end
+        end
+
+        def serializer
+          options.fetch(:output, YAMLSerializer.new)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module ThreeScaleToolbox
+  module Commands
+    module PoliciesCommand
+      class ImportSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+        include ThreeScaleToolbox::ResourceReader
+
+        def self.command
+          Cri::Command.define do
+            name        'import'
+            usage       'import [opts] <remote> <product>'
+            summary     'import product policy chain'
+            description 'import product policy chain'
+
+            option      :f, :file, 'Read from file', argument: :required
+            option      :u, :url, 'Read from url', argument: :required
+            param       :remote
+            param       :service_ref
+
+            runner ImportSubcommand
+          end
+        end
+
+        def run
+          res = product.update_policies('policies_config' => policies)
+          if res.is_a?(Hash) && (errors = res['errors'])
+            raise ThreeScaleToolbox::Error, "Product policies have not been imported. #{errors}"
+          end
+          if res.is_a?(Array) && (error_item = res.find { |i| i.key?('errors') })
+            raise ThreeScaleToolbox::Error, "Product policies have not been imported. #{error_item['errors']}"
+          end
+        end
+
+        private
+
+        def remote
+          @remote ||= threescale_client(arguments[:remote])
+        end
+
+        def service_ref
+          arguments[:service_ref]
+        end
+
+        def product
+          @product ||= find_product
+        end
+
+        def find_product
+          Entities::Service.find(remote: remote,
+                                 ref: service_ref).tap do |svc|
+            raise ThreeScaleToolbox::Error, "Product #{service_ref} does not exist" if svc.nil?
+          end
+        end
+
+        def policies
+          @policies ||= load_resource(options[:file] || options[:url] || '-')
+        end
+      end
+    end
+  end
+end

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(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