aspera-cli 4.4.0 → 4.7.0

data/lib/aspera/cli/main.rb

@@ -1,119 +1,179 @@
+# frozen_string_literal: true
 require 'aspera/cli/manager'
 require 'aspera/cli/formater'
 require 'aspera/cli/plugins/config'
 require 'aspera/cli/extended_value'
 require 'aspera/cli/transfer_agent'
 require 'aspera/cli/version'
+require 'aspera/cli/info'
+require 'aspera/fasp/error'
 require 'aspera/open_application'
 require 'aspera/temp_file_manager'
 require 'aspera/persistency_folder'
 require 'aspera/log'
 require 'aspera/rest'
 require 'aspera/nagios'
-require 'aspera/secrets'
+require 'aspera/colors'
 
 module Aspera
   module Cli
     # The main CLI class
     class Main
+      # prefix to display error messages
+      ERROR_FLASH='ERROR:'.bg_red.gray.blink.freeze
+      private_constant :ERROR_FLASH
 
-      attr_reader :plugin_env
-      private
-      # name of application, also foldername where config is stored
-      PROGRAM_NAME = 'ascli'
-      # name of the containing gem, same as in <gem name>.gemspec
-      GEM_NAME = 'aspera-cli'
-      HELP_URL = "http://www.rubydoc.info/gems/#{GEM_NAME}"
-      GEM_URL  = "https://rubygems.org/gems/#{GEM_NAME}"
-      SRC_URL  = "https://github.com/IBM/aspera-cli"
+      # store transfer result using this key and use result_transfer_multiple
       STATUS_FIELD = 'status'
 
-      private_constant :PROGRAM_NAME,:GEM_NAME,:HELP_URL,:GEM_URL
+      class << self
+        # expect some list, but nothing to display
+        def result_empty; return {type: :empty, data: :nil}; end
+
+        # nothing expected
+        def result_nothing; return {type: :nothing, data: :nil}; end
+
+        def result_status(status); return {type: :status, data: status}; end
+
+        def result_success; return result_status('complete'); end
+
+        # Process statuses of finished transfer sessions
+        # raise exception if there is one error
+        # else returns an empty status
+        def result_transfer(statuses)
+          worst=TransferAgent.session_status(statuses)
+          raise worst unless worst.eql?(:success)
+          return Main.result_nothing
+        end
+
+        # used when one command executes several transfer jobs (each job being possibly multi session)
+        # @param status_table [Array] [{STATUS_FIELD=>[status array],...},...]
+        # @return a status object suitable as command result
+        # each element has a key STATUS_FIELD which contains the result of possibly multiple sessions
+        def result_transfer_multiple(status_table)
+          global_status=:success
+          # transform status array into string and find if there was problem
+          status_table.each do |item|
+            worst=TransferAgent.session_status(item[STATUS_FIELD])
+            global_status=worst unless worst.eql?(:success)
+            item[STATUS_FIELD]=item[STATUS_FIELD].map(&:to_s).join(',')
+          end
+          raise global_status unless global_status.eql?(:success)
+          return {type: :object_list,data: status_table}
+        end
+      end
+
+      private
+
       # =============================================================
       # Parameter handlers
       #
-      def option_insecure; Rest.insecure ; end
-
-      def option_insecure=(value); Rest.insecure = value; end
+      attr_accessor :option_insecure, :option_http_options, :option_cache_tokens
 
       def option_ui; OpenApplication.instance.url_method; end
 
       def option_ui=(value); OpenApplication.instance.url_method=value; end
 
+      # called everytime a new REST HTTP session is opened
+      # @param http [Net::HTTP] the newly created http session object
+      def http_parameters=(http)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @option_insecure
+        http.set_debug_output($stdout) if @option_rest_debug
+        raise 'http_options expects Hash' unless @option_http_options.is_a?(Hash)
+
+        @option_http_options.each do |k,v|
+          method="#{k}=".to_sym
+          # check if accessor is a method of Net::HTTP
+          # continue_timeout= read_timeout= write_timeout=
+          if http.respond_to?(method)
+            http.send(method,v)
+          else
+            Log.log.error("no such attribute: #{k}")
+          end
+        end
+      end
+
       # minimum initialization
       def initialize(argv)
         # first thing : manage debug level (allows debugging of option parser)
         early_debug_setup(argv)
         # compare $0 with expected name
         current_prog_name=File.basename($PROGRAM_NAME)
-        unless current_prog_name.eql?(PROGRAM_NAME)
-          @plugin_env[:formater].display_message(:error,"#{"WARNING".bg_red.blink.gray} Please use '#{PROGRAM_NAME}' instead of '#{current_prog_name}', '#{current_prog_name}' will be removed in a future version")
-        end
+        @plugin_env[:formater].display_message(:error,"#{'WARNING'.bg_red.blink.gray} Please use '#{PROGRAM_NAME}' instead of '#{current_prog_name}'") unless current_prog_name.eql?(PROGRAM_NAME)
         @option_help=false
         @bash_completion=false
         @option_show_config=false
+        @option_insecure=false
+        @option_rest_debug=false
+        @option_cache_tokens=true
+        @option_http_options={}
         # environment provided to plugin for various capabilities
         @plugin_env={}
-        # find out application main folder
-        app_main_folder=ENV[conf_dir_env_var]
-        # if env var undefined or empty
-        if app_main_folder.nil? or app_main_folder.empty?
-          user_home_folder=Dir.home
-          raise CliError,"Home folder does not exist: #{user_home_folder}. Check your user environment or use #{conf_dir_env_var}." unless Dir.exist?(user_home_folder)
-          app_main_folder=File.join(user_home_folder,Plugins::Config::ASPERA_HOME_FOLDER_NAME,PROGRAM_NAME)
-        end
-        # give command line arguments to option manager (no parsing)
-        @plugin_env[:options]=@opt_mgr=Manager.new(PROGRAM_NAME,argv,app_banner())
+        # give command line arguments to option manager
+        @plugin_env[:options]=@opt_mgr=Manager.new(PROGRAM_NAME,argv)
+        # formatter adds options
         @plugin_env[:formater]=Formater.new(@plugin_env[:options])
         Rest.user_agent=PROGRAM_NAME
+        Rest.session_cb=lambda{|http|self.http_parameters=http}
         # declare and parse global options
         init_global_options()
-        # secret manager
-        @plugin_env[:secret]=Aspera::Secrets.new
-        # the Config plugin adds the @preset parser
-        @plugin_env[:config]=Plugins::Config.new(@plugin_env,PROGRAM_NAME,HELP_URL,Aspera::Cli::VERSION,app_main_folder)
+        # the Config plugin adds the @preset parser, so declare before TransferAgent which may use it
+        @plugin_env[:config]=Plugins::Config.new(@plugin_env, gem: GEM_NAME, name: PROGRAM_NAME, help: DOC_URL, version: Aspera::Cli::VERSION)
         # the TransferAgent plugin may use the @preset parser
-        @plugin_env[:transfer]=TransferAgent.new(@plugin_env)
-        # set application folder for modules
+        @plugin_env[:transfer]=TransferAgent.new(@plugin_env[:options],@plugin_env[:config])
+        # data persistency
         @plugin_env[:persistency]=PersistencyFolder.new(File.join(@plugin_env[:config].main_folder,'persist_store'))
         Log.log.debug('plugin env created'.red)
-        Oauth.persist_mgr=@plugin_env[:persistency]
+        Oauth.persist_mgr=@plugin_env[:persistency] if @option_cache_tokens
         Fasp::Parameters.file_list_folder=File.join(@plugin_env[:config].main_folder,'filelists')
         Aspera::RestErrorAnalyzer.instance.log_file=File.join(@plugin_env[:config].main_folder,'rest_exceptions.log')
         # register aspera REST call error handlers
-        Aspera::RestErrorsAspera.registerHandlers
+        Aspera::RestErrorsAspera.register_handlers
+        # set banner when all environment is created so that additional extended value modifiers are known, e.g. @preset
+        @opt_mgr.parser.banner=app_banner
       end
 
       def app_banner
-        banner = "NAME\n\t#{PROGRAM_NAME} -- a command line tool for Aspera Applications (v#{Aspera::Cli::VERSION})\n\n"
-        banner << "SYNOPSIS\n"
-        banner << "\t#{PROGRAM_NAME} COMMANDS [OPTIONS] [ARGS]\n"
-        banner << "\nDESCRIPTION\n"
-        banner << "\tUse Aspera application to perform operations on command line.\n"
-        banner << "\tDocumentation and examples: #{GEM_URL}\n"
-        banner << "\texecute: #{PROGRAM_NAME} conf doc\n"
-        banner << "\tor visit: #{HELP_URL}\n"
-        banner << "\nENVIRONMENT VARIABLES\n"
-        banner << "\t#{conf_dir_env_var}  config folder, default: $HOME/#{Plugins::Config::ASPERA_HOME_FOLDER_NAME}/#{PROGRAM_NAME}\n"
-        banner << "\t#any option can be set as an environment variable, refer to the manual\n"
-        banner << "\nCOMMANDS\n"
-        banner << "\tTo list first level commands, execute: #{PROGRAM_NAME}\n"
-        banner << "\tNote that commands can be written shortened (provided it is unique).\n"
-        banner << "\nOPTIONS\n"
-        banner << "\tOptions begin with a '-' (minus), and value is provided on command line.\n"
-        banner << "\tSpecial values are supported beginning with special prefix, like: #{ExtendedValue.instance.modifiers.map{|m|"@#{m}:"}.join(' ')}.\n"
-        banner << "\tDates format is 'DD-MM-YY HH:MM:SS', or 'now' or '-<num>h'\n\n"
-        banner << "ARGS\n"
-        banner << "\tSome commands require mandatory arguments, e.g. a path.\n"
+        return <<~END_OF_BANNER
+          NAME
+          \t#{PROGRAM_NAME} -- a command line tool for Aspera Applications (v#{Aspera::Cli::VERSION})
+
+          SYNOPSIS
+          \t#{PROGRAM_NAME} COMMANDS [OPTIONS] [ARGS]
+
+          DESCRIPTION
+          \tUse Aspera application to perform operations on command line.
+          \tDocumentation and examples: #{GEM_URL}
+          \texecute: #{PROGRAM_NAME} conf doc
+          \tor visit: #{DOC_URL}
+          \tsource repo: #{SRC_URL}
+
+          ENVIRONMENT VARIABLES
+          \t#{@plugin_env[:config].conf_dir_env_var} config folder, default: $HOME/#{Plugins::Config::ASPERA_HOME_FOLDER_NAME}/#{PROGRAM_NAME}
+          \tAny option can be set as an environment variable, refer to the manual
+
+          COMMANDS
+          \tTo list first level commands, execute: #{PROGRAM_NAME}
+          \tNote that commands can be written shortened (provided it is unique).
+
+          OPTIONS
+          \tOptions begin with a '-' (minus), and value is provided on command line.
+          \tSpecial values are supported beginning with special prefix @pfx:, where pfx is one of:
+          \t#{ExtendedValue.instance.modifiers.map(&:to_s).join(', ')}
+          \tDates format is 'DD-MM-YY HH:MM:SS', or 'now' or '-<num>h'
+
+          ARGS
+          \tSome commands require mandatory arguments, e.g. a path.
+        END_OF_BANNER
       end
 
       # define header for manual
       def init_global_options
-        Log.log.debug("init_global_options")
-        @opt_mgr.add_opt_switch(:help,"-h","Show this message.") { @option_help=true }
-        @opt_mgr.add_opt_switch(:bash_comp,"generate bash completion for command") { @bash_completion=true }
-        @opt_mgr.add_opt_switch(:show_config, "Display parameters used for the provided action.") { @option_show_config=true }
-        @opt_mgr.add_opt_switch(:rest_debug,"-r","more debug for HTTP calls") { Rest.debug=true }
+        Log.log.debug('init_global_options')
+        @opt_mgr.add_opt_switch(:help,'-h','Show this message.') { @option_help=true }
+        @opt_mgr.add_opt_switch(:bash_comp,'generate bash completion for command') { @bash_completion=true }
+        @opt_mgr.add_opt_switch(:show_config, 'Display parameters used for the provided action.') { @option_show_config=true }
+        @opt_mgr.add_opt_switch(:rest_debug,'-r','more debug for HTTP calls') { @option_rest_debug=true }
         @opt_mgr.add_opt_switch(:version,'-v','display version') { @plugin_env[:formater].display_message(:data,Aspera::Cli::VERSION);Process.exit(0) }
         @opt_mgr.add_opt_switch(:warnings,'-w','check for language warnings') { $VERBOSE=true }
         # handler must be set before declaration
@@ -121,15 +181,21 @@ module Aspera
         @opt_mgr.set_obj_attr(:logger,Log.instance,:logger_type)
         @opt_mgr.set_obj_attr(:insecure,self,:option_insecure,:no)
         @opt_mgr.set_obj_attr(:ui,self,:option_ui)
+        @opt_mgr.set_obj_attr(:http_options,self,:option_http_options)
+        @opt_mgr.set_obj_attr(:log_secrets,Log.instance,:log_secrets)
+        @opt_mgr.set_obj_attr(:cache_tokens,self,:option_cache_tokens)
         @opt_mgr.add_opt_list(:ui,OpenApplication.user_interfaces,'method to start browser')
-        @opt_mgr.add_opt_list(:log_level,Log.levels,"Log level")
-        @opt_mgr.add_opt_list(:logger,Log.logtypes,"log method")
-        @opt_mgr.add_opt_simple(:lock_port,"prevent dual execution of a command, e.g. in cron")
-        @opt_mgr.add_opt_simple(:query,"additional filter for API calls (extended value) (some commands)")
-        @opt_mgr.add_opt_boolean(:insecure,"do not validate HTTPS certificate")
-        @opt_mgr.add_opt_boolean(:once_only,"process only new items (some commands)")
+        @opt_mgr.add_opt_list(:log_level,Log.levels,'Log level')
+        @opt_mgr.add_opt_list(:logger,Log.logtypes,'log method')
+        @opt_mgr.add_opt_simple(:lock_port,'prevent dual execution of a command, e.g. in cron')
+        @opt_mgr.add_opt_simple(:query,'additional filter for API calls (extended value) (some commands)')
+        @opt_mgr.add_opt_simple(:http_options,'options for http socket (extended value)')
+        @opt_mgr.add_opt_boolean(:insecure,'do not validate HTTPS certificate')
+        @opt_mgr.add_opt_boolean(:once_only,'process only new items (some commands)')
+        @opt_mgr.add_opt_boolean(:log_secrets,'show passwords in logs')
+        @opt_mgr.add_opt_boolean(:cache_tokens,'save and reuse Oauth tokens')
         @opt_mgr.set_option(:ui,OpenApplication.default_gui_mode)
-        @opt_mgr.set_option(:once_only,:false)
+        @opt_mgr.set_option(:once_only,false)
         # parse declared options
         @opt_mgr.parse_options!
       end
@@ -143,33 +209,23 @@ module Aspera
         require @plugin_env[:config].plugins[plugin_name_sym][:require_stanza]
         # load default params only if no param already loaded before plugin instanciation
         env[:config].add_plugin_default_preset(plugin_name_sym)
-        command_plugin=Plugins::Config.plugin_new(plugin_name_sym,env)
+        command_plugin=Plugins::Config.plugin_class(plugin_name_sym).new(env)
         Log.log.debug("got #{command_plugin.class}")
         # TODO: check that ancestor is Plugin?
         return command_plugin
       end
 
       def generate_bash_completion
-        if @opt_mgr.get_next_argument("",:multiple,:optional).nil?
+        if @opt_mgr.get_next_argument('',:multiple,:optional).nil?
           @plugin_env[:config].plugins.keys.each{|p|puts p.to_s}
         else
-          Log.log.warn("only first level completion so far")
+          Log.log.warn('only first level completion so far')
         end
         Process.exit(0)
       end
 
-      # expect some list, but nothing to display
-      def self.result_empty; return {:type => :empty, :data => :nil }; end
-
-      # nothing expected
-      def self.result_nothing; return {:type => :nothing, :data => :nil }; end
-
-      def self.result_status(status); return {:type => :status, :data => status }; end
-
-      def self.result_success; return result_status('complete'); end
-
       def exit_with_usage(all_plugins)
-        Log.log.debug("exit_with_usage".bg_red)
+        Log.log.debug('exit_with_usage'.bg_red)
         # display main plugin options
         @plugin_env[:formater].display_message(:error,@opt_mgr.parser)
         if all_plugins
@@ -179,10 +235,11 @@ module Aspera
             # override main option parser with a brand new, to avoid having global options
             plugin_env=@plugin_env.clone
             plugin_env[:man_only]=true
-            plugin_env[:options]=Manager.new(PROGRAM_NAME,[],'')
+            plugin_env[:options]=Manager.new(PROGRAM_NAME)
+            plugin_env[:options].parser.banner='' # remove default banner
             get_plugin_instance_with_options(plugin_name_sym,plugin_env)
             # display generated help for plugin options
-            @plugin_env[:formater].display_message(:error,plugin_env[:options].parser.to_s)
+            @plugin_env[:formater].display_message(:error,plugin_env[:options].parser.help)
           end
         end
         Process.exit(0)
@@ -190,54 +247,21 @@ module Aspera
 
       protected
 
-      # env var name to override the app's main folder
-      # default main folder is $HOME/<vendor main app folder>/<program name>
-      def conf_dir_env_var
-        return "#{PROGRAM_NAME}_home".upcase
-      end
-
       # early debug for parser
       # Note: does not accept shortcuts
       def early_debug_setup(argv)
         Log.instance.program_name=PROGRAM_NAME
         argv.each do |arg|
           case arg
-          when '--'
-            return
-          when /^--log-level=(.*)/
-            Log.instance.level = $1.to_sym
-          when /^--logger=(.*)/
-            Log.instance.logger_type=$1.to_sym
+          when '--' then break
+          when /^--log-level=(.*)/ then Log.instance.level = Regexp.last_match(1).to_sym
+          when /^--logger=(.*)/ then Log.instance.logger_type=Regexp.last_match(1).to_sym
           end
         end
       end
 
       public
 
-      # Process statuses of finished transfer sessions
-      # raise exception if there is one error
-      # else returns an empty status
-      def self.result_transfer(statuses)
-        worst=TransferAgent.session_status(statuses)
-        raise worst unless worst.eql?(:success)
-        return Main.result_nothing
-      end
-
-      # used when one command executes several transfer jobs (each job being possibly multi session)
-      # @param status_table [Array] [{STATUS_FIELD=>[status array],...},...]
-      # each element has a key STATUS_FIELD which contains the result of possibly mulmtiple sessions
-      def self.result_transfer_multiple(status_table)
-        global_status=:success
-        # transform status into string and find if there was problem
-        status_table.each do |item|
-          worst=TransferAgent.session_status(item[STATUS_FIELD])
-          global_status=worst unless worst.eql?(:success)
-          item[STATUS_FIELD]=item[STATUS_FIELD].map{|i|i.to_s}.join(',')
-        end
-        raise global_status unless global_status.eql?(:success)
-        return {:type=>:object_list,:data=>status_table}
-      end
-
       # this is the main function called by initial script just after constructor
       def process_command_line
         Log.log.debug('process_command_line')
@@ -249,17 +273,17 @@ module Aspera
           # find plugins, shall be after parse! ?
           @plugin_env[:config].add_plugins_from_lookup_folders
           # help requested without command ? (plugins must be known here)
-          exit_with_usage(true) if @option_help and @opt_mgr.command_or_arg_empty?
+          exit_with_usage(true) if @option_help && @opt_mgr.command_or_arg_empty?
           generate_bash_completion if @bash_completion
-          # load global default options and process
-          @plugin_env[:config].add_plugin_default_preset(Plugins::Config::CONF_GLOBAL_SYM)
-          @opt_mgr.parse_options!
           @plugin_env[:config].periodic_check_newer_gem_version
-          if @option_show_config and @opt_mgr.command_or_arg_empty?
-            command_sym=Plugins::Config::CONF_PLUGIN_SYM
+          command_sym=
+          if @option_show_config && @opt_mgr.command_or_arg_empty?
+            Plugins::Config::CONF_PLUGIN_SYM
           else
-            command_sym=@opt_mgr.get_next_command(@plugin_env[:config].plugins.keys.dup.unshift(:help))
+            @opt_mgr.get_next_command(@plugin_env[:config].plugins.keys.dup.unshift(:help))
           end
+          # command will not be executed, but we need manual
+          @opt_mgr.fail_on_missing_mandatory=false if @option_help || @option_show_config
           # main plugin is not dynamically instanciated
           case command_sym
           when :help
@@ -275,8 +299,8 @@ module Aspera
           # help requested for current plugin
           exit_with_usage(false) if @option_help
           if @option_show_config
-            @plugin_env[:formater].display_results({:type=>:single_object,:data=>@opt_mgr.declared_options(false)})
-            Process.exit(0)
+            @plugin_env[:formater].display_results({type: :single_object,data: @opt_mgr.declared_options(only_defined: true)})
+            execute_command=false
           end
           # locking for single execution (only after "per plugin" option, in case lock port is there)
           lock_port=@opt_mgr.get_option(:lock_port,:optional)
@@ -285,7 +309,7 @@ module Aspera
               # no need to close later, will be freed on process exit. must save in member else it is garbage collected
               Log.log.debug("Opening lock port #{lock_port.to_i}")
               @tcp_server=TCPServer.new('127.0.0.1',lock_port.to_i)
-            rescue => e
+            rescue StandardError => e
               execute_command=false
               Log.log.warn("Another instance is already running (#{e.message}).")
             end
@@ -294,40 +318,40 @@ module Aspera
           @plugin_env[:formater].display_results(command_plugin.execute_action) if execute_command
           # finish
           @plugin_env[:transfer].shutdown
-        rescue CliBadArgument => e;          exception_info=[e,'Argument',:usage]
-        rescue CliNoSuchId => e;             exception_info=[e,'Identifier']
-        rescue CliError => e;                exception_info=[e,'Tool',:usage]
-        rescue Fasp::Error => e;             exception_info=[e,'FASP(ascp)']
-        rescue Aspera::RestCallError => e;   exception_info=[e,'Rest']
-        rescue SocketError => e;             exception_info=[e,'Network']
-        rescue StandardError => e;           exception_info=[e,'Other',:debug]
-        rescue Interrupt => e;               exception_info=[e,'Interruption',:debug]
+        rescue CliBadArgument => e;          exception_info={e: e,t: 'Argument',usage: true}
+        rescue CliNoSuchId => e;             exception_info={e: e,t: 'Identifier'}
+        rescue CliError => e;                exception_info={e: e,t: 'Tool',usage: true}
+        rescue Fasp::Error => e;             exception_info={e: e,t: 'FASP(ascp)'}
+        rescue Aspera::RestCallError => e;   exception_info={e: e,t: 'Rest'}
+        rescue SocketError => e;             exception_info={e: e,t: 'Network'}
+        rescue StandardError => e;           exception_info={e: e,t: 'Other',debug: true}
+        rescue Interrupt => e;               exception_info={e: e,t: 'Interruption',debug: true}
         end
         # cleanup file list files
         TempFileManager.instance.cleanup
         # 1- processing of error condition
         unless exception_info.nil?
-          @plugin_env[:formater].display_message(:error,"ERROR:".bg_red.gray.blink+" "+exception_info[1]+": "+exception_info[0].message)
-          @plugin_env[:formater].display_message(:error,"Use '-h' option to get help.") if exception_info[2].eql?(:usage)
-          if exception_info.first.is_a?(Fasp::Error) and exception_info.first.message.eql?('Remote host is not who we expected')
+          @plugin_env[:formater].display_message(:error,"#{ERROR_FLASH} #{exception_info[:t]}: #{exception_info[:e].message}")
+          @plugin_env[:formater].display_message(:error,'Use option -h to get help.') if exception_info[:usage]
+          if exception_info[:e].is_a?(Fasp::Error) && exception_info[:e].message.eql?('Remote host is not who we expected')
             @plugin_env[:formater].display_message(:error,"For this specific error, refer to:\n#{SRC_URL}#error-remote-host-is-not-who-we-expected\nAdd this to arguments:\n--ts=@json:'{\"sshfp\":null}'")
           end
         end
         # 2- processing of command not processed (due to exception or bad command line)
-        if execute_command
+        if execute_command || @option_show_config
           @opt_mgr.final_errors.each do |msg|
-            @plugin_env[:formater].display_message(:error,"ERROR:".bg_red.gray.blink+" Argument: "+msg)
+            @plugin_env[:formater].display_message(:error,"#{ERROR_FLASH} Argument: #{msg}")
+            # add code as exception if there is not already an error
+            exception_info={e: Exception.new(msg),t: 'UnusedArg'} if exception_info.nil?
           end
         end
         # 3- in case of error, fail the process status
         unless exception_info.nil?
-          if Log.instance.level.eql?(:debug)
-            # will force to show stack trace
-            raise exception_info[0]
-          else
-            @plugin_env[:formater].display_message(:error,"Use '--log-level=debug' to get more details.") if exception_info[2].eql?(:debug)
-            Process.exit(1)
-          end
+          # show stack trace in debug mode
+          raise exception_info[:e] if Log.instance.level.eql?(:debug)
+          # else give hint and exit
+          @plugin_env[:formater].display_message(:error,'Use --log-level=debug to get more details.') if exception_info[:debug]
+          Process.exit(1)
         end
         return nil
       end # process_command_line