aspera-cli 4.27.0 → 4.27.1

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

@@ -1,576 +0,0 @@
-# frozen_string_literal: true
-
-# cspell:ignore passcode xrds workgroups dmembership wmembership
-require 'aspera/cli/plugins/basic_auth'
-require 'aspera/cli/plugins/node'
-require 'aspera/cli/extended_value'
-require 'aspera/cli/special_values'
-require 'aspera/cli/transfer_agent'
-require 'aspera/transfer/result'
-require 'aspera/transfer/uri'
-require 'aspera/transfer/spec'
-require 'aspera/persistency_action_once'
-require 'aspera/rest_list'
-require 'aspera/environment'
-require 'aspera/nagios'
-require 'aspera/id_generator'
-require 'aspera/log'
-require 'aspera/assert'
-require 'xmlsimple'
-require 'json'
-
-module Aspera
-  module Cli
-    module Plugins
-      class Faspex < BasicAuth
-        application_name 'Faspex v4'
-        # required hash key for source in config
-        KEY_NODE = 'node' # value must be hash with url, username, password
-        KEY_PATH = 'path' # value must be same sub-path as in Faspex's node
-        # added field in result that identifies the package
-        PACKAGE_MATCH_FIELD = 'package_id'
-        # list of supported atoms
-        ATOM_MAILBOXES = %i[inbox archive sent].freeze
-        # allowed parameters for inbox.atom
-        ATOM_PARAMS = %w[page count startIndex].freeze
-        # with special parameters (from Plugin class) : max and pmax (from Plugin)
-        ATOM_EXT_PARAMS = [RestList::MAX_ITEMS, RestList::MAX_PAGES].concat(ATOM_PARAMS).freeze
-        # sub path in url for public link delivery
-        PUB_LINK_EXTERNAL_MATCH = 'external_deliveries/'
-        STANDARD_PATH = '/aspera/faspex'
-        HEADER_FASPEX_VERSION = 'X-IBM-Aspera'
-        private_constant :KEY_NODE, :KEY_PATH, :PACKAGE_MATCH_FIELD, :ATOM_MAILBOXES, :ATOM_PARAMS, :ATOM_EXT_PARAMS, :PUB_LINK_EXTERNAL_MATCH, :HEADER_FASPEX_VERSION
-
-        class << self
-          # @return [Hash,NilClass]
-          def detect(address_or_url)
-            address_or_url = "https://#{address_or_url}" unless address_or_url.match?(%r{^[a-z]{1,6}://})
-            urls = [address_or_url]
-            urls.push("#{address_or_url}#{STANDARD_PATH}") unless address_or_url.end_with?(STANDARD_PATH)
-            error = nil
-            urls.each do |base_url|
-              next unless base_url.start_with?('https://')
-              api = Rest.new(base_url: base_url, redirect_max: 1)
-              http = api.call(
-                operation:        'POST',
-                headers:          {
-                  'Content-type' => Mime::TEXT,
-                  'Accept'       => 'application/xrds+xml'
-                },
-                ret: :resp
-              )
-              # 4.x
-              next unless http.body.start_with?('<?xml')
-              res_s = XmlSimple.xml_in(http.body, {'ForceArray' => false})
-              Log.log.debug{"version: #{http[HEADER_FASPEX_VERSION]}"}
-              version = res_s['XRD']['application']['version']
-              # take redirect if any
-              return {
-                version: version,
-                url:     http.uri.to_s
-              }
-            rescue StandardError => e
-              error = e
-              Log.log.debug{"detect error: #{e}"}
-            end
-            raise error if error
-            return
-          end
-
-          # extract elements from faspex public link
-          def get_link_data(public_url)
-            public_uri = URI.parse(public_url)
-            Aspera.assert(m = public_uri.path.match(%r{^(.*)/(external.*)$}), 'Public link does not match Faspex format', type: Cli::BadArgument)
-            base = m[1]
-            subpath = m[2]
-            port_add = public_uri.port.eql?(public_uri.default_port) ? '' : ":#{public_uri.port}"
-            result = {
-              base_url: "#{public_uri.scheme}://#{public_uri.host}#{port_add}#{base}",
-              subpath:  subpath,
-              query:    Rest.query_to_h(public_uri.query)
-            }
-            Log.dump(:link_data, result)
-            return result
-          end
-
-          # get Transfer::Uri::SCHEME URI from entry in xml, and fix problems.
-          def get_fasp_uri_from_entry(entry, raise_no_link: true)
-            unless entry.key?('link')
-              Aspera.assert(!raise_no_link, type: Cli::BadArgument){'package has no link (deleted?)'}
-              return
-            end
-            result = entry['link'].find{ |e| e['rel'].eql?('package')}['href']
-            return result
-          end
-
-          # @return [Integer] identifier of source
-          def get_source_id_by_name(source_name, source_list)
-            match_source = source_list.find{ |i| i['name'].eql?(source_name)}
-            return match_source['id'] unless match_source.nil?
-            raise Cli::Error, %Q(No such Faspex source: "#{source_name}" in [#{source_list.map{ |i| %Q("#{i['name']}")}.join(', ')}])
-          end
-        end
-
-        # @param wizard  [Wizard] The wizard object
-        # @param app_url [String] Tested URL
-        # @return [Hash] :preset_value, :test_args
-        def wizard(wizard, app_url)
-          return {
-            preset_value: {
-              url:      app_url,
-              username: options.get_option(:username, mandatory: true),
-              password: options.get_option(:password, mandatory: true)
-            },
-            test_args:    'me'
-          }
-        end
-
-        option :link,          description: 'Public link for specific operation'
-        option :delivery_info, description: 'Package delivery information', allowed: Hash
-        option :remote_source, description: 'Remote source for package send (id or %name:)'
-        option :storage,       description: 'Faspex local storage definition (for browsing source)'
-        option :recipient,     description: 'Use if recipient is a dropbox (with *)'
-        option :box,           description: 'Package box', allowed: ATOM_MAILBOXES, default: :inbox
-
-        def initialize(**_)
-          super
-          @api_v3 = nil
-          @api_v4 = nil
-          options.parse_options!
-        end
-
-        def api_v3
-          @api_v3 = basic_auth_api if @api_v3.nil?
-          return @api_v3
-        end
-
-        def api_v4
-          if @api_v4.nil?
-            faspex_api_base = options.get_option(:url, mandatory: true)
-            @api_v4 = Rest.new(
-              base_url: "#{faspex_api_base}/api",
-              auth:     {
-                type:         :oauth2,
-                grant_method: :generic,
-                base_url:     "#{faspex_api_base}/auth/oauth2",
-                auth:         {type: :basic, username: options.get_option(:username, mandatory: true), password: options.get_option(:password, mandatory: true)},
-                params:       {
-                  scope: 'admin'
-                },
-                grant_type:   'password'
-              }
-            )
-          end
-          return @api_v4
-        end
-
-        # query supports : {"startIndex":10,"count":1,"page":109,"max":2,"pmax":1}
-        def mailbox_filtered_entries(stop_at_id: nil)
-          recipient_names = [options.get_option(:recipient) || options.get_option(:username, mandatory: true)]
-          # some workgroup messages have no star in recipient name
-          recipient_names.push(recipient_names.first.delete_prefix('*')) if recipient_names.first.start_with?('*')
-          # mailbox is in ATOM_MAILBOXES
-          mailbox = options.get_option(:box, mandatory: true)
-          # parameters
-          mailbox_query = options.get_option(:query)
-          max_items = nil
-          max_pages = nil
-          result = []
-          if !mailbox_query.nil?
-            Aspera.assert_type(mailbox_query, Hash){'query'}
-            Aspera.assert((mailbox_query.keys - ATOM_EXT_PARAMS).empty?){"query: supported params: #{ATOM_EXT_PARAMS}"}
-            Aspera.assert(!(mailbox_query.key?('startIndex') && mailbox_query.key?('page')), 'query: startIndex and page are exclusive')
-            # Extract pagination control parameters (not part of API query)
-            max_items = mailbox_query.delete(RestList::MAX_ITEMS)
-            max_pages = mailbox_query.delete(RestList::MAX_PAGES)
-          end
-          loop do
-            # get a batch of package information
-            # order: first batch is latest packages, and then in a batch ids are increasing
-            atom_xml = api_v3.call(
-              operation: 'GET',
-              subpath:   "#{mailbox}.atom",
-              headers:   {'Accept' => 'application/xml'},
-              query:     mailbox_query,
-              ret:       :resp
-            ).body
-            box_data = XmlSimple.xml_in(atom_xml, {'ForceArray' => %w[entry field link to]})
-            Log.dump(:box_data, box_data)
-            items = box_data.key?('entry') ? box_data['entry'] : []
-            Log.log.debug{"new items: #{items.count}"}
-            # it is the end if page is empty
-            break if items.empty?
-            stop_condition = false
-            # results will be sorted in reverse id
-            items.reverse_each do |package|
-              # create the package id, based on recipient's box
-              package[PACKAGE_MATCH_FIELD] =
-                case mailbox
-                when :inbox, :archive
-                  recipient = package['to'].find{ |i| recipient_names.include?(i['name'])}
-                  recipient.nil? ? nil : recipient['recipient_delivery_id']
-                else # :sent
-                  package['delivery_id']
-                end
-              # add special key
-              package['items'] = package['link'].is_a?(Array) ? package['link'].length : 0
-              package['metadata'] = package['metadata']['field'].to_h{ |i| [i['name'], i['content']]}
-              # if we look for a specific package
-              stop_condition = true if !stop_at_id.nil? && stop_at_id.eql?(package[PACKAGE_MATCH_FIELD])
-              # keep only those for the specified recipient
-              result.push(package) unless package[PACKAGE_MATCH_FIELD].nil?
-            end
-            break if stop_condition
-            # result.push({PACKAGE_MATCH_FIELD=>'======'})
-            Log.log.debug{"total items: #{result.count}"}
-            # reach the limit ?
-            if !max_items.nil? && (result.count >= max_items)
-              result = result.slice(0, max_items) if result.count > max_items
-              break
-            end
-            link = box_data['link'].find{ |i| i['rel'].eql?('next')}
-            Log.log.debug{"link: #{link}"}
-            # no next link
-            break if link.nil?
-            # replace parameters with the ones from next link
-            mailbox_query = Rest.query_to_h(URI.parse(link['href']).query)
-            Log.log.debug{"query: #{mailbox_query}"}
-            break if !max_pages.nil? && (mailbox_query['page'].to_i > max_pages)
-          end
-          return result
-        end
-
-        # retrieve transfer spec from pub link for send package
-        def send_public_link_to_ts(public_link_url, package_create_params)
-          delivery_info = package_create_params['delivery']
-          # pub link user
-          link_data = self.class.get_link_data(public_link_url)
-          Aspera.assert_values(link_data[:subpath], ['external/submissions/new', 'external/dropbox_submissions/new'], type: Cli::BadArgument){'pub link subpath'}
-          create_path = link_data[:subpath].split('/')[0..-2].join('/')
-          package_create_params[:passcode] = link_data[:query]['passcode']
-          delivery_info[:transfer_type] = 'connect'
-          delivery_info[:source_paths_list] = transfer.source_list.join("\r\n")
-          api_public_link = Rest.new(base_url: link_data[:base_url])
-          # Hum, as this does not always work (only user, but not dropbox), we get the javascript and need hack
-          # pkg_created=api_public_link.create(create_path,package_create_params)
-          # so extract data from javascript
-          package_creation_data = api_public_link.call(
-            operation:    'POST',
-            subpath:      create_path,
-            content_type: Mime::JSON,
-            body:         package_create_params,
-            headers:      {'Accept' => 'text/javascript'},
-            ret:          :resp
-          ).body
-          # get arguments of function call
-          package_creation_data.delete!("\n") # one line
-          package_creation_data.gsub!(/^[^"]+\("\{/, '{') # delete header
-          package_creation_data.gsub!(/"\);[^"]+$/, '"') # delete trailer
-          package_creation_data.gsub!(/\}", *"/, '},"') # between two arguments
-          package_creation_data.gsub!('\\"', '"') # remove protecting quote
-          begin
-            package_creation_data = JSON.parse("[#{package_creation_data}]")
-          rescue JSON::ParserError # => e
-            raise Aspera::Error, 'Unexpected response: missing metadata ?'
-          end
-          return package_creation_data.first
-        end
-
-        # --- DSL ---
-
-        command :health,       description: 'Check Faspex 4 API health'
-        command :package,      description: 'Manage packages'
-        command :source,       description: 'Manage sources'
-        command :me,           description: 'Show current user information', action: ->{Result::SingleObject.new(api_v3.read('me'))}
-        command :dropbox,      description: 'Manage dropboxes'
-        command :v4,           description: 'Faspex v4 admin commands'
-        command :address_book, description: 'Show address book'
-        command :login_methods, description: 'Show login methods'
-
-        commands_under(:package) do
-          command :send,    description: 'Send a package'
-          command :receive, description: 'Receive a package', aliases: [:recv]
-          command :list,    description: 'List packages', action: ->{Result::ObjectList.new(mailbox_filtered_entries, fields: [PACKAGE_MATCH_FIELD, 'title', 'items'])}
-          command :show,    description: 'Show a package'
-        end
-
-        commands_under(:source) do
-          command :list, description: 'List sources', action: ->{Result::ObjectList.new(api_v3.read('source_shares')['items'])}
-          command :info, description: 'Show source info', setup: :setup_source_selected, action: ->(source_info:){Result::SingleObject.new(source_info)}
-          command :node, description: 'Execute node commands on source', setup: :setup_source_selected
-        end
-
-        commands_under(%i[source node]) do
-          Node::COMMANDS_FASPEX.each do |cmd|
-            command(cmd, description: "Node #{cmd} command", setup: :setup_source_node)
-          end
-        end
-
-        commands_under(:dropbox) do
-          command :list, description: 'List dropboxes'
-        end
-
-        commands_under(:v4) do
-          entity_command :dropbox, description: 'Manage v4 dropboxes', api: :api_v4, entity: 'admin/dropboxes', display_fields: %w[id e_wg_name e_wg_desc created_at]
-          entity_command :dmembership, description: 'Manage dropbox memberships', api: :api_v4, entity: 'dropbox_memberships'
-          entity_command :workgroup, api: :api_v4, entity: 'admin/workgroups', display_fields: %w[id e_wg_name e_wg_desc created_at]
-          entity_command :wmembership, description: 'Manage workgroup memberships', api: :api_v4, entity: 'workgroup_memberships'
-          entity_command :user, api: :api_v4, entity: 'users', display_fields: %w[id name first_name last_name]
-          entity_command :metadata_profile, description: 'Manage metadata profiles', api: :api_v4, entity: 'metadata_profiles'
-          command :package, description: 'List packages for a box'
-        end
-
-        commands_under(%i[v4 package]) do
-          command :users, description: 'List packages for users'
-        end
-
-        # --- handlers ---
-
-        def action_health
-          nagios = Nagios.new
-          begin
-            api_v3.read('me')
-            nagios.add_ok('faspex api', 'accessible')
-          rescue StandardError => e
-            nagios.add_critical('faspex api', e.to_s)
-          end
-          Result::ObjectList.new(nagios.status_list)
-        end
-
-        # package sub-handlers
-
-        def action_package_show
-          delivery_id = options.instance_identifier
-          Result::SingleObject.new(mailbox_filtered_entries(stop_at_id: delivery_id).find{ |p| p[PACKAGE_MATCH_FIELD].eql?(delivery_id)})
-        end
-
-        def action_package_send
-          delivery_info = options.get_option(:delivery_info, mandatory: true)
-          Aspera.assert_type(delivery_info, Hash, type: Cli::BadArgument){'delivery_info'}
-          # actual parameter to faspex API
-          package_create_params = {'delivery' => delivery_info}
-          public_link_url = options.get_option(:link)
-          if public_link_url.nil?
-            # authenticated user
-            delivery_info['sources'] ||= [{'paths' => []}]
-            first_source = delivery_info['sources'].first
-            first_source['paths'].concat(transfer.source_list)
-            source_id = options.get_option(:remote_source)
-            if source_id && (m = Parser.percent_selector(source_id))
-              Aspera.assert_values(m[:field], ['name'], type: Cli::BadArgument){'selector field'}
-              source_list = api_v3.read('source_shares')['items']
-              source_id = self.class.get_source_id_by_name(m[:value], source_list)
-            end
-            first_source['id'] = source_id.to_i unless source_id.nil?
-            pkg_created = api_v3.create('send', package_create_params)
-            if first_source.key?('id')
-              # no transfer spec if remote source: handled by faspex
-              return Result::ValueList.new([pkg_created['links']['status']], name: 'link')
-            end
-            Aspera.assert(pkg_created['xfer_sessions'].length == 1, type: Cli::BadArgument){'expecting one session exactly'}
-            transfer_spec = pkg_created['xfer_sessions'].first
-            # use source from cmd line, this one only contains destination (already in dest root)
-            transfer_spec.delete('paths')
-          else # public link
-            transfer_spec = send_public_link_to_ts(public_link_url, package_create_params)
-          end
-          # Log.dump(:transfer_spec,transfer_spec)
-          return Runner.result_transfer(transfer.start(transfer_spec))
-        end
-
-        def action_package_receive
-          link_url = options.get_option(:link)
-          # list of faspex ID/URI to download
-          pkg_id_uri = nil
-          skip_ids_data = []
-          skip_ids_persistency = nil
-          case link_url
-          when nil # usual case: no link
-            if options.get_option(:once_only, mandatory: true)
-              skip_ids_persistency = PersistencyActionOnce.new(
-                manager: persistency,
-                data:    skip_ids_data,
-                id:      IdGenerator.from_list(
-                  'faspex_recv',
-                  options.get_option(:url, mandatory: true),
-                  options.get_option(:username, mandatory: true),
-                  options.get_option(:box, mandatory: true).to_s
-                )
-              )
-            end
-            # get command line parameters
-            delivery_id = options.instance_identifier
-            Aspera.assert(!delivery_id.empty?, 'empty id')
-            recipient = options.get_option(:recipient)
-            if delivery_id.eql?(SpecialValues::ALL)
-              pkg_id_uri = mailbox_filtered_entries.map{ |i| {id: i[PACKAGE_MATCH_FIELD], uri: self.class.get_fasp_uri_from_entry(i, raise_no_link: false)}}
-            elsif delivery_id.eql?(SpecialValues::INIT)
-              Aspera.assert(skip_ids_persistency, 'Only with option once_only')
-              skip_ids_persistency.data.clear.concat(mailbox_filtered_entries.map{ |i| {id: i[PACKAGE_MATCH_FIELD]}})
-              skip_ids_persistency.save
-              return Result::Status.new("Initialized skip for #{skip_ids_persistency.data.count} package(s)")
-            elsif !recipient.nil? && recipient.start_with?('*')
-              found_package_link = mailbox_filtered_entries(stop_at_id: delivery_id).find{ |p| p[PACKAGE_MATCH_FIELD].eql?(delivery_id)}['link'].first['href']
-              raise "Not Found. Dropbox and Workgroup packages can use the link option with #{Transfer::Uri::SCHEME}" if found_package_link.nil?
-              pkg_id_uri = [{id: delivery_id, uri: found_package_link}]
-            else
-              # TODO: delivery id is the right one if package was receive by workgroup
-              endpoint =
-                case options.get_option(:box, mandatory: true)
-                when :inbox, :archive then 'received'
-                when :sent then 'sent'
-                end
-              entry_xml = api_v3.call(operation: 'GET', subpath: "#{endpoint}/#{delivery_id}", headers: {'Accept' => 'application/xml'}, ret: :resp).body
-              package_entry = XmlSimple.xml_in(entry_xml, {'ForceArray' => true})
-              pkg_id_uri = [{id: delivery_id, uri: self.class.get_fasp_uri_from_entry(package_entry)}]
-            end
-          when /^#{Transfer::Uri::SCHEME}:/o
-            pkg_id_uri = [{id: 'package', uri: link_url}]
-          else
-            link_data = self.class.get_link_data(link_url)
-            Aspera.assert(link_data[:subpath].start_with?(PUB_LINK_EXTERNAL_MATCH), type: Cli::BadArgument){"Pub link is #{link_data[:subpath]}. Expecting #{PUB_LINK_EXTERNAL_MATCH}"}
-            # NOTE: unauthenticated API (authorization is in url params)
-            api_public_link = Rest.new(base_url: link_data[:base_url])
-            pkg_xml = api_public_link.call(
-              operation: 'GET',
-              subpath:   link_data[:subpath],
-              headers:   {'Accept' => 'application/xml'},
-              query:     {passcode: link_data[:query]['passcode']},
-              ret:       :resp
-            ).body
-            if !pkg_xml.start_with?('<?xml ')
-              Environment.instance.open_uri(link_url)
-              raise Cli::Error, 'Unexpected response: package not found ?'
-            end
-            package_entry = XmlSimple.xml_in(pkg_xml, {'ForceArray' => false})
-            Log.dump(:package_entry, package_entry)
-            transfer_uri = self.class.get_fasp_uri_from_entry(package_entry)
-            pkg_id_uri = [{id: package_entry['id'], uri: transfer_uri}]
-          end
-          # prune packages already downloaded
-          # TODO : remove ids from skip not present in inbox to avoid growing too big
-          # skip_ids_data.select!{|id|pkg_id_uri.select{|p|p[:id].eql?(id)}}
-          pkg_id_uri.reject!{ |i| skip_ids_data.include?(i[:id])}
-          Log.dump(:pkg_id_uri, pkg_id_uri)
-          return Result::Status.new('no new package') if pkg_id_uri.empty?
-          result_transfer = []
-          pkg_id_uri.each do |id_uri|
-            if id_uri[:uri].nil?
-              # skip package with no link: empty or content deleted
-              statuses = Transfer::Result.success
-            else
-              transfer_spec = Transfer::Uri.new(id_uri[:uri]).transfer_spec
-              # NOTE: only external users have token in Transfer::Uri::SCHEME link !
-              if !transfer_spec.key?('token')
-                sanitized = id_uri[:uri].gsub('&', '&amp;')
-                xml_payload =
-                  %Q(<?xml version="1.0" encoding="UTF-8"?><url-list xmlns="http://schemas.asperasoft.com/xml/url-list"><url href="#{sanitized}"/></url-list>)
-                transfer_spec['token'] = api_v3.call(
-                  operation:    'POST',
-                  subpath:      'issue-token',
-                  query:        {'direction' => 'down'},
-                  content_type: Mime::TEXT,
-                  body:         xml_payload,
-                  headers:      {'Accept' => Mime::TEXT, 'Content-Type' => 'application/vnd.aspera.url-list+xml'},
-                  ret:          :resp
-                ).body
-              end
-              transfer_spec['direction'] = Transfer::Spec::DIRECTION_RECEIVE
-              statuses = transfer.start(transfer_spec)
-            end
-            result_transfer.push({'package' => id_uri[:id], Runner::STATUS_FIELD => statuses})
-            # skip only if all sessions completed
-            skip_ids_data.push(id_uri[:id]) if statuses.is_a?(Transfer::Result::Success)
-          end
-          skip_ids_persistency&.save
-          return Runner.result_transfer_multiple(result_transfer)
-        end
-
-        # Resolve a source by id/name and validate the storage option.
-        # @return [Hash] ctx with :source_info and :source_node_plugin
-        def setup_source_selected(**)
-          source_list = api_v3.read('source_shares')['items']
-          source_id = options.instance_identifier do |field, value|
-            Aspera.assert_values(field, ['name'], type: Cli::BadArgument){'selector field'}
-            self.class.get_source_id_by_name(value, source_list)
-          end.to_i
-          selected_source = source_list.find{ |i| i['id'].eql?(source_id)}
-          Aspera.assert(!selected_source.nil?, type: BadArgument){'No such source'}
-          source_name = selected_source['name']
-          source_hash = options.get_option(:storage, mandatory: true)
-          Aspera.assert_type(source_hash, Hash, type: Cli::Error){'storage option'}
-          source_hash.each do |name, storage|
-            Aspera.assert_type(storage, Hash, type: Cli::Error){"storage '#{name}'"}
-            [KEY_NODE, KEY_PATH].each do |key|
-              Aspera.assert(storage.key?(key), type: Cli::Error){"storage '#{name}' must have a '#{key}'"}
-            end
-          end
-          Aspera.assert(source_hash.key?(source_name), type: Cli::Error){"No such storage in config file: \"#{source_name}\" in [#{source_hash.keys.join(', ')}]"}
-          {source_info: source_hash[source_name]}
-        end
-
-        # source > node sub-handlers: one per COMMANDS_FASPEX
-        # setup_source_selected injects :source_info; setup_source_node builds the Node plugin.
-        def setup_source_node(source_info:, **)
-          Log.dump(:source_info, source_info)
-          node_config = ExtendedValue.instance.evaluate(source_info[KEY_NODE], context: 'faspex node')
-          Log.log.debug{"node=#{node_config}"}
-          Aspera.assert_type(node_config, Hash, type: Cli::Error){source_info[KEY_NODE]}
-          api_node = Rest.new(
-            base_url: node_config['url'],
-            auth:     {
-              type:     :basic,
-              username: node_config['username'],
-              password: node_config['password']
-            }
-          )
-          {source_node_plugin: Node.new(context: context, api: api_node, prefix_path: source_info[KEY_PATH])}
-        end
-
-        Node::COMMANDS_FASPEX.each do |cmd|
-          define_action_method([:source, :node, cmd]) do |source_node_plugin:, **|
-            source_node_plugin.dispatch_v3_command(cmd)
-          end
-        end
-
-        # dropbox sub-handler
-
-        def action_dropbox_list
-          dropbox_list = api_v3.read('dropboxes')
-          Result::ObjectList.new(dropbox_list['items'], fields: %w[name id description can_read can_write])
-        end
-
-        def action_v4_package_users
-          pkg_box_id = options.instance_identifier
-          entity_execute(api: api_v4, entity: "users/#{pkg_box_id}/packages", command: :list)
-        end
-
-        def action_address_book
-          result = api_v3.read('address-book', {'format' => 'json', 'count' => 100_000})
-          formatter.display_status("users: #{result['itemsPerPage']}/#{result['totalResults']}, start:#{result['startIndex']}")
-          users = result['entry']
-          # add missing entries
-          users.each do |u|
-            unless u['emails'].nil?
-              email = u['emails'].find{ |i| i['primary'].eql?('true')}
-              u['email'] = email['value'] unless email.nil?
-            end
-            if u['email'].nil?
-              Log.log.warn{"Skip user without email: #{u}"}
-              next
-            end
-            u['first_name'], u['last_name'] = u['displayName'].split(' ', 2)
-            u['x'] = true
-          end
-          return Result::ObjectList.new(users)
-        end
-
-        def action_login_methods
-          login_meths = api_v3.call(operation: 'GET', subpath: 'login/new', headers: {'Accept' => 'application/xrds+xml'}, ret: :resp).body
-          login_methods = XmlSimple.xml_in(login_meths, {'ForceArray' => false})
-          return Result::ObjectList.new(login_methods['XRD']['Service'])
-        end
-      end
-    end
-  end
-end

data/lib/aspera/transfer/uri.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-# cspell:words httpport targetrate minrate bwcap createpath lockpolicy lockminrate faspe
-
-require 'aspera/log'
-require 'aspera/rest'
-require 'aspera/command_line_converter'
-
-module Aspera
-  module Transfer
-    # translates a "faspe:" URI (used in Faspex 4) into transfer spec (Hash)
-    class Uri
-      SCHEME = 'faspe'
-      def initialize(fasp_link)
-        @fasp_uri = URI.parse(fasp_link.gsub(' ', '%20'))
-        Aspera.assert_values(@fasp_uri.scheme, [SCHEME]){"Invalid scheme: #{@fasp_uri.scheme}"}
-      end
-
-      # Generate transfer spec from provided faspe: URL
-      def transfer_spec
-        result_ts = {}
-        result_ts['remote_host'] = @fasp_uri.host
-        result_ts['remote_user'] = @fasp_uri.user
-        result_ts['ssh_port'] = @fasp_uri.port
-        result_ts['paths'] = [{'source' => URI.decode_www_form_component(@fasp_uri.path)}]
-        # faspex 4 does not encode trailing base64 padding, fix that to be able to decode properly
-        fixed_query = @fasp_uri.query.gsub(/(=+)$/){ |trail_equals| '%3D' * trail_equals.length}
-
-        Rest.query_to_h(fixed_query).each do |name, value|
-          case name
-          when 'cookie'      then result_ts['cookie'] = value
-          when 'token'       then result_ts['token'] = value
-          when 'sshfp'       then result_ts['sshfp'] = value
-          when 'policy'      then result_ts['rate_policy'] = value
-          when 'httpport'    then result_ts['http_fallback_port'] = value.to_i
-          when 'targetrate'  then result_ts['target_rate_kbps'] = value.to_i
-          when 'minrate'     then result_ts['min_rate_kbps'] = value.to_i
-          when 'port'        then result_ts['fasp_port'] = value.to_i
-          when 'bwcap'       then result_ts['target_rate_cap_kbps'] = value.to_i
-          when 'enc'         then result_ts['cipher'] = value.gsub(/^aes/, 'aes-').gsub(/cfb$/, '-cfb').gsub(/gcm$/, '-gcm').gsub('--', '-')
-          when 'tags64'      then result_ts['tags'] = JSON.parse(Base64.strict_decode64(value))
-          when 'createpath'  then result_ts['create_dir'] = CommandLineConverter.yes_to_true(value)
-          when 'fallback'    then result_ts['http_fallback'] = CommandLineConverter.yes_to_true(value)
-          when 'lockpolicy'  then result_ts['lock_rate_policy'] = CommandLineConverter.yes_to_true(value)
-          when 'lockminrate' then result_ts['lock_min_rate'] = CommandLineConverter.yes_to_true(value)
-          when 'auth'        then Log.log.debug{"ignoring #{name}=#{value}"} # Not used (yes/no)
-          when 'v'           then Log.log.debug{"ignoring #{name}=#{value}"} # rubocop:disable Lint/DuplicateBranch -- Not used (shall be 2)
-          when 'protect'     then Log.log.debug{"ignoring #{name}=#{value}"} # rubocop:disable Lint/DuplicateBranch -- TODO: what is this ?
-          else                    Log.log.warn{"URI parameter ignored: #{name} = #{value}"}
-          end
-        end
-        return result_ts
-      end
-    end
-  end
-end