aspera-cli 4.25.4 → 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,7 +151,7 @@ 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
@@ -182,13 +176,9 @@ 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
 
@@ -251,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}")
@@ -286,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')
@@ -308,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]
@@ -336,7 +325,7 @@ module Aspera
           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
@@ -427,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
@@ -449,7 +437,7 @@ 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]
@@ -462,14 +450,17 @@ module Aspera
           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])
@@ -480,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'],
@@ -515,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)
@@ -526,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],
@@ -548,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,
@@ -558,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
@@ -579,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'
@@ -633,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'))
@@ -705,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
@@ -732,7 +719,8 @@ module Aspera
         ACCOUNT_TYPES = %w{local_user saml_user self_registered_user external_user}.freeze
         WORKGROUP_TYPES = %w{workgroup shared_inbox}.freeze
         CONTACT_TYPES = (WORKGROUP_TYPES + %w{distribution_list user external_user}).freeze
-        private_constant :SHARED_INBOX_MEMBER_LEVELS, :ACCOUNT_TYPES, :CONTACT_TYPES
+        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'
@@ -166,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?
@@ -196,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
@@ -221,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']
@@ -243,7 +244,7 @@ module Aspera
             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
           RestParameters.instance.spinner_cb.call(action: :success)
@@ -286,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?
@@ -300,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
@@ -378,7 +379,7 @@ 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)
@@ -882,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
@@ -928,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|
@@ -1094,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")
@@ -1132,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/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.4'
+    VERSION = '4.25.5'
   end
 end

data/lib/aspera/dot_container.rb

@@ -7,13 +7,14 @@ module Aspera
   class DotContainer
     class << self
       # Insert extended value `value` into struct `result` at `path`
-      # @param path   [String] Dotted path in container
-      # @param value  [String] Last value to insert
-      # @param result [NilClass, Hash, Array] current value
-      # @return [Hash, Array]
+      # @param path   [Array<String>] Path in container
+      # @param value  [Object]        Value to insert in deep container
+      # @param result [nil, Hash, Array] Current container to use (or nil to create a new one)
+      # @return [Hash, Array] Container
       def dotted_to_container(path, value, result = nil)
+        Aspera.assert_array_all(path, String)
         # Typed keys
-        keys = path.split(OPTION_DOTTED_SEPARATOR).map{ |k| int_or_string(k)}
+        keys = path.map{ |k| int_or_string(k)}
         # Create, or re-use first level container
         current = (result ||= new_hash_or_array_from_key(keys.first))
         # walk the path, and create sub-containers if necessary
@@ -78,7 +79,7 @@ module Aspera
               to_insert = current.map{ |i| i['name']}
             # Array of Hashes with only 'name' and 'value' keys -> Hash of key/values
             elsif current.all?{ |i| i.is_a?(Hash) && i.keys.sort == %w[name value]}
-              add_elements(path, current.each_with_object({}){ |i, h| h[i['name']] = i['value']})
+              add_elements(path, current.to_h{ |i| [i['name'], i['value']]})
             else
               add_elements(path, current.each_with_index.map{ |v, i| [i, v]})
             end
@@ -86,7 +87,7 @@ module Aspera
             to_insert = current
           end
         end
-        result[path.map(&:to_s).join(OPTION_DOTTED_SEPARATOR)] = to_insert unless to_insert.nil?
+        result[path.join(SEPARATOR)] = to_insert unless to_insert.nil?
       end
       result
     end
@@ -101,8 +102,7 @@ module Aspera
       nil
     end
 
-    # "."
-    OPTION_DOTTED_SEPARATOR = '.'
-    private_constant :OPTION_DOTTED_SEPARATOR
+    # Dot-path separator: `.`
+    SEPARATOR = '.'
   end
 end

data/lib/aspera/log.rb

@@ -26,7 +26,7 @@ class Logger
   # Hash
   # key   [Integer] Log level (e.g. 0 for DEBUG)
   # value [Symbol]  Uppercase log level label (e.g. :DEBUG)
-  SEVERITY_LABEL = Severity.constants.each_with_object({}){ |name, hash| hash[Severity.const_get(name)] = name}
+  SEVERITY_LABEL = Severity.constants.to_h{ |name| [Severity.const_get(name), name]}
 
   # Override
   # @param severity [Integer] Log severity as int

data/lib/aspera/markdown.rb

@@ -33,7 +33,7 @@ module Aspera
 
       # type: NOTE CAUTION WARNING IMPORTANT TIP INFO
       def admonition(lines, type: 'INFO')
-        "> [!{type}]\n#{lines.map{ |l| "> #{l}"}.join("\n")}\n\n"
+        "> [!#{type}]\n#{lines.map{ |l| "> #{l}"}.join("\n")}\n\n"
       end
 
       def code(lines, type: 'shell')

data/lib/aspera/persistency_folder.rb

@@ -79,7 +79,7 @@ module Aspera
     end
 
     def current_items(persist_category)
-      current_files(persist_category).each_with_object({}){ |i, h| h[File.basename(i, FILE_SUFFIX)] = File.read(i)}
+      current_files(persist_category).to_h{ |i| [File.basename(i, FILE_SUFFIX), File.read(i)]}
     end
 
     private