aspera-cli 4.21.2 → 4.22.0

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

@@ -52,7 +52,7 @@ module Aspera
               result = api.call(
                 operation:        'POST',
                 headers:          {
-                  'Content-type' => 'text/plain',
+                  'Content-type' => Rest::MIME_TEXT,
                   'Accept'       => 'application/xrds+xml'
                 }
               )
@@ -74,7 +74,9 @@ module Aspera
             return nil
           end
 
-          def wizard(object:, private_key_path: nil, pub_key_pem: nil)
+          # @param object [Plugin] An instance of this class
+          # @return [Hash] :preset_value, :test_args
+          def wizard(object:)
             options = object.options
             return {
               preset_value: {
@@ -89,7 +91,7 @@ module Aspera
           # 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.*)$})), exception_class: Cli::BadArgument){'Public link does not match Faspex format'}
+            Aspera.assert(m = public_uri.path.match(%r{^(.*)/(external.*)$}), exception_class: Cli::BadArgument){'Public link does not match Faspex format'}
             base = m[1]
             subpath = m[2]
             port_add = public_uri.port.eql?(public_uri.default_port) ? '' : ":#{public_uri.port}"
@@ -108,15 +110,15 @@ module Aspera
               raise Cli::BadArgument, 'package has no link (deleted?)' if raise_no_link
               return nil
             end
-            result = entry['link'].find{|e| e['rel'].eql?('package')}['href']
+            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) }
+            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(', ')}])
+            raise Cli::Error, %Q(No such Faspex source: "#{source_name}" in [#{source_list.map{ |i| %Q("#{i['name']}")}.join(', ')}])
           end
         end
 
@@ -199,14 +201,14 @@ module Aspera
               package[PACKAGE_MATCH_FIELD] =
                 case mailbox
                 when :inbox, :archive
-                  recipient = package['to'].find{|i|recipient_names.include?(i['name'])}
+                  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'].each_with_object({}){|i, m| m[i['name']] = i['content'] }
+              package['metadata'] = package['metadata']['field'].each_with_object({}){ |i, m| m[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
@@ -220,13 +222,13 @@ module Aspera
               result = result.slice(0, max_items) if result.count > max_items
               break
             end
-            link = box_data['link'].find{|i|i['rel'].eql?('next')}
+            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
             params = CGI.parse(URI.parse(link['href']).query)
-            mailbox_query = params.keys.each_with_object({}){|i, m| m[i] = params[i].first }
+            mailbox_query = params.keys.each_with_object({}){ |i, m| m[i] = params[i].first}
             Log.log.debug{"query: #{mailbox_query}"}
             break if !max_pages.nil? && (mailbox_query['page'].to_i > max_pages)
           end
@@ -250,11 +252,12 @@ module Aspera
           # 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,
-            headers:     {'Accept' => 'text/javascript'},
-            body:        package_create_params,
-            body_type:   :json)[:http].body
+            operation:    'POST',
+            subpath:      create_path,
+            content_type: Rest::MIME_JSON,
+            body:         package_create_params,
+            headers:      {'Accept' => 'text/javascript'}
+          )[:http].body
           # get arguments of function call
           package_creation_data.delete!("\n") # one line
           package_creation_data.gsub!(/^[^"]+\("\{/, '{') # delete header
@@ -288,7 +291,7 @@ module Aspera
             case command_pkg
             when :show
               delivery_id = instance_identifier
-              return {type: :single_object, data: mailbox_filtered_entries(stop_at_id: delivery_id).find{|p|p[PACKAGE_MATCH_FIELD].eql?(delivery_id)} }
+              return Main.result_single_object(mailbox_filtered_entries(stop_at_id: delivery_id).find{ |p| p[PACKAGE_MATCH_FIELD].eql?(delivery_id)})
             when :list
               return {
                 type:   :object_list,
@@ -350,14 +353,14 @@ module Aspera
                 raise 'empty id' if delivery_id.empty?
                 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)}}
+                  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.data.clear.concat(mailbox_filtered_entries.map{ |i| {id: i[PACKAGE_MATCH_FIELD]}})
                   skip_ids_persistency.save
                   return Main.result_status("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']
+                  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
@@ -397,7 +400,7 @@ module Aspera
               # 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])}
+              pkg_id_uri.reject!{ |i| skip_ids_data.include?(i[:id])}
               Log.log.debug{Log.dump(:pkg_id_uri, pkg_id_uri)}
               return Main.result_status('no new package') if pkg_id_uri.empty?
               result_transfer = []
@@ -413,12 +416,13 @@ module Aspera
                     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',
-                      headers:    {'Accept' => 'text/plain', 'Content-Type' => 'application/vnd.aspera.url-list+xml'},
-                      query:      {'direction' => 'down'},
-                      body:       xml_payload,
-                      body_type:  :text)[:http].body
+                      operation:    'POST',
+                      subpath:      'issue-token',
+                      query:        {'direction' => 'down'},
+                      content_type: Rest::MIME_TEXT,
+                      body:         xml_payload,
+                      headers:      {'Accept' => Rest::MIME_TEXT, 'Content-Type' => 'application/vnd.aspera.url-list+xml'}
+                    )[:http].body
                   end
                   transfer_spec['direction'] = Transfer::Spec::DIRECTION_RECEIVE
                   statuses = transfer.start(transfer_spec)
@@ -435,13 +439,13 @@ module Aspera
             source_list = api_v3.read('source_shares')['items']
             case command_source
             when :list
-              return {type: :object_list, data: source_list}
+              return Main.result_object_list(source_list)
             else # :info :node
               source_id = instance_identifier do |field, value|
                 Aspera.assert(field.eql?('name'), exception_class: Cli::BadArgument){'only name as selector, or give id'}
                 self.class.get_source_id_by_name(value, source_list)
               end.to_i
-              selected_source = source_list.find{|i|i['id'].eql?(source_id)}
+              selected_source = source_list.find{ |i| i['id'].eql?(source_id)}
               raise 'No such source' if selected_source.nil?
               source_name = selected_source['name']
               source_hash = options.get_option(:storage, mandatory: true)
@@ -460,7 +464,7 @@ module Aspera
               Log.log.debug{Log.dump(:source_info, source_info)}
               case command_source
               when :info
-                return {data: source_info, type: :single_object}
+                return Main.result_single_object(source_info)
               when :node
                 node_config = ExtendedValue.instance.evaluate(source_info[KEY_NODE])
                 Log.log.debug{"node=#{node_config}"}
@@ -472,18 +476,18 @@ module Aspera
                     username: node_config['username'],
                     password: node_config['password']})
                 command = options.get_next_command(Node::COMMANDS_FASPEX)
-                return Node.new(**init_params, api: api_node).execute_action(command, source_info[KEY_PATH])
+                return Node.new(**init_params, api: api_node, prefix_path: source_info[KEY_PATH]).execute_action(command)
               end
             end
           when :me
             my_info = api_v3.read('me')
-            return {data: my_info, type: :single_object}
+            return Main.result_single_object(my_info)
           when :dropbox
             command_pkg = options.get_next_command([:list])
             case command_pkg
             when :list
               dropbox_list = api_v3.read('dropboxes')
-              return {type: :object_list, data: dropbox_list['items'], fields: %w[name id description can_read can_write]}
+              return Main.result_object_list(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])
@@ -512,7 +516,7 @@ module Aspera
             # add missing entries
             users.each do |u|
               unless u['emails'].nil?
-                email = u['emails'].find{|i|i['primary'].eql?('true')}
+                email = u['emails'].find{ |i| i['primary'].eql?('true')}
                 u['email'] = email['value'] unless email.nil?
               end
               if u['email'].nil?
@@ -522,11 +526,11 @@ module Aspera
               u['first_name'], u['last_name'] = u['displayName'].split(' ', 2)
               u['x'] = true
             end
-            return {type: :object_list, data: users}
+            return Main.result_object_list(users)
           when :login_methods
             login_meths = api_v3.call(operation: 'GET', subpath: 'login/new', headers: {'Accept' => 'application/xrds+xml'})[:http].body
             login_methods = XmlSimple.xml_in(login_meths, {'ForceArray' => false})
-            return {type: :object_list, data: login_methods['XRD']['Service']}
+            return Main.result_object_list(login_methods['XRD']['Service'])
           end
         end
       end

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

@@ -74,6 +74,10 @@ module Aspera
             return nil
           end
 
+          # @param object [Plugin] An instance of this class
+          # @param private_key_path [String] path to private key
+          # @param pub_key_pem [String] PEM of public key
+          # @return [Hash] :preset_value, :test_args
           def wizard(object:, private_key_path:, pub_key_pem:)
             options = object.options
             formatter = object.formatter
@@ -183,7 +187,7 @@ module Aspera
           else Aspera.error_unexpected_value(auth_type)
           end
           # 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'] }
+          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
@@ -300,7 +304,7 @@ module Aspera
             Aspera.assert(field.eql?('name')){'Default query is on name only'}
             query = {'q'=> value}
           end
-          found = list_entities(type: type, real_path: real_path, query: query, item_list_key: item_list_key).select{|i|i[field].eql?(value)}
+          found = list_entities(type: type, real_path: real_path, query: query, item_list_key: item_list_key).select{ |i| i[field].eql?(value)}
           case found.length
           when 0 then raise "No #{type} with #{field} = #{value}"
           when 1 then return found.first
@@ -346,28 +350,28 @@ module Aspera
           case package_ids
           when SpecialValues::INIT
             Aspera.assert(skip_ids_persistency){'Only with option once_only'}
-            skip_ids_persistency.data.clear.concat(list_packages_with_filter.map{|p|p['id']})
+            skip_ids_persistency.data.clear.concat(list_packages_with_filter.map{ |p| p['id']})
             skip_ids_persistency.save
             return Main.result_status("Initialized skip for #{skip_ids_persistency.data.count} package(s)")
           when SpecialValues::ALL
             # TODO: if packages have same name, they will overwrite ?
             packages = list_packages_with_filter(query: {'status' => 'completed'})
-            Log.log.trace1{Log.dump(:package_ids, packages.map{|p|p['id']})}
+            Log.log.trace1{Log.dump(:package_ids, packages.map{ |p| p['id']})}
             Log.log.trace1{Log.dump(:skip_ids, skip_ids_persistency.data)}
-            packages.reject!{|p|skip_ids_persistency.data.include?(p['id'])} if skip_ids_persistency
-            Log.log.trace1{Log.dump(:package_ids, packages.map{|p|p['id']})}
+            packages.reject!{ |p| skip_ids_persistency.data.include?(p['id'])} if skip_ids_persistency
+            Log.log.trace1{Log.dump(:package_ids, packages.map{ |p| p['id']})}
           else
             # a single id was provided, or a list of ids
             package_ids = [package_ids] unless package_ids.is_a?(Array)
             Aspera.assert_type(package_ids, Array){'Expecting a single package id or a list of ids'}
             Aspera.assert(package_ids.all?(String)){'Package id shall be String'}
             # packages = package_ids.map{|pkg_id|@api_v5.read("packages/#{pkg_id}")}
-            packages = package_ids.map{|pkg_id|{'id'=>pkg_id}}
+            packages = package_ids.map{ |pkg_id| {'id'=>pkg_id}}
           end
           result_transfer = []
           param_file_list = {}
           begin
-            param_file_list['paths'] = transfer.source_list.map{|source|{'path'=>source}}
+            param_file_list['paths'] = transfer.source_list.map{ |source| {'path'=>source}}
           rescue Cli::BadArgument
             # paths is optional
           end
@@ -387,12 +391,12 @@ module Aspera
             formatter.display_status("Receiving package #{pkg_id}")
             # TODO: allow from sent as well ?
             transfer_spec = @api_v5.call(
-              operation:   'POST',
-              subpath:     "packages/#{pkg_id}/transfer_spec/download",
-              headers:     {'Accept' => 'application/json'},
-              query:       download_params,
-              body:        param_file_list,
-              body_type:   :json
+              operation:    'POST',
+              subpath:      "packages/#{pkg_id}/transfer_spec/download",
+              query:        download_params,
+              content_type: Rest::MIME_JSON,
+              body:         param_file_list,
+              headers:      {'Accept' => Rest::MIME_JSON}
             )[:data]
             # delete flag for Connect Client
             transfer_spec.delete('authentication')
@@ -407,45 +411,64 @@ module Aspera
           return Main.result_transfer_multiple(result_transfer)
         end
 
-        # browse a folder
+        # Browse a folder
         # @param browse_endpoint [String] the endpoint to browse
         def browse_folder(browse_endpoint)
-          folders_to_process = [options.get_next_argument('folder path', mandatory: false, default: '/')]
+          folders_to_process = [options.get_next_argument('folder path', default: '/')]
           query = query_read_delete(default: {})
-          query['filters'] = {} unless query.key?('filters')
-          filters = query.delete('filters')
-          filters['basenames'] = [] unless filters.key?('basenames')
+          filters = query.delete('filters'){{}}
+          Aspera.assert_type(filters, Hash)
+          filters['basenames'] ||= []
           Aspera.assert_type(filters, Hash){'filters'}
-          max_items = query.delete('max')
+          max_items = query.delete(MAX_ITEMS)
           recursive = query.delete('recursive')
+          use_paging = query.delete('paging'){true}
+          if use_paging
+            browse_endpoint = "#{browse_endpoint}/page"
+            query['per_page'] ||= 500
+          else
+            query['offset'] ||= 0
+            query['limit'] ||= 500
+          end
           all_items = []
+          total_count = nil
           until folders_to_process.empty?
             path = folders_to_process.shift
             loop do
               response = @api_v5.call(
-                operation:   'POST',
-                subpath:     browse_endpoint,
-                headers:     {'Accept' => 'application/json'},
-                query:       query,
-                body:        {'path' => path, 'filters' => filters},
-                body_type:   :json)
+                operation:    'POST',
+                subpath:      browse_endpoint,
+                query:        query,
+                content_type: Rest::MIME_JSON,
+                body:         {'path' => path, 'filters' => filters},
+                headers:      {'Accept' => Rest::MIME_JSON}
+              )
               all_items.concat(response[:data]['items'])
-              if recursive
-                folders_to_process.concat(response[:data]['items'].select{|i|i['type'].eql?('directory')}.map{|i|i['path']})
-              end
               if !max_items.nil? && (all_items.count >= max_items)
                 all_items = all_items.slice(0, max_items) if all_items.count > max_items
                 break
               end
-              iteration_token = response[:http][HEADER_ITERATION_TOKEN]
-              break if iteration_token.nil? || iteration_token.empty?
-              query['iteration_token'] = iteration_token
+              if recursive
+                folders_to_process.concat(response[:data]['items'].select{ |i| i['type'].eql?('directory')}.map{ |i| i['path']})
+              end
+              if use_paging
+                iteration_token = response[:http][HEADER_ITERATION_TOKEN]
+                break if iteration_token.nil? || iteration_token.empty?
+                query['iteration_token'] = iteration_token
+              else
+                if total_count.nil?
+                  total_count = response[:data]['total_count']
+                end
+                break if response[:data]['item_count'].eql?(0)
+                query['offset'] += response[:data]['item_count']
+              end
               formatter.long_operation_running(all_items.count)
             end
             query.delete('iteration_token')
           end
           formatter.long_operation_terminated
-          return {type: :object_list, data: all_items}
+
+          return Main.result_object_list(all_items, total: total_count)
         end
 
         def package_action
@@ -456,7 +479,7 @@ module Aspera
             end
           case command
           when :show
-            return {type: :single_object, data: @api_v5.read("packages/#{package_id}")}
+            return Main.result_single_object(@api_v5.read("packages/#{package_id}"))
           when :browse
             location = case options.get_option(:box)
             when 'inbox' then 'received'
@@ -467,7 +490,7 @@ module Aspera
           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)
-            return {type: :single_object, data: status}
+            return Main.result_single_object(status)
           when :delete
             ids = package_id
             ids = [ids] unless ids.is_a?(Array)
@@ -475,11 +498,12 @@ module Aspera
             Aspera.assert(ids.all?(String)){"Package id(s) shall be String, but have: #{ids.map(&:class).uniq.join(', ')}"}
             # API returns 204, empty on success
             @api_v5.call(
-              operation: 'DELETE',
-              subpath:   'packages',
-              headers:   {'Accept' => 'application/json'},
-              body:      {ids: ids},
-              body_type: :json)
+              operation:    'DELETE',
+              subpath:      'packages',
+              content_type: Rest::MIME_JSON,
+              body:         {ids: ids},
+              headers:      {'Accept' => Rest::MIME_JSON}
+            )
             return Main.result_status('Package(s) deleted')
           when :receive
             return package_receive(package_id)
@@ -498,12 +522,12 @@ module Aspera
             if shared_folder.nil?
               # send from local files
               transfer_spec = @api_v5.call(
-                operation:   'POST',
-                subpath:     "packages/#{package['id']}/transfer_spec/upload",
-                headers:     {'Accept' => 'application/json'},
-                query:       {transfer_type: TRANSFER_CONNECT},
-                body:        {paths: transfer.source_list},
-                body_type:   :json
+                operation:    'POST',
+                subpath:      "packages/#{package['id']}/transfer_spec/upload",
+                query:        {transfer_type: TRANSFER_CONNECT},
+                content_type: Rest::MIME_JSON,
+                body:         {paths: transfer.source_list},
+                headers:      {'Accept' => Rest::MIME_JSON}
               )[:data]
               # well, we asked a TS for connect, but we actually want a generic one
               transfer_spec.delete('authentication')
@@ -524,7 +548,7 @@ module Aspera
                 formatter.display_status("Package #{package['id']}")
                 result = wait_package_status(package['id'])
               end
-              return {type: :single_object, data: result}
+              return Main.result_single_object(result)
             end
           when :list
             return {
@@ -605,7 +629,7 @@ module Aspera
             end
             return browse_folder("#{res_path}/#{node_id}/browse")
           when :invite_external_collaborator
-            shared_inbox_id = instance_identifier { |field, value| lookup_entity_by_field(type: res_type.to_s, field: field, value: value, query: res_id_query)['id']}
+            shared_inbox_id = instance_identifier{ |field, value| lookup_entity_by_field(type: res_type.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)
             res_path = "#{res_type}/#{shared_inbox_id}/external_collaborator"
@@ -616,9 +640,9 @@ module Aspera
               real_path: "#{res_type}/#{shared_inbox_id}/members",
               value: creation_payload['email_address'],
               query: {})
-            return {type: :single_object, data: result}
+            return Main.result_single_object(result)
           when :members, :saml_groups
-            res_id = instance_identifier { |field, value| lookup_entity_by_field(type: res_type.to_s, field: field, value: value, query: res_id_query)['id']}
+            res_id = instance_identifier{ |field, value| lookup_entity_by_field(type: res_type.to_s, field: field, value: value, query: res_id_query)['id']}
             res_prefix = "#{res_type}/#{res_id}"
             res_path = "#{res_prefix}/#{res_command}"
             list_key = res_command.to_s
@@ -641,7 +665,7 @@ module Aspera
                 end
               end
               access = options.get_next_argument('level', mandatory: false, accept_list: %i[submit_only standard shared_inbox_admin], default: :standard)
-              options.unshift_next_argument({user: users.map{|u|{id: u, access: access}}})
+              options.unshift_next_argument({user: users.map{ |u| {id: u, access: access}}})
             end
             return entity_command(sub_command, adm_api, res_path, item_list_key: list_key) do |field, value|
                      lookup_entity_by_field(
@@ -651,7 +675,7 @@ module Aspera
                        query: {type: Rest.array_params(%w{local_user saml_user self_registered_user external_user})})['id']
                    end
           when :reset_password
-            contact_id = instance_identifier { |field, value| lookup_entity_by_field(type: res_type.to_s, field: field, value: value, query: res_id_query)['id']}
+            contact_id = instance_identifier{ |field, value| lookup_entity_by_field(type: res_type.to_s, field: field, value: value, query: res_id_query)['id']}
             adm_api.create("#{res_type}/#{contact_id}/reset_password", {})
             return Main.result_status('password reset, user shall check email')
           end
@@ -671,35 +695,37 @@ module Aspera
             delete_data = value_create_modify(command: command, default: {})
             delete_data = @api_v5.read('configuration').slice('days_before_deleting_package_records') if delete_data.empty?
             res = @api_v5.create('internal/packages/clean_deleted', delete_data)
-            return {type: :single_object, data: res}
+            return Main.result_single_object(res)
           when :events
             event_type = options.get_next_command(%i[application webhook])
             case event_type
             when :application
-              return {type: :object_list, data: list_entities(type: 'application_events', query: query_read_delete),
-fields: %w[event_type created_at application user.name]}
+              return Main.result_object_list(
+                list_entities(type: 'application_events', query: query_read_delete),
+                fields: %w[event_type created_at application user.name])
             when :webhook
-              return {type: :object_list, data: list_entities(type: 'all_webhooks_events', query: query_read_delete, item_list_key: 'events')}
+              return Main.result_object_list(
+                list_entities(type: 'all_webhooks_events', query: query_read_delete, item_list_key: 'events'))
             end
           when :configuration
             conf_path = 'configuration'
             conf_cmd = options.get_next_command(%i[show modify])
             case conf_cmd
             when :show
-              return { type: :single_object, data: @api_v5.read(conf_path) }
+              return Main.result_single_object(@api_v5.read(conf_path))
             when :modify
-              return { type: :single_object, data: @api_v5.update(conf_path, value_create_modify(command: conf_cmd)) }
+              return Main.result_single_object(@api_v5.update(conf_path, value_create_modify(command: conf_cmd)))
             end
           when :smtp
             smtp_path = 'configuration/smtp'
             smtp_cmd = options.get_next_command(%i[show create modify delete test])
             case smtp_cmd
             when :show
-              return { type: :single_object, data: @api_v5.read(smtp_path) }
+              return Main.result_single_object(@api_v5.read(smtp_path))
             when :create
-              return { type: :single_object, data: @api_v5.create(smtp_path, value_create_modify(command: smtp_cmd)) }
+              return Main.result_single_object(@api_v5.create(smtp_path, value_create_modify(command: smtp_cmd)))
             when :modify
-              return { type: :single_object, data: @api_v5.update(smtp_path, value_create_modify(command: smtp_cmd)) }
+              return Main.result_single_object(@api_v5.update(smtp_path, value_create_modify(command: smtp_cmd)))
             when :delete
               @api_v5.delete(smtp_path)
               return Main.result_status('SMTP configuration deleted')
@@ -709,7 +735,7 @@ fields: %w[event_type created_at application user.name]}
               creation = @api_v5.create(File.join(smtp_path, 'test'), test_data)
               result = wait_for_job(creation['job_id'])
               result['serialized_args'] = JSON.parse(result['serialized_args']) rescue result['serialized_args']
-              return { type: :single_object, data: result }
+              return Main.result_single_object(result)
             end
           end
         end
@@ -721,7 +747,7 @@ fields: %w[event_type created_at application user.name]}
           set_api unless command.eql?(:postprocessing)
           case command
           when :version
-            return { type: :single_object, data: @api_v5.read('version') }
+            return Main.result_single_object(@api_v5.read('version'))
           when :health
             nagios = Nagios.new
             begin
@@ -736,33 +762,33 @@ fields: %w[event_type created_at application user.name]}
           when :user
             case options.get_next_command(%i[account profile])
             when :account
-              return { type: :single_object, data: @api_v5.read('account') }
+              return Main.result_single_object(@api_v5.read('account'))
             when :profile
               case options.get_next_command(%i[show modify])
               when :show
-                return { type: :single_object, data: @api_v5.read('account/preferences') }
+                return Main.result_single_object(@api_v5.read('account/preferences'))
               when :modify
                 @api_v5.update('account/preferences', options.get_next_argument('modified parameters', validation: Hash))
                 return Main.result_status('modified')
               end
             end
           when :bearer_token
-            return {type: :text, data: @api_v5.oauth.authorization}
+            return Main.result_text(@api_v5.oauth.authorization)
           when :packages
             return package_action
           when :shared_folders
             all_shared_folders = @api_v5.read('shared_folders')['shared_folders']
             case options.get_next_command(%i[list browse])
             when :list
-              return {type: :object_list, data: all_shared_folders}
+              return Main.result_object_list(all_shared_folders)
             when :browse
               shared_folder_id = instance_identifier do |field, value|
-                matches = all_shared_folders.select{|i|i[field].eql?(value)}
+                matches = all_shared_folders.select{ |i| i[field].eql?(value)}
                 raise "no match for #{field} = #{value}" if matches.empty?
                 raise "multiple matches for #{field} = #{value}" if matches.length > 1
                 matches.first['id']
               end
-              node = all_shared_folders.find{|i|i['id'].eql?(shared_folder_id)}
+              node = all_shared_folders.find{ |i| i['id'].eql?(shared_folder_id)}
               raise "No such shared folder id #{shared_folder_id}" if node.nil?
               return browse_folder("nodes/#{node['node_id']}/shared_folders/#{shared_folder_id}/browse")
             end
@@ -789,22 +815,20 @@ fields: %w[event_type created_at application user.name]}
             end
           when :gateway
             require 'aspera/faspex_gw'
-            url = value_create_modify(command: command, description: 'listening url (e.g. https://localhost:12345)', type: String)
-            uri = URI.parse(url)
-            server = WebServerSimple.new(uri)
+            parameters = value_create_modify(command: command, default: {}).symbolize_keys
+            uri = URI.parse(parameters.delete(:url){WebServerSimple::DEFAULT_URL})
+            server = WebServerSimple.new(uri, **parameters.slice(*WebServerSimple::PARAMS))
+            Aspera.assert(parameters.except(*WebServerSimple::PARAMS).empty?)
             server.mount(uri.path, Faspex4GWServlet, @api_v5, nil)
             server.start
             return Main.result_status('Gateway terminated')
           when :postprocessing
             require 'aspera/faspex_postproc' # cspell:disable-line
-            parameters = value_create_modify(command: command)
-            parameters = parameters.symbolize_keys
-            Aspera.assert(parameters.key?(:url)){'Missing key: url'}
-            uri = URI.parse(parameters[:url])
-            parameters[:processing] ||= {}
-            parameters[:processing][:root] = uri.path
-            server = WebServerSimple.new(uri, certificate: parameters[:certificate])
-            server.mount(uri.path, Faspex4PostProcServlet, parameters[:processing])
+            parameters = value_create_modify(command: command, default: {}).symbolize_keys
+            uri = URI.parse(parameters.delete(:url){WebServerSimple::DEFAULT_URL})
+            parameters[:root] = uri.path
+            server = WebServerSimple.new(uri, **parameters.slice(*WebServerSimple::PARAMS))
+            server.mount(uri.path, Faspex4PostProcServlet, parameters.except(*WebServerSimple::PARAMS))
             server.start
             return Main.result_status('Gateway terminated')
           end