aspera-cli 4.23.0 → 4.24.0

data/lib/aspera/cli/sync_actions.rb

@@ -1,108 +1,129 @@
 # frozen_string_literal: true
 
-require 'aspera/transfer/sync'
+require 'aspera/sync/operations'
 require 'aspera/assert'
+require 'aspera/environment'
+require 'pathname'
 
 module Aspera
   module Cli
-    # Module for sync actions
+    # Manage command line arguments to provide to Sync::Run, Sync::Database and Sync::Operations
     module SyncActions
-      # Optional simple command line arguments for sync
-      # in Array to keep order as on command line
-      # conf: key in option --conf
-      # args: key for command line args
-      # values: possible values for argument
-      # type: type for validation
-      ARGUMENTS_INFO = [
-        {
-          conf:   'direction',
-          args:   'direction',
-          values: Transfer::Sync::DIRECTIONS
-        }, {
-          conf: 'local.path',
-          args: 'local_dir',
-          type: String
-        }, {
-          conf: 'remote.path',
-          args: 'remote_dir',
-          type: String
-        }
-      ].freeze
-      # name of minimal arguments required, also used to generate a session name
-      ARGUMENTS_LIST = ARGUMENTS_INFO.map{ |i| i[:conf]}.freeze
-      private_constant :ARGUMENTS_INFO
-
+      # translate state id (int) to string
+      STATE_STR = (['Nil'] +
+        (1..18).map{ |i| "P(#{i})"} +
+        %w[Syncd Error Confl Pconf] +
+        (23..24).map{ |i| "P(#{i})"}).freeze
       class << self
-        def declare_options(options)
-          options.declare(:sync_info, 'Information for sync instance and sessions', types: Hash)
+        def declare_options(_options)
         end
       end
 
-      # Read command line arguments (3) and converts to sync_info format
-      def sync_args_to_params(async_params)
-        # sync session parameters can be provided on command line instead of sync_info
-        arguments = {}
-        ARGUMENTS_INFO.each do |info|
-          value = options.get_next_argument(
-            info[:conf],
-            mandatory: false,
-            validation: info[:type],
-            accept_list: info[:values])
-          break if value.nil?
-          arguments[info[:conf]] = value.to_s
-        end
-        Log.log.debug{Log.dump('arguments', arguments)}
-        case arguments.keys.length
-        when 0 then nil
-        when 3
-          session_info = async_params
-          param_path = :conf
-          if async_params.key?('sessions') || async_params.key?('instance')
-            async_params['sessions'] ||= [{}]
-            Aspera.assert(async_params['sessions'].length == 1){'Only one session is supported with arguments'}
-            session_info = async_params['sessions'][0]
-            param_path = :args
+      # Read command line arguments (1 to 3) and converts to sync_info format
+      # @param sync [Bool] Set to `true` for non-admin
+      # @return [Hash] sync info
+      def async_info_from_args(direction: nil)
+        path = options.get_next_argument('path')
+        sync_info = options.get_next_argument('sync info', mandatory: false, validation: Hash, default: {})
+        path_is_remote = direction.eql?(:pull)
+        if sync_info.key?('sessions') || sync_info.key?('instance')
+          # "args"
+          sync_info['sessions'] ||= [{}]
+          Aspera.assert(sync_info['sessions'].length == 1){'Only one session is supported'}
+          session = sync_info['sessions'].first
+          dir_key = path_is_remote ? 'remote_dir' : 'local_dir'
+          raise "Parameter #{dir_key} shall not be in sync_info" if session.key?(dir_key)
+          session[dir_key] = path
+          if direction
+            dir_key = path_is_remote ? 'local_dir' : 'remote_dir'
+            raise "Parameter #{dir_key} shall not be in sync_info" if session.key?(dir_key)
+            session[dir_key] = transfer.destination_folder(path_is_remote ? Transfer::Spec::DIRECTION_RECEIVE : Transfer::Spec::DIRECTION_SEND)
+            local_remote = %w[local remote].map{ |i| session["#{i}_dir"]}
           end
-          ARGUMENTS_INFO.each do |info|
-            key_path = info[param_path].split('.')
-            hash_for_key = session_info
-            if key_path.length > 1
-              first = key_path.shift
-              async_params[first] ||= {}
-              hash_for_key = async_params[first]
-            end
-            raise "Parameter #{info[:conf]} is also set in sync_info, remove from sync_info" if hash_for_key.key?(key_path.last)
-            hash_for_key[key_path.last] = arguments[info[:conf]]
+        else
+          # "conf"
+          session = sync_info
+          dir_key = path_is_remote ? 'remote' : 'local'
+          session[dir_key] ||= {}
+          raise "Parameter #{dir_key}.path shall not be in sync_info" if session[dir_key].key?('path')
+          session[dir_key]['path'] = path
+          if direction
+            dir_key = path_is_remote ? 'local' : 'remote'
+            session[dir_key] ||= {}
+            raise "Parameter #{dir_key}.path shall not be in sync_info" if session[dir_key].key?('path')
+            session[dir_key]['path'] = transfer.destination_folder(path_is_remote ? Transfer::Spec::DIRECTION_RECEIVE : Transfer::Spec::DIRECTION_SEND)
+            local_remote = %w[local remote].map{ |i| session[i]['path']}
           end
-          if !session_info.key?('name')
-            # if no name is specified, generate one from simple arguments
-            session_info['name'] = ARGUMENTS_LIST.filter_map do |arg_name|
-              arguments[arg_name]&.gsub(/[^a-zA-Z0-9]+/, '_')
-            end.reject(&:empty?).join('_').gsub(/__+/, '_')
+          # "conf" is quiet by default
+          session['quiet'] = false if !session.key?('quiet') && Environment.terminal?
+        end
+        if direction
+          raise BadArgument, 'direction shall not be in sync_info' if session.key?('direction')
+          session['direction'] = direction.to_s
+          # generate name if not provided by user
+          if !session.key?('name')
+            session['name'] = Environment.instance.sanitized_filename(
+              ([direction.to_s] + local_remote).map do |value|
+                Pathname(value).each_filename.to_a.last(2).join(Environment.instance.safe_filename_character)
+              end.join(Environment.instance.safe_filename_character)
+            )
           end
-        else raise Cli::BadArgument, "Provide 0 or 3 arguments, not #{arguments.keys.length} for: #{ARGUMENTS_LIST.join(', ')}"
         end
+        sync_info
       end
 
+      # provide database object from command line arguments for admin ops
+      def db_from_args
+        sync_info = async_info_from_args
+        session = sync_info.key?('sessions') ? sync_info['sessions'].first : sync_info
+        # if name not provided, check in db folder if there is only one name
+        if !session.key?('name')
+          local_db_dir = Sync::Operations.local_db_folder(sync_info)
+          dbs = Sync::Operations.list_db_files(local_db_dir)
+          raise "#{dbs.length} session found in #{local_db_dir}, please provide a name" unless dbs.length == 1
+          session['name'] = dbs.keys.first
+        end
+        Sync::Database.new(Sync::Operations.session_db_file(sync_info))
+      end
+
+      # Execute sync action
+      # @param &block [nil, Proc] block to generate transfer spec, takes: direction (one of DIRECTIONS), local_dir, remote_dir
       def execute_sync_action(&block)
-        Aspera.assert(block){'No block given'}
-        command = options.get_next_command(%i[start admin])
+        command = options.get_next_command(%i[admin] + Sync::Operations::DIRECTIONS)
         # try to get 3 arguments as simple arguments
         case command
-        when :start
-          # possibilities are:
-          async_params = options.get_option(:sync_info, default: {})
-          sync_args_to_params(async_params)
-          Transfer::Sync.start(async_params, &block)
+        when *Sync::Operations::DIRECTIONS
+          Sync::Operations.start(async_info_from_args(direction: command), transfer.option_transfer_spec, &block)
           return Main.result_success
         when :admin
-          command2 = options.get_next_command([:status])
+          command2 = options.get_next_command(%i[status find meta counters file_info overview])
+          require 'aspera/sync/database' unless command2.eql?(:status)
           case command2
           when :status
-            sync_session_name = options.get_next_argument('name of sync session', mandatory: false, validation: String)
-            async_params = options.get_option(:sync_info, mandatory: true)
-            return Main.result_single_object(Transfer::Sync.admin_status(async_params, sync_session_name))
+            return Main.result_single_object(Sync::Operations.admin_status(async_info_from_args))
+          when :find
+            folder = options.get_next_argument('path')
+            dbs = Sync::Operations.list_db_files(folder)
+            return Main.result_object_list(dbs.keys.map{ |n| {name: n, path: dbs[n]}})
+          when :meta, :counters
+            return Main.result_single_object(db_from_args.send(command2))
+          when :file_info
+            result = db_from_args.send(command2)
+            result.each do |r|
+              r['sstate'] = SyncActions::STATE_STR[r['state']] if r['state']
+            end
+            return Main.result_object_list(
+              result,
+              fields: %w[sstate record_id f_meta_path message]
+            )
+          when :overview
+            return Main.result_object_list(
+              db_from_args.overview,
+              fields: %w[table name type]
+            )
+          else Aspera.error_unexpected_value(command2)
           end
+        else Aspera.error_unexpected_value(command)
         end
       end
     end

data/lib/aspera/cli/transfer_agent.rb

@@ -12,9 +12,9 @@ module Aspera
     # one of the supported transfer agents
     # provides CLI options to select one of the transfer agents (FASP/ascp client)
     class TransferAgent
-      # special value for --sources : read file list from arguments
+      # @args special value for --sources : read file list from arguments
       FILE_LIST_FROM_ARGS = '@args'
-      # special value for --sources : read file list from transfer spec (--ts)
+      # @ts special value for --sources : read file list from transfer spec (--ts)
       FILE_LIST_FROM_TRANSFER_SPEC = '@ts'
       FILE_LIST_OPTIONS = [FILE_LIST_FROM_ARGS, FILE_LIST_FROM_TRANSFER_SPEC, 'Array'].freeze
       DEFAULT_TRANSFER_NOTIFY_TEMPLATE = <<~END_OF_TEMPLATE
@@ -49,7 +49,10 @@ module Aspera
         @opt_mgr = opt_mgr
         @config = config_plugin
         # command line can override transfer spec
-        @transfer_spec_command_line = {'create_dir' => true}
+        @transfer_spec_command_line = {
+          'create_dir'    => true,
+          'resume_policy' => 'sparse_csum'
+        }
         # options for transfer agent
         @transfer_info = {}
         # the currently selected transfer agent
@@ -60,7 +63,7 @@ module Aspera
         @httpgw_url_lambda = nil
         @opt_mgr.declare(:ts, 'Override transfer spec values', types: Hash, handler: {o: self, m: :option_transfer_spec})
         @opt_mgr.declare(:to_folder, 'Destination folder for transferred files')
-        @opt_mgr.declare(:sources, "How list of transferred files is provided (#{FILE_LIST_OPTIONS.join(',')})")
+        @opt_mgr.declare(:sources, "How list of transferred files is provided (#{FILE_LIST_OPTIONS.join(',')})", default: FILE_LIST_FROM_ARGS)
         @opt_mgr.declare(:src_type, 'Type of file list', values: %i[list pair], default: :list)
         @opt_mgr.declare(:transfer, 'Type of transfer agent', values: TRANSFER_AGENTS, default: :direct)
         @opt_mgr.declare(:transfer_info, 'Parameters for transfer agent', types: Hash, handler: {o: self, m: :transfer_info})
@@ -86,7 +89,7 @@ module Aspera
       end
 
       # add other transfer spec parameters
-      def option_transfer_spec_deep_merge(ts); @transfer_spec_command_line.deep_merge!(ts); end
+      def option_transfer_spec_deep_merge(value); @transfer_spec_command_line.deep_merge!(value); end
 
       attr_reader :transfer_info
 
@@ -163,54 +166,56 @@ module Aspera
         @httpgw_url_lambda = httpgw_url_proc
       end
 
+      # transform the list of paths to a list of hash with source/dest
+      def list_to_paths(file_list)
+        source_type = @opt_mgr.get_option(:src_type, mandatory: true)
+        case source_type
+        when :list
+          # when providing a list, just specify source
+          @transfer_paths = file_list.map{ |i| {'source' => i}}
+        when :pair
+          Aspera.assert(file_list.length.even?, type: Cli::BadArgument){"When using pair, provide an even number of paths: #{file_list.length}"}
+          @transfer_paths = file_list.each_slice(2).map{ |s, d| {'source' => s, 'destination' => d}}
+        else Aspera.error_unexpected_value(source_type)
+        end
+      end
+
       # This is how the list of files to be transferred is specified
       # get paths suitable for transfer spec from command line
-      # @param default [String] if set, used as default file for --sources=@args
-      # @return [Hash] {source: (mandatory), destination: (optional)}
       # computation is done only once, cache is kept in @transfer_paths
+      # @param default [Array] of [String] if set, used as default file for --sources=@args
+      # @return [Array, nil] of Hash {source: (mandatory), destination: (optional)}
       def ts_source_paths(default: nil)
         # return cache if set
         return @transfer_paths unless @transfer_paths.nil?
         # start with lower priority : get paths from transfer spec on command line
         @transfer_paths = @transfer_spec_command_line['paths'] if @transfer_spec_command_line.key?('paths')
         # is there a source list option ?
-        file_list = @opt_mgr.get_option(:sources)
-        case file_list
-        when nil, FILE_LIST_FROM_ARGS
-          Log.log.debug('getting file list as parameters')
-          Aspera.assert_type(default, Array) unless default.nil?
-          # get remaining arguments
-          file_list = @opt_mgr.get_next_argument('source file list', multiple: true, default: default)
-          raise Cli::BadArgument, 'specify at least one file on command line or use ' \
-            "--sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !file_list.is_a?(Array) || file_list.empty?
-        when FILE_LIST_FROM_TRANSFER_SPEC
-          Log.log.debug('assume list provided in transfer spec')
-          special_case_direct_with_list =
-            @opt_mgr.get_option(:transfer, mandatory: true).eql?(:direct) &&
-            Transfer::Parameters.ascp_args_file_list?(@opt_mgr.get_option(:transfer_info)['ascp_args'])
-          raise Cli::BadArgument, 'transfer spec on command line must have sources' if @transfer_paths.nil? && !special_case_direct_with_list
-          # here we assume check of sources is made in transfer agent
-          return @transfer_paths
-        when Array
-          Log.log.debug('getting file list as extended value')
-          raise Cli::BadArgument, 'sources must be a Array of String' if !file_list.reject{ |f| f.is_a?(String)}.empty?
-        else
-          raise Cli::BadArgument, "sources must be a Array, not #{file_list.class}"
-        end
-        # here, file_list is an Array or String
-        if !@transfer_paths.nil?
-          Log.log.warn('--sources overrides paths from --ts')
-        end
-        source_type = @opt_mgr.get_option(:src_type, mandatory: true)
-        case source_type
-        when :list
-          # when providing a list, just specify source
-          @transfer_paths = file_list.map{ |i| {'source' => i}}
-        when :pair
-          Aspera.assert(file_list.length.even?, exception_class: Cli::BadArgument){"When using pair, provide an even number of paths: #{file_list.length}"}
-          @transfer_paths = file_list.each_slice(2).to_a.map{ |s, d| {'source' => s, 'destination' => d}}
-        else Aspera.error_unexpected_value(source_type)
-        end
+        sources = @opt_mgr.get_option(:sources)
+        @transfer_paths =
+          case sources
+          when FILE_LIST_FROM_ARGS
+            Log.log.debug('getting file list as parameters')
+            Aspera.assert_type(default, Array, NilClass)
+            # get remaining arguments
+            list = @opt_mgr.get_next_argument('source file list', multiple: true, default: default)
+            raise Cli::BadArgument, 'specify at least one file on command line or use ' \
+              "--sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !list.is_a?(Array) || list.empty?
+            list_to_paths(list)
+          when FILE_LIST_FROM_TRANSFER_SPEC
+            Log.log.debug('assume list provided in transfer spec')
+            special_case_direct_with_list =
+              @opt_mgr.get_option(:transfer, mandatory: true).eql?(:direct) &&
+              Transfer::Parameters.ascp_args_file_list?(@opt_mgr.get_option(:transfer_info)['ascp_args'])
+            raise Cli::BadArgument, 'transfer spec on command line must have sources' if @transfer_paths.nil? && !special_case_direct_with_list
+            # can be nil
+            @transfer_paths
+          when Array
+            Log.log.debug('getting file list as extended value')
+            Aspera.assert(sources.all?(String), type: Cli::BadArgument){'sources must be a Array of String'}
+            list_to_paths(sources)
+          else Aspera.error_unexpected_value(sources){'sources'}
+          end
         Log.log.debug{"paths=#{@transfer_paths}"}
         return @transfer_paths
       end
@@ -221,9 +226,7 @@ module Aspera
       def start(transfer_spec, rest_token: nil)
         # check parameters
         Aspera.assert_type(transfer_spec, Hash){'transfer_spec'}
-        if transfer_spec['remote_host'].eql?(CP4I_REMOTE_HOST_LB)
-          raise "Wrong remote host: #{CP4I_REMOTE_HOST_LB}"
-        end
+        raise "Wrong remote host: #{CP4I_REMOTE_HOST_LB}" if transfer_spec['remote_host'].eql?(CP4I_REMOTE_HOST_LB)
         # process :src option
         case transfer_spec['direction']
         when Transfer::Spec::DIRECTION_RECEIVE
@@ -250,9 +253,7 @@ module Aspera
         # recursively remove values that are nil (user wants to delete)
         transfer_spec.deep_do{ |hash, key, value, _unused| hash.delete(key) if value.nil?}
         # if TS from app has content_protection (e.g. F5), that means content is protected: ask password if not provided
-        if transfer_spec['content_protection'].eql?('decrypt') && !transfer_spec.key?('content_protection_password')
-          transfer_spec['content_protection_password'] = @opt_mgr.prompt_user_input('content protection password', sensitive: true)
-        end
+        transfer_spec['content_protection_password'] = @opt_mgr.prompt_user_input('content protection password', sensitive: true) if transfer_spec['content_protection'].eql?('decrypt') && !transfer_spec.key?('content_protection_password')
         # create transfer agent
         agent_instance.start_transfer(transfer_spec, token_regenerator: rest_token)
         # list of: :success or "error message string"

data/lib/aspera/cli/transfer_progress.rb

@@ -8,13 +8,10 @@ module Aspera
   module Cli
     # Progress bar for transfers.
     # Supports multi-session.
+    # Note that we can have this case:
+    # 2 sessions (-C x:2), but one session fails and restarts...
     class TransferProgress
       def initialize
-        reset
-      end
-
-      # Reset progress bar, to re-use it.
-      def reset
         @progress_bar = nil
         # key is session id
         @sessions = {}
@@ -22,11 +19,16 @@ module Aspera
         @title = nil
       end
 
+      # Reset progress bar, to re-use it.
+      def reset
+        send(:initialize)
+      end
+
       # Called by user of progress bar with a status on a transfer session
       # @param session_id the unique identifier of a transfer session
-      # @param type one of: pre_start, session_start, session_size, transfer, end
+      # @param type [Symbol] one of: sessions_init, session_start, session_size, transfer, session_end and end
       # @param info optional specific additional info for the given event type
-      def event(type, session_id:, info: nil)
+      def event(type, session_id: nil, info: nil)
         Log.log.trace1{"progress: #{type} #{session_id} #{info}"}
         return if @completed
         if @progress_bar.nil?
@@ -34,11 +36,12 @@ module Aspera
             format:      '%t %a %B %p%% %r Mbps %E',
             rate_scale:  lambda{ |rate| rate / Environment::BYTES_PER_MEBIBIT},
             title:       '',
-            total:       nil)
+            total:       nil
+          )
         end
         progress_provided = false
         case type
-        when :pre_start
+        when :sessions_init
           # give opportunity to show progress of initialization with multiple status
           Aspera.assert(session_id.nil?)
           Aspera.assert_type(info, String)
@@ -50,35 +53,41 @@ module Aspera
           raise "Session #{session_id} already started" if @sessions[session_id]
           @sessions[session_id] = {
             job_size: 0, # total size of transfer (pre-calc)
-            current:  0
+            current:  0,
+            running:  true
           }
           # remove last pre-start message if any
           @title = nil
         when :session_size
           Aspera.assert_type(session_id, String)
           Aspera.assert(!info.nil?)
+          Aspera.assert_type(@sessions[session_id], Hash)
           @sessions[session_id][:job_size] = info.to_i
-          current_total = total(:job_size)
-          @progress_bar.total = current_total unless current_total.eql?(@progress_bar.total) || current_total < @progress_bar.progress
+          sessions_total = total(:job_size)
+          @progress_bar.total = sessions_total unless sessions_total.eql?(@progress_bar.total) || sessions_total < @progress_bar.progress
         when :transfer
           Aspera.assert_type(session_id, String)
+          Aspera.assert_type(@sessions[session_id], Hash)
           if !@progress_bar.total.nil? && !info.nil?
             progress_provided = true
             @sessions[session_id][:current] = info.to_i
-            current_total = total(:current)
-            @progress_bar.progress = current_total unless @progress_bar.progress.eql?(current_total)
+            sessions_current = total(:current)
+            @progress_bar.progress = sessions_current unless @progress_bar.progress.eql?(sessions_current) || sessions_current > total(:job_size)
           end
+        when :session_end
+          Aspera.assert_type(session_id, String)
+          Aspera.assert(info.nil?)
+          # a session may be too short and finish before it has been started
+          @sessions[session_id][:running] = false if @sessions[session_id].is_a?(Hash)
         when :end
-          Aspera.assert(session_id, String)
+          Aspera.assert(session_id.nil?)
           Aspera.assert(info.nil?)
-          @title = nil
-          @completed = true
           @progress_bar.finish
         else Aspera.error_unexpected_value(type){'event type'}
         end
-        new_title = @sessions.length < 2 ? @title.to_s : "[#{@sessions.length}] #{@title}"
-        @progress_bar.title = new_title unless @progress_bar.title.eql?(new_title)
-        @progress_bar.increment if !progress_provided && !@completed
+        new_title = @sessions.length < 2 ? @title.to_s : "[#{@sessions.count{ |_i, d| d[:running]}}] #{@title}"
+        @progress_bar&.title = new_title unless @progress_bar&.title.eql?(new_title)
+        @progress_bar&.increment if !progress_provided && @progress_bar.progress.nil?
       rescue ProgressBar::InvalidProgressError => e
         Log.log.error{"Progress error: #{e}"}
       end

data/lib/aspera/cli/version.rb

@@ -4,6 +4,6 @@ module Aspera
   module Cli
     # for beta add extension : .beta1
     # for dev version add extension : .pre
-    VERSION = '4.23.0'
+    VERSION = '4.24.0'
   end
 end

data/lib/aspera/cli/wizard.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'aspera/oauth/jwt'
+
+module Aspera
+  module Cli
+    class Wizard
+      WIZARD_RESULT_KEYS = %i[preset_value test_args].freeze
+      DEFAULT_PRIV_KEY_FILENAME = 'my_private_key.pem' # pragma: allowlist secret
+      private_constant :WIZARD_RESULT_KEYS,
+        :DEFAULT_PRIV_KEY_FILENAME
+
+      def initialize(parent, main_folder)
+        @parent = parent
+        @main_folder = main_folder
+        # wizard options
+        options.declare(:override, 'Wizard: override existing value', values: :bool, default: :no)
+        options.declare(:default, 'Wizard: set as default configuration for specified plugin (also: update)', values: :bool, default: true)
+        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')
+      end
+
+      def options
+        @parent.options
+      end
+
+      def formatter
+        @parent.formatter
+      end
+
+      # Find a plugin, and issue the "require"
+      # @return [Hash] plugin info: { product:, name:, url:, version: }
+      def identify_plugins_for_url
+        app_url = options.get_next_argument('url', mandatory: true)
+        check_only = options.get_next_argument('plugin name', mandatory: false)
+        check_only = check_only.to_sym unless check_only.nil?
+        found_apps = []
+        my_self_plugin_sym = self.class.name.split('::').last.downcase.to_sym
+        PluginFactory.instance.plugin_list.each do |plugin_name_sym|
+          # no detection for internal plugin
+          next if plugin_name_sym.eql?(my_self_plugin_sym)
+          next if check_only && !check_only.eql?(plugin_name_sym)
+          # load plugin class
+          detect_plugin_class = PluginFactory.instance.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}"}
+            formatter.long_operation_running("#{plugin_name_sym}\r")
+            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.class}] #{e}"}
+            next
+          end
+          next if detection_info.nil?
+          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
+        raise "No known application found at #{app_url}" if found_apps.empty?
+        Aspera.assert(found_apps.all?{ |a| a.keys.all?(Symbol)})
+        return found_apps
+      end
+
+      def find(apps)
+        identification = if apps.length.eql?(1)
+          Log.log.debug{"Detected: #{identification}"}
+          apps.first
+        else
+          formatter.display_status('Multiple applications detected, please select from:')
+          formatter.display_results(type: :object_list, data: apps, fields: %w[product url version])
+          answer = options.prompt_user_input_in_list('product', apps.map{ |a| a[:product]})
+          apps.find{ |a| a[:product].eql?(answer)}
+        end
+        wiz_preset_name = options.get_next_argument('preset name', default: '')
+        Log.dump(:identification, identification)
+        wiz_url = identification[:url]
+        formatter.display_status("Using: #{identification[:name]} at #{wiz_url}".bold)
+        # set url for instantiation of plugin
+        options.add_option_preset({url: wiz_url}, 'wizard')
+        # instantiate plugin: command line options will be known and wizard can be called
+        wiz_plugin_class = PluginFactory.instance.plugin_class(identification[:product])
+        Aspera.assert(wiz_plugin_class.respond_to?(:wizard), type: 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(context: @parent.context)
+        wiz_params = {
+          object: plugin_instance
+        }
+        # is private key needed ?
+        if options.known_options.key?(:private_key) &&
+            (!wiz_plugin_class.respond_to?(:private_key_required?) || wiz_plugin_class.private_key_required?(wiz_url))
+          # lets see if path to priv key is provided
+          private_key_path = options.get_option(:key_path)
+          # give a chance to provide
+          if private_key_path.nil?
+            formatter.display_status('Please provide the path to your private RSA key, or nothing to generate one:')
+            private_key_path = options.get_option(:key_path, mandatory: true).to_s
+          end
+          # else generate path
+          private_key_path = File.join(@main_folder, DEFAULT_PRIV_KEY_FILENAME) if private_key_path.empty?
+          if File.exist?(private_key_path)
+            formatter.display_status('Using existing key:')
+          else
+            formatter.display_status("Generating #{OAuth::Jwt::DEFAULT_PRIV_KEY_LENGTH} bit RSA key...")
+            OAuth::Jwt.generate_rsa_private_key(path: private_key_path)
+            formatter.display_status('Created key:')
+          end
+          formatter.display_status(private_key_path)
+          private_key_pem = File.read(private_key_path)
+          options.set_option(:private_key, private_key_pem)
+          wiz_params[:private_key_path] = private_key_path
+          wiz_params[:pub_key_pem] = OpenSSL::PKey::RSA.new(private_key_pem).public_key.to_s
+        end
+        Log.dump(:wiz_params, wiz_params)
+        # finally, call the wizard
+        wizard_result = wiz_plugin_class.wizard(**wiz_params)
+        Log.log.debug{"wizard result: #{wizard_result}"}
+        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
+        if wiz_preset_name.empty?
+          elements = [
+            identification[:product],
+            URI.parse(wiz_url).host
+          ]
+          elements.push(options.get_option(:username, mandatory: true)) unless wizard_result[:preset_value].key?(:link) rescue nil
+          wiz_preset_name = elements.join('_').strip.downcase.gsub(/[^a-z0-9]/, '_').squeeze('_')
+        end
+        # test mode does not change conf file
+        return Main.result_single_object(wizard_result) if options.get_option(:test_mode)
+        # Write configuration file
+        formatter.display_status("Preparing preset: #{wiz_preset_name}")
+        # init defaults if necessary
+        @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_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_DEFAULTS][identification[:product].to_s] = wiz_preset_name
+        else
+          test_args = "-P#{wiz_preset_name} #{test_args}"
+        end
+        # TODO: actually test the command
+        return Main.result_status("You can test with:\n#{Info::CMD_NAME} #{identification[:product]} #{test_args}")
+      end
+    end
+  end
+end