3scale_toolbox 0.5.1 → 0.6.0

data/lib/3scale_toolbox/cli/error_handler.rb

@@ -0,0 +1,120 @@
+require 'json'
+
+module ThreeScaleToolbox
+  module CLI
+    class ErrorHandler
+      def self.error_watchdog
+        new.error_watchdog { yield }
+      end
+
+      # Catches errors and prints nice diagnostic messages
+      def error_watchdog
+        # Run
+        yield
+      rescue StandardError, ScriptError => e
+        handle_error e
+        e
+      else
+        nil
+      end
+
+      private
+
+      def handle_error(error)
+        if expected_error?(error)
+          warn
+          warn "\e[1m\e[31mError: #{error.message}\e[0m"
+        else
+          print_error(error)
+        end
+      end
+
+      def expected_error?(error)
+        case error
+        when ThreeScaleToolbox::Error
+          true
+        else
+          false
+        end
+      end
+
+      def print_error(error)
+        write_error(error, $stderr)
+
+        File.open('crash.log', 'w') do |io|
+          write_verbose_error(error, io)
+        end
+
+        write_section_header($stderr, 'Detailed information')
+        warn
+        warn 'A detailed crash log has been written to ./crash.log.'
+      end
+
+      def write_error(error, stream)
+        write_error_message(error, stream)
+        write_stack_trace(error, stream)
+      end
+
+      def write_error_message(error, stream)
+        write_section_header(stream, 'Message')
+        stream.puts "\e[1m\e[31m#{error.class}: #{error.message}\e[0m"
+      end
+
+      def write_stack_trace(error, stream)
+        write_section_header(stream, 'Backtrace')
+        stream.puts error.backtrace
+      end
+
+      def write_version_information(stream)
+        write_section_header(stream, 'Version Information')
+        stream.puts ThreeScaleToolbox::VERSION
+      end
+
+      def write_system_information(stream)
+        write_section_header(stream, 'System Information')
+        stream.puts Etc.uname.to_json
+      end
+
+      def write_installed_gems(stream)
+        write_section_header(stream, 'Installed gems')
+        gems_and_versions.each do |g|
+          stream.puts "  #{g.first} #{g.last.join(', ')}"
+        end
+      end
+
+      def write_load_paths(stream)
+        write_section_header(stream, 'Load paths')
+        $LOAD_PATH.each_with_index do |i, index|
+          stream.puts "  #{index}. #{i}"
+        end
+      end
+
+      def write_verbose_error(error, stream)
+        stream.puts "Crashlog created at #{Time.now}"
+
+        write_error_message(error, stream)
+        write_stack_trace(error, stream)
+        write_version_information(stream)
+        write_system_information(stream)
+        write_installed_gems(stream)
+        write_load_paths(stream)
+      end
+
+      def gems_and_versions
+        gems = {}
+        Gem::Specification.find_all.sort_by { |s| [s.name, s.version] }.each do |spec|
+          gems[spec.name] ||= []
+          gems[spec.name] << spec.version.to_s
+        end
+        gems
+      end
+
+      def write_section_header(stream, title)
+        stream.puts
+
+        stream.puts "===== #{title.upcase}:"
+        stream.puts
+      end
+    end
+  end
+end

data/lib/3scale_toolbox/commands.rb

@@ -3,6 +3,7 @@ require '3scale_toolbox/commands/help_command'
 require '3scale_toolbox/commands/copy_command'
 require '3scale_toolbox/commands/import_command'
 require '3scale_toolbox/commands/update_command'
+require '3scale_toolbox/commands/remote_command'
 
 module ThreeScaleToolbox
   module Commands
@@ -10,15 +11,8 @@ module ThreeScaleToolbox
       ThreeScaleToolbox::Commands::HelpCommand,
       ThreeScaleToolbox::Commands::CopyCommand,
       ThreeScaleToolbox::Commands::ImportCommand,
-      ThreeScaleToolbox::Commands::UpdateCommand
+      ThreeScaleToolbox::Commands::UpdateCommand,
+      ThreeScaleToolbox::Commands::RemoteCommand::RemoteCommand
     ].freeze
-
-    def self.service_valid_params
-      %w[
-        name backend_version deployment_option description
-        system_name end_user_registration_required
-        support_email tech_support_email admin_support_email
-      ]
-    end
   end
 end

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

@@ -5,16 +5,18 @@ require '3scale_toolbox/base_command'
 module ThreeScaleToolbox
   module Commands
     module ThreeScaleCommand
-      extend ThreeScaleToolbox::Command
+      include ThreeScaleToolbox::Command
       def self.command
         Cri::Command.define do
           name        '3scale'
-          usage       '3scale <command> [options]'
-          summary     '3scale CLI Toolbox'
-          description '3scale CLI tools to manage your API from the terminal.'
-          flag :v, :version, 'Prints the version of this command' do |_, _|
+          usage       '3scale <sub-command> [options]'
+          summary     '3scale toolbox'
+          description '3scale toolbox to manage your API from the terminal.'
+          option :c, 'config-file', '3scale toolbox configuration file',
+            argument: :required, default: ThreeScaleToolbox.default_config_file
+          flag :v, :version, 'Prints the version of this command' do
             puts ThreeScaleToolbox::VERSION
-            exit
+            exit 0
           end
           flag :k, :insecure, 'Proceed and operate even for server connections otherwise considered insecure'
           flag :h, :help, 'show help for this command' do |_, cmd|

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

@@ -5,13 +5,13 @@ require '3scale_toolbox/commands/copy_command/copy_service'
 module ThreeScaleToolbox
   module Commands
     module CopyCommand
-      extend ThreeScaleToolbox::Command
+      include ThreeScaleToolbox::Command
       def self.command
         Cri::Command.define do
           name        'copy'
-          usage       'copy <command> [options]'
-          summary     '3scale copy command'
-          description '3scale copy command.'
+          usage       'copy <sub-command> [options]'
+          summary     'copy super command'
+          description 'Copy 3scale entities between tenants'
         end
       end
       add_subcommand(CopyServiceSubcommand)

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

@@ -4,213 +4,60 @@ require '3scale_toolbox/base_command'
 module ThreeScaleToolbox
   module Commands
     module CopyCommand
-      module CopyServiceSubcommand
-        extend ThreeScaleToolbox::Command
+      class CopyServiceSubcommand < Cri::CommandRunner
+        include ThreeScaleToolbox::Command
+
         def self.command
           Cri::Command.define do
             name        'service'
             usage       'service [opts] -s <src> -d <dst> <service_id>'
-            summary     'Copy service'
-            description 'Will create a new services, copy existing proxy settings, metrics, methods, application plans and mapping rules.'
+            summary     'copy service'
+            description 'will create a new services, copy existing 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"'
-            required  :t, 'target_system_name', 'Target system name'
+            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
+            param   :service_id
 
-            run do |opts, args, _|
-              CopyServiceSubcommand.run opts, args
-            end
+            runner CopyServiceSubcommand
           end
         end
 
-        def self.run(opts, args)
-          source      = fetch_required_option(opts, :source)
-          destination = fetch_required_option(opts, :destination)
-          system_name = fetch_required_option(opts, :target_system_name)
-          insecure    = opts[:insecure] || false
-          exit_with_message 'error: missing service_id argument' if args.empty?
-          service_id = args[0]
-          copy_service(service_id, source, destination, system_name, insecure)
-        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.compare_hashes(first, second, keys)
-          keys.map{ |key| first.fetch(key) } == keys.map{ |key| second.fetch(key) }
-        end
-
-        def self.provider_key_from_url(url)
-          url[/\w*@/][0..-2]
-        end
-
-        def self.endpoint_from_url(url)
-          url.sub /\w*@/, ''
+        def run
+          source      = fetch_required_option(:source)
+          destination = fetch_required_option(:destination)
+          system_name = fetch_required_option(:target_system_name)
+
+          source_service = Entities::Service.new(id: arguments[:service_id],
+                                                 remote: threescale_client(source))
+          target_service = create_new_service(source_service.show_service, destination, system_name)
+          puts "new service id #{target_service.id}"
+          context = create_context(source_service, target_service)
+          tasks = [
+            Tasks::CopyServiceProxyTask.new(context),
+            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.each(&:call)
         end
 
+        private
 
-        # Returns new hash object with not nil valid params
-        def self.filter_params(valid_params, source)
-          valid_params.each_with_object({}) do |key, target|
-            target[key] = source[key] unless source[key].nil?
-          end
-        end
-
-        def self.copy_service_params(original, system_name)
-          service_params = filter_params(Commands.service_valid_params, original)
-          service_params.tap do |hash|
-            hash['system_name'] = system_name if system_name
-          end
+        def create_context(source, target)
+          {
+            source: source,
+            target: target
+          }
         end
 
-        def self.copy_service(service_id, source, destination, system_name, insecure)
-          require '3scale/api'
-
-          source_client = ThreeScale::API.new(
-            endpoint:     endpoint_from_url(source),
-            provider_key: provider_key_from_url(source),
-            verify_ssl: !insecure
-          )
-          client = ThreeScale::API.new(
-            endpoint:     endpoint_from_url(destination),
-            provider_key: provider_key_from_url(destination),
-            verify_ssl: !insecure
-          )
-
-          service = source_client.show_service(service_id)
-          copy    = client.create_service(copy_service_params(service, system_name))
-
-          raise "Service has not been saved. Errors: #{copy['errors']}" unless copy['errors'].nil?
-
-          service_copy_id = copy.fetch('id')
-
-          puts "new service id #{service_copy_id}"
-
-          proxy = source_client.show_proxy(service_id)
-          client.update_proxy(service_copy_id, proxy)
-          puts "updated proxy of #{service_copy_id} to match the original"
-
-          metrics = source_client.list_metrics(service_id)
-          metrics_copies = client.list_metrics(service_copy_id)
-
-          hits = metrics.find{ |metric| metric['system_name'] == 'hits' } or raise 'missing hits metric'
-          hits_copy = metrics_copies.find{ |metric| metric['system_name'] == 'hits' } or raise 'missing hits metric'
-
-          methods = source_client.list_methods(service_id, hits['id'])
-          methods_copies = client.list_methods(service_copy_id, hits_copy['id'])
-
-          puts "original service hits metric #{hits['id']} has #{methods.size} methods"
-          puts "copied service hits metric #{hits_copy['id']} has #{methods_copies.size} methods"
-
-          missing_methods = methods.reject { |method|  methods_copies.find{|copy| compare_hashes(method, copy, ['system_name']) } }
-
-          puts "creating #{missing_methods.size} missing methods on copied service"
-
-          missing_methods.each do |method|
-            copy = { friendly_name: method['friendly_name'], system_name: method['system_name'] }
-            client.create_method(service_copy_id, hits_copy['id'], copy)
-          end
-
-          metrics_copies = client.list_metrics(service_copy_id)
-
-          puts "original service has #{metrics.size} metrics"
-          puts "copied service has #{metrics_copies.size} metrics"
-
-          missing_metrics = metrics.reject { |metric| metrics_copies.find{|copy| compare_hashes(metric, copy, ['system_name']) } }
-
-          missing_metrics.map do |metric|
-            metric.delete('links')
-            client.create_metric(service_copy_id, metric)
-          end
-
-          puts "created #{missing_metrics.size} metrics on the copied service"
-
-          plans = source_client.list_service_application_plans(service_id)
-          plan_copies = client.list_service_application_plans(service_copy_id)
-
-          puts "original service has #{plans.size} application plans "
-          puts "copied service has #{plan_copies.size} application plans"
-
-          missing_application_plans = plans.reject { |plan| plan_copies.find{|copy| plan.fetch('system_name') == copy.fetch('system_name') } }
-
-          puts "copied service missing #{missing_application_plans.size} application plans"
-
-          missing_application_plans.each do |plan|
-            plan.delete('links')
-            plan.delete('default') # TODO: handle default plan
-
-            if plan.delete('custom') # TODO: what to do with custom plans?
-              puts "skipping custom plan #{plan}"
-            else
-              client.create_application_plan(service_copy_id, plan)
-            end
-          end
-
-          application_plan_mapping = client.list_service_application_plans(service_copy_id).map do |plan_copy|
-            plan = plans.find{|plan| plan.fetch('system_name') == plan_copy.fetch('system_name') }
-
-            [plan['id'], plan_copy['id']]
-          end
-
-          metrics_mapping = client.list_metrics(service_copy_id).map do |copy|
-            metric = metrics.find{|metric| metric.fetch('system_name') == copy.fetch('system_name') }
-            metric ||= {}
-
-            [metric['id'], copy['id']]
-          end.to_h
-
-          puts "destroying all mapping rules of the copy which have been created by default"
-          client.list_mapping_rules(service_copy_id).each do |mapping_rule|
-            client.delete_mapping_rule(service_copy_id, mapping_rule['id'])
-          end
-
-          mapping_rules = source_client.list_mapping_rules(service_id)
-          mapping_rules_copy = client.list_mapping_rules(service_copy_id)
-
-          puts "the original service has #{mapping_rules.size} mapping rules"
-          puts "the copy has #{mapping_rules_copy.size} mapping rules"
-
-          unique_mapping_rules_copy = mapping_rules_copy.dup
-
-          missing_mapping_rules = mapping_rules.reject do |mapping_rule|
-            matching_metric = unique_mapping_rules_copy.find do |copy|
-              compare_hashes(mapping_rule, copy, %w(pattern http_method delta)) &&
-                metrics_mapping.fetch(mapping_rule.fetch('metric_id')) == copy.fetch('metric_id')
-            end
-
-            unique_mapping_rules_copy.delete(matching_metric)
-          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'))
-            client.create_mapping_rule(service_copy_id, mapping_rule)
-          end
-          puts "created #{missing_mapping_rules.size} mapping rules"
-
-          puts "extra #{unique_mapping_rules_copy.size} mapping rules"
-          puts unique_mapping_rules_copy.each{|rule| rule.delete('links') }
-
-          application_plan_mapping.each do |original_id, copy_id|
-            limits = source_client.list_application_plan_limits(original_id)
-            limits_copy = client.list_application_plan_limits(copy_id)
-
-            missing_limits = limits.reject { |limit| limits_copy.find{|limit_copy| limit.fetch('period') == limit_copy.fetch('period') } }
-
-            missing_limits.each do |limit|
-              limit.delete('links')
-              client.create_application_plan_limit(copy_id, metrics_mapping.fetch(limit.fetch('metric_id')), limit)
-            end
-            puts "copied application plan #{copy_id} is missing #{missing_limits.size} from the original plan #{original_id}"
-          end
+        def create_new_service(service, destination, system_name)
+          Entities::Service.create(remote: threescale_client(destination),
+                                   service: service,
+                                   system_name: system_name)
         end
       end
     end

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

@@ -4,7 +4,7 @@ require '3scale_toolbox/base_command'
 module ThreeScaleToolbox
   module Commands
     module HelpCommand
-      extend ThreeScaleToolbox::Command
+      include ThreeScaleToolbox::Command
       def self.command
         Cri::Command.new_basic_help
       end