aspera-cli 4.25.2 → 4.25.4

data/lib/aspera/log.rb

@@ -65,11 +65,8 @@ module Aspera
 
     # Class methods
     class << self
-      # Applies the provided list of string decoration (colors) to the value.
-      # @param value [String]         Value to enhance.
-      # @param colors [Array(Symbol)] List of decorations
-      def apply_colors(value, colors)
-        colors.inject(value){ |s, c| s.send(c)}
+      def short_levl(level)
+        "#{level[0, 3]}#{level[-1]}"
       end
 
       # Get the logger object of singleton
@@ -154,8 +151,8 @@ module Aspera
 
     def formatter=(formatter)
       if formatter.is_a?(String)
-        raise Error, "Unknown formatter #{formatter}, use one of: #{FORMATTERS.keys.join(', ')}" unless FORMATTERS.key?(formatter.to_sym)
-        formatter = FORMATTERS[formatter.to_sym]
+        raise Error, "Unknown formatter #{formatter}, use one of: #{FORMATTERS.join(', ')}" unless FORMATTER_LAMBDAS.key?(formatter.to_sym)
+        formatter = FORMATTER_LAMBDAS[formatter.to_sym]
       elsif !formatter.respond_to?(:call) && !formatter.is_a?(Logger::Formatter)
         raise Error, 'Formatter must be a String, a Logger::Formatter or a Proc'
       end
@@ -226,18 +223,22 @@ module Aspera
       UNKNOWN: %i{blink}
     }.freeze
 
-    # Short levels with color
-    LVL_COLOR = LVL_DECO.map{ |k, v| [k, apply_colors("#{k[..2]}#{k[-1]}", v)]}.to_h.freeze
+    # Short (4-letters) levels with color
+    LVL_COLOR = LVL_DECO.to_h do |k, v|
+      [k, short_levl(k).apply(*v)]
+    end.freeze
 
     DEFAULT_FORMATTER = ->(s, _d, _p, m){"#{LVL_COLOR[s]} #{m}\n"}
 
     # pre-defined formatters
-    FORMATTERS = {
+    FORMATTER_LAMBDAS = {
       standard: Logger::Formatter.new,
       default:  DEFAULT_FORMATTER,
       caller:   ->(s, _d, _p, m){"#{LVL_COLOR[s]} #{Log.caller_method}\n#{m}\n"}
     }.freeze
 
-    private_constant :LVL_DECO, :LVL_COLOR, :DEFAULT_FORMATTER, :FORMATTERS
+    FORMATTERS = FORMATTER_LAMBDAS.keys
+
+    private_constant :LVL_DECO, :DEFAULT_FORMATTER, :FORMATTER_LAMBDAS
   end
 end

data/lib/aspera/markdown.rb

@@ -40,6 +40,11 @@ module Aspera
         "```#{type}\n#{lines.join("\n")}\n```\n\n"
       end
 
+      # inline code
+      def icode(text)
+        "`#{text}`"
+      end
+
       def paragraph(text)
         "#{text}\n\n"
       end

data/lib/aspera/node_simulator.rb

@@ -328,7 +328,7 @@ module Aspera
 
     def set_json_response(request, response, json, code: 200)
       response.status = code
-      response['Content-Type'] = Rest::MIME_JSON
+      response['Content-Type'] = Mime::JSON
       response.body = json.to_json
       Log.log.trace1{Log.obj_dump("response for #{request.request_method} #{request.path}", json)}
     end

data/lib/aspera/oauth/base.rb

@@ -53,7 +53,7 @@ module Aspera
       def create_token_call(creation_params)
         Log.log.debug{'Generating a new token'.bg_green}
         return @api.create(@path_token, nil, query: creation_params, ret: :resp) if @use_query
-        return @api.create(@path_token, creation_params, content_type: Rest::MIME_WWW, ret: :resp)
+        return @api.create(@path_token, creation_params, content_type: Mime::WWW, ret: :resp)
       end
 
       # Create base parameters for token creation calls

data/lib/aspera/oauth/url_json.rb

@@ -24,9 +24,9 @@ module Aspera
           operation:    'POST',
           subpath:      path_token,
           query:        @query.merge(scope: params[:scope]), # scope is here because it may change over time (node)
-          content_type: Rest::MIME_JSON,
+          content_type: Mime::JSON,
           body:         @body,
-          headers:      {'Accept' => Rest::MIME_JSON},
+          headers:      {'Accept' => Mime::JSON},
           ret:          :resp
         )
       end

data/lib/aspera/rest.rb

@@ -33,7 +33,7 @@ module Aspera
   class RestParameters
     include Singleton
 
-    attr_accessor :user_agent, :download_partial_suffix, :retry_on_error, :retry_on_timeout, :retry_on_unavailable, :retry_max, :retry_sleep, :session_cb, :progress_bar
+    attr_accessor :user_agent, :download_partial_suffix, :retry_on_error, :retry_on_timeout, :retry_on_unavailable, :retry_max, :retry_sleep, :session_cb, :progress_bar, :spinner_cb
 
     private
 
@@ -47,20 +47,31 @@ module Aspera
       @retry_sleep = 4
       @session_cb = nil
       @progress_bar = nil
+      @spinner_cb = nil
     end
   end
 
   class EntityNotFound < Error
   end
 
-  # a simple class to make HTTP calls, equivalent to rest-client
+  module Mime
+    JSON = 'application/json'
+    WWW = 'application/x-www-form-urlencoded'
+    TEXT = 'text/plain'
+    # Check if a MIME type is JSON, including parameters, e.g. application/json; charset=utf-8
+    def json?(mime)
+      JSON_LIST.include?(mime)
+    end
+    module_function :json?
+    # Content-Type that are JSON
+    JSON_LIST = [JSON, 'application/vnd.api+json', 'application/x-javascript'].freeze
+    private_constant :JSON_LIST
+  end
+
+  # Make HTTP calls, equivalent to rest-client
   # rest call errors are raised as exception RestCallError
   # and error are analyzed in RestErrorAnalyzer
   class Rest
-    MIME_JSON = 'application/json'
-    MIME_WWW = 'application/x-www-form-urlencoded'
-    MIME_TEXT = 'text/plain'
-
     # Special query parameter: max number of items for list command
     MAX_ITEMS = 'max'
     # Special query parameter: max number of pages for list command
@@ -78,8 +89,9 @@ module Aspera
         query
       end
 
-      # Build URI from URL and parameters and check it is http or https
-      # Check iof php style is specified
+      # Build URI from URL and parameters and check it is `http` or `https`.
+      # Check if php style is specified.
+      # `nil` values in query result in key without value, e.g. `?a`, while empty string values result in `?a=`.
       # @param url   [String]            The URL without query.
       # @param query [Hash,Array,String] The query.
       def build_uri(url, query)
@@ -95,18 +107,19 @@ module Aspera
             URI.encode_www_form(h_to_query_array(query))
           when Array
             Aspera.assert(query.all?{ |i| i.is_a?(Array) && i.length.eql?(2)}){'Query must be array of arrays of 2 elements'}
-            URI.encode_www_form(query)
+            URI.encode_www_form(query) # remove nil values
           else Aspera.error_unexpected_value(query.class){'query type'}
           end.gsub('%5B%5D=', '[]=')
         # [] is allowed in url parameters
         uri
       end
 
+      # Support array for query parameter, there is no standard.
+      # Either p=1&p=2 (default)
+      # or p[]=1&p[]=2 (if `:x_array_php_style` is set to true in query)
       # @param query [Hash] HTTP query as hash
       def h_to_query_array(query)
         Aspera.assert_type(query, Hash)
-        # Support array for query parameter, there is no standard.
-        # Either p[]=1&p[]=2, or p=1&p=2
         suffix = query.delete(:x_array_php_style) ? '[]' : nil
         query.each_with_object([]) do |(k, v), query_array|
           case v
@@ -143,8 +156,8 @@ module Aspera
       end
 
       # Start a HTTP/S session, also used for web sockets
-      # @param base_url [String] base url of HTTP/S session
-      # @return [Net::HTTP] a started HTTP session
+      # @param base_url [String] Base url of HTTP/S session
+      # @return [Net::HTTP] A started HTTP session
       def start_http_session(base_url)
         uri = URI.parse(base_url)
         Aspera.assert_values(uri.scheme, %w[http https]){'URI scheme'}
@@ -302,16 +315,16 @@ module Aspera
     # HTTP/S REST call
     # @param operation    [String] HTTP operation (GET, POST, PUT, DELETE)
     # @param subpath      [String] subpath of REST API
-    # @param query        [Hash] URL parameters
+    # @param query        [Hash{String,Symbol => Object}] URL parameters
     # @param content_type [String, nil] Type of body parameters (one of MIME_*) and serialization, else use headers
-    # @param body       [Hash, String] body parameters
-    # @param headers      [Hash] additional headers (override Content-Type)
-    # @param save_to_file [String, nil](filepath)
-    # @param exception    [Boolean] `true`, error raise exception
-    # @param ret [:data, :resp, :both] Tell to return only data, only http response, or both
-    # @return [(HTTPResponse,Hash)] If ret is :both
-    # @return [HTTPResponse] If ret is :resp
-    # @return [Hash] If ret is :data
+    # @param body         [Hash, String, nil] Body parameters
+    # @param headers      [Hash{String => String}] Additional headers (override Content-Type)
+    # @param save_to_file [String, nil] File path to save response body
+    # @param exception    [Boolean] Whether to raise an exception on HTTP error
+    # @param ret          [Symbol] One of :data, :resp, :both — controls return value
+    # @return [Array(Hash, Net::HTTPResponse)] When `ret` is :both
+    # @return [Net::HTTPResponse] When `ret` is :resp
+    # @return [Hash] When `ret` is :data
     # @raise [RestCallError] on error if `exception` is true
     def call(
       operation:,
@@ -373,15 +386,15 @@ module Aspera
         end
         case content_type
         when nil # ignore
-        when MIME_JSON
+        when Mime::JSON
           req.body = JSON.generate(body) # , ascii_only: true
-          req['Content-Type'] = MIME_JSON
-        when MIME_WWW
+          req['Content-Type'] = Mime::JSON
+        when Mime::WWW
           req.body = URI.encode_www_form(body)
-          req['Content-Type'] = MIME_WWW
-        when MIME_TEXT
+          req['Content-Type'] = Mime::WWW
+        when Mime::TEXT
           req.body = body
-          req['Content-Type'] = MIME_TEXT
+          req['Content-Type'] = Mime::TEXT
         else Aspera.error_unexpected_value(content_type){'body type'}
         end
         # set headers
@@ -401,12 +414,12 @@ module Aspera
         # make http request (pipelined)
         http_session.request(req) do |response|
           result_http = response
-          result_mime = self.class.parse_header(result_http['Content-Type'] || MIME_TEXT)[:type]
-          Log.log.debug{"response: code=#{result_http.code}, mime=#{result_mime}, mime2= #{response['Content-Type']}"}
+          result_mime = self.class.parse_header(result_http['Content-Type'] || Mime::TEXT)[:type]
+          Log.log.debug{"response: code=#{result_http.code}, mime=#{result_mime}, content-type=#{response['Content-Type']}"}
           # JSON data needs to be parsed, in case it contains an error code
           if !save_to_file.nil? &&
               result_http.code.to_s.start_with?('2') &&
-              !JSON_DECODE.include?(result_mime)
+              !Mime.json?(result_mime)
             total_size = result_http['Content-Length']&.to_i
             Log.log.debug('before write file')
             target_file = save_to_file
@@ -439,16 +452,14 @@ module Aspera
           end
         end
         Log.log.debug{"result: code=#{result_http.code} mime=#{result_mime}"}
-        # sometimes there is a UTF8 char (e.g. (c) ), TODO : related to mime type encoding ?
+        # sometimes there is a UTF8 char (e.g. © )
+        # TODO : related to mime type encoding ?
         # result_http.body.force_encoding('UTF-8') if result_http.body.is_a?(String)
         # Log.log.debug{"result: body=#{result_http.body}"}
-        case result_mime
-        when *JSON_DECODE
-          result_data = JSON.parse(result_http.body) rescue result_http.body
-          Log.dump(:result_data, result_data)
-        else # when MIME_TEXT
-          result_data = result_http.body
-        end
+        result_data = result_http.body
+        Log.dump(:result_data_raw, result_data, level: :trace1)
+        result_data = JSON.parse(result_data) if Mime.json?(result_mime) && !result_data.nil? && !result_data.empty?
+        Log.dump(:result_data, result_data)
         RestErrorAnalyzer.instance.raise_on_error(req, result_data, result_http)
         unless file_saved || save_to_file.nil?
           FileUtils.mkdir_p(File.dirname(save_to_file))
@@ -526,27 +537,39 @@ module Aspera
 
     # Create: `POST`
     def create(subpath, params, **kwargs)
-      return call(operation: 'POST', subpath: subpath, headers: {'Accept' => MIME_JSON}, body: params, content_type: MIME_JSON, **kwargs)
+      kwargs[:headers] ||= {}
+      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
+      kwargs[:content_type] = Mime::JSON unless kwargs.key?(:content_type)
+      return call(operation: 'POST', subpath: subpath, body: params, **kwargs)
     end
 
     # Read: `GET`
     def read(subpath, query = nil, **kwargs)
-      return call(operation: 'GET', subpath: subpath, headers: {'Accept' => MIME_JSON}, query: query, **kwargs)
+      kwargs[:headers] ||= {}
+      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
+      return call(operation: 'GET', subpath: subpath, query: query, **kwargs)
     end
 
     # Update: `PUT`
     def update(subpath, params, **kwargs)
-      return call(operation: 'PUT', subpath: subpath, headers: {'Accept' => MIME_JSON}, body: params, content_type: MIME_JSON, **kwargs)
+      kwargs[:headers] ||= {}
+      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
+      kwargs[:content_type] = Mime::JSON unless kwargs.key?(:content_type)
+      return call(operation: 'PUT', subpath: subpath, body: params, **kwargs)
     end
 
     # Delete: `DELETE`
     def delete(subpath, params = nil, **kwargs)
-      return call(operation: 'DELETE', subpath: subpath, headers: {'Accept' => MIME_JSON}, query: params, **kwargs)
+      kwargs[:headers] ||= {}
+      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
+      return call(operation: 'DELETE', subpath: subpath, query: params, **kwargs)
     end
 
     # Cancel: `CANCEL`
     def cancel(subpath, **kwargs)
-      return call(operation: 'CANCEL', subpath: subpath, headers: {'Accept' => MIME_JSON}, **kwargs)
+      kwargs[:headers] ||= {}
+      kwargs[:headers]['Accept'] = Mime::JSON unless kwargs[:headers].key?('Accept')
+      return call(operation: 'CANCEL', subpath: subpath, **kwargs)
     end
 
     # Query entity by general search (read with parameter `q`)
@@ -577,11 +600,8 @@ module Aspera
       end
     end
 
-    # Content-Type that are JSON
-    JSON_DECODE = [MIME_JSON, 'application/vnd.api+json', 'application/x-javascript'].freeze
-
     UNAVAILABLE_CODES = ['503']
 
-    private_constant :JSON_DECODE, :UNAVAILABLE_CODES
+    private_constant :UNAVAILABLE_CODES
   end
 end

data/lib/aspera/rest_error_analyzer.rb

@@ -3,6 +3,7 @@
 require 'aspera/rest_call_error'
 require 'aspera/log'
 require 'singleton'
+require 'net/http'
 
 module Aspera
   # analyze error codes returned by REST calls and raise ruby exception
@@ -16,10 +17,10 @@ module Aspera
       # list of handlers
       @error_handlers = []
       @log_file = nil
-      add_handler('Type Generic') do |type, call_context|
-        if !call_context[:response].code.start_with?('2')
+      add_handler('Type Generic') do |type, context|
+        if !context[:response].code.start_with?('2')
           # add generic information
-          RestErrorAnalyzer.add_error(call_context, type, "#{call_context[:request]['host']} #{call_context[:response].code} #{call_context[:response].message}")
+          RestErrorAnalyzer.add_error(context, type, "#{context[:request]['host']} #{context[:response].code} #{context[:response].message}")
         end
       end
     end
@@ -27,9 +28,12 @@ module Aspera
     # Use this method to analyze a EST result and raise an exception
     # Analyzes REST call response and raises a RestCallError exception
     # if HTTP result code is not 2XX
+    # @param req  [Net::HTTPRequest]
+    # @param data [Object]
+    # @param http [Net::HTTPResponse]
     def raise_on_error(req, data, http)
       Log.log.debug{"raise_on_error #{req.method} #{req.path} #{http.code}"}
-      call_context = {
+      context = {
         messages: [],
         request:  req,
         response: http,
@@ -39,44 +43,42 @@ module Aspera
       # analyze errors from provided handlers
       # note that there can be an error even if code is 2XX
       @error_handlers.each do |handler|
-        begin # rubocop:disable Style/RedundantBegin
-          # Log.log.debug{"test exception: #{handler[:name]}"}
-          handler[:block].call(handler[:name], call_context)
-        rescue StandardError => e
-          Log.log.error{"ERROR in handler:\n#{e.message}\n#{e.backtrace}"}
-        end
+        handler[:block].call(handler[:name], context)
+      rescue StandardError => e
+        Log.log.error{"ERROR in handler:\n#{e.message}\n#{e.backtrace}"}
       end
-      raise RestCallError.new(call_context) unless call_context[:messages].empty?
+      raise RestCallError, context unless context[:messages].empty?
     end
 
-    # add a new error handler (done at application initialization)
-    # @param name : name of error handler (for logs)
-    # @param block : processing of response: takes two parameters: name, call_context
+    # Add a new error handler (done at application initialization)
+    # @param name  [String] name of error handler (for logs)
+    # @param block [Proc]   processing of response: takes two parameters: `name`, `context`
     # name is the one provided here
-    # call_context is built in method raise_on_error
+    # context is built in method raise_on_error
     def add_handler(name, &block)
       @error_handlers.unshift({name: name, block: block})
+      nil
     end
 
-    # add a simple error handler
-    # check that key exists and is string under specified path (hash)
-    # adds other keys as secondary information
-    # @param name [String] name of error handler (for logs)
-    # @param always [boolean] if true, always add error message, even if response code is 2XX
-    # @param path [Array] path to error message in response
+    # Add a simple error handler
+    # Check that key exists and is string under specified path (hash)
+    # Adds other keys as secondary information
+    # @param name   [String]  name of error handler (for logs)
+    # @param always [Boolean] if true, always add error message, even if response code is 2XX
+    # @param path   [Array]   path to error message in response
     def add_simple_handler(name:, always: false, path:)
       path.freeze
-      add_handler(name) do |type, call_context|
-        if call_context[:data].is_a?(Hash) && (!call_context[:response].code.start_with?('2') || always)
+      add_handler(name) do |type, context|
+        if context[:data].is_a?(Hash) && (!context[:response].code.start_with?('2') || always)
           # Log.log.debug{"simple_handler: #{type} #{path} #{path.last}"}
           # dig and find hash containing error message
-          error_struct = path.length.eql?(1) ? call_context[:data] : call_context[:data].dig(*path[0..-2])
+          error_struct = path.length.eql?(1) ? context[:data] : context[:data].dig(*path[0..-2])
           # Log.log.debug{"found: #{error_struct.class} #{error_struct}"}
           if error_struct.is_a?(Hash) && error_struct[path.last].is_a?(String)
-            RestErrorAnalyzer.add_error(call_context, type, error_struct[path.last])
+            RestErrorAnalyzer.add_error(context, type, error_struct[path.last])
             error_struct.each do |k, v|
               next if k.eql?(path.last)
-              RestErrorAnalyzer.add_error(call_context, "#{type}(sub)", "#{k}: #{v}") if [String, Integer].include?(v.class)
+              RestErrorAnalyzer.add_error(context, "#{type}(sub)", "#{k}: #{v}") if [String, Integer].include?(v.class)
             end
           end
         end
@@ -84,20 +86,20 @@ module Aspera
     end
 
     class << self
-      # used by handler to add an error description to list of errors
-      # for logging and tracing : collect error descriptions (create file to activate)
-      # @param call_context a Hash containing the result call_context, provided to handler
-      # @param type a string describing type of exception, for logging purpose
-      # @param msg one error message  to add to list
-      def add_error(call_context, type, msg)
-        call_context[:messages].push(msg)
-        Log.log.trace1{"Found error: #{type}: #{msg}"}
+      # Used by handler to add an error description to list of errors
+      # For logging and tracing : collect error descriptions (create file to activate)
+      # @param context [Hash]   the result context, provided to handler
+      # @param type    [String] type of exception, for logging purpose
+      # @param message [String] one error message  to add to list
+      def add_error(context, type, message)
+        context[:messages].push(message)
+        Log.log.trace1{"Found error: #{type}: #{message}"}
         log_file = instance.log_file
         # log error for further analysis (file must exist to activate)
         return if log_file.nil? || !File.exist?(log_file)
         File.open(log_file, 'a+') do |f|
-          f.write("\n=#{type}=====\n#{call_context[:request].method} #{call_context[:request].path}\n#{call_context[:response].code}\n" \
-            "#{JSON.generate(call_context[:data])}\n#{call_context[:messages].join("\n")}")
+          f.write("\n=#{type}=====\n#{context[:request].method} #{context[:request].path}\n#{context[:response].code}\n" \
+            "#{JSON.generate(context[:data])}\n#{context[:messages].join("\n")}")
         end
       end
     end

data/lib/aspera/rest_errors_aspera.rb

@@ -17,48 +17,49 @@ module Aspera
         RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 3: error:internal_message', path: %w[error internal_message])
         RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 5', path: ['error_description'])
         RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 6', path: ['message'])
+        RestErrorAnalyzer.instance.add_simple_handler(name: 'Type 6', path: ['failure'], always: true)
         # AoC Automation
         RestErrorAnalyzer.instance.add_simple_handler(name: 'AoC Automation', path: ['error'])
-        RestErrorAnalyzer.instance.add_handler('Type 7: errors[]') do |type, call_context|
-          next unless call_context[:data].is_a?(Hash) && call_context[:data]['errors'].is_a?(Hash)
+        RestErrorAnalyzer.instance.add_handler('Type 7: errors[]') do |type, context|
+          next unless context[:data].is_a?(Hash) && context[:data]['errors'].is_a?(Hash)
           # special for Shares: false positive ? (update global transfer_settings)
-          next if call_context[:data].key?('min_connect_version')
-          call_context[:data]['errors'].each do |k, v|
-            RestErrorAnalyzer.add_error(call_context, type, "#{k}: #{v}")
+          next if context[:data].key?('min_connect_version')
+          context[:data]['errors'].each do |k, v|
+            RestErrorAnalyzer.add_error(context, type, "#{k}: #{v}")
           end
         end
         # call to upload_setup and download_setup of node api
-        RestErrorAnalyzer.instance.add_handler('T8:node: *_setup') do |type, call_context|
-          next unless call_context[:data].is_a?(Hash)
-          d_t_s = call_context[:data]['transfer_specs']
+        RestErrorAnalyzer.instance.add_handler('T8:node: *_setup') do |type, context|
+          next unless context[:data].is_a?(Hash)
+          d_t_s = context[:data]['transfer_specs']
           next unless d_t_s.is_a?(Array)
           d_t_s.each do |res|
             r_err = res.dig(*%w[transfer_spec error]) || res['error']
             next unless r_err.is_a?(Hash)
-            RestErrorAnalyzer.add_error(call_context, type, r_err.values.join(': '))
+            RestErrorAnalyzer.add_error(context, type, r_err.values.join(': '))
           end
         end
         RestErrorAnalyzer.instance.add_simple_handler(name: 'T9:IBM cloud IAM', path: ['errorMessage'])
         RestErrorAnalyzer.instance.add_simple_handler(name: 'T10:faspex v4', path: ['user_message'])
-        RestErrorAnalyzer.instance.add_handler('bss graphql') do |type, call_context|
-          next unless call_context[:data].is_a?(Hash)
-          d_t_s = call_context[:data]['errors']
+        RestErrorAnalyzer.instance.add_handler('bss graphql') do |type, context|
+          next unless context[:data].is_a?(Hash)
+          d_t_s = context[:data]['errors']
           next unless d_t_s.is_a?(Array)
           d_t_s.each do |res|
             r_err = res['message']
             next unless r_err.is_a?(String)
-            RestErrorAnalyzer.add_error(call_context, type, r_err)
+            RestErrorAnalyzer.add_error(context, type, r_err)
           end
         end
-        RestErrorAnalyzer.instance.add_handler('Orchestrator') do |type, call_context|
-          next if call_context[:response].code.start_with?('2')
-          data = call_context[:data]
+        RestErrorAnalyzer.instance.add_handler('Orchestrator') do |type, context|
+          next if context[:response].code.start_with?('2')
+          data = context[:data]
           next unless data.is_a?(Hash)
           work_order = data['work_order']
           next unless work_order.is_a?(Hash)
-          RestErrorAnalyzer.add_error(call_context, type, work_order['statusDetails'])
+          RestErrorAnalyzer.add_error(context, type, work_order['statusDetails'])
           data['missing_parameters']&.each do |param|
-            RestErrorAnalyzer.add_error(call_context, type, "missing parameter: #{param}")
+            RestErrorAnalyzer.add_error(context, type, "missing parameter: #{param}")
           end
         end
       end

data/lib/aspera/transfer/spec.rb

@@ -25,6 +25,7 @@ module Aspera
       TRANSPORT_FIELDS = (%w[remote_host] + AK_TSPEC_BASE.keys + WSS_FIELDS).freeze
       # reserved tag for Aspera
       TAG_RESERVED = 'aspera'
+      SPECIFIC = %w{token paths direction source_root destination_root}.freeze
       class << self
         # wrong def in transferd
         POLICY_FIX = {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aspera-cli
 version: !ruby/object:Gem::Version
-  version: 4.25.2
+  version: 4.25.4
 platform: ruby
 authors:
 - Laurent Martin
@@ -454,7 +454,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/IBM/aspera-cli
   source_code_uri: https://github.com/IBM/aspera-cli/tree/main/lib/aspera
-  changelog_uri: https://github.com/IBM/aspera-cli/CHANGELOG.md
+  changelog_uri: https://github.com/IBM/aspera-cli/blob/main/CHANGELOG.md
   rubygems_uri: https://rubygems.org/gems/aspera-cli
   documentation_uri: https://www.rubydoc.info/gems/aspera-cli
 rdoc_options: []