aspera-cli 4.16.0 → 4.17.0

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

@@ -7,11 +7,11 @@ require 'aspera/cli/version'
 require 'aspera/cli/formatter'
 require 'aspera/cli/info'
 require 'aspera/cli/transfer_progress'
-require 'aspera/fasp/installation'
-require 'aspera/fasp/products'
-require 'aspera/fasp/parameters'
-require 'aspera/fasp/transfer_spec'
-require 'aspera/fasp/error_info'
+require 'aspera/ascp/installation'
+require 'aspera/ascp/products'
+require 'aspera/transfer/error_info'
+require 'aspera/transfer/parameters'
+require 'aspera/transfer/spec'
 require 'aspera/keychain/encrypted_hash'
 require 'aspera/keychain/macos_security'
 require 'aspera/proxy_auto_config'
@@ -24,6 +24,7 @@ require 'aspera/line_logger'
 require 'aspera/rest'
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/oauth'
 require 'open3'
 require 'date'
 require 'erb'
@@ -32,7 +33,7 @@ module Aspera
   module Cli
     module Plugins
       # manage the CLI config file
-      class Config < Aspera::Cli::Plugin
+      class Config < Cli::Plugin
         # folder in $HOME for application files (config, cache)
         ASPERA_HOME_FOLDER_NAME = '.aspera'
         # default config file
@@ -45,20 +46,18 @@ module Aspera
         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
         # folder containing custom plugins in user's config folder
         ASPERA_PLUGINS_FOLDERNAME = 'plugins'
         PERSISTENCY_FOLDER = 'persist_store'
-        RUBY_FILE_EXT = '.rb'
         ASPERA = 'aspera'
         SERVER_COMMAND = 'server'
         APP_NAME_SDK = 'sdk'
         CONNECT_WEB_URL = 'https://d3gcli72yxqn2z.cloudfront.net/connect'
         CONNECT_VERSIONS = 'connectversions.js' # cspell: disable-line
         TRANSFER_SDK_ARCHIVE_URL = 'https://ibm.biz/aspera_transfer_sdk'
-        DEMO = 'demo'
-        DEMO_SERVER_PRESET = 'demoserver' # cspell: disable-line
+        DEMO_SERVER = 'demo'
+        DEMO_PRESET = 'demoserver' # cspell: disable-line
         EMAIL_TEST_TEMPLATE = <<~END_OF_TEMPLATE
           From: <%=from_name%> <<%=from_email%>>
           To: <<%=to%>>
@@ -84,11 +83,10 @@ module Aspera
           :CONF_PRESET_DEFAULTS,
           :CONF_PRESET_GLOBAL,
           :ASPERA_PLUGINS_FOLDERNAME,
-          :RUBY_FILE_EXT,
           :ASPERA,
-          :DEMO,
           :TRANSFER_SDK_ARCHIVE_URL,
-          :DEMO_SERVER_PRESET,
+          :DEMO_SERVER,
+          :DEMO_PRESET,
           :EMAIL_TEST_TEMPLATE,
           :EXTEND_PRESET,
           :EXTEND_VAULT,
@@ -118,23 +116,11 @@ module Aspera
             File.dirname(File.expand_path(__FILE__))
           end
 
-          # name of englobing module
-          # @return "Aspera::Cli::Plugins"
-          def module_full_name
-            return Module.nesting[2].to_s
-          end
-
           # @return main folder where code is, i.e. .../lib
           # go up as many times as englobing modules (not counting class, as it is a file)
           def gem_src_root
-            File.expand_path(module_full_name.gsub('::', '/').gsub(%r{[^/]+}, '..'), gem_plugins_folder)
-          end
-
-          # instantiate a plugin
-          # plugins must be Capitalized
-          def plugin_class(plugin_name_sym)
-            # Module.nesting[2] is Aspera::Cli::Plugins
-            return Object.const_get("#{module_full_name}::#{plugin_name_sym.to_s.capitalize}")
+            # Module.nesting[2] is Cli::Plugins
+            File.expand_path(Module.nesting[2].to_s.gsub('::', '/').gsub(%r{[^/]+}, '..'), gem_plugins_folder)
           end
 
           # deep clone hash so that it does not get modified in case of display and secret hide
@@ -145,27 +131,25 @@ module Aspera
           # return product family folder (~/.aspera)
           def module_family_folder
             user_home_folder = Dir.home
-            assert(Dir.exist?(user_home_folder), exception_class: Cli::Error){"Home folder does not exist: #{user_home_folder}. Check your user environment."}
+            Aspera.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:)
-            assert_type(app_name, String)
-            assert(!app_name.empty?)
+            Aspera.assert_type(app_name, String)
+            Aspera.assert(!app_name.empty?)
             return File.join(module_family_folder, app_name)
           end
         end # self
 
-        def initialize(env, params)
-          assert_type(env, Hash)
-          assert_type(params, Hash)
-          assert(%i[gem help name version].eql?(params.keys.sort)){'missing param'}
+        def initialize(gem:, name:, help:, version:, **env)
           # we need to defer parsing of options until we have the config file, so we can use @extend with @preset
-          super(env)
-          @info = params
-          @plugins = {}
-          @plugin_lookup_folders = []
+          super(**env)
+          @gem = gem
+          @name = name
+          @help = help
+          @version = version
           @use_plugin_defaults = true
           @config_presets = nil
           @config_checksum_on_disk = nil
@@ -182,7 +166,9 @@ module Aspera
           @proxy_credentials = nil
           @main_folder = nil
           @option_config_file = nil
+          # store is used for ruby https
           @certificate_store = nil
+          # paths are used for ascp
           @certificate_paths = nil
           @progress_bar = nil
           # option to set main folder
@@ -190,14 +176,14 @@ module Aspera
             :home, 'Home folder for tool',
             handler: {o: self, m: :main_folder},
             types: String,
-            default: self.class.default_app_main_folder(app_name: @info[:name]))
+            default: self.class.default_app_main_folder(app_name: @name))
           options.parse_options!
-          Log.log.debug{"#{@info[:name]} folder: #{@main_folder}"}
-          # data persistency manager
-          env[:persistency] = PersistencyFolder.new(File.join(@main_folder, PERSISTENCY_FOLDER))
+          Log.log.debug{"#{@name} folder: #{@main_folder}"}
+          # data persistency manager, created by config plugin
+          @persistency = PersistencyFolder.new(File.join(@main_folder, PERSISTENCY_FOLDER))
           # set folders for plugin lookup
-          add_plugin_lookup_folder(self.class.gem_plugins_folder)
-          add_plugin_lookup_folder(File.join(@main_folder, ASPERA_PLUGINS_FOLDERNAME))
+          PluginFactory.instance.add_lookup_folder(self.class.gem_plugins_folder)
+          PluginFactory.instance.add_lookup_folder(File.join(@main_folder, ASPERA_PLUGINS_FOLDERNAME))
           # option to set config file
           options.declare(
             :config_file, 'Path to YAML file with preset configuration',
@@ -229,10 +215,10 @@ module Aspera
           options.declare(:test_mode, 'Wizard: skip private key check step', values: :bool, default: false)
           options.declare(:key_path, 'Wizard: path to private key for JWT')
           # Transfer SDK options
-          options.declare(:ascp_path, 'Path to ascp', handler: {o: Fasp::Installation.instance, m: :ascp_path})
+          options.declare(:ascp_path, 'Path to ascp', handler: {o: Ascp::Installation.instance, m: :ascp_path})
           options.declare(:use_product, 'Use ascp from specified product', handler: {o: self, m: :option_use_product})
           options.declare(:sdk_url, 'URL to get SDK', default: TRANSFER_SDK_ARCHIVE_URL)
-          options.declare(:sdk_folder, 'SDK folder path', handler: {o: Fasp::Installation.instance, m: :sdk_folder})
+          options.declare(:sdk_folder, 'SDK folder path', handler: {o: Ascp::Installation.instance, m: :sdk_folder})
           options.declare(:progress_bar, 'Display progress bar', values: :bool, default: Environment.terminal?)
           # email options
           options.declare(:smtp, 'SMTP configuration', types: Hash)
@@ -244,13 +230,13 @@ module Aspera
           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})
+          options.declare(:cache_tokens, 'Save and reuse OAuth tokens', values: :bool, handler: {o: self, m: :option_cache_tokens})
           options.declare(:fpac, 'Proxy auto configuration script')
           options.declare(:proxy_credentials, 'HTTP proxy credentials (user and password)', types: Array)
           options.parse_options!
           @progress_bar = TransferProgress.new if options.get_option(:progress_bar)
           # Check SDK folder is set or not, for compatibility, we check in two places
-          sdk_folder = Fasp::Installation.instance.sdk_folder rescue nil
+          sdk_folder = Ascp::Installation.instance.sdk_folder rescue nil
           if sdk_folder.nil?
             @sdk_default_location = true
             Log.log.debug('SDK folder is not set, checking default')
@@ -260,19 +246,19 @@ module Aspera
             if !Dir.exist?(sdk_folder)
               Log.log.debug{"not exists: #{sdk_folder}"}
               # former location
-              former_sdk_folder = File.join(self.class.default_app_main_folder(app_name: @info[:name]), APP_NAME_SDK)
+              former_sdk_folder = File.join(self.class.default_app_main_folder(app_name: @name), APP_NAME_SDK)
               Log.log.debug{"checking: #{former_sdk_folder}"}
               sdk_folder = former_sdk_folder if Dir.exist?(former_sdk_folder)
             end
             Log.log.debug{"using: #{sdk_folder}"}
-            Fasp::Installation.instance.sdk_folder = sdk_folder
+            Ascp::Installation.instance.sdk_folder = sdk_folder
           end
           pac_script = options.get_option(:fpac)
           # create PAC executor
-          @pac_exec = Aspera::ProxyAutoConfig.new(pac_script).register_uri_generic unless pac_script.nil?
+          @pac_exec = ProxyAutoConfig.new(pac_script).register_uri_generic unless pac_script.nil?
           proxy_user_pass = options.get_option(:proxy_credentials)
           if !proxy_user_pass.nil?
-            assert(proxy_user_pass.length.eql?(2), exception_class: Cli::BadArgument){"proxy_credentials shall have two elements (#{proxy_user_pass.length})"}
+            Aspera.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]
@@ -281,34 +267,36 @@ module Aspera
             user_agent:  PROGRAM_NAME,
             session_cb:  lambda{|http_session|update_http_session(http_session)},
             progress_bar: @progress_bar)
-          Oauth.persist_mgr = persistency if @option_cache_tokens
-          Fasp::Parameters.file_list_folder = File.join(@main_folder, 'filelists') # cspell: disable-line
-          Aspera::RestErrorAnalyzer.instance.log_file = File.join(@main_folder, 'rest_exceptions.log')
+          OAuth::Factory.instance.persist_mgr = persistency if @option_cache_tokens
+          Transfer::Parameters.file_list_folder = File.join(@main_folder, 'filelists') # cspell: disable-line
+          RestErrorAnalyzer.instance.log_file = File.join(@main_folder, 'rest_exceptions.log')
           # register aspera REST call error handlers
-          Aspera::RestErrorsAspera.register_handlers
+          RestErrorsAspera.register_handlers
         end
 
         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
 
+        # add files, folders or default locations to the certificate store
         def trusted_cert_locations=(path_list)
           path_list = [path_list] unless path_list.is_a?(Array)
+          Aspera.assert_type(path_list, Array){'cert locations'}
           if @certificate_store.nil?
             Log.log.debug('Creating SSL Cert store')
             @certificate_store = OpenSSL::X509::Store.new
-            @certificate_store.set_default_paths
             @certificate_paths = []
           end
 
           path_list.each do |path|
-            assert_type(path, String){'Expecting a String for cert location'}
-            Log.log.debug("Adding cert location: #{path}")
+            Aspera.assert_type(path, String){'Expecting a String for certificate location'}
+            paths_to_add = [path]
+            Log.log.debug{"Adding cert location: #{path}"}
             if path.eql?(ExtendedValue::DEF)
-              path = OpenSSL::X509::DEFAULT_CERT_DIR
-              @certificate_store.add_path(path)
-              @certificate_paths.push(path)
-              path = OpenSSL::X509::DEFAULT_CERT_FILE
-              @certificate_store.add_file(path)
+              @certificate_store.set_default_paths
+              paths_to_add = [
+                OpenSSL::X509::DEFAULT_CERT_DIR,
+                OpenSSL::X509::DEFAULT_CERT_FILE
+              ].select{|f|File.exist?(f)}
             elsif File.file?(path)
               @certificate_store.add_file(path)
             elsif File.directory?(path)
@@ -316,17 +304,29 @@ module Aspera
             else
               raise "No such file or folder: #{path}"
             end
-            @certificate_paths.push(path)
+            paths_to_add.each do |p|
+              pp = [File.realpath(p)]
+              if File.directory?(p)
+                pp = Dir.entries(p)
+                  .map{|e|File.realpath(File.join(p, e))}
+                  .select{|entry|File.file?(entry)}
+              end
+              @certificate_paths.concat(pp)
+            end
           end
+          @certificate_paths.uniq!
         end
 
-        def trusted_cert_locations(files_only: false)
-          locations = if @certificate_paths.nil?
-            [OpenSSL::X509::DEFAULT_CERT_DIR, OpenSSL::X509::DEFAULT_CERT_FILE]
-          else
-            @certificate_paths
+        # returns only files
+        def trusted_cert_locations
+          locations = @certificate_paths
+          if locations.nil?
+            # compute default locations
+            self.trusted_cert_locations = ExtendedValue::DEF
+            locations = @certificate_paths
+            # restore defaults
+            @certificate_paths = @certificate_store = nil
           end
-          locations = locations.select{|f|File.file?(f)} if files_only
           return locations
         end
 
@@ -384,7 +384,7 @@ module Aspera
         def check_gem_version
           latest_version =
             begin
-              Rest.new(base_url: 'https://rubygems.org/api/v1').read("versions/#{@info[:gem]}/latest.json")[:data]['version']
+              Rest.new(base_url: 'https://rubygems.org/api/v1').read("versions/#{@gem}/latest.json")[:data]['version']
             rescue StandardError
               Log.log.warn('Could not retrieve latest gem version on rubygems.')
               '0'
@@ -396,10 +396,10 @@ module Aspera
             end
           end
           return {
-            name:        @info[:gem],
-            current:     Aspera::Cli::VERSION,
+            name:        @gem,
+            current:     Cli::VERSION,
             latest:      latest_version,
-            need_update: Gem::Version.new(Aspera::Cli::VERSION) < Gem::Version.new(latest_version)
+            need_update: Gem::Version.new(Cli::VERSION) < Gem::Version.new(latest_version)
           }
         end
 
@@ -432,8 +432,8 @@ module Aspera
         # retrieve structure from cloud (CDN) with all versions available
         def connect_versions
           if @connect_versions.nil?
-            api_connect_cdn = Rest.new({base_url: CONNECT_WEB_URL})
-            javascript = api_connect_cdn.call({operation: 'GET', subpath: CONNECT_VERSIONS})
+            api_connect_cdn = Rest.new(base_url: CONNECT_WEB_URL)
+            javascript = api_connect_cdn.call(operation: 'GET', subpath: CONNECT_VERSIONS)
             # get result on one line
             connect_versions_javascript = javascript[:http].body.gsub(/\r?\n\s*/, '')
             Log.log.debug{"javascript=[\n#{connect_versions_javascript}\n]"}
@@ -468,14 +468,14 @@ module Aspera
         end
 
         def set_preset_key(preset, param_name, param_value)
-          assert_values(param_name.class, [String, Symbol]){'parameter'}
+          Aspera.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
-          assert_type(selected_preset, Hash){"#{preset}.#{param_name}"}
+          Aspera.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}"}
@@ -496,7 +496,7 @@ module Aspera
         end
 
         # $HOME/.aspera/`program_name`
-        attr_reader :gem_url, :plugins
+        attr_reader :gem_url
         attr_accessor :option_config_file
 
         # @return the hash from name (also expands possible includes)
@@ -507,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|
-            assert_type(current, Hash, exception_class: Cli::Error){"sub key: #{include_path}"}
+            Aspera.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?
@@ -517,7 +517,7 @@ module Aspera
         end
 
         def option_use_product=(value)
-          Fasp::Installation.instance.use_ascp_from_product(value)
+          Ascp::Installation.instance.use_ascp_from_product(value)
         end
 
         def option_use_product
@@ -525,14 +525,14 @@ module Aspera
         end
 
         def option_plugin_folder=(value)
-          assert_values(value.class, [String, Array]){'plugin folder'}
+          Aspera.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)}
+          Aspera.assert(value.all?(String)){'plugin folder'}
+          value.each{|f|PluginFactory.instance.add_lookup_folder(f)}
         end
 
         def option_plugin_folder
-          return @plugin_lookup_folders
+          return PluginFactory.instance.lookup_folders
         end
 
         def option_preset; 'write-only option'; end
@@ -571,9 +571,9 @@ module Aspera
           end
           files_to_copy = []
           Log.log.debug{Log.dump('Available_presets', @config_presets)}
-          assert_type(@config_presets, Hash){'config file YAML'}
+          Aspera.assert_type(@config_presets, Hash){'config file YAML'}
           # check there is at least the config section
-          assert(@config_presets.key?(CONF_PRESET_CONFIG)){"Cannot find key: #{CONF_PRESET_CONFIG}"}
+          Aspera.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}"}
@@ -582,7 +582,7 @@ module Aspera
           @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]
+          @config_presets[CONF_PRESET_CONFIG][CONF_PRESET_VERSION] = @version
           unless files_to_copy.empty?
             Log.log.warn('Copying referenced files')
             files_to_copy.each do |file|
@@ -597,7 +597,7 @@ module Aspera
           Log.log.debug{"-> #{e.class.name} : #{e}"}
           if File.exist?(@option_config_file)
             # then there is a problem with that file.
-            new_name = "#{@option_config_file}.pre#{@info[:version]}.manual_conversion_needed"
+            new_name = "#{@option_config_file}.pre#{@version}.manual_conversion_needed"
             File.rename(@option_config_file, new_name)
             Log.log.warn{"Renamed config file to #{new_name}."}
             Log.log.warn('Manual Conversion is required. Next time, a new empty file will be created.')
@@ -605,33 +605,6 @@ module Aspera
           raise Cli::Error, e.to_s
         end
 
-        # find plugins in defined paths
-        def add_plugins_from_lookup_folders
-          @plugin_lookup_folders.each do |folder|
-            next unless File.directory?(folder)
-            # TODO: add gem root to load path ? and require short folder ?
-            # $LOAD_PATH.push(folder) if i[:add_path]
-            Dir.entries(folder).select{|file|file.end_with?(RUBY_FILE_EXT)}.each do |source|
-              add_plugin_info(File.join(folder, source))
-            end
-          end
-        end
-
-        def add_plugin_lookup_folder(folder)
-          @plugin_lookup_folders.unshift(folder)
-        end
-
-        def add_plugin_info(path)
-          raise "ERROR: plugin path must end with #{RUBY_FILE_EXT}" if !path.end_with?(RUBY_FILE_EXT)
-          plugin_symbol = File.basename(path, RUBY_FILE_EXT).to_sym
-          req = path.gsub(/#{RUBY_FILE_EXT}$/o, '')
-          if @plugins.key?(plugin_symbol)
-            Log.log.warn{"skipping plugin already registered: #{plugin_symbol}"}
-            return
-          end
-          @plugins[plugin_symbol] = {source: path, require_stanza: req}
-        end
-
         # Find a plugin, and issue the "require"
         # @return [Hash] plugin info: { product: , url:, version: }
         def identify_plugins_for_url
@@ -639,34 +612,36 @@ module Aspera
           check_only = options.get_next_argument('plugin name', mandatory: false)
           check_only = check_only.to_sym unless check_only.nil?
           found_apps = []
-          plugins.each do |plugin_name_sym, plugin_info|
+          my_self_plugin_sym = self.class.name.split('::').last.downcase.to_sym
+          PluginFactory.instance.plugins.each do |plugin_name_sym, plugin_info|
             # no detection for internal plugin
-            next if plugin_name_sym.eql?(CONF_PLUGIN_SYM)
+            next if plugin_name_sym.eql?(my_self_plugin_sym)
             next if check_only && !check_only.eql?(plugin_name_sym)
             # load plugin class
             require plugin_info[:require_stanza]
-            detect_plugin_class = self.class.plugin_class(plugin_name_sym)
+            detect_plugin_class = PluginFactory.plugin_class(plugin_name_sym)
             # requires detection method
             next unless detect_plugin_class.respond_to?(:detect)
             detection_info = nil
             begin
+              Log.log.debug{"detecting #{plugin_name_sym} at #{app_url}"}
               detection_info = detect_plugin_class.detect(app_url)
             rescue OpenSSL::SSL::SSLError => e
               Log.log.warn(e.message)
               Log.log.warn('Use option --insecure=yes to allow unchecked certificate') if e.message.include?('cert')
             rescue StandardError => e
-              Log.log.debug{"detect error: #{e}"}
+              Log.log.debug{"detect error: [#{e.class}] #{e}"}
               next
             end
             next if detection_info.nil?
-            assert_type(detection_info, Hash)
-            assert_type(detection_info[:url], String) if detection_info.key?(:url)
+            Aspera.assert_type(detection_info, Hash)
+            Aspera.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?
-          assert(found_apps.all?{|a|a.keys.all?(Symbol)})
+          Aspera.assert(found_apps.all?{|a|a.keys.all?(Symbol)})
           return found_apps
         end
 
@@ -695,12 +670,12 @@ module Aspera
             when :list
               return {type: :object_list, data: all_links}
             when :download
-              folder_dest = transfer.destination_folder(Fasp::TransferSpec::DIRECTION_RECEIVE)
+              folder_dest = transfer.destination_folder(Transfer::Spec::DIRECTION_RECEIVE)
               # folder_dest=self.options.get_next_argument('destination folder')
-              api_connect_cdn = Rest.new({base_url: CONNECT_WEB_URL})
+              api_connect_cdn = Rest.new(base_url: CONNECT_WEB_URL)
               file_url = one_link['href']
               filename = file_url.gsub(%r{.*/}, '')
-              api_connect_cdn.call({operation: 'GET', subpath: file_url, save_to_file: File.join(folder_dest, filename)})
+              api_connect_cdn.call(operation: 'GET', subpath: file_url, save_to_file: File.join(folder_dest, filename))
               return Main.result_status("Downloaded: #{filename}")
             when :open
               OpenApplication.instance.uri(one_link['href'])
@@ -716,15 +691,15 @@ module Aspera
             return execute_connect_action
           when :use
             ascp_path = options.get_next_argument('path to ascp')
-            ascp_version = Fasp::Installation.instance.get_ascp_version(ascp_path)
+            ascp_version = Ascp::Installation.instance.get_ascp_version(ascp_path)
             formatter.display_status("ascp version: #{ascp_version}")
             set_global_default(:ascp_path, ascp_path)
             return Main.result_nothing
           when :show
-            return {type: :status, data: Fasp::Installation.instance.path(:ascp)}
+            return {type: :status, data: Ascp::Installation.instance.path(:ascp)}
           when :info
             # collect info from ascp executable
-            data = Fasp::Installation.instance.ascp_info
+            data = Ascp::Installation.instance.ascp_info
             # add command line transfer spec
             data['ts'] = transfer.updated_ts
             # add keys
@@ -736,27 +711,27 @@ module Aspera
             command = options.get_next_command(%i[list use])
             case command
             when :list
-              return {type: :object_list, data: Fasp::Products.installed_products, fields: %w[name app_root]}
+              return {type: :object_list, data: Ascp::Products.installed_products, fields: %w[name app_root]}
             when :use
               default_product = options.get_next_argument('product name')
-              Fasp::Installation.instance.use_ascp_from_product(default_product)
-              set_global_default(:ascp_path, Fasp::Installation.instance.path(:ascp))
+              Ascp::Installation.instance.use_ascp_from_product(default_product)
+              set_global_default(:ascp_path, Ascp::Installation.instance.path(:ascp))
               return Main.result_nothing
             end
           when :install
             # reset to default location, if older default was used
-            Fasp::Installation.instance.sdk_folder = self.class.default_app_main_folder(app_name: APP_NAME_SDK) if @sdk_default_location
-            v = Fasp::Installation.instance.install_sdk(options.get_option(:sdk_url, mandatory: true))
+            Ascp::Installation.instance.sdk_folder = self.class.default_app_main_folder(app_name: APP_NAME_SDK) if @sdk_default_location
+            v = Ascp::Installation.instance.install_sdk(options.get_option(:sdk_url, mandatory: true))
             return Main.result_status("Installed version #{v}")
           when :spec
             return {
               type:   :object_list,
-              data:   Fasp::Parameters.man_table,
-              fields: [%w[name type], Fasp::Parameters::SUPPORTED_AGENTS_SHORT.map(&:to_s), %w[description]].flatten.freeze
+              data:   Transfer::Parameters.man_table,
+              fields: [%w[name type], Transfer::Parameters::SUPPORTED_AGENTS_SHORT.map(&:to_s), %w[description]].flatten.freeze
             }
           when :errors
             error_data = []
-            Fasp::ERROR_INFO.each_pair do |code, prop|
+            Transfer::ERROR_INFO.each_pair do |code, prop|
               error_data.push(code: code, mnemonic: prop[:c], retry: prop[:r], info: prop[:a])
             end
             return {type: :object_list, data: error_data}
@@ -901,7 +876,7 @@ module Aspera
           when :documentation
             section = options.get_next_argument('private key file path', mandatory: false)
             section = "##{section}" unless section.nil?
-            OpenApplication.instance.uri("#{@info[:help]}#{section}")
+            OpenApplication.instance.uri("#{@help}#{section}")
             return Main.result_nothing
           when :genkey # generate new rsa key
             private_key_path = options.get_next_argument('private key file path')
@@ -912,28 +887,34 @@ module Aspera
             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
+            cert_action = options.get_next_command(%i[chain only name])
             remote_url = options.get_next_argument('remote URL')
-            @option_insecure = true
-            remote_certificate = Rest.start_http_session(remote_url).peer_cert
-            remote_certificate.subject.to_a.find { |name, _, _| name == 'CN' }[1]
-            formatter.display_status("CN=#{remote_certificate.subject.to_a.find { |name, _, _| name == 'CN' }[1] rescue ''}")
-            return Main.result_status(remote_certificate.to_pem)
+            remote_chain = Rest.remote_certificate_chain(remote_url, as_string: false)
+            raise "No certificate found for #{remote_url}" unless remote_chain&.first
+            case cert_action
+            when :chain
+              return Main.result_status(remote_chain.map(&:to_pem).join("\n"))
+            when :only
+              return Main.result_status(remote_chain.first.to_pem)
+            when :name
+              return Main.result_status(remote_chain.first.subject.to_a.find { |name, _, _| name == 'CN' }[1])
+            end
           when :echo # display the content of a value given on command line
             return Formatter.auto_type(options.get_next_argument('value'))
           when :flush_tokens
-            deleted_files = Oauth.flush_tokens
+            deleted_files = OAuth::Factory.instance.flush_tokens
             return {type: :value_list, data: deleted_files, name: 'file'}
           when :plugins
             case options.get_next_command(%i[list create])
             when :list
               result = []
-              @plugins.each do |name, info|
+              PluginFactory.instance.plugins.each do |name, info|
                 require info[:require_stanza]
-                plugin_class = self.class.plugin_class(name)
+                plugin_klass = PluginFactory.plugin_class(name)
                 result.push({
                   plugin: name,
-                  detect: Formatter.tick(plugin_class.respond_to?(:detect)),
-                  wizard: Formatter.tick(plugin_class.respond_to?(:wizard)),
+                  detect: Formatter.tick(plugin_klass.respond_to?(:detect)),
+                  wizard: Formatter.tick(plugin_klass.respond_to?(:wizard)),
                   path:   info[:source]
                 })
               end
@@ -979,8 +960,8 @@ module Aspera
           when :gem
             case options.get_next_command(%i[path version name])
             when :path then return Main.result_status(self.class.gem_src_root)
-            when :version then return Main.result_status(Aspera::Cli::VERSION)
-            when :name then return Main.result_status(@info[:gem])
+            when :version then return Main.result_status(Cli::VERSION)
+            when :name then return Main.result_status(@gem)
             end
           when :folder
             return Main.result_status(@main_folder)
@@ -999,24 +980,24 @@ module Aspera
           when :check_update
             return {type: :single_object, data: check_gem_version}
           when :initdemo
-            if @config_presets.key?(DEMO_SERVER_PRESET)
-              Log.log.warn{"Demo server preset already present: #{DEMO_SERVER_PRESET}"}
+            if @config_presets.key?(DEMO_PRESET)
+              Log.log.warn{"Demo server preset already present: #{DEMO_PRESET}"}
             else
-              Log.log.info{"Creating Demo server preset: #{DEMO_SERVER_PRESET}"}
-              @config_presets[DEMO_SERVER_PRESET] = {
-                'url'                                    => "ssh://#{DEMO}.asperasoft.com:33001",
+              Log.log.info{"Creating Demo server preset: #{DEMO_PRESET}"}
+              @config_presets[DEMO_PRESET] = {
+                'url'                                    => "ssh://#{DEMO_SERVER}.asperasoft.com:33001",
                 'username'                               => ASPERA,
-                'ssAP'.downcase.reverse + 'drow'.reverse => DEMO + ASPERA # cspell:disable-line
+                'ssAP'.downcase.reverse + 'drow'.reverse => DEMO_SERVER + ASPERA # cspell:disable-line
               }
             end
             @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_DEFAULTS][SERVER_COMMAND])
+              Log.log.warn{"Use #{DEMO_PRESET} for demo: -P#{DEMO_PRESET}"} unless
+                DEMO_PRESET.eql?(@config_presets[CONF_PRESET_DEFAULTS][SERVER_COMMAND])
             else
-              @config_presets[CONF_PRESET_DEFAULTS][SERVER_COMMAND] = DEMO_SERVER_PRESET
-              Log.log.info{"Setting server default preset to : #{DEMO_SERVER_PRESET}"}
+              @config_presets[CONF_PRESET_DEFAULTS][SERVER_COMMAND] = DEMO_PRESET
+              Log.log.info{"Setting server default preset to : #{DEMO_PRESET}"}
             end
             return Main.result_status('Done')
           when :vault then execute_vault
@@ -1026,9 +1007,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)
-            assert(exception_class <= Exception){"#{exception_class} is not an exception: #{exception_class.class}"}
+            Aspera.assert(exception_class <= Exception){"#{exception_class} is not an exception: #{exception_class.class}"}
             raise exception_class, exception_text
-          else error_unreachable_line
+          else Aspera.error_unreachable_line
           end
         end
 
@@ -1043,15 +1024,17 @@ module Aspera
             apps.find{|a|a[:product].eql?(answer)}
           end
           wiz_url = identification[:url]
-          Log.log.debug{Log.dump(:identification, identification, :ruby)}
+          Log.log.debug{Log.dump(:identification, identification)}
           formatter.display_status("Using: #{identification[:name]} at #{wiz_url}".bold)
           # set url for instantiation of plugin
           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])
-          assert(wiz_plugin_class.respond_to?(:wizard), exception_class: Cli::BadArgument){"Detected: #{identification[:product]}, but this application has no wizard"}
+          wiz_plugin_class = PluginFactory.plugin_class(identification[:product])
+          Aspera.assert(wiz_plugin_class.respond_to?(:wizard), exception_class: Cli::BadArgument) do
+            "Detected: #{identification[:product]}, but this application has no wizard"
+          end
           # instantiate plugin: command line options will be known, e.g. private_key
-          plugin_instance = wiz_plugin_class.new(@agents)
+          plugin_instance = wiz_plugin_class.new(**init_params)
           wiz_params = {
             object: plugin_instance
           }
@@ -1087,7 +1070,7 @@ module Aspera
           # finally, call the wizard
           wizard_result = wiz_plugin_class.wizard(**wiz_params)
           Log.log.debug{"wizard result: #{wizard_result}"}
-          assert(WIZARD_RESULT_KEYS.eql?(wizard_result.keys.sort)){"missing or extra keys in wizard result: #{wizard_result.keys}"}
+          Aspera.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,7 +1101,7 @@ module Aspera
             test_args = "-P#{wiz_preset_name} #{test_args}"
           end
           # TODO: actually test the command
-          return Main.result_status("You can test with:\n#{@info[:name]} #{identification[:product]} #{test_args}")
+          return Main.result_status("You can test with:\n#{@name} #{identification[:product]} #{test_args}")
         end
 
         # @return [Hash] email server setting with defaults if not defined
@@ -1136,11 +1119,11 @@ module Aspera
             25
           end
           smtp[:from_email] ||= smtp[:username] if smtp.key?(:username)
-          smtp[:from_name] ||= smtp[:from_email].gsub(/@.*$/, '').gsub(/[^a-zA-Z]/, ' ').capitalize if smtp.key?(:username)
-          smtp[:domain] ||= smtp[:from_email].gsub(/^.*@/, '') if smtp.key?(:from_email)
+          smtp[:from_name] ||= smtp[:from_email].sub(/@.*$/, '').gsub(/[^a-zA-Z]/, ' ').capitalize if smtp.key?(:username)
+          smtp[:domain] ||= smtp[:from_email].sub(/^.*@/, '') if smtp.key?(:from_email)
           # check minimum required
           %i[server port domain].each do |n|
-            assert(smtp.key?(n)){"Missing mandatory smtp parameter: #{n}"}
+            Aspera.assert(smtp.key?(n)){"Missing mandatory smtp parameter: #{n}"}
           end
           Log.log.debug{"smtp=#{smtp}"}
           return smtp
@@ -1154,7 +1137,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|
-            assert(values.key?(n)){"Missing email parameter: #{n}"}
+            Aspera.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)
@@ -1162,7 +1145,7 @@ module Aspera
           template_binding = Environment.empty_binding
           # add variables to binding
           values.each do |k, v|
-            assert_type(k, Symbol)
+            Aspera.assert_type(k, Symbol)
             template_binding.local_variable_set(k, v)
           end
           # execute template
@@ -1196,7 +1179,7 @@ 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)
-          assert(!@config_presets.nil?){'config_presets shall be defined'}
+          Aspera.assert(!@config_presets.nil?){'config_presets shall be defined'}
           if !@use_plugin_defaults
             Log.log.debug('skip default config')
             return nil
@@ -1208,7 +1191,7 @@ module Aspera
               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" \
                   'Please fix the issue: either create preset with one parameter: ' \
-                  "(#{@info[:name]} config id #{default_config_name} init @json:'{}') or remove default (#{@info[:name]} config id default remove #{plugin_name_sym})."
+                  "(#{@name} config id #{default_config_name} init @json:'{}') or remove default (#{@name} config id default remove #{plugin_name_sym})."
               end
             end
             raise Cli::Error, "Config name [#{default_config_name}] must be a hash, check config file." if !@config_presets[default_config_name].is_a?(Hash)
@@ -1239,7 +1222,7 @@ module Aspera
             vault.delete(label: options.get_next_argument('label'))
             return Main.result_status('Password deleted')
           when :password
-            assert(vault.respond_to?(:password=)){'Vault does not support password change'}
+            Aspera.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
@@ -1249,12 +1232,12 @@ module Aspera
 
         # @return [String] value from vault matching <name>.<param>
         def vault_value(name)
-          m = name.match(/^(.+)\.(.+)$/)
-          raise 'vault name shall match <name>.<param>' if m.nil?
+          m = name.split('.')
+          raise 'vault name shall match <name>.<param>' unless m.length.eql?(2)
           # this raise exception if label not found:
-          info = vault.get(label: m[1])
-          value = info[m[2].to_sym]
-          raise "no such entry value: #{m[2]}" if value.nil?
+          info = vault.get(label: m[0])
+          value = info[m[1].to_sym]
+          raise "no such entry value: #{m[1]}" if value.nil?
           return value
         end
 
@@ -1263,8 +1246,8 @@ module Aspera
           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'}
+          Aspera.assert(info.keys.sort == %i[name type]) {"vault info shall have exactly keys 'type' and 'name'"}
+          Aspera.assert(info.values.all?(String)){'vault info shall have only string values'}
           info[:password] = options.get_option(:vault_password, mandatory: true)
           return info
         end
@@ -1296,14 +1279,14 @@ module Aspera
 
         # version of URL without trailing "/" and removing default port
         def canonical_url(url)
-          url.gsub(%r{/+$}, '').gsub(%r{^(https://[^/]+):443$}, '\1')
+          url.sub(%r{/+$}, '').sub(%r{^(https://[^/]+):443$}, '\1')
         end
 
         def lookup_preset(url:, username:)
           # remove extra info to maximize match
           url = canonical_url(url)
           Log.log.debug{"Lookup preset for #{username}@#{url}"}
-          @config_presets.each do |_k, v|
+          @config_presets.each_value do |v|
             next unless v.is_a?(Hash)
             conf_url = v['url'].is_a?(String) ? canonical_url(v['url']) : nil
             return self.class.protect_presets(v) if conf_url.eql?(url) && v['username'].eql?(username)