aspera-cli 4.26.2 → 4.27.1

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

@@ -1,539 +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/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
-        # 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')
-              raise Cli::BadArgument, 'package has no link (deleted?)' if raise_no_link
-              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
-
-        def initialize(**_)
-          super
-          @api_v3 = nil
-          @api_v4 = nil
-          options.declare(:link, 'Public link for specific operation')
-          options.declare(:delivery_info, 'Package delivery information', allowed: Hash)
-          options.declare(:remote_source, 'Remote source for package send (id or %name:)')
-          options.declare(:storage, 'Faspex local storage definition (for browsing source)')
-          options.declare(:recipient, 'Use if recipient is a dropbox (with *)')
-          options.declare(:box, 'Package box', allowed: ATOM_MAILBOXES, default: :inbox)
-          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)
-          raise Cli::BadArgument, "pub link is #{link_data[:subpath]}, expecting external/submissions/new" if !['external/submissions/new', 'external/dropbox_submissions/new'].include?(link_data[: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
-
-        ACTIONS = %i[health package source me dropbox v4 address_book login_methods].freeze
-
-        def execute_action
-          command = options.get_next_command(ACTIONS)
-          case command
-          when :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)
-          when :package
-            command_pkg = options.get_next_command(%i[send receive list show], aliases: {recv: :receive})
-            case command_pkg
-            when :show
-              delivery_id = options.instance_identifier
-              return Result::SingleObject.new(mailbox_filtered_entries(stop_at_id: delivery_id).find{ |p| p[PACKAGE_MATCH_FIELD].eql?(delivery_id)})
-            when :list
-              return Result::ObjectList.new(mailbox_filtered_entries, fields: [PACKAGE_MATCH_FIELD, 'title', 'items'])
-            when :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 = Manager.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
-                raise Cli::BadArgument, 'expecting one session exactly' if pkg_created['xfer_sessions'].length != 1
-                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))
-            when :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)
-                raise Cli::BadArgument, "Pub link is #{link_data[:subpath]}. Expecting #{PUB_LINK_EXTERNAL_MATCH}" if !link_data[:subpath].start_with?(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 = [: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 TransferAgent.session_status(statuses).eql?(:success)
-              end
-              skip_ids_persistency&.save
-              return Runner.result_transfer_multiple(result_transfer)
-            end
-          when :source
-            command_source = options.get_next_command(%i[list info node])
-            source_list = api_v3.read('source_shares')['items']
-            case command_source
-            when :list
-              return Result::ObjectList.new(source_list)
-            else # :info :node
-              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)}
-              raise BadArgument, 'No such source' if selected_source.nil?
-              source_name = selected_source['name']
-              source_hash = options.get_option(:storage, mandatory: true)
-              # check value of option
-              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
-              raise Cli::Error, "No such storage in config file: \"#{source_name}\" in [#{source_hash.keys.join(', ')}]" if !source_hash.key?(source_name)
-              source_info = source_hash[source_name]
-              Log.dump(:source_info, source_info)
-              case command_source
-              when :info
-                return Result::SingleObject.new(source_info)
-              when :node
-                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']
-                  }
-                )
-                command = options.get_next_command(Node::COMMANDS_FASPEX)
-                return Node.new(context: context, api: api_node, prefix_path: source_info[KEY_PATH]).execute_action(command)
-              end
-            end
-          when :me
-            my_info = api_v3.read('me')
-            return Result::SingleObject.new(my_info)
-          when :dropbox
-            command_pkg = options.get_next_command([:list])
-            case command_pkg
-            when :list
-              dropbox_list = api_v3.read('dropboxes')
-              return Result::ObjectList.new(dropbox_list['items'], fields: %w[name id description can_read can_write])
-            end
-          when :v4
-            command = options.get_next_command(%i[package dropbox dmembership workgroup wmembership user metadata_profile])
-            case command
-            when :dropbox
-              return entity_execute(api: api_v4, entity: 'admin/dropboxes', display_fields: %w[id e_wg_name e_wg_desc created_at])
-            when :dmembership
-              return entity_execute(api: api_v4, entity: 'dropbox_memberships')
-            when :workgroup
-              return entity_execute(api: api_v4, entity: 'admin/workgroups', display_fields: %w[id e_wg_name e_wg_desc created_at])
-            when :wmembership
-              return entity_execute(api: api_v4, entity: 'workgroup_memberships')
-            when :user
-              return entity_execute(api: api_v4, entity: 'users', display_fields: %w[id name first_name last_name])
-            when :metadata_profile
-              return entity_execute(api: api_v4, entity: 'metadata_profiles')
-            when :package
-              pkg_box_type = options.get_next_command([:users])
-              pkg_box_id = options.instance_identifier
-              return entity_execute(api: api_v4, entity: "#{pkg_box_type}/#{pkg_box_id}/packages")
-            end
-          when :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)
-          when :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
-end

data/lib/aspera/json_rpc.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-# cspell:ignore blankslate
-
-require 'aspera/rest_error_analyzer'
-require 'aspera/assert'
-require 'blankslate'
-
-Aspera::RestErrorAnalyzer.instance.add_simple_handler(name: 'JSON RPC', path: %w[error message], always: true)
-
-module Aspera
-  # a very simple JSON RPC client
-  class JsonRpcClient < BlankSlate
-    JSON_RPC_VERSION = '2.0'
-    reveal :instance_variable_get
-    reveal :inspect
-    reveal :to_s
-
-    def initialize(api, namespace = nil)
-      super()
-      @api = api
-      @namespace = namespace
-      @request_id = 0
-    end
-
-    def respond_to_missing?(_sym, _include_private = false)
-      true
-    end
-
-    def method_missing(method, *args, &block)
-      args = args.first if args.size == 1 && args.first.is_a?(Hash)
-      data = @api.create('', {
-        jsonrpc: JSON_RPC_VERSION,
-        method:  "#{@namespace}#{method}",
-        params:  args,
-        id:      @request_id += 1
-      })
-      Aspera.assert_type(data, Hash){'response'}
-      Aspera.assert(data['jsonrpc'] == JSON_RPC_VERSION, 'bad version in response')
-      Aspera.assert(data.key?('id'), 'missing id in response')
-      Aspera.assert(!(data.key?('error') && data.key?('result')), 'both error and response')
-      Aspera.assert(
-        !data.key?('error') ||
-        data['error'].is_a?(Hash) &&
-        data['error']['code'].is_a?(Integer) &&
-        data['error']['message'].is_a?(String),
-        'bad error response'
-      )
-      return data['result']
-    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