3scale_toolbox 0.15.0 → 0.18.2

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/proxy_config_command/export_command.rb

@@ -0,0 +1,74 @@
+module ThreeScaleToolbox
+  module Commands
+    module ProxyConfigCommand
+      module Export
+        class ExportSubcommand < Cri::CommandRunner
+          include ThreeScaleToolbox::Command
+
+          def self.command
+            Cri::Command.define do
+              name        'export'
+              usage       'export <remote>'
+              summary     'Export proxy configuration for the entire provider account'
+              description <<-HEREDOC
+              Export proxy configuration for the entire provider account
+              \n Can be used as 3scale apicast configuration file
+              \n https://github.com/3scale/apicast/blob/master/doc/parameters.md#threescale_config_file
+              HEREDOC
+
+              param :remote
+
+              ThreeScaleToolbox::CLI.output_flag(self)
+              option nil, :environment, "Gateway environment. Must be 'sandbox' or 'production'", default: 'sandbox', argument: :required, transform: ProxyConfigCommand::EnvironmentTransformer.new
+
+              runner ExportSubcommand
+            end
+          end
+
+          def run
+            printer.print_record proxy_config_list_obj
+          end
+
+          private
+
+          def proxy_config_list_obj
+            {
+              'services' => proxy_config_list
+            }
+          end
+
+          def proxy_config_list
+            service_list.map do |service|
+              pc = Entities::ProxyConfig.find_latest(service: service, environment: environment)
+              pc.attrs['content'] unless pc.nil?
+            end.compact
+          end
+
+          def service_list
+            tmp_list = remote.list_services
+
+            if tmp_list.respond_to?(:has_key?) && (errors = tmp_list['errors'])
+              raise ThreeScaleToolbox::ThreeScaleApiError.new('Service list not read', errors)
+            end
+
+            tmp_list.map do |svc_attrs|
+              Entities::Service.new(id: svc_attrs.fetch('id'), remote: remote, attrs: svc_attrs)
+            end
+          end
+
+          def remote
+            @remote ||= threescale_client(arguments[:remote])
+          end
+
+          def environment
+            options[:environment]
+          end
+
+          def printer
+            options.fetch(:output, CLI::JsonPrinter.new)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands/proxy_config_command/helper.rb

@@ -0,0 +1,15 @@
+module ThreeScaleToolbox
+  module Commands
+    module ProxyConfigCommand
+      class EnvironmentTransformer
+        def call(param_str)
+          raise ArgumentError unless param_str.is_a?(String)
+
+          raise ArgumentError unless %w[production sandbox].include? param_str
+
+          param_str
+        end
+      end
+    end
+  end
+end

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

@@ -5,30 +5,30 @@ module ThreeScaleToolbox
         class ListSubcommand < Cri::CommandRunner
           include ThreeScaleToolbox::Command
 
+          FIELDS = %w[id version environment]
+
           def self.command
             Cri::Command.define do
               name        'list'
               usage       'list <remote> <service> <environment>'
               summary     'List Proxy Configurations'
               description 'List all defined Proxy Configurations'
-              runner ListSubcommand
 
+              ThreeScaleToolbox::CLI.output_flag(self)
               param   :remote
               param   :service_ref
               param   :environment
+
+              runner ListSubcommand
             end
           end
 
           def run
-            print_proxy_config_data(proxy_configs, PROXYCONFIG_FIELDS_TO_SHOW)
+            printer.print_collection service.proxy_configs(proxy_config_environment).map(&:attrs)
           end
 
           private
 
-          PROXYCONFIG_FIELDS_TO_SHOW = %w[
-            id version environment
-          ]
-
           def remote
             @remote ||= threescale_client(arguments[:remote])
           end
@@ -41,29 +41,8 @@ module ThreeScaleToolbox
             arguments[:service_ref]
           end
 
-          def proxy_configs
-            @proxyconfigs ||= service.proxy_configs(proxy_config_environment)
-          end
-
-          def print_proxy_config_data(proxyconfigs, fields_to_show)
-            print_header(fields_to_show)
-            print_results(proxyconfigs, fields_to_show)
-          end
-
-          def print_header(fields_to_show)
-            puts fields_to_show.map{ |e| e.upcase}.join("\t")
-          end
-
-          def print_results(proxyconfigs, fields_to_show)
-            proxyconfigs.each do |proxyconfig|
-              proxy_config_attrs = proxyconfig.attrs
-              puts fields_to_show.map { |field| proxy_config_attrs.fetch(field, '(empty)') }.join("\t")
-            end
-          end
-
           def find_service
-            Entities::Service.find(remote: remote,
-                                   ref: service_ref).tap do |svc|
+            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
@@ -71,8 +50,13 @@ module ThreeScaleToolbox
           def service
             @service ||= find_service
           end
+
+          def printer
+            # keep backwards compatibility
+            options.fetch(:output, CLI::CustomTablePrinter.new(FIELDS))
+          end
         end
       end
     end
   end
-end
+end

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

@@ -11,41 +11,39 @@ module ThreeScaleToolbox
               usage       'show <remote> <service> <environment>'
               summary     'Show Proxy Configuration'
               description 'Show a Proxy Configuration'
-              runner ShowSubcommand
 
               param   :remote
               param   :service_ref
               param   :environment
 
-              option nil, :'config-version', "Specify the Proxy Configuration version. If not specified it gets the latest version", argument: :required
+              ThreeScaleToolbox::CLI.output_flag(self)
+              option nil, :'config-version', "Specify the Proxy Configuration version. If not specified it gets the latest version", default: 'latest', argument: :required
+
+              runner ShowSubcommand
             end
           end
 
-          def run      
-            print_proxy_config
+          def run
+            printer.print_record proxy_config.attrs
           end
 
           private
 
           def proxy_config
-            @proxy_config ||= find_proxy_config 
-          end
-
-          def find_proxy_config
-            if proxy_config_version == "latest"
-              find_proxy_config_latest
+            if proxy_config_version_option == 'latest'
+              proxy_config_latest
             else
-              find_proxy_config_version
+              proxy_config_version
             end
           end
 
-          def find_proxy_config_version
-            Entities::ProxyConfig.find(service: service, environment: proxy_config_environment, version: proxy_config_version).tap do |pc|
+          def proxy_config_version
+            Entities::ProxyConfig.find(service: service, environment: proxy_config_environment, version: proxy_config_version_option).tap do |pc|
               raise ThreeScaleToolbox::Error, "ProxyConfig #{proxy_config_environment} in service #{service.id} does not exist" if pc.nil?
             end
           end
 
-          def find_proxy_config_latest
+          def proxy_config_latest
             Entities::ProxyConfig.find_latest(service: service, environment: proxy_config_environment).tap do |pc|
               raise ThreeScaleToolbox::Error, "ProxyConfig #{proxy_config_environment} in service #{service.id} does not exist" if pc.nil?
             end
@@ -55,25 +53,20 @@ module ThreeScaleToolbox
             @remote ||= threescale_client(arguments[:remote])
           end
 
-          def proxy_config_version
-            options[:'config-version'] || "latest"
+          def proxy_config_version_option
+            options[:'config-version']
           end
 
           def proxy_config_environment
             arguments[:environment]
           end
 
-          def print_proxy_config
-            puts JSON.pretty_generate(proxy_config.attrs)    
-          end
-
           def service_ref
             arguments[:service_ref]
           end
 
           def find_service
-            Entities::Service.find(remote: remote,
-                                   ref: service_ref).tap do |svc|
+            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
@@ -81,8 +74,12 @@ module ThreeScaleToolbox
           def service
             @service ||= find_service
           end
+
+          def printer
+            options.fetch(:output, CLI::JsonPrinter.new)
+          end
         end
       end
     end
   end
-end
+end

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

@@ -5,6 +5,7 @@ require '3scale_toolbox/commands/service_command/show_command'
 require '3scale_toolbox/commands/service_command/delete_command'
 require '3scale_toolbox/commands/service_command/create_command'
 require '3scale_toolbox/commands/service_command/apply_command'
+require '3scale_toolbox/commands/service_command/copy_command'
 
 module ThreeScaleToolbox
   module Commands
@@ -24,11 +25,12 @@ module ThreeScaleToolbox
         end
       end
 
-      add_subcommand(List::ListSubcommand)
-      add_subcommand(Show::ShowSubcommand)
-      add_subcommand(Delete::DeleteSubcommand)
-      add_subcommand(Create::CreateSubcommand)
-      add_subcommand(Apply::ApplySubcommand)
+      add_subcommand(ListSubcommand)
+      add_subcommand(ShowSubcommand)
+      add_subcommand(DeleteSubcommand)
+      add_subcommand(CreateSubcommand)
+      add_subcommand(ApplySubcommand)
+      add_subcommand(CopySubcommand)
     end
   end
 end

data/lib/3scale_toolbox/commands/service_command/apply_command.rb

@@ -1,75 +1,86 @@
 module ThreeScaleToolbox
   module Commands
     module ServiceCommand
-      module Apply
-        class ApplySubcommand < Cri::CommandRunner
-          include ThreeScaleToolbox::Command
-
-          def self.command
-            Cri::Command.define do
-              name        'apply'
-              usage       'apply <remote> <service-id_or_system-name>'
-              summary     'Update service'
-              description "Update (create if it does not exist) service"
-              runner ApplySubcommand
-
-              param   :remote
-              param   :service_id_or_system_name
-
-              option :d, :'deployment-mode', "Specify the deployment mode of the service", argument: :required
-              option :n, :name, "Specify the name of the metric", argument: :required
-              option :a, :'authentication-mode', "Specify authentication mode of the service ('1' for API key, '2' for App Id / App Key, 'oauth' for OAuth mode, 'oidc' for OpenID Connect)", argument: :required
-              option nil, :description, "Specify the description of the service", argument: :required
-              option nil, :'support-email', "Specify the support email of the service", argument: :required
-            end
-          end
+      class CustomPrinter
+        attr_reader :option_default, :option_disabled
 
-          def run
-            res = service
-            if res.nil?
-              res = Entities::Service.create(remote: remote, service_params: create_service_attrs)
-            else
-              res.update(service_attrs) unless service_attrs.empty?
-            end
+        def print_record(service)
+          puts "Applied Service id: #{service['id']}"
+        end
 
-            output_msg_array = ["Applied Service id: #{res.id}"]
-            puts output_msg_array
-          end
+        def print_collection(collection) end
+      end
 
-          private
+      class ApplySubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
 
-          def remote
-            @remote ||= threescale_client(arguments[:remote])
-          end
+        def self.command
+          Cri::Command.define do
+            name        'apply'
+            usage       'apply <remote> <service-id_or_system-name>'
+            summary     'Update service'
+            description "Update (create if it does not exist) service"
 
-          def ref
-            @ref ||= arguments[:service_id_or_system_name]
-          end
+            param   :remote
+            param   :service_id_or_system_name
 
-          def service
-            @service ||= find_service
-          end
+            ThreeScaleToolbox::CLI.output_flag(self)
+            option :d, :'deployment-mode', "Specify the deployment mode of the service", argument: :required
+            option :n, :name, "Specify the name of the metric", argument: :required
+            option :a, :'authentication-mode', "Specify authentication mode of the service ('1' for API key, '2' for App Id / App Key, 'oauth' for OAuth mode, 'oidc' for OpenID Connect)", argument: :required
+            option nil, :description, "Specify the description of the service", argument: :required
+            option nil, :'support-email', "Specify the support email of the service", argument: :required
 
-          def find_service
-            Entities::Service::find(remote: remote, ref: ref)
+            runner ApplySubcommand
           end
+        end
 
-          def service_attrs
-            {
-              "deployment_option" => options[:'deployment-mode'],
-              "backend_version" => options[:'authentication-mode'],
-              "description" => options[:description],
-              "support_email" => options[:'support-email'],
-              "name" => options[:name],
-            }.compact
+        def run
+          service = Entities::Service.find(remote: remote, ref: ref)
+          if service.nil?
+            service = Entities::Service.create(remote: remote,
+                                               service_params: create_attrs)
+          else
+            service.update(update_attrs) unless update_attrs.empty?
           end
 
-          def create_service_attrs
-            service_attrs.merge(
-              "system_name" => ref,
-              "name" => ref
-            ) { |_key, oldval, _newval| oldval } # receiver of the merge message has key priority
-          end
+          printer.print_record service.attrs
+        end
+
+        private
+
+        def remote
+          @remote ||= threescale_client(arguments[:remote])
+        end
+
+        def ref
+          @ref ||= arguments[:service_id_or_system_name]
+        end
+
+        def base_service_attrs
+          {
+            "deployment_option" => options[:'deployment-mode'],
+            "backend_version" => options[:'authentication-mode'],
+            "description" => options[:description],
+            "support_email" => options[:'support-email'],
+            "name" => options[:name],
+          }.compact
+        end
+
+        def update_attrs
+          base_service_attrs
+        end
+
+        def create_attrs
+          base_service_attrs.merge(
+            "system_name" => ref,
+            "name" => ref
+          ) { |_key, oldval, _newval| oldval } # receiver of the merge message has key priority
+        end
+
+        def printer
+          # keep backwards compatibility
+          options.fetch(:output, CustomPrinter.new)
         end
       end
     end