3scale_toolbox 0.5.1 → 0.6.0

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

@@ -0,0 +1,45 @@
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        module Step
+          attr_reader :context
+
+          def initialize(context)
+            @context = context
+          end
+
+          # Can be nil on initialization time and not nil afterwards
+          # method to fetch from context required
+          def service
+            context[:target]
+          end
+
+          def service=(service)
+            context[:target] = service
+          end
+
+          def api_spec
+            context[:api_spec]
+          end
+
+          def threescale_client
+            context[:threescale_client]
+          end
+
+          def operations
+            # api_spec.operations are readonly
+            # store operations in context
+            # each operation can be extended with extra information to be used later
+            context[:operations] ||= api_spec.operations
+          end
+
+          def target_system_name
+            # could be nil
+            context[:target_system_name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module ThreeScaleToolbox
+  module Commands
+    module ImportCommand
+      module OpenAPI
+        class ThreeScaleApiSpec
+          attr_reader :openapi
+
+          def initialize(openapi)
+            @openapi = openapi
+          end
+
+          def title
+            openapi.info.title
+          end
+
+          def description
+            openapi.info.description
+          end
+
+          def operations
+            openapi.operations.map do |op|
+              Operation.new(
+                path: "#{openapi.base_path}#{op.path}",
+                verb: op.verb,
+                operationId: op.operationId
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'cri'
+require '3scale_toolbox/base_command'
+require '3scale_toolbox/remotes'
+require '3scale_toolbox/commands/remote_command/remote_add'
+require '3scale_toolbox/commands/remote_command/remote_remove'
+require '3scale_toolbox/commands/remote_command/remote_rename'
+require '3scale_toolbox/commands/remote_command/remote_list'
+
+module ThreeScaleToolbox
+  module Commands
+    module RemoteCommand
+      class RemoteCommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        def self.command
+          Cri::Command.define do
+            name        'remote'
+            usage       'remote <sub-command> [options]'
+            summary     'remotes super command'
+            description 'Manage your remotes'
+            runner RemoteCommand
+          end
+        end
+
+        def run
+          puts command.help
+        end
+
+        add_subcommand(RemoteAddSubcommand)
+        add_subcommand(RemoteRemoveSubcommand)
+        add_subcommand(RemoteRenameSubcommand)
+        add_subcommand(RemoteListSubcommand)
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/remote_command/remote_add.rb

@@ -0,0 +1,47 @@
+module ThreeScaleToolbox
+  module Commands
+    module RemoteCommand
+      class RemoteAddSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        def self.command
+          Cri::Command.define do
+            name        'add'
+            usage       'add <name> <url>'
+            summary     'remote add'
+            description 'Add new remote to the list'
+            param       :remote_name
+            param       :remote_url
+            runner RemoteAddSubcommand
+          end
+        end
+
+        def run
+          # 'arguments' cannot be converted to Hash
+          add_remote arguments[:remote_name], arguments[:remote_url]
+        end
+
+        private
+
+        def validate_remote_name(name)
+          raise ThreeScaleToolbox::Error, 'remote name already exists.' if remotes.all.key?(name)
+        end
+
+        def validate_remote(remote_url_str)
+          # parsing url before trying to create client
+          # raises Invalid URL when syntax is incorrect
+          ThreeScaleToolbox::Helper.parse_uri(remote_url_str)
+          threescale_client(remote_url_str).list_services
+        rescue ThreeScale::API::HttpClient::ForbiddenError
+          raise ThreeScaleToolbox::Error, 'remote not valid'
+        end
+
+        def add_remote(remote_name, remote_url)
+          validate_remote_name remote_name
+          validate_remote remote_url
+          remotes.add_uri(remote_name, remote_url)
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/remote_command/remote_list.rb

@@ -0,0 +1,29 @@
+module ThreeScaleToolbox
+  module Commands
+    module RemoteCommand
+      class RemoteListSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        def self.command
+          Cri::Command.define do
+            name        'list'
+            usage       'list'
+            summary     'remote list'
+            description 'List all defined remotes'
+            runner RemoteListSubcommand
+          end
+        end
+
+        def run
+          if remotes.all.empty?
+            puts 'Empty remote list.'
+          else
+            remotes.all.each do |name, remote|
+              puts "#{name} #{remote[:endpoint]} #{remote[:authentication]}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/remote_command/remote_remove.rb

@@ -0,0 +1,26 @@
+module ThreeScaleToolbox
+  module Commands
+    module RemoteCommand
+      class RemoteRemoveSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        def self.command
+          Cri::Command.define do
+            name        'remove'
+            usage       'remove <name>'
+            summary     'remote remove'
+            description 'Remove remote from list'
+            param       :remote_name
+            runner RemoteRemoveSubcommand
+          end
+        end
+
+        def run
+          remotes.delete(arguments[:remote_name]) do |el|
+            raise ThreeScaleToolbox::Error, "could not remove remote '#{el}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/remote_command/remote_rename.rb

@@ -0,0 +1,42 @@
+module ThreeScaleToolbox
+  module Commands
+    module RemoteCommand
+      class RemoteRenameSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
+        def self.command
+          Cri::Command.define do
+            name        'rename'
+            usage       'rename <old_name> <new_name>'
+            summary     'remote rename'
+            description 'Rename remote name'
+            param       :remote_old_name
+            param       :remote_new_name
+            runner RemoteRenameSubcommand
+          end
+        end
+
+        def run
+          # 'arguments' cannot be converted to Hash
+          rename_remote arguments[:remote_old_name], arguments[:remote_new_name]
+        end
+
+        private
+
+        def validate_remote_old_name(name)
+          raise ThreeScaleToolbox::Error, "Could not rename, old name '#{name}' does not exist." unless remotes.all.key?(name)
+        end
+
+        def validate_remote_new_name(name)
+          raise ThreeScaleToolbox::Error, "Could not rename, new name '#{name}' already exists." if remotes.all.key?(name)
+        end
+
+        def rename_remote(remote_old_name, remote_new_name)
+          validate_remote_old_name remote_old_name
+          validate_remote_new_name remote_new_name
+          remotes.add(remote_new_name, remotes.delete(remote_old_name))
+        end
+      end
+    end
+  end
+end

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

@@ -5,13 +5,13 @@ require '3scale_toolbox/commands/update_command/update_service'
 module ThreeScaleToolbox
   module Commands
     module UpdateCommand
-      extend ThreeScaleToolbox::Command
+      include ThreeScaleToolbox::Command
       def self.command
         Cri::Command.define do
           name        'update'
-          usage       'update <command> [options]'
-          summary     '3scale update command'
-          description '3scale update command.'
+          usage       'update <sub-command> [options]'
+          summary     'update super command'
+          description 'Update 3scale entities between tenants'
         end
       end
       add_subcommand(UpdateServiceSubcommand)

data/lib/3scale_toolbox/commands/update_command/update_service.rb

@@ -4,253 +4,63 @@ require '3scale_toolbox/base_command'
 module ThreeScaleToolbox
   module Commands
     module UpdateCommand
-      module UpdateServiceSubcommand
-        extend ThreeScaleToolbox::Command
+      class UpdateServiceSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
         def self.command
           Cri::Command.define do
             name        'service'
             usage       'service [opts] -s <src> -d <dst> <src_service_id> <dst_service_id>'
-            summary     'Update service'
-            description 'Will update existing service, update proxy settings, metrics, methods, application plans and mapping rules.'
-
-            required  :s, :source, '3scale source instance. Format: "http[s]://<provider_key>@3scale_url"'
-            required  :d, :destination, '3scale target instance. Format: "http[s]://<provider_key>@3scale_url"'
-            option    :t, 'target_system_name', 'Target system name', argument: :required
-            flag      :f, :force, 'Overwrites the mapping rules by deleting all rules from target service first'
-            flag      :r, 'rules-only', 'Updates only the mapping rules'
-
-            run do |opts, args, _|
-              UpdateServiceSubcommand.run opts, args
-            end
+            summary     'update service'
+            description 'Update existing service, update proxy settings, metrics, methods, application plans and mapping rules.'
+
+            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', argument: :required
+            flag    :f, :force, 'Overwrites the mapping rules by deleting all rules from target service first'
+            flag    :r, 'rules-only', 'Updates only the mapping rules'
+            param   :src_service_id
+            param   :dst_service_id
+
+            runner UpdateServiceSubcommand
           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
-
-        class ServiceUpdater
-          attr_reader :source_client, :target_client, :source_service_id, :target_service_id, :target_system_name
-
-          def initialize (source, source_service_id, destination, target_service_id, insecure, system_name)
-            @source_client = ThreeScale::API.new(
-              endpoint:     endpoint_from_url(source),
-              provider_key: provider_key_from_url(source),
-              verify_ssl: !insecure
-            )
-            @target_client = ThreeScale::API.new(
-              endpoint:     endpoint_from_url(destination),
-              provider_key: provider_key_from_url(destination),
-              verify_ssl: !insecure
-            )
-            @source_service_id = source_service_id
-            @target_service_id = target_service_id
-            @target_system_name = system_name
-          end
-
-          def compare_hashes(first, second, keys)
-            keys.map{ |key| first.fetch(key) } == keys.map{ |key| second.fetch(key) }
-          end
-
-          def provider_key_from_url(url)
-            URI(url).user
-          end
-
-          def endpoint_from_url(url)
-            uri      = URI(url)
-            uri.user = nil
-
-            uri.to_s
-          end
-
-          # system name only included when specified from options
-          def target_service_params(source)
-            target_service = source.select do |k, v|
-              Commands.service_valid_params.include?(k) \
-                && k != 'system_name' \
-                && v
-            end
-            target_service.tap do |hash|
-              hash['system_name'] = target_system_name unless target_system_name.nil?
-            end
-          end
-
-          def source_metrics
-            @source_metrics ||= source_client.list_metrics(source_service_id)
-          end
-
-          def metrics_mapping
-            @metrics_mapping ||= target_client.list_metrics(target_service_id).map do |target|
-              metric = source_metrics.find{|metric| metric.fetch('system_name') == target.fetch('system_name') }
-              metric ||= {}
-
-              [metric['id'], target['id']]
-            end.to_h
-          end
-
-          def copy_service_settings
-            source_service = source_client.show_service(source_service_id)
-            puts "updating service settings for service id #{target_service_id}..."
-            target_update_response = target_client.update_service(target_service_id, target_service_params(source_service))
-            raise "Service has not been saved. Errors: #{target_update_response['errors']}" unless target_update_response['errors'].nil?
-          end
-
-          def copy_proxy_settings
-            puts "updating proxy configuration for service id #{target_service_id}..."
-            proxy = source_client.show_proxy(source_service_id)
-            target_client.update_proxy(target_service_id, proxy)
-            puts "updated proxy of #{target_service_id} to match the source #{source_service_id}"
-          end
-
-          def copy_metrics_and_methods
-            target_metrics = target_client.list_metrics(target_service_id)
-
-            source_hits = source_metrics.find{ |metric| metric['system_name'] == 'hits' } or raise 'missing hits metric'
-            target_hits = target_metrics.find{ |metric| metric['system_name'] == 'hits' } or raise 'missing hits metric'
-
-            source_methods = source_client.list_methods(source_service_id, source_hits['id'])
-            target_methods = target_client.list_methods(target_service_id, target_hits['id'])
-
-            puts "source service hits metric #{source_hits['id']} has #{source_methods.size} methods"
-            puts "target service hits metric #{target_hits['id']} has #{target_methods.size} methods"
-
-            missing_methods = source_methods.reject { |source_method|  target_methods.find{|target_method| compare_hashes(source_method, target_method, ['system_name']) } }
-
-            puts "creating #{missing_methods.size} missing methods on target service..."
-            missing_methods.each do |method|
-              target = { friendly_name: method['friendly_name'], system_name: method['system_name'] }
-              target_client.create_method(target_service_id, target_hits['id'], target)
-            end
-
-            target_metrics = target_client.list_metrics(target_service_id)
-
-            puts "source service has #{source_metrics.size} metrics"
-            puts "target service has #{target_metrics.size} metrics"
-
-            missing_metrics = source_metrics.reject { |source_metric| target_metrics.find{|target_metric| compare_hashes(source_metric, target_metric, ['system_name']) } }
-
-            missing_metrics.map do |metric|
-              metric.delete('links')
-              target_client.create_metric(target_service_id, metric)
-            end
-
-            puts "created #{missing_metrics.size} metrics on the target service"
+        def run
+          source_service = Entities::Service.new(
+            id: arguments[:src_service_id],
+            remote: threescale_client(fetch_required_option(:source))
+          )
+          update_service = Entities::Service.new(
+            id: arguments[:dst_service_id],
+            remote: threescale_client(fetch_required_option(:destination))
+          )
+          system_name = options[:target_system_name]
+          context = create_context(source_service, update_service)
+
+          tasks = []
+          unless options[:'rules-only']
+            tasks << Tasks::UpdateServiceSettingsTask.new(context.merge(target_name: system_name))
+            tasks << Tasks::CopyServiceProxyTask.new(context)
+            tasks << Tasks::CopyMethodsTask.new(context)
+            tasks << Tasks::CopyMetricsTask.new(context)
+            tasks << Tasks::CopyApplicationPlansTask.new(context)
+            tasks << Tasks::CopyLimitsTask.new(context)
           end
+          tasks << Tasks::DestroyMappingRulesTask.new(context) if options[:force]
+          tasks << Tasks::CopyMappingRulesTask.new(context)
 
-          def copy_application_plans
-            source_plans = source_client.list_service_application_plans(source_service_id)
-            target_plans = target_client.list_service_application_plans(target_service_id)
-
-            puts "source service has #{source_plans.size} application plans"
-            puts "target service has #{target_plans.size} application plans"
-
-            missing_application_plans = source_plans.reject { |source_plan| target_plans.find{|target_plan| source_plan.fetch('system_name') == target_plan.fetch('system_name') } }
-
-            puts "creating #{missing_application_plans.size} missing application plans..."
-
-            missing_application_plans.each do |plan|
-              plan.delete('links')
-              plan.delete('default') # TODO: handle default plans
-
-              if plan.delete('custom') # TODO: what to do with custom plans?
-                puts "skipping custom plan #{plan}"
-              else
-                target_client.create_application_plan(target_service_id, plan)
-              end
-            end
-
-            puts "updating limits for application plans..."
-
-            application_plan_mapping = target_client.list_service_application_plans(target_service_id).map do |plan_target|
-              plan = source_plans.find{|plan| plan.fetch('system_name') == plan_target.fetch('system_name') }
-              plan ||= {}
-              [plan['id'], plan_target['id']]
-            end.to_h.reject { |key, value| !key }
-
-            application_plan_mapping.each do |source_id, target_id|
-              source_limits = source_client.list_application_plan_limits(source_id)
-              target_limits = target_client.list_application_plan_limits(target_id)
-
-              missing_limits = source_limits.reject { |limit| target_limits.find{|limit_target| limit.fetch('period') == limit_target.fetch('period') } }
-
-              puts "target application plan #{target_id} is missing #{missing_limits.size} from the source plan #{source_id}"
-
-              missing_limits.each do |limit|
-                limit.delete('links')
-                target_client.create_application_plan_limit(target_id, metrics_mapping.fetch(limit.fetch('metric_id')), limit)
-              end
-
-            end
-          end
-
-          def copy_mapping_rules force_mapping_rules
-            source_mapping_rules = source_client.list_mapping_rules(source_service_id)
-            target_mapping_rules = target_client.list_mapping_rules(target_service_id)
-
-            puts "the source service has #{source_mapping_rules.size} mapping rules"
-            puts "the target has #{target_mapping_rules.size} mapping rules"
-
-            if force_mapping_rules
-              puts "force mode was chosen, deleting existing mapping rules on target service..."
-              target_mapping_rules.each do |rule|
-                target_client.delete_mapping_rule(target_service_id, rule['id'])
-              end
-              missing_mapping_rules = source_mapping_rules
-            else
-              unique_target_mapping_rules = target_mapping_rules.dup
-
-              missing_mapping_rules = source_mapping_rules.reject do |mapping_rule|
-                matching_metric = unique_target_mapping_rules.find do |target|
-                  compare_hashes(mapping_rule, target, %w(pattern http_method delta)) &&
-                    metrics_mapping.fetch(mapping_rule.fetch('metric_id')) == target.fetch('metric_id')
-                end
-
-                unique_target_mapping_rules.delete(matching_metric)
-              end
-            end
-
-            puts "missing #{missing_mapping_rules.size} mapping rules"
-
-            missing_mapping_rules.each do |mapping_rule|
-              mapping_rule.delete('links')
-              mapping_rule['metric_id'] = metrics_mapping.fetch(mapping_rule.delete('metric_id'))
-              target_client.create_mapping_rule(target_service_id, mapping_rule)
-            end
-            puts "created #{missing_mapping_rules.size} mapping rules"
-          end
-
-          def update_service force_mapping_rules=false
-            copy_service_settings
-            copy_proxy_settings
-            copy_metrics_and_methods
-            copy_application_plans
-            copy_mapping_rules force_mapping_rules
-          end
+          # run tasks
+          tasks.each(&:call)
         end
 
-        def self.run(opts, args)
-          source      = fetch_required_option(opts, :source)
-          destination = fetch_required_option(opts, :destination)
-          insecure    = opts[:insecure] || false
-          exit_with_message 'error: missing source_service_id argument' if args.empty?
-          exit_with_message 'error: missing target_service_id argument' if args.size < 2
-          source_service_id = args[0]
-          target_service_id = args[1]
-          force_update = opts[:force] || false
-          rules_only = opts[:'rules-only'] || false
-          system_name = opts[:target_system_name]
-          updater = ServiceUpdater.new(source, source_service_id, destination, target_service_id, insecure, system_name)
+        private
 
-          if rules_only
-            updater.copy_mapping_rules force_update
-          else
-            updater.update_service force_update
-          end
+        def create_context(source, target)
+          {
+            source: source,
+            target: target
+          }
         end
       end
     end