aspera-cli 4.15.0 → 4.16.0

data/lib/aspera/cli/plugins/config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# cspell:ignore initdemo genkey asperasoft
+# cspell:ignore initdemo genkey pubkey asperasoft
 require 'aspera/cli/basic_auth_plugin'
 require 'aspera/cli/extended_value'
 require 'aspera/cli/version'
@@ -19,9 +19,11 @@ require 'aspera/open_application'
 require 'aspera/persistency_action_once'
 require 'aspera/id_generator'
 require 'aspera/persistency_folder'
+require 'aspera/data_repository'
 require 'aspera/line_logger'
 require 'aspera/rest'
 require 'aspera/log'
+require 'aspera/assert'
 require 'open3'
 require 'date'
 require 'erb'
@@ -35,11 +37,13 @@ module Aspera
         ASPERA_HOME_FOLDER_NAME = '.aspera'
         # default config file
         DEFAULT_CONFIG_FILENAME = 'config.yaml'
+        DEFAULT_VAULT_FILENAME = 'vault.bin'
         # reserved preset names
         CONF_PRESET_CONFIG = 'config'
         CONF_PRESET_VERSION = 'version'
-        CONF_PRESET_DEFAULT = 'default'
+        CONF_PRESET_DEFAULTS = 'default'
         CONF_PRESET_GLOBAL = 'global_common_defaults'
+        # special name to identify value of default
         GLOBAL_DEFAULT_KEYWORD = 'GLOBAL'
         CONF_PLUGIN_SYM = :config # Plugins::Config.name.split('::').last.downcase.to_sym
         CONF_GLOBAL_SYM = :config
@@ -77,7 +81,7 @@ module Aspera
         private_constant :DEFAULT_CONFIG_FILENAME,
           :CONF_PRESET_CONFIG,
           :CONF_PRESET_VERSION,
-          :CONF_PRESET_DEFAULT,
+          :CONF_PRESET_DEFAULTS,
           :CONF_PRESET_GLOBAL,
           :ASPERA_PLUGINS_FOLDERNAME,
           :RUBY_FILE_EXT,
@@ -141,20 +145,22 @@ module Aspera
           # return product family folder (~/.aspera)
           def module_family_folder
             user_home_folder = Dir.home
-            raise Cli::Error, "Home folder does not exist: #{user_home_folder}. Check your user environment." unless Dir.exist?(user_home_folder)
+            assert(Dir.exist?(user_home_folder), exception_class: Cli::Error){"Home folder does not exist: #{user_home_folder}. Check your user environment."}
             return File.join(user_home_folder, ASPERA_HOME_FOLDER_NAME)
           end
 
           # return product config folder (~/.aspera/<name>)
           def default_app_main_folder(app_name:)
-            raise 'app_name must be a non-empty String' unless app_name.is_a?(String) && !app_name.empty?
+            assert_type(app_name, String)
+            assert(!app_name.empty?)
             return File.join(module_family_folder, app_name)
           end
         end # self
 
         def initialize(env, params)
-          raise 'Internal Error: env and params must be Hash' unless env.is_a?(Hash) && params.is_a?(Hash)
-          raise 'Internal Error: missing param' unless %i[gem help name version].eql?(params.keys.sort)
+          assert_type(env, Hash)
+          assert_type(params, Hash)
+          assert(%i[gem help name version].eql?(params.keys.sort)){'missing param'}
           # we need to defer parsing of options until we have the config file, so we can use @extend with @preset
           super(env)
           @info = params
@@ -168,6 +174,7 @@ module Aspera
           @pac_exec = nil
           @sdk_default_location = false
           @option_insecure = false
+          @option_warn_insecure_cert = true
           @option_ignore_cert_host_port = []
           @option_http_options = {}
           @ssl_warned_urls = []
@@ -233,7 +240,8 @@ module Aspera
           options.declare(:notify_template, 'Email ERB template for notification of transfers')
           # HTTP options
           options.declare(:insecure, 'Do not validate any HTTPS certificate', values: :bool, handler: {o: self, m: :option_insecure}, default: :no)
-          options.declare(:ignore_certificate, 'List of HTTPS url where to no validate certificate', types: Array, handler: {o: self, m: :option_ignore_cert_host_port})
+          options.declare(:ignore_certificate, 'Do not validate HTTPS certificate for these URLs', types: Array, handler: {o: self, m: :option_ignore_cert_host_port})
+          options.declare(:silent_insecure, 'Issue a warning if certificate is ignored', values: :bool, handler: {o: self, m: :option_warn_insecure_cert}, default: :yes)
           options.declare(:cert_stores, 'List of folder with trusted certificates', types: [Array, String], handler: {o: self, m: :trusted_cert_locations})
           options.declare(:http_options, 'Options for HTTP/S socket', types: Hash, handler: {o: self, m: :option_http_options}, default: {})
           options.declare(:cache_tokens, 'Save and reuse Oauth tokens', values: :bool, handler: {o: self, m: :option_cache_tokens})
@@ -264,7 +272,7 @@ module Aspera
           @pac_exec = Aspera::ProxyAutoConfig.new(pac_script).register_uri_generic unless pac_script.nil?
           proxy_user_pass = options.get_option(:proxy_credentials)
           if !proxy_user_pass.nil?
-            raise Cli::BadArgument, "proxy_credentials shall have two elements (#{proxy_user_pass.length})" unless proxy_user_pass.length.eql?(2)
+            assert(proxy_user_pass.length.eql?(2), exception_class: Cli::BadArgument){"proxy_credentials shall have two elements (#{proxy_user_pass.length})"}
             @proxy_credentials = {user: proxy_user_pass[0], pass: proxy_user_pass[1]}
             @pac_exec.proxy_user = @proxy_credentials[:user]
             @pac_exec.proxy_pass = @proxy_credentials[:pass]
@@ -280,7 +288,7 @@ module Aspera
           Aspera::RestErrorsAspera.register_handlers
         end
 
-        attr_accessor :main_folder, :option_cache_tokens, :option_insecure, :option_http_options
+        attr_accessor :main_folder, :option_cache_tokens, :option_insecure, :option_warn_insecure_cert, :option_http_options
         attr_reader :option_ignore_cert_host_port, :progress_bar
 
         def trusted_cert_locations=(path_list)
@@ -293,7 +301,7 @@ module Aspera
           end
 
           path_list.each do |path|
-            raise 'Expecting a String for cert location' unless path.is_a?(String)
+            assert_type(path, String){'Expecting a String for cert location'}
             Log.log.debug("Adding cert location: #{path}")
             if path.eql?(ExtendedValue::DEF)
               path = OpenSSL::X509::DEFAULT_CERT_DIR
@@ -325,22 +333,28 @@ module Aspera
         def option_ignore_cert_host_port=(url_list)
           url_list.each do |url|
             uri = URI.parse(url)
+            raise "Expecting https scheme: #{url}" unless uri.scheme.eql?('https')
             @option_ignore_cert_host_port.push([uri.host, uri.port].freeze)
           end
         end
 
         def ignore_cert?(address, port)
           endpoint = [address, port].freeze
-          Log.log.debug{"ignore cert? #{endpoint}"}
-          return false unless @option_insecure || @option_ignore_cert_host_port.any?(endpoint)
-          base_url = "https://#{address}:#{port}"
-          if !@ssl_warned_urls.include?(base_url)
-            formatter.display_message(
-              :error,
-              "#{Formatter::WARNING_FLASH} Ignoring certificate for: #{base_url}. Do not deactivate certificate verification in production.")
-            @ssl_warned_urls.push(base_url)
+          ignore_cert = false
+          if @option_insecure || @option_ignore_cert_host_port.any?(endpoint)
+            ignore_cert = true
+            if @option_warn_insecure_cert
+              base_url = "https://#{address}:#{port}"
+              if !@ssl_warned_urls.include?(base_url)
+                formatter.display_message(
+                  :error,
+                  "#{Formatter::WARNING_FLASH} Ignoring certificate for: #{base_url}. Do not deactivate certificate verification in production.")
+                @ssl_warned_urls.push(base_url)
+              end
+            end
           end
-          return true
+          Log.log.debug{"ignore cert? #{endpoint} -> #{ignore_cert}"}
+          return ignore_cert
         end
 
         # called every time a new REST HTTP session is opened to set user-provided options
@@ -443,25 +457,25 @@ module Aspera
           return nil
         end
 
-        # get the default global preset, or init a new one
+        # get the default global preset, or set default one
         def global_default_preset
-          global_default_preset_name = get_plugin_default_config_name(CONF_GLOBAL_SYM)
-          if global_default_preset_name.nil?
-            global_default_preset_name = CONF_PRESET_GLOBAL.to_s
-            set_preset_key(CONF_PRESET_DEFAULT, CONF_GLOBAL_SYM, global_default_preset_name)
+          result = get_plugin_default_config_name(CONF_GLOBAL_SYM)
+          if result.nil?
+            result = CONF_PRESET_GLOBAL
+            set_preset_key(CONF_PRESET_DEFAULTS, CONF_GLOBAL_SYM, result)
           end
-          return global_default_preset_name
+          return result
         end
 
         def set_preset_key(preset, param_name, param_value)
-          raise "Parameter name must be a String or Symbol, not #{param_name.class}" unless [String, Symbol].include?(param_name.class)
+          assert_values(param_name.class, [String, Symbol]){'parameter'}
           param_name = param_name.to_s
           selected_preset = @config_presets[preset]
           if selected_preset.nil?
             Log.log.debug{"No such preset name: #{preset}, initializing"}
             selected_preset = @config_presets[preset] = {}
           end
-          raise "expecting Hash for #{preset}.#{param_name}" unless selected_preset.is_a?(Hash)
+          assert_type(selected_preset, Hash){"#{preset}.#{param_name}"}
           if selected_preset.key?(param_name)
             if selected_preset[param_name].eql?(param_value)
               Log.log.warn{"keeping same value for #{preset}: #{param_name}: #{param_value}"}
@@ -493,7 +507,7 @@ module Aspera
           include_path = include_path.clone # avoid messing up if there are multiple branches
           current = @config_presets
           config_name.split(PRESET_DIG_SEPARATOR).each do |name|
-            raise Cli::Error, "Expecting Hash for sub key: #{include_path} (#{current.class})" unless current.is_a?(Hash)
+            assert_type(current, Hash, exception_class: Cli::Error){"sub key: #{include_path}"}
             include_path.push(name)
             current = current[name]
             raise Cli::Error, "No such config preset: #{include_path}" if current.nil?
@@ -511,11 +525,10 @@ module Aspera
         end
 
         def option_plugin_folder=(value)
-          case value
-          when String then add_plugin_lookup_folder(value)
-          when Array then value.each{|f|add_plugin_lookup_folder(f)}
-          else raise "folder shall be Array or String, not #{value.class}"
-          end
+          assert_values(value.class, [String, Array]){'plugin folder'}
+          value = [value] if value.is_a?(String)
+          assert(value.all?(String)){'plugin folder'}
+          value.each{|f|add_plugin_lookup_folder(f)}
         end
 
         def option_plugin_folder
@@ -558,15 +571,15 @@ module Aspera
           end
           files_to_copy = []
           Log.log.debug{Log.dump('Available_presets', @config_presets)}
-          raise 'Expecting YAML Hash' unless @config_presets.is_a?(Hash)
+          assert_type(@config_presets, Hash){'config file YAML'}
           # check there is at least the config section
-          raise "Cannot find key: #{CONF_PRESET_CONFIG}" unless @config_presets.key?(CONF_PRESET_CONFIG)
+          assert(@config_presets.key?(CONF_PRESET_CONFIG)){"Cannot find key: #{CONF_PRESET_CONFIG}"}
           version = @config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION]
           raise 'No version found in config section.' if version.nil?
           Log.log.debug{"conf version: #{version}"}
           # VVV if there are any conversion needed, those happen here.
           # fix bug in 4.4 (creating key "true" in "default" preset)
-          @config_presets[CONF_PRESET_DEFAULT].delete(true) if @config_presets[CONF_PRESET_DEFAULT].is_a?(Hash)
+          @config_presets[CONF_PRESET_DEFAULTS].delete(true) if @config_presets[CONF_PRESET_DEFAULTS].is_a?(Hash)
           # ^^^ Place new compatibility code before this line
           # set version to current
           @config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION] = @info[:version]
@@ -646,13 +659,14 @@ module Aspera
               next
             end
             next if detection_info.nil?
-            raise 'internal error' if detection_info.key?(:url) && !detection_info[:url].is_a?(String)
+            assert_type(detection_info, Hash)
+            assert_type(detection_info[:url], String) if detection_info.key?(:url)
             app_name = detect_plugin_class.respond_to?(:application_name) ? detect_plugin_class.application_name : detect_plugin_class.name.split('::').last
             # if there is a redirect, then the detector can override the url.
             found_apps.push({product: plugin_name_sym, name: app_name, url: app_url, version: 'unknown'}.merge(detection_info))
           end # loop
           raise "No known application found at #{app_url}" if found_apps.empty?
-          raise 'Internal error' unless found_apps.all?{|a|a.keys.all?(Symbol)}
+          assert(found_apps.all?{|a|a.keys.all?(Symbol)})
           return found_apps
         end
 
@@ -666,10 +680,10 @@ module Aspera
           case command
           when :list
             return {type: :object_list, data: connect_versions, fields: %w[id title version]}
-          when :info # shows files used
+          when :info
             one_res.delete('links')
             return {type: :single_object, data: one_res}
-          when :version # shows files used
+          when :version
             all_links = one_res['links']
             command = options.get_next_command(%i[list download open])
             if %i[download open].include?(command)
@@ -678,7 +692,7 @@ module Aspera
               raise 'no such value' if one_link.nil?
             end
             case command
-            when :list # shows files used
+            when :list
               return {type: :object_list, data: all_links}
             when :download
               folder_dest = transfer.destination_folder(Fasp::TransferSpec::DIRECTION_RECEIVE)
@@ -706,49 +720,17 @@ module Aspera
             formatter.display_status("ascp version: #{ascp_version}")
             set_global_default(:ascp_path, ascp_path)
             return Main.result_nothing
-          when :show # shows files used
+          when :show
             return {type: :status, data: Fasp::Installation.instance.path(:ascp)}
-          when :info # shows files used
-            data = Fasp::Installation.instance.file_paths
-            # read PATHs from ascp directly, and pvcl modules as well
-            Open3.popen3(data['ascp'], '-DDL-') do |_stdin, _stdout, stderr, thread|
-              last_line = ''
-              while (line = stderr.gets)
-                line.chomp!
-                last_line = line
-                case line
-                when /^DBG Path ([^ ]+) (dir|file) +: (.*)$/
-                  data[Regexp.last_match(1)] = Regexp.last_match(3)
-                when /^DBG Added module group:"(?<module>[^"]+)" name:"(?<scheme>[^"]+)", version:"(?<version>[^"]+)" interface:"(?<interface>[^"]+)"$/
-                  c = Regexp.last_match.named_captures.symbolize_keys
-                  data[c[:interface]] ||= {}
-                  data[c[:interface]][c[:module]] ||= []
-                  data[c[:interface]][c[:module]].push("#{c[:scheme]} v#{c[:version]}")
-                when %r{^DBG License result \(/license/(\S+)\): (.+)$}
-                  data[Regexp.last_match(1)] = Regexp.last_match(2)
-                when /^LOG (.+) version ([0-9.]+)$/
-                  data['product_name'] = Regexp.last_match(1)
-                  data['product_version'] = Regexp.last_match(2)
-                when /^LOG Initializing FASP version ([^,]+),/
-                  data['ascp_version'] = Regexp.last_match(1)
-                end
-              end
-              if !thread.value.exitstatus.eql?(1) && !data.key?('root')
-                raise last_line
-              end
-            end
-            # ascp's openssl directory
-            ascp_file = data['ascp']
-            File.binread(ascp_file).scan(/[\x20-\x7E]{4,}/) do |match|
-              if (m = match.match(/OPENSSLDIR.*"(.*)"/))
-                data['openssldir'] = m[1]
-              end
-            end if File.file?(ascp_file)
-            data['uuid'] = Fasp::Installation.instance.ssh_cert_uuid
-            # log is "-" no need to display
-            data.delete('log')
-            # show command line transfer spec
+          when :info
+            # collect info from ascp executable
+            data = Fasp::Installation.instance.ascp_info
+            # add command line transfer spec
             data['ts'] = transfer.updated_ts
+            # add keys
+            DataRepository::ELEMENTS.each_with_object(data){|i, h|h[i.to_s] = DataRepository.instance.item(i)}
+            # declare those as secrets
+            SecretHider::ADDITIONAL_KEYS_TO_HIDE.push(*DataRepository::ELEMENTS.map(&:to_s))
             return {type: :single_object, data: data}
           when :products
             command = options.get_next_command(%i[list use])
@@ -887,6 +869,7 @@ module Aspera
           open
           documentation
           genkey
+          pubkey
           remote_certificate
           gem
           plugins
@@ -925,6 +908,9 @@ module Aspera
             private_key_length = options.get_next_argument('size in bits', mandatory: false, type: Integer, default: DEFAULT_PRIV_KEY_LENGTH)
             self.class.generate_rsa_private_key(path: private_key_path, length: private_key_length)
             return Main.result_status("Generated #{private_key_length} bit RSA key: #{private_key_path}")
+          when :pubkey # get pub key
+            private_key_pem = options.get_next_argument('private key PEM value')
+            return Main.result_status(OpenSSL::PKey::RSA.new(private_key_pem).public_key.to_s)
           when :remote_certificate
             remote_url = options.get_next_argument('remote URL')
             @option_insecure = true
@@ -984,8 +970,7 @@ module Aspera
             return wizard_find(apps)
           when :coffee
             if OpenApplication.instance.url_method.eql?(:text)
-              require 'aspera/preview/terminal'
-              return Main.result_status(Preview::Terminal.build(Rest.new(base_url: COFFEE_IMAGE).read('')[:http].body))
+              return Main.result_picture_in_terminal(options, Rest.new(base_url: COFFEE_IMAGE).read('')[:http].body)
             end
             OpenApplication.instance.uri(COFFEE_IMAGE)
             return Main.result_nothing
@@ -1024,13 +1009,13 @@ module Aspera
                 'ssAP'.downcase.reverse + 'drow'.reverse => DEMO + ASPERA # cspell:disable-line
               }
             end
-            @config_presets[CONF_PRESET_DEFAULT] ||= {}
-            if @config_presets[CONF_PRESET_DEFAULT].key?(SERVER_COMMAND)
-              Log.log.warn{"Server default preset already set to: #{@config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND]}"}
+            @config_presets[CONF_PRESET_DEFAULTS] ||= {}
+            if @config_presets[CONF_PRESET_DEFAULTS].key?(SERVER_COMMAND)
+              Log.log.warn{"Server default preset already set to: #{@config_presets[CONF_PRESET_DEFAULTS][SERVER_COMMAND]}"}
               Log.log.warn{"Use #{DEMO_SERVER_PRESET} for demo: -P#{DEMO_SERVER_PRESET}"} unless
-                DEMO_SERVER_PRESET.eql?(@config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND])
+                DEMO_SERVER_PRESET.eql?(@config_presets[CONF_PRESET_DEFAULTS][SERVER_COMMAND])
             else
-              @config_presets[CONF_PRESET_DEFAULT][SERVER_COMMAND] = DEMO_SERVER_PRESET
+              @config_presets[CONF_PRESET_DEFAULTS][SERVER_COMMAND] = DEMO_SERVER_PRESET
               Log.log.info{"Setting server default preset to : #{DEMO_SERVER_PRESET}"}
             end
             return Main.result_status('Done')
@@ -1041,9 +1026,9 @@ module Aspera
             exception_class_name = options.get_next_argument('exception class name', mandatory: true)
             exception_text = options.get_next_argument('exception text', mandatory: true)
             exception_class = Object.const_get(exception_class_name)
-            raise "#{exception_class} is not an exception: #{exception_class.class}" unless exception_class <= Exception
+            assert(exception_class <= Exception){"#{exception_class} is not an exception: #{exception_class.class}"}
             raise exception_class, exception_text
-          else raise 'INTERNAL ERROR: wrong case'
+          else error_unreachable_line
           end
         end
 
@@ -1064,7 +1049,7 @@ module Aspera
           options.add_option_preset({url: wiz_url})
           # instantiate plugin: command line options will be known and wizard can be called
           wiz_plugin_class = self.class.plugin_class(identification[:product])
-          raise Cli::BadArgument, "Detected: #{identification[:product]}, but this application has no wizard" unless wiz_plugin_class.respond_to?(:wizard)
+          assert(wiz_plugin_class.respond_to?(:wizard), exception_class: Cli::BadArgument){"Detected: #{identification[:product]}, but this application has no wizard"}
           # instantiate plugin: command line options will be known, e.g. private_key
           plugin_instance = wiz_plugin_class.new(@agents)
           wiz_params = {
@@ -1089,7 +1074,7 @@ module Aspera
               formatter.display_status('Using existing key:')
             else
               formatter.display_status("Generating #{DEFAULT_PRIV_KEY_LENGTH} bit RSA key...")
-              Config.generate_rsa_private_key(path: private_key_path)
+              self.class.generate_rsa_private_key(path: private_key_path)
               formatter.display_status('Created key:')
             end
             formatter.display_status(private_key_path)
@@ -1102,7 +1087,7 @@ module Aspera
           # finally, call the wizard
           wizard_result = wiz_plugin_class.wizard(**wiz_params)
           Log.log.debug{"wizard result: #{wizard_result}"}
-          raise "Internal error: missing or extra keys in wizard result: #{wizard_result.keys}" unless WIZARD_RESULT_KEYS.eql?(wizard_result.keys.sort)
+          assert(WIZARD_RESULT_KEYS.eql?(wizard_result.keys.sort)){"missing or extra keys in wizard result: #{wizard_result.keys}"}
           # get preset name from user or default
           wiz_preset_name = options.get_option(:id)
           if wiz_preset_name.nil?
@@ -1118,17 +1103,17 @@ module Aspera
           # Write configuration file
           formatter.display_status("Preparing preset: #{wiz_preset_name}")
           # init defaults if necessary
-          @config_presets[CONF_PRESET_DEFAULT] ||= {}
+          @config_presets[CONF_PRESET_DEFAULTS] ||= {}
           option_override = options.get_option(:override, mandatory: true)
           raise Cli::Error, "A default configuration already exists for plugin '#{identification[:product]}' (use --override=yes or --default=no)" \
-            if !option_override && options.get_option(:default, mandatory: true) && @config_presets[CONF_PRESET_DEFAULT].key?(identification[:product])
+            if !option_override && options.get_option(:default, mandatory: true) && @config_presets[CONF_PRESET_DEFAULTS].key?(identification[:product])
           raise Cli::Error, "Preset already exists: #{wiz_preset_name}  (use --override=yes or --id=<name>)" \
             if !option_override && @config_presets.key?(wiz_preset_name)
           @config_presets[wiz_preset_name] = wizard_result[:preset_value].stringify_keys
           test_args = wizard_result[:test_args]
           if options.get_option(:default, mandatory: true)
             formatter.display_status("Setting config preset as default for #{identification[:product]}")
-            @config_presets[CONF_PRESET_DEFAULT][identification[:product].to_s] = wiz_preset_name
+            @config_presets[CONF_PRESET_DEFAULTS][identification[:product].to_s] = wiz_preset_name
           else
             test_args = "-P#{wiz_preset_name} #{test_args}"
           end
@@ -1155,7 +1140,7 @@ module Aspera
           smtp[:domain] ||= smtp[:from_email].gsub(/^.*@/, '') if smtp.key?(:from_email)
           # check minimum required
           %i[server port domain].each do |n|
-            raise "Missing mandatory smtp parameter: #{n}" unless smtp.key?(n)
+            assert(smtp.key?(n)){"Missing mandatory smtp parameter: #{n}"}
           end
           Log.log.debug{"smtp=#{smtp}"}
           return smtp
@@ -1169,7 +1154,7 @@ module Aspera
           values[:from_name] ||= mail_conf[:from_name]
           values[:from_email] ||= mail_conf[:from_email]
           %i[from_name from_email].each do |n|
-            raise "Missing email parameter: #{n}" unless values.key?(n)
+            assert(values.key?(n)){"Missing email parameter: #{n}"}
           end
           start_options = [mail_conf[:domain]]
           start_options.push(mail_conf[:username], mail_conf[:password], :login) if mail_conf.key?(:username) && mail_conf.key?(:password)
@@ -1177,7 +1162,7 @@ module Aspera
           template_binding = Environment.empty_binding
           # add variables to binding
           values.each do |k, v|
-            raise "key (#{k.class}) must be Symbol" unless k.is_a?(Symbol)
+            assert_type(k, Symbol)
             template_binding.local_variable_set(k, v)
           end
           # execute template
@@ -1211,14 +1196,14 @@ module Aspera
         # returns [String] name if config_presets has default
         # returns nil if there is no config or bypass default params
         def get_plugin_default_config_name(plugin_name_sym)
-          raise 'internal error: config_presets shall be defined' if @config_presets.nil?
+          assert(!@config_presets.nil?){'config_presets shall be defined'}
           if !@use_plugin_defaults
             Log.log.debug('skip default config')
             return nil
           end
-          if @config_presets.key?(CONF_PRESET_DEFAULT) &&
-              @config_presets[CONF_PRESET_DEFAULT].key?(plugin_name_sym.to_s)
-            default_config_name = @config_presets[CONF_PRESET_DEFAULT][plugin_name_sym.to_s]
+          if @config_presets.key?(CONF_PRESET_DEFAULTS) &&
+              @config_presets[CONF_PRESET_DEFAULTS].key?(plugin_name_sym.to_s)
+            default_config_name = @config_presets[CONF_PRESET_DEFAULTS][plugin_name_sym.to_s]
             if !@config_presets.key?(default_config_name)
               Log.log.error do
                 "Default config name [#{default_config_name}] specified for plugin [#{plugin_name_sym}], but it does not exist in config file.\n" \
@@ -1235,16 +1220,17 @@ module Aspera
         # TODO: delete: ALLOWED_KEYS = %i[password username description].freeze
         # @return [Hash] result of execution of vault command
         def execute_vault
-          command = options.get_next_command(%i[list show create delete password])
+          command = options.get_next_command(%i[info list show create delete password])
           case command
+          when :info
+            return {type: :single_object, data: vault_info}
           when :list
             return {type: :object_list, data: vault.list}
           when :show
             return {type: :single_object, data: vault.get(label: options.get_next_argument('label'))}
           when :create
-            label = options.get_next_argument('label')
-            info = options.get_next_argument('info Hash')
-            raise 'info must be Hash' unless info.is_a?(Hash)
+            label = options.get_next_argument('label', type: String)
+            info = options.get_next_argument('info', type: Hash)
             info = info.symbolize_keys
             info[:label] = label
             vault.set(info)
@@ -1253,7 +1239,7 @@ module Aspera
             vault.delete(label: options.get_next_argument('label'))
             return Main.result_status('Password deleted')
           when :password
-            raise 'Vault does not support password change' unless vault.respond_to?(:password=)
+            assert(vault.respond_to?(:password=)){'Vault does not support password change'}
             new_password = options.get_next_argument('new_password')
             vault.password = new_password
             vault.save
@@ -1272,27 +1258,36 @@ module Aspera
           return value
         end
 
+        def vault_info
+          info = options.get_option(:vault) || {}
+          info = info.symbolize_keys
+          info[:type] ||= 'file'
+          info[:name] ||= (info[:type].eql?('file') ? DEFAULT_VAULT_FILENAME : PROGRAM_NAME)
+          assert(info.keys.sort == %i[name type]) {"vault info shall have exactly keys 'type' and 'name'"}
+          assert(info.values.all?(String)){'vault info shall have only string values'}
+          info[:password] = options.get_option(:vault_password, mandatory: true)
+          return info
+        end
+
         # @return [Object] vault, from options or cache
         def vault
           if @vault.nil?
-            vault_info = options.get_option(:vault) || {'type' => 'file', 'name' => 'vault.bin'}
-            vault_password = options.get_option(:vault_password, mandatory: true)
-            vault_type = vault_info['type'] || 'file'
-            vault_name = vault_info['name'] || (vault_type.eql?('file') ? 'vault.bin' : PROGRAM_NAME)
-            case vault_type
+            info = vault_info
+            case info[:type]
             when 'file'
               # absolute_path? introduced in ruby 2.7
-              vault_path = vault_name.eql?(File.absolute_path(vault_name)) ? vault_name : File.join(@main_folder, vault_name)
-              @vault = Keychain::EncryptedHash.new(vault_path, vault_password)
+              @vault = Keychain::EncryptedHash.new(
+                info[:name].eql?(File.absolute_path(info[:name])) ? info[:name] : File.join(@main_folder, info[:name]),
+                info[:password])
             when 'system'
               case Environment.os
               when Environment::OS_X
-                @vault = Keychain::MacosSystem.new(vault_name, vault_password)
+                @vault = Keychain::MacosSystem.new(info[:name], info[:password])
               else
                 raise 'not implemented for this OS'
               end
             else
-              raise Cli::BadArgument, "Unknown vault type: #{vault_type}"
+              raise Cli::BadArgument, "Unknown vault type: #{info[:type]}"
             end
           end
           raise 'No vault defined' if @vault.nil?

data/lib/aspera/cli/plugins/cos.rb

@@ -3,6 +3,7 @@
 require 'aspera/cli/plugin'
 require 'aspera/cli/plugins/node'
 require 'aspera/cos_node'
+require 'aspera/assert'
 
 module Aspera
   module Cli
@@ -30,8 +31,7 @@ module Aspera
             # get service credentials, Hash, e.g. @json:@file:...
             service_credentials = options.get_option(:service_credentials)
             storage_endpoint = options.get_option(:endpoint)
-            raise Cli::BadArgument, 'one of: endpoint or service_credentials is required' if service_credentials.nil? && storage_endpoint.nil?
-            raise Cli::BadArgument, 'endpoint and service_credentials are mutually exclusive' unless service_credentials.nil? || storage_endpoint.nil?
+            assert(service_credentials.nil? ^ storage_endpoint.nil?, exception_class: Cli::BadArgument){'endpoint and service_credentials are mutually exclusive'}
             if service_credentials.nil?
               service_api_key = options.get_option(:apikey, mandatory: true)
               instance_id = options.get_option(:crn, mandatory: true)