aspera-cli 4.25.3 → 4.25.5

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

@@ -100,24 +100,18 @@ module Aspera
           options.parse_options!
         end
 
-        def set_api
-          # create an API object with the same options, but with a different subpath
-          @api_v5 = Api::Faspex.new(**Oauth.args_from_options(options))
-          # in case user wants to use HTTPGW tell transfer agent how to get address
-          transfer.httpgw_url_cb = lambda{@api_v5.read('account')['gateway_url']}
-        end
-
         # if recipient is just an email, then convert to expected API hash : name and type
-        def normalize_recipients(parameters)
-          return unless parameters.key?('recipients')
-          Aspera.assert_type(parameters['recipients'], Array){'recipients'}
+        def normalize_recipients(parameters, type)
+          type = type.to_s
+          return unless parameters.key?(type)
+          Aspera.assert_type(parameters[type], Array){type}
           recipient_types = Api::Faspex::RECIPIENT_TYPES
           if parameters.key?('recipient_types')
             recipient_types = parameters['recipient_types']
             parameters.delete('recipient_types')
             recipient_types = [recipient_types] unless recipient_types.is_a?(Array)
           end
-          parameters['recipients'].map! do |recipient_data|
+          parameters[type].map! do |recipient_data|
             # If just a string, make a general lookup and build expected name/type hash
             if recipient_data.is_a?(String)
               matched = @api_v5.lookup_by_name('contacts', recipient_data, query: Rest.php_style({context: 'packages', type: recipient_types}))
@@ -157,17 +151,17 @@ module Aspera
           end
         end
 
-        # @param [Srting] job identifier
+        # @param [String] job identifier
         # @return [Hash] result of API call for job status
         def wait_for_job(job_id)
           result = nil
           loop do
             result = @api_v5.read("jobs/#{job_id}", {type: :formatted})
             break unless Api::Faspex::JOB_RUNNING.include?(result['status'])
-            formatter.long_operation_running(result['status'])
+            RestParameters.instance.spinner_cb.call(result['status'])
             sleep(0.5)
           end
-          formatter.long_operation_terminated
+          RestParameters.instance.spinner_cb.call(action: :success)
           return result
         end
 
@@ -182,16 +176,22 @@ module Aspera
             when *Api::Faspex::API_LIST_MAILBOX_TYPES then "#{box}/packages"
             else
               group_type = options.get_option(:group_type)
-              "#{group_type}/#{lookup_entity_by_field(api: @api_v5, entity: group_type, value: box)['id']}/packages"
+              "#{group_type}/#{@api_v5.lookup_entity_by_field(entity: group_type, value: box)['id']}/packages"
             end
-          list, total = list_entities_limit_offset_total_count(
-            api: @api_v5,
-            entity: entity,
-            query:  query_read_delete(default: query)
-          )
+          list, total = @api_v5.list_entities_limit_offset_total_count(entity: entity, query: query_read_delete(default: query))
           return list.select(&filter), total
         end
 
+        # Build query to get package recipients based on package info in case of shared inbox or workgroup recipient
+        # @param package_id [String] the package id to get info from
+        def recipient_query(package_id)
+          package_info = @api_v5.read("packages/#{package_id}")
+          base_query = {}
+          base_query['recipient_workgroup_id'] = package_info['recipients'].first['id'] if WORKGROUP_TYPES.include?(package_info['recipients'].first['recipient_type'])
+          base_query['recipient_user_id'] = package_info['recipients'].first['id'] if package_info['recipients'].first['recipient_type'].eql?('user')
+          base_query
+        end
+
         def package_receive(package_ids)
           # prepare persistency if needed
           skip_ids_persistency = nil
@@ -241,7 +241,7 @@ module Aspera
             type:          Api::Faspex.box_type(box),
             transfer_type: Api::Faspex::TRANSFER_CONNECT
           }
-          download_params[:recipient_workgroup_id] = lookup_entity_by_field(api: @api_v5, entity: options.get_option(:group_type), value: box)['id'] if !Api::Faspex::API_LIST_MAILBOX_TYPES.include?(box) && box != SpecialValues::ALL
+          # download_params[:recipient_workgroup_id] = @api_v5.lookup_entity_by_field(entity: options.get_option(:group_type), value: box)['id'] if !Api::Faspex::API_LIST_MAILBOX_TYPES.include?(box) && box != SpecialValues::ALL
           packages.each do |package|
             pkg_id = package['id']
             formatter.display_status("Receiving package #{pkg_id}")
@@ -249,7 +249,7 @@ module Aspera
             transfer_spec = @api_v5.call(
               operation:    'POST',
               subpath:      "packages/#{pkg_id}/transfer_spec/download",
-              query:        download_params,
+              query:        download_params.merge(recipient_query(pkg_id)),
               content_type: Mime::JSON,
               body:         param_file_list,
               headers:      {'Accept' => Mime::JSON}
@@ -276,7 +276,7 @@ module Aspera
               recipient_type: @api_v5.pub_link_context['recipient_type']
             }]
           end
-          normalize_recipients(parameters)
+          PACKAGE_RECIPIENT_TYPES.each{ |type| normalize_recipients(parameters, type)}
           # User specified content prot in tspec, but faspex requires in package creation
           # `transfer_spec/upload` will set `content_protection`
           if transfer.user_transfer_spec['content_protection'] && !parameters.key?('ear_enabled')
@@ -298,8 +298,7 @@ module Aspera
           else
             # send from remote shared folder
             if (m = Base.percent_selector(shared_folder))
-              shared_folder = lookup_entity_by_field(
-                api: @api_v5,
+              shared_folder = @api_v5.lookup_entity_by_field(
                 entity: 'shared_folders',
                 field: m[:field],
                 value: m[:value]
@@ -319,14 +318,14 @@ module Aspera
 
         # Browse a folder
         # @param browse_endpoint [String] the endpoint to browse
-        def browse_folder(browse_endpoint)
+        def browse_folder(browse_endpoint, base_query = {})
           folders_to_process = [options.get_next_argument('folder path', default: '/')]
-          query = query_read_delete(default: {})
+          query = base_query.merge(query_read_delete(default: {}))
           filters = query.delete('filters'){{}}
           Aspera.assert_type(filters, Hash)
           filters['basenames'] ||= []
           Aspera.assert_type(filters, Hash){'filters'}
-          max_items = query.delete(MAX_ITEMS)
+          max_items = query.delete(RestList::MAX_ITEMS)
           recursive = query.delete('recursive')
           use_paging = query.delete('paging'){true}
           if use_paging
@@ -357,7 +356,7 @@ module Aspera
               end
               folders_to_process.concat(data['items'].select{ |i| i['type'].eql?('directory')}.map{ |i| i['path']}) if recursive
               if use_paging
-                iteration_token = http[Api::Faspex::HEADER_ITERATION_TOKEN]
+                iteration_token = http[Api::Faspex::HEADER_X_NEXT_ITER_TOKEN]
                 break if iteration_token.nil? || iteration_token.empty?
                 query['iteration_token'] = iteration_token
               else
@@ -365,12 +364,11 @@ module Aspera
                 break if data['item_count'].eql?(0)
                 query['offset'] += data['item_count']
               end
-              formatter.long_operation_running(all_items.count)
+              RestParameters.instance.spinner_cb.call(all_items.count)
             end
             query.delete('iteration_token')
           end
-          formatter.long_operation_terminated
-
+          RestParameters.instance.spinner_cb.call(action: :success)
           return Main.result_object_list(all_items, total: total_count)
         end
 
@@ -384,7 +382,7 @@ module Aspera
           when :show
             return Main.result_single_object(@api_v5.read("packages/#{package_id}"))
           when :browse
-            return browse_folder("packages/#{package_id}/files/#{Api::Faspex.box_type(options.get_option(:box))}")
+            return browse_folder("packages/#{package_id}/files/#{Api::Faspex.box_type(options.get_option(:box))}", recipient_query(package_id))
           when :status
             status_list = options.get_next_argument('list of states, or nothing', mandatory: false, validation: Array)
             status = wait_package_status(package_id, status_list: status_list)
@@ -418,8 +416,7 @@ module Aspera
         def execute_resource(res_sym)
           exec_args = {
             api:    @api_v5,
-            entity: res_sym.to_s,
-            tclo:   true
+            entity: res_sym.to_s
           }
           res_id_query = :default
           available_commands = ALL_OPS
@@ -440,25 +437,30 @@ module Aspera
             available_commands += [:reset_password]
           when :oauth_clients
             exec_args[:display_fields] = Formatter.all_but('public_key')
-            exec_args[:api] = @api_v5.auth_api
+            exec_args[:api] = Api::Faspex.new(root: Api::Faspex::PATH_AUTH, **Oauth.args_from_options(options))
             exec_args[:list_query] = {'expand': true, 'no_api_path': true, 'client_types[]': 'public'}
           when :shared_inboxes, :workgroups
             available_commands += %i[members saml_groups invite_external_collaborator]
             res_id_query = {'all': true}
           when :nodes
             available_commands += %i[shared_folders browse]
+          when :jobs
+            exec_args[:display_fields] = %w[id job_name job_type status]
           end
           res_command = options.get_next_command(available_commands)
           return Main.result_value_list(Api::Faspex::EMAIL_NOTIF_LIST, name: 'email_id') if res_command.eql?(:list) && res_sym.eql?(:email_notifications)
           case res_command
-          when *ALL_OPS
+          when :create, :modify, :delete, :show
             return entity_execute(command: res_command, **exec_args) do |field, value|
-                     lookup_entity_by_field(api: @api_v5, entity: exec_args[:entity], value: value, field: field, items_key: exec_args[:items_key], query: res_id_query)['id']
+                     @api_v5.lookup_entity_by_field(entity: exec_args[:entity], value: value, field: field, items_key: exec_args[:items_key], query: res_id_query)['id']
                    end
+          when :list
+            data, total = exec_args[:api].list_entities_limit_offset_total_count(entity: exec_args[:entity], items_key: exec_args[:items_key], query: query_read_delete(default: exec_args[:list_query]))
+            return Main.result_object_list(data, total: total, fields: exec_args[:display_fields])
           when :shared_folders
             # nodes
             node_id = instance_identifier do |field, value|
-              lookup_entity_by_field(api: @api_v5, entity: 'nodes', field: field, value: value)['id']
+              @api_v5.lookup_entity_by_field(entity: 'nodes', field: field, value: value)['id']
             end
             shfld_entity = "nodes/#{node_id}/shared_folders"
             sh_command = options.get_next_command(ALL_OPS + [:user])
@@ -469,33 +471,32 @@ module Aspera
                 entity: shfld_entity,
                 command: sh_command
               ) do |field, value|
-                       lookup_entity_by_field(api: @api_v5, entity: shfld_entity, field: field, value: value)['id']
+                       @api_v5.lookup_entity_by_field(entity: shfld_entity, field: field, value: value)['id']
                      end
             when :user
               sh_id = instance_identifier do |field, value|
-                lookup_entity_by_field(api: @api_v5, entity: shfld_entity, field: field, value: value)['id']
+                @api_v5.lookup_entity_by_field(entity: shfld_entity, field: field, value: value)['id']
               end
               user_path = "#{shfld_entity}/#{sh_id}/custom_access_users"
               return entity_execute(api: @api_v5, entity: user_path, items_key: 'users') do |field, value|
-                       lookup_entity_by_field(api: @api_v5, entity: user_path, items_key: 'users', field: field, value: value)['id']
+                       @api_v5.lookup_entity_by_field(entity: user_path, items_key: 'users', field: field, value: value)['id']
                      end
 
             end
           when :browse
             # nodes
             node_id = instance_identifier do |field, value|
-              lookup_entity_by_field(api: @api_v5, entity: 'nodes', value: value, field: field)['id']
+              @api_v5.lookup_entity_by_field(entity: 'nodes', value: value, field: field)['id']
             end
             return browse_folder("nodes/#{node_id}/browse")
           when :invite_external_collaborator
             # :shared_inboxes, :workgroups
-            shared_inbox_id = instance_identifier{ |field, value| lookup_entity_by_field(api: @api_v5, entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
+            shared_inbox_id = instance_identifier{ |field, value| @api_v5.lookup_entity_by_field(entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
             creation_payload = value_create_modify(command: res_command, type: [Hash, String])
             creation_payload = {'email_address' => creation_payload} if creation_payload.is_a?(String)
             result = @api_v5.create("#{res_sym}/#{shared_inbox_id}/external_collaborator", creation_payload)
             formatter.display_status(result['message'])
-            result = lookup_entity_by_field(
-              api: @api_v5,
+            result = @api_v5.lookup_entity_by_field(
               entity: "#{res_sym}/#{shared_inbox_id}/members",
               items_key: 'members',
               value: creation_payload['email_address'],
@@ -504,7 +505,7 @@ module Aspera
             return Main.result_single_object(result)
           when :members, :saml_groups
             # res_command := :shared_inboxes, :workgroups
-            res_id = instance_identifier{ |field, value| lookup_entity_by_field(api: @api_v5, entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
+            res_id = instance_identifier{ |field, value| @api_v5.lookup_entity_by_field(entity: res_sym.to_s, field: field, value: value, query: res_id_query)['id']}
             res_path = "#{res_sym}/#{res_id}/#{res_command}"
             list_key = res_command.to_s
             list_key = 'groups' if res_command.eql?(:saml_groups)
@@ -515,8 +516,7 @@ module Aspera
               users = [users] unless users.is_a?(Array)
               users = users.map do |user|
                 if (m = Base.percent_selector(user))
-                  lookup_entity_by_field(
-                    api: @api_v5,
+                  @api_v5.lookup_entity_by_field(
                     entity: 'accounts',
                     field: m[:field],
                     value: m[:value],
@@ -537,8 +537,7 @@ module Aspera
               command: sub_command,
               items_key: list_key
             ) do |field, value|
-                     lookup_entity_by_field(
-                       api: @api_v5,
+                     @api_v5.lookup_entity_by_field(
                        entity: res_path,
                        field: field,
                        value: value,
@@ -547,7 +546,7 @@ module Aspera
                    end
           when :reset_password
             # :accounts
-            contact_id = instance_identifier{ |field, value| lookup_entity_by_field(api: @api_v5, entity: 'accounts', field: field, value: value, query: res_id_query)['id']}
+            contact_id = instance_identifier{ |field, value| @api_v5.lookup_entity_by_field(entity: 'accounts', field: field, value: value, query: res_id_query)['id']}
             @api_v5.create("accounts/#{contact_id}/reset_password", {})
             return Main.result_status('password reset, user shall check email')
           end
@@ -568,16 +567,10 @@ module Aspera
             event_type = options.get_next_command(%i[application webhook])
             case event_type
             when :application
-              list, total = list_entities_limit_offset_total_count(
-                api: @api_v5,
-                entity: 'application_events',
-                query: query_read_delete
-              )
-
+              list, total = @api_v5.list_entities_limit_offset_total_count(entity: 'application_events', query: query_read_delete)
               return Main.result_object_list(list, total: total, fields: %w[event_type created_at application user.name])
             when :webhook
-              list, total = list_entities_limit_offset_total_count(
-                api: @api_v5,
+              list, total = @api_v5.list_entities_limit_offset_total_count(
                 entity: 'all_webhooks_events',
                 query: query_read_delete,
                 items_key: 'events'
@@ -622,7 +615,12 @@ module Aspera
 
         def execute_action
           command = options.get_next_command(ACTIONS)
-          set_api unless %i{postprocessing health}.include?(command)
+          unless %i{postprocessing health}.include?(command)
+            # create an API object with the same options, but with a different subpath
+            @api_v5 = Api::Faspex.new(**Oauth.args_from_options(options))
+            # in case user wants to use HTTPGW tell transfer agent how to get address
+            transfer.httpgw_url_cb = lambda{@api_v5.read('account')['gateway_url']}
+          end
           case command
           when :version
             return Main.result_single_object(@api_v5.read('version'))
@@ -694,7 +692,7 @@ module Aspera
                 items_key: invitation_endpoint,
                 display_fields: %w[id public recipient_type recipient_name email_address]
               ) do |field, value|
-                lookup_entity_by_field(api: @api_v5, entity: invitation_endpoint, field: field, value: value, query: {})['id']
+                @api_v5.lookup_entity_by_field(entity: invitation_endpoint, field: field, value: value, query: {})['id']
               end
             end
           when :gateway
@@ -719,8 +717,10 @@ module Aspera
         end
         SHARED_INBOX_MEMBER_LEVELS = %i[submit_only standard shared_inbox_admin].freeze
         ACCOUNT_TYPES = %w{local_user saml_user self_registered_user external_user}.freeze
-        CONTACT_TYPES = %w{workgroup shared_inbox distribution_list user external_user}.freeze
-        private_constant :SHARED_INBOX_MEMBER_LEVELS, :ACCOUNT_TYPES, :CONTACT_TYPES
+        WORKGROUP_TYPES = %w{workgroup shared_inbox}.freeze
+        CONTACT_TYPES = (WORKGROUP_TYPES + %w{distribution_list user external_user}).freeze
+        PACKAGE_RECIPIENT_TYPES = %i{recipients private_recipients notified_on_upload notified_on_download notified_on_receipt}
+        private_constant :SHARED_INBOX_MEMBER_LEVELS, :ACCOUNT_TYPES, :CONTACT_TYPES, :PACKAGE_RECIPIENT_TYPES
       end
     end
   end

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

@@ -11,6 +11,7 @@ require 'aspera/id_generator'
 require 'aspera/api/node'
 require 'aspera/oauth'
 require 'aspera/node_simulator'
+require 'aspera/rest_list'
 require 'aspera/assert'
 require 'base64'
 require 'zlib'
@@ -93,12 +94,9 @@ module Aspera
             options.declare(:validator, 'Identifier of validator (optional for central)')
             options.declare(:asperabrowserurl, 'URL for simple aspera web ui', default: 'https://asperabrowser.mybluemix.net')
             options.declare(
-              :default_ports, 'Gen4: Use standard FASP ports (true) or get from node API (false)', allowed: Allowed::TYPES_BOOLEAN, default: true,
-              handler: {o: Api::Node, m: :use_standard_ports}
-            )
-            options.declare(
-              :node_cache, 'Gen4: Set to no to force actual file system read', allowed: Allowed::TYPES_BOOLEAN,
-              handler: {o: Api::Node, m: :use_node_cache}
+              :node_api, 'Gen4: standard_ports: Use standard FASP ports (true) or get from node API (false). cache: Set to false to force actual file system read',
+              allowed: Hash,
+              handler: {o: Api::Node, m: :api_options}
             )
             options.declare(:root_id, 'Gen4: File id of top folder when using access key (override AK root id)')
             options.declare(:dynamic_key, 'Private key PEM to use for dynamic key auth', handler: {o: Api::Node, m: :use_dynamic_key})
@@ -169,7 +167,7 @@ module Aspera
         # @param api [Rest] an existing API object for the Node API
         # @param prefix_path [String,nil] for Faspex 4, allows browsing a package without full path in node (removes storage prefix)
         def initialize(context:, api: nil, prefix_path: nil)
-          @prefixer = prefix_path ? NodePathPrefix.new(prefix_path) : nil
+          @node_path_prefix = prefix_path ? NodePathPrefix.new(prefix_path) : nil
           super(context: context, basic_options: api.nil?)
           Node.declare_options(options)
           return if context.only_manual?
@@ -199,11 +197,11 @@ module Aspera
         # Gen3 API
         def browse_gen3
           folders_to_process = options.get_next_argument('path', validation: String)
-          folders_to_process = @prefixer.add_to_path(folders_to_process) unless @prefixer.nil?
+          folders_to_process = @node_path_prefix.add_to_path(folders_to_process) unless @node_path_prefix.nil?
           folders_to_process = [folders_to_process]
           query = options.get_option(:query) || {}
           # special parameter: max number of entries in result
-          max_items = query.delete(MAX_ITEMS)
+          max_items = query.delete(RestList::MAX_ITEMS)
           # special parameter: recursive browsing
           recursive = query.delete('recursive')
           # special parameter: only return one entry for the path, even if folder
@@ -224,7 +222,7 @@ module Aspera
               response = @api_node.create('files/browse', query)
               # 'file','symbolic_link'
               if !Node.gen3_entry_folder?(response['self']) || only_path
-                @prefixer&.remove_in_object_list!([response['self']])
+                @node_path_prefix&.remove_in_object_list!([response['self']])
                 return Main.result_single_object(response['self'])
               end
               items = response['items']
@@ -242,14 +240,14 @@ module Aspera
               break if all_items.count >= total_count
               offset += items.count
               query['skip'] = offset
-              formatter.long_operation_running(all_items.count)
+              RestParameters.instance.spinner_cb.call(all_items.count)
             end
             query.delete('skip')
           end
-          @prefixer&.remove_in_object_list!(all_items)
+          @node_path_prefix&.remove_in_object_list!(all_items)
           return Main.result_object_list(all_items)
         ensure
-          formatter.long_operation_terminated
+          RestParameters.instance.spinner_cb.call(action: :success)
         end
 
         # Create async transfer spec request from direction and folders
@@ -289,12 +287,12 @@ module Aspera
           when :delete
             # TODO: add query for recursive
             paths_to_delete = options.get_next_argument('file list', multiple: true)
-            @prefixer&.add_to_paths!(paths_to_delete)
+            @node_path_prefix&.add_to_paths!(paths_to_delete)
             resp = @api_node.create('files/delete', {paths: paths_to_delete.map{ |i| {'path' => i.start_with?('/') ? i : "/#{i}"}}})
             return cli_result_from_paths_response(resp, 'file deleted')
           when :search
             search_root = options.get_next_argument('search root', validation: String)
-            search_root = @prefixer.add_to_path(search_root) unless @prefixer.nil?
+            search_root = @node_path_prefix.add_to_path(search_root) unless @node_path_prefix.nil?
             parameters = {'path' => search_root}
             other_options = options.get_option(:query)
             parameters.merge!(other_options) unless other_options.nil?
@@ -303,40 +301,40 @@ module Aspera
             fields = resp['items'].first.keys.reject{ |i| SEARCH_REMOVE_FIELDS.include?(i)}
             formatter.display_item_count(resp['item_count'], resp['total_count'])
             formatter.display_status("params: #{resp['parameters'].keys.map{ |k| "#{k}:#{resp['parameters'][k]}"}.join(',')}")
-            @prefixer&.remove_in_object_list!(resp['items'])
+            @node_path_prefix&.remove_in_object_list!(resp['items'])
             return Main.result_object_list(resp['items'], fields: fields)
           when :space
             path_list = options.get_next_argument('folder path or ext.val. list', multiple: true)
-            @prefixer&.add_to_paths!(path_list)
+            @node_path_prefix&.add_to_paths!(path_list)
             resp = @api_node.create('space', {'paths' => path_list.map{ |i| {path: i}}})
-            @prefixer&.remove_in_object_list!(resp['paths'])
+            @node_path_prefix&.remove_in_object_list!(resp['paths'])
             return Main.result_object_list(resp['paths'])
           when :mkdir
             path_list = options.get_next_argument('folder path or ext.val. list', multiple: true)
-            @prefixer&.add_to_paths!(path_list)
+            @node_path_prefix&.add_to_paths!(path_list)
             resp = @api_node.create('files/create', {'paths' => path_list.map{ |i| {type: :directory, path: i}}})
             return cli_result_from_paths_response(resp, 'folder created')
           when :mklink
             target = options.get_next_argument('target', validation: String)
-            target = @prefixer.add_to_path(target) unless @prefixer.nil?
+            target = @node_path_prefix.add_to_path(target) unless @node_path_prefix.nil?
             one_path = options.get_next_argument('link path', validation: String)
-            one_path = @prefixer.add_to_path(one_path) unless @prefixer.nil?
+            one_path = @node_path_prefix.add_to_path(one_path) unless @node_path_prefix.nil?
             resp = @api_node.create('files/create', {'paths' => [{type: :symbolic_link, path: one_path, target: {path: target}}]})
             return cli_result_from_paths_response(resp, 'link created')
           when :mkfile
             one_path = options.get_next_argument('file path', validation: String)
-            one_path = @prefixer.add_to_path(one_path) unless @prefixer.nil?
+            one_path = @node_path_prefix.add_to_path(one_path) unless @node_path_prefix.nil?
             contents64 = Base64.strict_encode64(options.get_next_argument('contents'))
             resp = @api_node.create('files/create', {'paths' => [{type: :file, path: one_path, contents: contents64}]})
             return cli_result_from_paths_response(resp, 'file created')
           when :rename
             # TODO: multiple ?
             path_base = options.get_next_argument('path_base', validation: String)
-            path_base = @prefixer.add_to_path(path_base) unless @prefixer.nil?
+            path_base = @node_path_prefix.add_to_path(path_base) unless @node_path_prefix.nil?
             path_src = options.get_next_argument('path_src', validation: String)
-            path_src = @prefixer.add_to_path(path_src) unless @prefixer.nil?
+            path_src = @node_path_prefix.add_to_path(path_src) unless @node_path_prefix.nil?
             path_dst = options.get_next_argument('path_dst', validation: String)
-            path_dst = @prefixer.add_to_path(path_dst) unless @prefixer.nil?
+            path_dst = @node_path_prefix.add_to_path(path_dst) unless @node_path_prefix.nil?
             resp = @api_node.create('files/rename', {'paths' => [{'path' => path_base, 'source' => path_src, 'destination' => path_dst}]})
             return cli_result_from_paths_response(resp, 'entry moved')
           when :browse
@@ -381,14 +379,14 @@ module Aspera
             return Main.result_transfer(transfer.start(transfer_spec))
           when :cat
             remote_path = options.get_next_argument('remote path', validation: String)
-            remote_path = @prefixer.add_to_path(remote_path) unless @prefixer.nil?
+            remote_path = @node_path_prefix.add_to_path(remote_path) unless @node_path_prefix.nil?
             File.basename(remote_path)
             http = @api_node.read("files/#{URI.encode_www_form_component(remote_path)}/contents", ret: :resp)
             return Main.result_text(http.body)
           when :transport
             return Main.result_single_object(@api_node.transport_params)
           when :spec
-            return Main.result_single_object(@api_node.base_spec)
+            return Main.result_single_object(@api_node.base_spec, fields: Formatter.all_but(Transfer::Spec::SPECIFIC))
           end
           Aspera.error_unreachable_line
         end
@@ -523,7 +521,7 @@ module Aspera
             return Main.result_text(result[:password])
           when :browse
             apifid = apifid_from_next_arg(top_file_id)
-            file_info = apifid[:api].read("files/#{apifid[:file_id]}", **Api::Node.cache_control)
+            file_info = apifid[:api].read("files/#{apifid[:file_id]}", headers: Api::Node.add_cache_control)
             unless file_info['type'].eql?('folder')
               # a single file
               return Main.result_object_list([file_info], fields: GEN4_LS_FIELDS)
@@ -885,10 +883,10 @@ module Aspera
                   iteration_persistency.save
                   return Main.result_status('Persistency reset')
                 end
+              else
+                Aspera.assert(!transfer_filter.key?('reset'), type: Cli::BadArgument){'reset only with once_only'}
               end
-              raise Cli::BadArgument, 'reset only with once_only' if transfer_filter.key?('reset') && iteration_persistency.nil?
-              max_items = transfer_filter.delete(MAX_ITEMS)
-              transfers_data = call_with_iteration(api: @api_node, operation: 'GET', subpath: 'ops/transfers', max: max_items, query: transfer_filter, iteration: iteration_persistency&.data)
+              transfers_data = @api_node.read_with_paging('ops/transfers', transfer_filter, iteration: iteration_persistency&.data)
               iteration_persistency&.save
               return Main.result_object_list(transfers_data, fields: %w[id status start_spec.direction start_spec.remote_user start_spec.remote_host start_spec.destination_path])
             when :sessions
@@ -931,10 +929,8 @@ module Aspera
                 # do not process last one
                 break if end_date.nil?
                 # init data for this period
-                period_bandwidth = Transfer::Spec::DIRECTION_ENUM_VALUES.map(&:to_sym).each_with_object({}) do |direction, h|
-                  h[direction] = dir_info.each_with_object({}) do |k2, h2|
-                    h2[k2] = 0
-                  end
+                period_bandwidth = Transfer::Spec::DIRECTION_ENUM_VALUES.map(&:to_sym).to_h do |direction|
+                  [direction, dir_info.to_h{ |k2| [k2, 0]}]
                 end
                 # find all transfers that were active at this time
                 transfers_data.each do |transfer|
@@ -1097,7 +1093,7 @@ module Aspera
             }
             loop do
               timestamp = Time.now
-              transfers_data = call_with_iteration(api: @api_node, operation: 'GET', subpath: 'ops/transfers', query: {active_only: true})
+              transfers_data = @api_node.read_with_paging('ops/transfers', {active_only: true})
               datapoint[:asInt] = transfers_data.length
               datapoint[:timeUnixNano] = timestamp.to_i * 1_000_000_000 + timestamp.nsec
               Log.log.info("#{datapoint[:asInt]} active transfers")
@@ -1135,50 +1131,9 @@ module Aspera
         # Translates paths results into CLI result, and removes prefix
         def cli_result_from_paths_response(response, success_msg)
           obj_list = response_to_result(response, success_msg)
-          @prefixer&.remove_in_object_list!(obj_list)
+          @node_path_prefix&.remove_in_object_list!(obj_list)
           return Main.result_object_list(obj_list, fields: %w[path result])
         end
-
-        # Executes the provided API call in loop
-        # @param api       [Rest]    the API to call
-        # @param iteration [Array]   a single element array with the iteration token or nil
-        # @param max       [Integer] maximum number of items to return, or nil for no limit
-        # @param query     [Hash]    query parameters to use for the API call
-        # @param call_args [Hash]    additional arguments to pass to the API call
-        # @return [Array] list of items returned by the API call
-        def call_with_iteration(api:, iteration: nil, max: nil, query: nil, **call_args)
-          Aspera.assert_type(iteration, Array, NilClass){'iteration'}
-          Aspera.assert_type(query, Hash, NilClass){'query'}
-          query_token = query&.dup || {}
-          item_list = []
-          query_token[:iteration_token] = iteration[0] unless iteration.nil?
-          loop do
-            data, http = api.call(**call_args, query: query_token, ret: :both)
-            Aspera.assert_type(data, Array){"Expected data to be an Array, got: #{data.class}"}
-            # no data
-            break if data.empty?
-            # get next iteration token from link
-            next_iteration_token = nil
-            link_info = http['Link']
-            unless link_info.nil?
-              m = link_info.match(/<([^>]+)>/)
-              Aspera.assert(m){"Cannot parse iteration in Link: #{link_info}"}
-              next_iteration_token = Rest.query_to_h(URI.parse(m[1]).query)['iteration_token']
-            end
-            # same as last iteration: stop
-            break if next_iteration_token&.eql?(query_token[:iteration_token])
-            query_token[:iteration_token] = next_iteration_token
-            item_list.concat(data)
-            if max&.<=(item_list.length)
-              item_list = item_list.slice(0, max)
-              break
-            end
-            break if next_iteration_token.nil?
-          end
-          # save iteration token if needed
-          iteration[0] = query_token[:iteration_token] unless iteration.nil?
-          item_list
-        end
       end
     end
   end

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

@@ -3,6 +3,8 @@
 require 'aspera/cli/plugins/basic_auth'
 require 'aspera/cli/plugins/node'
 require 'aspera/assert'
+require 'aspera/rest_list'
+
 module Aspera
   module Cli
     module Plugins
@@ -128,7 +130,7 @@ module Aspera
           when :admin
             api_shares_admin = basic_auth_api(ADMIN_API_PATH)
             admin_command = options.get_next_command(%i[node share transfer_settings user group].freeze)
-            lookup_share = ->(field, value){lookup_entity_generic(entity: 'share', field: field, value: value){api_shares_admin.read('data/shares')}['id']}
+            lookup_share = ->(field, value){RestList.lookup_entity_generic(entity: 'share', field: field, value: value){api_shares_admin.read('data/shares')}['id']}
             case admin_command
             when :node
               return entity_execute(api: api_shares_admin, entity: 'data/nodes')
@@ -177,7 +179,7 @@ module Aspera
                 entity_commands = %i[import].freeze
               end
               entity_verb = options.get_next_command(entity_commands)
-              lookup_block = ->(field, value){lookup_entity_generic(entity: entity_type, field: field, value: value){api_shares_admin.read(entities_path)}['id']}
+              lookup_block = ->(field, value){RestList.lookup_entity_generic(entity: entity_type, field: field, value: value){api_shares_admin.read(entities_path)}['id']}
               case entity_verb
               when *ALL_OPS # list, show, delete, create, modify
                 display_fields = entity_type.eql?(:user) ? %w[id user_id username first_name last_name email] : nil

data/lib/aspera/cli/special_values.rb

@@ -8,6 +8,7 @@ module Aspera
       INIT = 'INIT'
       ALL = 'ALL'
       DEF = 'DEF'
+      EOA = 'END'
     end
   end
 end

data/lib/aspera/cli/transfer_agent.rb

@@ -33,6 +33,9 @@ module Aspera
         :DEFAULT_TRANSFER_NOTIFY_TEMPLATE
 
       class << self
+        # Analyze transfer session statuses and return a global status
+        #
+        # @param statuses [Array] list of session status, each status is :success or an error message string
         # @return [:success]  if all sessions statuses returned by "start" are success
         # @return [Exception] if one sessions statuses returned by "start" is failed
         def session_status(statuses)

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.25.3'
+    VERSION = '4.25.5'
   end
 end