3scale_toolbox 0.10.0 → 0.11.0

data/lib/3scale_toolbox/commands/application_command/delete_command.rb

@@ -0,0 +1,57 @@
+module ThreeScaleToolbox
+  module Commands
+    module ApplicationCommand
+      module Delete
+        class DeleteSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          def self.command
+            Cri::Command.define do
+              name        'delete'
+              usage       'delete [opts] <remote> <application>'
+              summary     'delete application'
+              description <<-HEREDOC
+              Delete application'
+              \n Application param allows:
+              \n * Application internal id
+              \n * User_key (API key)
+              \n * App_id (from app_id/app_key pair)
+              \n * Client ID (for OAuth and OpenID Connect authentication modes)
+              HEREDOC
+
+              param       :remote
+              param       :application_ref
+
+              runner DeleteSubcommand
+            end
+          end
+
+          def run
+            application.delete
+            puts "Application id: #{application.id} deleted"
+          end
+
+          private
+
+          def application
+            @application ||= find_application
+          end
+
+          def find_application
+            Entities::Application.find(remote: remote, ref: application_ref).tap do |app|
+              raise ThreeScaleToolbox::Error, "Application #{application_ref} does not exist" if app.nil?
+            end
+          end
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def application_ref
+            arguments[:application_ref]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/application_command/list_command.rb

@@ -0,0 +1,124 @@
+module ThreeScaleToolbox
+  module Commands
+    module ApplicationCommand
+      module List
+        class ListSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          FIELDS_TO_SHOW = %w[id name state enabled account_id service_id plan_id].freeze
+
+          def self.command
+            Cri::Command.define do
+              name        'list'
+              usage       'list [opts] <remote>'
+              summary     'list applications'
+              description 'List applications'
+
+              param       :remote
+              option      nil, :account, 'Filter by account', argument: :required
+              option      nil, :service, 'Filter by service', argument: :required
+              option      nil, :plan, 'Filter by application plan. Service option required', argument: :required
+
+              runner ListSubcommand
+            end
+          end
+
+          def run
+            validate_option_params
+
+            applications = if option_account
+                             account.applications
+                           elsif option_service && option_plan
+                             plan.applications
+                           elsif option_service
+                             service.applications
+                           else
+                             provider_account_applications
+                           end
+            print_header
+            print_data(applications)
+          end
+
+          private
+
+          def validate_option_params
+            raise ThreeScaleToolbox::Error, '--account and --service are mutually exclusive' \
+              if option_service && option_account
+
+            raise ThreeScaleToolbox::Error, '--plan requires --service option' \
+              if option_plan && option_service.nil?
+          end
+
+          def provider_account_applications
+            app_attrs_list = remote.list_applications
+            if app_attrs_list.respond_to?(:has_key?) && (errors = app_attrs_list['errors'])
+              raise ThreeScaleToolbox::ThreeScaleApiError.new('Provider account applications not read', errors)
+            end
+
+            app_attrs_list.map do |app_attrs|
+              Entities::Application.new(id: app_attrs.fetch('id'), remote: remote, attrs: app_attrs)
+            end
+          end
+
+          def option_service
+            options[:service]
+          end
+
+          def option_account
+            options[:account]
+          end
+
+          def option_plan
+            options[:plan]
+          end
+
+          def print_header
+            puts FIELDS_TO_SHOW.map(&:upcase).join("\t")
+          end
+
+          def print_data(applications)
+            applications.each do |app|
+              puts FIELDS_TO_SHOW.map { |field| app.attrs.fetch(field, '(empty)') }.join("\t")
+            end
+          end
+
+          def service
+            @service ||= find_service
+          end
+
+          def find_service
+            Entities::Service.find(remote: remote,
+                                   ref: option_service).tap do |svc|
+              raise ThreeScaleToolbox::Error, "Service #{option_service} does not exist" if svc.nil?
+            end
+          end
+
+          def account
+            @account ||= find_account
+          end
+
+          def find_account
+            Entities::Account.find(remote: remote,
+                                   ref: option_account).tap do |acc|
+              raise ThreeScaleToolbox::Error, "Account #{option_account} does not exist" if acc.nil?
+            end
+          end
+
+          def plan
+            @plan ||= find_plan
+          end
+
+          def find_plan
+            Entities::ApplicationPlan.find(service: service, ref: option_plan).tap do |plan|
+              raise ThreeScaleToolbox::Error, "Application plan #{option_plan} does not exist" if plan.nil?
+            end
+          end
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/application_command/show_command.rb

@@ -0,0 +1,72 @@
+module ThreeScaleToolbox
+  module Commands
+    module ApplicationCommand
+      module Show
+        class ShowSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          FIELDS_TO_SHOW = %w[id name description state enabled account_id service_id plan_id
+                              user_key application_id].freeze
+
+          def self.command
+            Cri::Command.define do
+              name        'show'
+              usage       'show [opts] <remote> <application>'
+              summary     'show application attributes'
+              description <<-HEREDOC
+              Show application attributes
+              \n Application param allows:
+              \n * Application internal id
+              \n * User_key (API key)
+              \n * App_id (from app_id/app_key pair)
+              \n * Client ID (for OAuth and OpenID Connect authentication modes)
+              HEREDOC
+
+              param       :remote
+              param       :application
+
+              runner ShowSubcommand
+            end
+          end
+
+          def run
+            print_header
+            print_data
+          end
+
+          private
+
+          def print_header
+            puts FIELDS_TO_SHOW.map(&:upcase).join("\t")
+          end
+
+          def print_data
+            puts FIELDS_TO_SHOW.map { |field| app_attrs.fetch(field, '(empty)') }.join("\t")
+          end
+
+          def app_attrs
+            @app_attrs ||= application.attrs
+          end
+
+          def application
+            @application ||= find_application
+          end
+
+          def find_application
+            Entities::Application.find(remote: remote, ref: application_ref).tap do |app|
+              raise ThreeScaleToolbox::Error, "Application #{application_ref} does not exist" if app.nil?
+            end
+          end
+
+          def application_ref
+            arguments[:application]
+          end
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,45 +7,64 @@ module ThreeScaleToolbox
         def self.command
           Cri::Command.define do
             name        'service'
-            usage       'service [opts] -s <src> -d <dst> <service_id>'
+            usage       'service [opts] -s <src> -d <dst> <source-service>'
             summary     'copy service'
-            description 'will create a new services, copy existing proxy settings, metrics, methods, application plans and mapping rules.'
+            description <<-HEREDOC
+            This command makes a copy of the referenced service.
+            Target service will be searched by source service system name. System name can be overriden with `--target_system_name` option.
+            If a service with the selected `system_name` is not found, it will be created.
+            \n Components of the service being copied:
+            \nservice settings
+            \nproxy settings
+            \npricing rules
+            \nactivedocs
+            \nmetrics
+            \nmethods
+            \napplication plans
+            \nmapping rules
+            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   :service_id
+            flag    :f, :force, 'Overwrites the mapping rules by deleting all rules from target service first'
+            flag    :r, 'rules-only', 'Only mapping rules are copied'
+            param   :source_service
 
             runner CopyServiceSubcommand
           end
         end
 
         def run
-          source      = fetch_required_option(:source)
-          destination = fetch_required_option(:destination)
+          target_service = Entities::Service.find(remote: target_remote,
+                                                  ref: target_service_ref)
+          if target_service.nil?
+            target_service = Entities::Service.create(remote: target_remote,
+                                                      service_params: create_service_attrs)
+          end
 
-          source_service = Entities::Service.new(id: arguments[:service_id],
-                                                 remote: threescale_client(source))
-          target_service = create_new_service(source_service.attrs, destination)
           puts "new service id #{target_service.id}"
+
           context = create_context(source_service, target_service)
-          tasks = [
-            Tasks::CopyMethodsTask.new(context),
-            Tasks::CopyMetricsTask.new(context),
-            Tasks::CopyApplicationPlansTask.new(context),
-            Tasks::CopyLimitsTask.new(context),
-            Tasks::DestroyMappingRulesTask.new(context),
-            Tasks::CopyMappingRulesTask.new(context),
-            Tasks::CopyPoliciesTask.new(context),
-            Tasks::CopyPricingRulesTask.new(context),
-            Tasks::CopyActiveDocsTask.new(context),
-            # Copy proxy must be the last task
-            # Proxy update is the mechanism to increase version of the proxy,
-            # Hence propagating (mapping rules, poicies, oidc, auth) update to
-            # latest proxy config, making available to gateway.
-            Tasks::CopyServiceProxyTask.new(context),
-          ]
+
+          tasks = []
+          unless option_rules_only
+            tasks << Tasks::CopyServiceSettingsTask.new(context)
+            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)
+            tasks << Tasks::CopyPoliciesTask.new(context)
+            tasks << Tasks::CopyPricingRulesTask.new(context)
+            tasks << Tasks::CopyActiveDocsTask.new(context)
+          end
+          tasks << Tasks::DestroyMappingRulesTask.new(context) if option_force
+          tasks << Tasks::CopyMappingRulesTask.new(context)
           tasks.each(&:call)
+
+          # This should be the last step
+          Tasks::BumpProxyVersionTask.new(service: target_service).call
         end
 
         private
@@ -57,10 +76,60 @@ module ThreeScaleToolbox
           }
         end
 
-        def create_new_service(service, destination)
-          Entities::Service.create(remote: threescale_client(destination),
-                                   service: service,
-                                   system_name: options[:target_system_name] || service['system_name'])
+        def option_rules_only
+          options[:'rules-only']
+        end
+
+        def option_force
+          options[:force]
+        end
+
+        def option_target_system_name
+          options[:target_system_name]
+        end
+
+        def create_service_attrs
+          # minimum required attrs.
+          # Service settings will be updated in later task
+          # These attrs are only when service is created
+          {
+            'name' => source_service.attrs.fetch('name'),
+            'system_name' => target_service_ref
+          }.compact
+        end
+
+        def source_service
+          @source_service ||= find_source_service
+        end
+
+        def find_source_service
+          Entities::Service.find(remote: source_remote, ref: source_service_ref).tap do |svc|
+            raise ThreeScaleToolbox::Error, "Service #{source_service_ref} does not exist" if svc.nil?
+          end
+        end
+
+        def source_remote
+          @source_remote ||= threescale_client(source)
+        end
+
+        def target_remote
+          @target_remote ||= threescale_client(target)
+        end
+
+        def source_service_ref
+          arguments[:source_service]
+        end
+
+        def target_service_ref
+          option_target_system_name || source_service.attrs.fetch('system_name')
+        end
+
+        def source
+          fetch_required_option(:source)
+        end
+
+        def target
+          fetch_required_option(:destination)
         end
       end
     end

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

@@ -35,7 +35,7 @@ module ThreeScaleToolbox
           data     = CSV.read file_path
           headings = data.shift
           services = {}
-          stats    = { services: 0, metrics: 0, methods: 0 , mapping_rules: 0 }
+          stats    = { services: 0, metrics: 0, methods: 0, mapping_rules: 0 }
 
           # prepare services data
           data.each do |row|
@@ -69,17 +69,16 @@ module ThreeScaleToolbox
             end
 
             services[service_name][:items].each do |item|
-
               metric, method = {}
 
               case item['type']
                 # create a metric
               when 'metric'
                 metric = client.create_metric(service['id'], {
-                  system_name:   item['endpoint_system_name'],
-                  friendly_name: item['endpoint_name'],
-                  unit:          'unit'
-                })
+                                                system_name:   item['endpoint_system_name'],
+                                                friendly_name: item['endpoint_name'],
+                                                unit:          'unit'
+                                              })
 
                 if metric['errors'].nil?
                   stats[:metrics] += 1
@@ -90,10 +89,10 @@ module ThreeScaleToolbox
                 # create a method
               when 'method'
                 method = client.create_method(service['id'], hits_metric['id'], {
-                  system_name:   item['endpoint_system_name'],
-                  friendly_name: item['endpoint_name'],
-                  unit:          'unit'
-                })
+                                                system_name:   item['endpoint_system_name'],
+                                                friendly_name: item['endpoint_name'],
+                                                unit:          'unit'
+                                              })
 
                 if method['errors'].nil?
                   stats[:methods] += 1
@@ -106,13 +105,13 @@ module ThreeScaleToolbox
               # create a mapping rule
               if (metric_id = metric['id'] || method['id'])
                 mapping_rule = client.create_mapping_rule(service['id'], {
-                  metric_id:          metric_id,
-                  pattern:            item['endpoint_path'],
-                  http_method:        item['endpoint_http_method'],
-                  metric_system_name: item['endpoint_system_name'],
-                  auth_app_key:       auth_app_key_according_service(service),
-                  delta:              1
-                })
+                                                            metric_id:          metric_id,
+                                                            pattern:            item['endpoint_path'],
+                                                            http_method:        item['endpoint_http_method'],
+                                                            metric_system_name: item['endpoint_system_name'],
+                                                            auth_app_key:       auth_app_key_according_service(service),
+                                                            delta:              1
+                                                          })
 
                 if mapping_rule['errors'].nil?
                   stats[:mapping_rules] += 1