3scale_toolbox 0.5.1 → 0.6.0

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

@@ -1,20 +1,22 @@
 require 'cri'
 require '3scale_toolbox/base_command'
 require '3scale_toolbox/commands/import_command/import_csv'
+require '3scale_toolbox/commands/import_command/openapi'
 
 module ThreeScaleToolbox
   module Commands
     module ImportCommand
-      extend ThreeScaleToolbox::Command
+      include ThreeScaleToolbox::Command
       def self.command
         Cri::Command.define do
           name        'import'
-          usage       'import <command> [options]'
-          summary     '3scale import command'
-          description '3scale import command.'
+          usage       'import <sub-command> [options]'
+          summary     'import super command'
+          description 'Importing 3scale entities'
         end
       end
       add_subcommand(ImportCsvSubcommand)
+      add_subcommand(OpenAPI::OpenAPISubcommand)
     end
   end
 end

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

@@ -7,45 +7,24 @@ require '3scale_toolbox/base_command'
 module ThreeScaleToolbox
   module Commands
     module ImportCommand
-      module ImportCsvSubcommand
-        extend ThreeScaleToolbox::Command
+      class ImportCsvSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
         def self.command
           Cri::Command.define do
             name        'csv'
             usage       'csv [opts] -d <dst> -f <file>'
-            summary     'Import csv file'
+            summary     'import csv file'
             description 'Create new services, metrics, methods and mapping rules from CSV formatted file'
 
-            required  :d, :destination, '3scale target instance. Format: "http[s]://<provider_key>@3scale_url"'
-            required  :f, 'file', 'CSV formatted file'
+            option  :d, :destination, '3scale target instance. Url or remote name', argument: :required
+            option  :f, 'file', 'CSV formatted file', argument: :required
 
-            run do |opts, args, _|
-              ImportCsvSubcommand.run opts, args
-            end
+            runner ImportCsvSubcommand
           end
         end
 
-        def self.exit_with_message(message)
-          puts message
-          exit 1
-        end
-
-        def self.fetch_required_option(options, key)
-          options.fetch(key) { exit_with_message "error: Missing argument #{key}" }
-        end
-
-        def self.provider_key_from_url(url)
-          URI(url).user
-        end
-
-        def self.endpoint_from_url(url)
-          uri      = URI(url)
-          uri.user = nil
-
-          uri.to_s
-        end
-
-        def self.auth_app_key_according_service(service)
+        def auth_app_key_according_service(service)
           case service['backend_version']
           when '1'
             'user_key'
@@ -56,14 +35,9 @@ module ThreeScaleToolbox
           end
         end
 
-        def self.import_csv(destination, file_path, insecure)
-          endpoint     = endpoint_from_url destination
-          provider_key = provider_key_from_url destination
+        def import_csv(destination, file_path)
+          client = threescale_client(destination)
 
-          client   = ThreeScale::API.new(endpoint: endpoint,
-                                         provider_key: provider_key,
-                                         verify_ssl: !insecure
-                                        )
           data     = CSV.read file_path
           headings = data.shift
           services = {}
@@ -163,11 +137,11 @@ module ThreeScaleToolbox
           puts "#{stats[:mapping_rules]} mapping rules have been created"
         end
 
-        def self.run(opts, _)
-          destination = fetch_required_option(opts, :destination)
-          file_path = fetch_required_option(opts, :file)
-          insecure = opts[:insecure] || false
-          import_csv(destination, file_path, insecure)
+        def run
+          destination = fetch_required_option(:destination)
+          file_path = fetch_required_option(:file)
+
+          import_csv(destination, file_path)
         end
       end
     end

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

@@ -0,0 +1,70 @@
+require 'swagger'
+require '3scale_toolbox/commands/import_command/openapi/method'
+require '3scale_toolbox/commands/import_command/openapi/mapping_rule'
+require '3scale_toolbox/commands/import_command/openapi/operation'
+require '3scale_toolbox/commands/import_command/openapi/step'
+require '3scale_toolbox/commands/import_command/openapi/resource_reader'
+require '3scale_toolbox/commands/import_command/openapi/threescale_api_spec'
+require '3scale_toolbox/commands/import_command/openapi/create_method_step'
+require '3scale_toolbox/commands/import_command/openapi/create_mapping_rule_step'
+require '3scale_toolbox/commands/import_command/openapi/create_service_step'
+
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        class OpenAPISubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+          include ResourceReader
+
+          def self.command
+            Cri::Command.define do
+              name        'openapi'
+              usage       'openapi [opts] -d <dst> <spec>'
+              summary     'Import API defintion in OpenAPI specification'
+              description 'Using an API definition format like OpenAPI, import to your 3scale API'
+
+              option  :d, :destination, '3scale target instance. Format: "http[s]://<authentication>@3scale_domain"', argument: :required
+              option  :t, 'target_system_name', 'Target system name', argument: :required
+              param   :openapi_resource
+
+              runner OpenAPISubcommand
+            end
+          end
+
+          def run
+            context = create_context
+
+            tasks = []
+            tasks << CreateServiceStep.new(context)
+            tasks << CreateMethodsStep.new(context)
+            tasks << ThreeScaleToolbox::Tasks::DestroyMappingRulesTask.new(context)
+            tasks << CreateMappingRulesStep.new(context)
+
+            # run tasks
+            tasks.each(&:call)
+          end
+
+          private
+
+          def create_context
+            {
+              api_spec: ThreeScaleApiSpec.new(load_openapi),
+              threescale_client: threescale_client(fetch_required_option(:destination)),
+              target_system_name: options[:target_system_name]
+            }
+          end
+
+          def load_openapi
+            Swagger.build(load_resource(arguments[:openapi_resource]))
+            # Disable validation step because https://petstore.swagger.io/v2/swagger.json
+            # does not pass validation. Maybe library's schema is outdated?
+            # openapi.tap(&:validate)
+          rescue Swagger::InvalidDefinition, Hashie::CoercionError, Psych::SyntaxError => e
+            raise ThreeScaleToolbox::Error, "OpenAPI schema validation failed: #{e.message}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/import_command/openapi/create_mapping_rule_step.rb

@@ -0,0 +1,18 @@
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        class CreateMappingRulesStep
+          include Step
+
+          def call
+            operations.each do |op|
+              service.create_mapping_rule(op.mapping_rule)
+              puts "Created #{op.http_method} #{op.pattern} endpoint"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/import_command/openapi/create_method_step.rb

@@ -0,0 +1,39 @@
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        class CreateMethodsStep
+          include Step
+
+          def call
+            hits_metric_id = service.hits['id']
+            operations.each do |op|
+              res = service.create_method(hits_metric_id, op.method)
+              metric_id = res['id']
+              # if method system_name exists, ignore error and get metric_id
+              # Make operation indempotent
+              unless res['errors'].nil?
+                if !res['errors']['system_name'].nil? \
+                  && res['errors']['system_name'][0] =~ /has already been taken/
+                  metric_id = method_id_by_system_name[op.method['system_name']]
+                else
+                  raise Error, "Metohd has not been saved. Errors: #{res['errors']}"
+                end
+              end
+
+              op.set(:metric_id, metric_id)
+            end
+          end
+
+          private
+
+          def method_id_by_system_name
+            @method_id_by_system_name ||= service.methods.each_with_object({}) do |method, acc|
+              acc[method['system_name']] = method['id']
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/import_command/openapi/create_service_step.rb

@@ -0,0 +1,69 @@
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        class CreateServiceStep
+          include Step
+
+          ##
+          # Creates service with a given system_name
+          # If service already exists, update basic settings like name and description
+          def call
+            # Create service and update context
+            self.service = Entities::Service.create(remote: threescale_client,
+                                                    service: service_settings,
+                                                    system_name: service_system_name)
+            puts "Created service id: #{service.id}, name: #{service_name}"
+          rescue ThreeScaleToolbox::Error => e
+            raise unless e.message =~ /"system_name"=>\["has already been taken"\]/
+
+            # Update service and update context
+            self.service = Entities::Service.new(id: service_id, remote: threescale_client)
+            service.update_service(service_settings)
+            puts "Updated service id: #{service.id}, name: #{service_name}"
+          end
+
+          private
+
+          def service_system_name
+            target_system_name || service_name.downcase.tr(' ', '_')
+          end
+
+          def service_id
+            @service_id ||= fetch_service_id
+          end
+
+          def fetch_service_id
+            # figure out service by system_name
+            service_found = threescale_client.list_services.find do |svc|
+              svc['system_name'] == service_system_name
+            end
+            # It should exist
+            raise ThreeScaleToolbox::Error, "Service with system_name: #{service_system_name}, should exist" if service_found.nil?
+
+            service_found['id']
+          end
+
+          def service_settings
+            default_service_settings.tap do |svc|
+              svc['name'] = service_name
+              svc['description'] = service_description
+            end
+          end
+
+          def default_service_settings
+            {}
+          end
+
+          def service_name
+            api_spec.title
+          end
+
+          def service_description
+            api_spec.description
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/import_command/openapi/mapping_rule.rb

@@ -0,0 +1,35 @@
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        module MappingRule
+          def mapping_rule
+            {
+              'pattern' => pattern,
+              'http_method' => http_method,
+              'delta' => delta,
+              'metric_id' => metric_id
+            }
+          end
+
+          def http_method
+            operation[:verb].upcase
+          end
+
+          def pattern
+            # apply strict matching
+            operation[:path] + '$'
+          end
+
+          def delta
+            1
+          end
+
+          def metric_id
+            operation[:metric_id]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/import_command/openapi/method.rb

@@ -0,0 +1,25 @@
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        module Method
+
+          def method
+            {
+              'friendly_name' => friendly_name,
+              'system_name' => system_name
+            }
+          end
+
+          def friendly_name
+            operation[:operationId]
+          end
+
+          def system_name
+            friendly_name.downcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/import_command/openapi/operation.rb

@@ -0,0 +1,22 @@
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        class Operation
+          include Method
+          include MappingRule
+
+          attr_reader :operation
+
+          def initialize(operation)
+            @operation = operation
+          end
+
+          def set(key, val)
+            operation[key] = val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/import_command/openapi/resource_reader.rb

@@ -0,0 +1,49 @@
+require 'uri'
+require 'net/http'
+
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        module ResourceReader
+          ##
+          # Load resource from different types of sources.
+          # Supported types are: file, URL, stdin
+          # Loaded content is returned
+          def load_resource(resource)
+            # Json format is parsed as well
+            YAML.safe_load(read_content(resource))
+          end
+
+          ##
+          # Reads resources from different types of sources.
+          # Supported types are: file, URL, stdin
+          # Resource raw content is returned
+          def read_content(resource)
+            case resource
+            when '-'
+              method(:read_stdin)
+            when /\A#{URI::DEFAULT_PARSER.make_regexp}\z/
+              method(:read_url)
+            else
+              method(:read_file)
+            end.call(resource)
+          end
+
+          # Detect format from file extension
+          def read_file(resource)
+            File.read(resource)
+          end
+
+          def read_stdin(_resource)
+            STDIN.read
+          end
+
+          def read_url(resource)
+            Net::HTTP.get(URI.parse(resource))
+          end
+        end
+      end
+    end
+  end
+end