aspera-cli 4.27.2 → 4.27.4

data/lib/aspera/oauth/base.rb

@@ -3,7 +3,10 @@
 require 'aspera/oauth/factory'
 require 'aspera/log'
 require 'aspera/assert'
+require 'aspera/mime'
 require 'date'
+require 'aspera/rainbow'
+using Rainbow
 
 module Aspera
   module OAuth
@@ -31,7 +34,7 @@ module Aspera
         Aspera.assert_type(params, Hash)
         Aspera.assert_type(cache_ids, Array)
         # This is the OAuth API
-        @api = Rest.new(**rest_params)
+        @api = Rest::Client.new(**rest_params)
         @params = params.dup.freeze
         @path_token = path_token
         @token_field = token_field
@@ -47,37 +50,40 @@ module Aspera
       # Sub path to generate token
       attr_reader :path_token
 
+      # Parameters for token creation call
+      # @param include_secret [Boolean] Add secret in default call parameters
+      # @param other_params [Hash] Other parameters to merge
+      # @return [Hash] Token creation parameters
+      def base_parameters(include_secret: false, **other_params)
+        call_params = @params.dup
+        call_params.delete(:client_secret) unless include_secret
+        call_params.merge(other_params)
+      end
+
       # Helper method to create token as per RFC
-      # @return [Net::HTTPResponse] raw HTTP response with token
-      # @raise [RestCallError] if not 2XX code
-      def create_token_call(creation_params)
-        Log.log.debug { 'Generating a new token'.bg_green }
+      # @param other_params [Hash] Additional parameter to base parameters
+      # @return [Net::HTTPResponse] Raw HTTP response with token
+      # @raise [Rest::CallError] If not 2XX code
+      def create_token_base(include_secret: false, **other_params)
+        Log.log.debug { 'Generating a new token'.bg(:green) }
+        creation_params = base_parameters(include_secret: include_secret, **other_params)
         return @api.create(@path_token, nil, query: creation_params, ret: :resp) if @use_query
         return @api.create(@path_token, creation_params, content_type: Mime::WWW, ret: :resp)
       end
 
-      # Create base parameters for token creation calls
-      # @param add_secret [Boolean] Add secret in default call parameters
-      # @return [Hash] Optional general parameters
-      def base_params(add_secret: false)
-        call_params = @params.dup
-        call_params.delete(:client_secret) unless add_secret
-        return call_params
-      end
-
-      # @return [String] value suitable for Authorization header
+      # @return [String] Value suitable for Authorization header: adds `Bearer `
       def authorization(**kwargs)
         return OAuth::Factory.bearer_authorization(token(**kwargs))
       end
 
-      # get an OAuth v2 token (generated, cached, refreshed)
-      # call token() to get a token.
-      # if a token is expired (api returns 4xx), call again token(refresh: true)
+      # Get a OAuth v2 token (generated, cached, refreshed)
+      # If a token is expired (api returns 4xx), call again token(refresh: true)
       # @param cache   [Boolean] set to false to disable cache
       # @param refresh [Boolean] set to true to force refresh or re-generation (if previous failed)
+      # @return [String] The bearer token
       def token(cache: true, refresh: false)
-        # get token info from cache (or nil), decoded with date and expiration status
-        token_info = Factory.instance.get_token_info(@token_cache_id) if cache
+        # Get token info from cache (or nil), decoded with date and expiration status
+        token_info = Factory.instance.get_token_info(@token_cache_id, token_field: @token_field) if cache
         token_data = nil
         unless token_info.nil?
           token_data = token_info[:data]
@@ -90,17 +96,21 @@ module Aspera
             Log.log.trace1 { "refresh: #{refresh} expired: #{token_info[:expired]}" }
             refresh_token = nil
             if token_data.key?('refresh_token') && !token_data['refresh_token'].eql?('not_supported')
-              # save possible refresh token, before deleting the cache
+              # Save possible refresh token, before deleting the cache
               refresh_token = token_data['refresh_token']
             end
-            # delete cache
+            # Delete cache
             Factory.instance.persist_mgr.delete(@token_cache_id)
             token_data = nil
-            # lets try the existing refresh token
+            # Lets try the existing refresh token
             # NOTE: AoC admin token has no refresh, and lives by default 1800secs
             if !refresh_token.nil?
               begin
-                http = create_token_call(base_params(add_secret: true).merge(grant_type: 'refresh_token', refresh_token: refresh_token))
+                http = create_token_base(
+                  include_secret: true,
+                  grant_type: 'refresh_token',
+                  refresh_token: refresh_token
+                )
                 # Save only if success
                 json_data = http.body
                 token_data = JSON.parse(json_data)
@@ -116,13 +126,14 @@ module Aspera
         # no cache, nor refresh: generate a token
         if token_data.nil?
           # Call the method-specific token creation
-          # which returns the result of create_token_call
+          # which returns the result of create_token_base
           json_data = create_token.body
           token_data = JSON.parse(json_data)
           Factory.instance.persist_mgr.put(@token_cache_id, json_data)
+          Factory.instance.get_token_info(@token_cache_id, token_field: @token_field)
         end
         Aspera.assert(token_data.key?(@token_field)) { "API error: No such field in answer: #{@token_field}" } unless token_data.nil?
-        # ok we shall have a token here
+        # Ok we shall have a token here
         return token_data[@token_field]
       end
     end

data/lib/aspera/oauth/factory.rb

@@ -2,6 +2,7 @@
 
 require 'aspera/id_generator'
 require 'aspera/assert'
+require 'aspera/string_ext'
 require 'singleton'
 require 'base64'
 module Aspera
@@ -120,7 +121,8 @@ module Aspera
         data.each.map do |k, v|
           info = {id: k}
           begin; info.merge!(JSON.parse(v)); rescue StandardError; nil; end
-          d = decode_token(info.delete(TOKEN_FIELD))
+          token_val = info.delete(TOKEN_FIELD) || info.delete('token')
+          d = decode_token(token_val)
           info.merge(d) if d
           info
         end
@@ -128,13 +130,15 @@ module Aspera
 
       # Get token information from cache
       # @param id [String] identifier of token
+      # @param token_field [String, nil] Field containing the token, or nil to auto-detect
       # @return [Hash] token internal information , including Date object for `expiration_date`
-      def get_token_info(id)
+      def get_token_info(id, token_field: nil)
         token_raw_string = persist_mgr.get(id)
         return if token_raw_string.nil?
         token_data = JSON.parse(token_raw_string)
         Aspera.assert_type(token_data, Hash)
-        decoded_token = decode_token(token_data[TOKEN_FIELD])
+        token_value = token_data[token_field] || token_data[TOKEN_FIELD] || token_data['token']
+        decoded_token = decode_token(token_value)
         info = {data: token_data}
         if decoded_token.is_a?(Hash)
           info[:decoded] = decoded_token

data/lib/aspera/oauth/generic.rb

@@ -23,7 +23,7 @@ module Aspera
       end
 
       def create_token
-        return create_token_call(base_params.merge(@create_params))
+        create_token_base(**@create_params)
       end
     end
     Factory.instance.register_token_creator(Generic)

data/lib/aspera/oauth/json_credentials.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'aspera/oauth/base'
+require 'digest'
+
+module Aspera
+  module OAuth
+    # Token creator using JSON credentials (e.g., username/password or apikey) sent to a login endpoint
+    class JsonCredentials < Base
+      # @param json           [Hash] Body parameters to send as JSON (e.g. {username:, password:} or {apikey:})
+      # @param generic_params [Hash] Generic parameters for OAuth::Base
+      def initialize(
+        json:,
+        **generic_params
+      )
+        cache_id = json[:username] || Digest::SHA256.hexdigest(json[:apikey] || json.to_s)[0..23]
+        super(**generic_params, cache_ids: [cache_id])
+        @body = json
+      end
+
+      def create_token
+        api.call(
+          operation:    'POST',
+          subpath:      path_token,
+          content_type: Mime::JSON,
+          body:         @body,
+          headers:      {'Accept' => Mime::JSON},
+          ret:          :resp
+        )
+      end
+    end
+    Factory.instance.register_token_creator(JsonCredentials)
+  end
+end

data/lib/aspera/oauth/jwt.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/oauth/base'
+require 'aspera/environment'
 require 'aspera/assert'
 require 'securerandom'
 require 'openssl'
@@ -17,10 +18,8 @@ module Aspera
       class << self
         def generate_rsa_private_key(path:, length: DEFAULT_PRIV_KEY_LENGTH)
           priv_key = OpenSSL::PKey::RSA.new(length)
-          File.write(path, priv_key.to_s)
-          File.write("#{path}.pub", priv_key.public_key.to_s)
-          Environment.restrict_file_access(path)
-          Environment.restrict_file_access("#{path}.pub")
+          Environment.write_file_restricted(path, force: true) { priv_key.to_s }
+          Environment.write_file_restricted("#{path}.pub", force: true) { priv_key.public_key.to_s }
           nil
         end
       end
@@ -59,7 +58,7 @@ module Aspera
         }.merge(@additional_payload)
         Log.dump(:jwt_payload, jwt_payload)
         assertion = JWT.encode(jwt_payload, @private_key_obj, 'RS256', @headers)
-        return create_token_call(base_params.merge(grant_type: GRANT_TYPE, assertion: assertion))
+        create_token_base(grant_type: GRANT_TYPE, assertion: assertion)
       end
     end
     Factory.instance.register_token_creator(Jwt)

data/lib/aspera/oauth/web.rb

@@ -2,7 +2,7 @@
 
 require 'aspera/oauth/base'
 require 'aspera/environment'
-require 'aspera/web_auth'
+require 'aspera/web_auth/server'
 require 'aspera/assert'
 module Aspera
   module OAuth
@@ -32,23 +32,24 @@ module Aspera
         random_state = SecureRandom.uuid
         login_page_url = Rest.build_uri(
           "#{api.base_url}/#{@path_authorize}",
-          base_params.merge(response_type: 'code', redirect_uri: @redirect_uri, state: random_state)
+          base_parameters(response_type: 'code', redirect_uri: @redirect_uri, state: random_state)
         )
         # here, we need a human to authorize on a web page
         Log.log.debug { "login_page_url=#{login_page_url}" }
         # start a web server to receive request code
-        web_server = WebAuth.new(@redirect_uri, self.class.additional_info)
+        web_server = WebAuth::Server.new(@redirect_uri, self.class.additional_info)
         # start browser on login page
         Environment.instance.open_uri(login_page_url)
         # wait for code in request
         received_params = web_server.received_request
         Aspera.assert(random_state.eql?(received_params['state'])) { 'wrong received state' }
         # exchange code for token
-        return create_token_call(base_params(add_secret: true).merge(
-          grant_type:   'authorization_code',
-          code:         received_params['code'],
-          redirect_uri: @redirect_uri
-        ))
+        create_token_base(
+          include_secret: true,
+          grant_type:     'authorization_code',
+          code:           received_params['code'],
+          redirect_uri:   @redirect_uri
+        )
       end
     end
     Factory.instance.register_token_creator(Web)

data/lib/aspera/oauth.rb

@@ -6,3 +6,4 @@ require 'aspera/oauth/generic'
 require 'aspera/oauth/jwt'
 require 'aspera/oauth/web'
 require 'aspera/oauth/url_json'
+require 'aspera/oauth/json_credentials'

data/lib/aspera/persistency_folder.rb

@@ -44,9 +44,7 @@ module Aspera
       Aspera.assert_type(value, String)
       persist_filepath = id_to_filepath(object_id)
       Log.log.debug { "persistency saving: #{persist_filepath}" }
-      FileUtils.rm_f(persist_filepath)
-      File.write(persist_filepath, value)
-      Environment.restrict_file_access(persist_filepath)
+      Environment.write_file_restricted(persist_filepath, force: true) { value }
       @cache[object_id] = value
       nil
     end

data/lib/aspera/preview/file_types.rb

@@ -57,11 +57,11 @@ module Aspera
 
       private_constant :SUPPORTED_MIME_TYPES
 
-      # @attr use_mimemagic [Boolean] `true` to use mimemagic to determine real mime type based on file content
-      attr_accessor :use_mimemagic
+      # @attr detect_mime [Boolean] `true` to determine real mime type based on file content
+      attr_accessor :detect_mime
 
       def initialize
-        @use_mimemagic = false
+        @detect_mime = false
       end
 
       # @param mimetype [String] mime type
@@ -81,7 +81,7 @@ module Aspera
       # @return [Symbol] file type, one of enum CONVERSION_TYPES
       # @raise [RuntimeError] if no conversion type found
       def conversion_type(filepath, mimetype)
-        Log.log.debug { "conversion_type(#{filepath},mime=#{mimetype},magic=#{@use_mimemagic})" }
+        Log.log.debug { "conversion_type(#{filepath},mime=#{mimetype},magic=#{@detect_mime})" }
         # Default type or empty means no type
         mimetype = TYPE_NOT_FOUND if mimetype.nil? || (mimetype.is_a?(String) && mimetype.empty?)
         mimetype = Marcel::MimeType.for(Pathname.new(filepath), name: File.basename(filepath), declared_type: mimetype)

data/lib/aspera/preview/generator.rb

@@ -4,9 +4,9 @@
 # spellchecker:ignore soffice pauseframes libx264 trunc bufsize muxer apng libmp3lame maxrate posterize movflags faststart
 # spellchecker:ignore palettegen paletteuse pointsize bordercolor repage lanczos unoconv optipng reencode conv transframes
 
-require 'aspera/preview/options'
 require 'aspera/preview/utils'
 require 'aspera/preview/file_types'
+require 'aspera/schema/registry'
 require 'aspera/log'
 require 'aspera/assert'
 
@@ -20,6 +20,9 @@ module Aspera
       # List of valid ffmpeg option keys for reencode configuration.
       FFMPEG_OPTIONS_LIST = %w[in out].freeze
 
+      # Generator options, members defined in `options.schema.yaml`.
+      Options = Struct.new(*Schema::Registry.instance.reader(Schema::Registry::PREVIEW_OPTIONS).current['properties'].keys.map(&:to_sym))
+
       # CLI needs to know conversion type to know if need skip it.
       # One of CONVERSION_TYPES.
       attr_reader :conversion_type, :destination
@@ -251,6 +254,7 @@ module Aspera
         tmp_pdf_file = File.join(this_tmpdir, "#{File.basename(@source, File.extname(@source))}.pdf")
         case @options.office_conversion
         when :unoconv
+          # `unoconv` is a python wrapper over `soffice`
           Utils.silent_execute(
             :unoconv,
             '-f', 'pdf',
@@ -261,6 +265,12 @@ module Aspera
           Utils.silent_execute(
             :soffice,
             '--headless',
+            '--invisible',
+            '--nocrashreport',
+            '--nodefault',
+            '--nofirststartwizard',
+            '--nologo',
+            '--norestore',
             '--convert-to', 'pdf',
             '--outdir', File.dirname(tmp_pdf_file),
             @source

data/lib/aspera/preview/options.schema.yaml

@@ -0,0 +1,119 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: https://github.com/IBM/aspera-cli/tree/main/lib/aspera/preview/options.schema.yaml
+title: Preview generator options
+description: >-
+  Options of the preview generator: tools and parameters used to generate PNG thumbnails and MP4 video previews.
+$comment: >-
+  Used to declare the options of the `preview` plugin: values of `enum` properties are `Symbol`.
+  Scaling uses `ffmpeg` scale filter arguments, see: https://trac.ffmpeg.org/wiki/Scaling
+  (`iw`/`ih`: input width/height, `-x`: keep aspect ratio, with a value multiple of `x`).
+type: object
+additionalProperties: false
+properties:
+  office_conversion:
+    description: 'PNG thumbnail of office document: conversion tool.'
+    type: string
+    enum: [soffice, unoconv]
+    default: soffice
+  max_size:
+    description: 'Maximum size (in bytes) of a preview file: a warning is logged if exceeded.'
+    type: integer
+    minimum: 1
+    default: 16777216
+  thumb_vid_scale:
+    description: 'PNG thumbnail of video: frame size, as `ffmpeg` scale filter argument.'
+    type: string
+    default: '-1:min(ih,100)'
+  thumb_vid_fraction:
+    description: 'PNG thumbnail of video (`fixed`): position of the snapshot, as a fraction of the video duration.'
+    type: number
+    minimum: 0
+    maximum: 1
+    default: 0.1
+  thumb_img_size:
+    description: 'PNG thumbnail of image, PDF, office document or text: size (in pixels).'
+    type: integer
+    minimum: 1
+    default: 800
+  thumb_text_font:
+    description: 'PNG thumbnail of text: font name, as listed by `magick identify -list font`.'
+    type: string
+    default: Courier
+  video_conversion:
+    description: >-
+      MP4 video preview: generation method.
+      `reencode`: re-encode the beginning of the video,
+      `blend`: key frames with transitions,
+      `clips`: concatenation of short clips.
+    type: string
+    enum: [reencode, blend, clips]
+    default: reencode
+  video_png_conv:
+    description: >-
+      PNG thumbnail of video: generation method.
+      `fixed`: single frame,
+      `animated`: animated PNG.
+    type: string
+    enum: [fixed, animated]
+    default: fixed
+  video_scale:
+    description: 'MP4 video preview: frame size, as `ffmpeg` scale filter argument.'
+    type: string
+    default: 'min(iw,360):-2'
+  video_start_sec:
+    description: 'Video: start offset (in seconds) of MP4 video preview and of `animated` PNG thumbnail.'
+    type: integer
+    minimum: 0
+    default: 10
+  video_codec:
+    description: >-
+      MP4 video preview (`reencode`): `ffmpeg` video codec, e.g. `libx264`, `h264_videotoolbox`, `h264_nvenc`.
+      Default: first available H.264 encoder.
+    type: string
+  reencode_ffmpeg:
+    description: >-
+      MP4 video preview (`reencode`): `ffmpeg` options replacing the default ones.
+    type: object
+    additionalProperties: false
+    properties:
+      in:
+        description: Input options.
+        type: array
+        items:
+          type: [string, number]
+      out:
+        description: Output options.
+        type: array
+        items:
+          type: [string, number]
+    default: {}
+  blend_keyframes:
+    description: 'MP4 video preview (`blend`): number of key frames.'
+    type: integer
+    minimum: 1
+    default: 30
+  blend_pauseframes:
+    description: 'MP4 video preview (`blend`): number of pause frames (repetitions of each key frame).'
+    type: integer
+    minimum: 0
+    default: 3
+  blend_transframes:
+    description: 'MP4 video preview (`blend`): number of transition frames between key frames.'
+    type: integer
+    minimum: 0
+    default: 5
+  blend_fps:
+    description: 'MP4 video preview (`blend`): frames per second.'
+    type: integer
+    minimum: 1
+    default: 15
+  clips_count:
+    description: 'MP4 video preview (`clips`): number of clips.'
+    type: integer
+    minimum: 1
+    default: 5
+  clips_length:
+    description: 'Video: length (in seconds) of each clip of MP4 video preview (`clips`), and of `animated` PNG thumbnail.'
+    type: integer
+    minimum: 1
+    default: 5

data/lib/aspera/preview/terminal.rb

@@ -2,11 +2,12 @@
 
 # cspell:words Magick MAGICKCORE ITERM mintty winsize termcap
 
-require 'rainbow'
 require 'base64'
 require 'io/console'
 require 'aspera/log'
 require 'aspera/environment'
+require 'aspera/rainbow'
+using Rainbow
 
 module Aspera
   module Preview
@@ -155,9 +156,9 @@ module Aspera
             row_data.each_with_index do |pixel_rgb, col|
               text_pixels.push("\n") if col.eql?(0) && !row.eql?(0)
               if double
-                text_pixels.push(Rainbow('▄').background(pixel_rgb).foreground(pixel_colors[row + 1][col]))
+                text_pixels.push('▄'.bg(pixel_rgb).fg(pixel_colors[row + 1][col]))
               else
-                text_pixels.push(Rainbow(' ').background(pixel_rgb))
+                text_pixels.push(' '.bg(pixel_rgb))
               end
             end
           end

data/lib/aspera/preview/utils.rb

@@ -25,6 +25,9 @@ module Aspera
       private_constant :EXTERNAL_TOOLS, :TEMP_FORMAT, :FFMPEG_DEFAULT_PARAMS, :H264_ENCODER_PREFERENCE
 
       class << self
+        # @param tool [Symbol] either `unoconv` or `soffice`
+        attr_accessor :office_tool
+
         # Return the first H.264 encoder available in the local ffmpeg installation.
         # Result is memoized after the first call.
         # @return [String] encoder name (e.g. 'libx264', 'libopenh264')
@@ -32,8 +35,10 @@ module Aspera
         def available_h264_encoder
           return @available_h264_encoder if defined?(@available_h264_encoder)
           stdout, = execute(:ffmpeg, '-encoders', mode: :capture, exception: false)
-          @available_h264_encoder = H264_ENCODER_PREFERENCE.find { |enc| stdout.include?(enc) } ||
-            raise("No supported H.264 encoder found in ffmpeg. Available: #{stdout.lines.grep(/h264/i).map(&:strip).join(', ')}")
+          available = stdout.lines.grep(/h264/i).map { |l| l.split[1] }
+          @available_h264_encoder = H264_ENCODER_PREFERENCE.find { |enc| available.include?(enc) }
+          Aspera.assert(@available_h264_encoder) { "No supported H.264 encoder found in ffmpeg. Available: #{available.join(', ')}" }
+          @available_h264_encoder
         end
 
         # Check that external tools can be executed.
@@ -42,10 +47,8 @@ module Aspera
         # @return [nil]
         def check_tools(skip_types = [])
           tools_to_check = EXTERNAL_TOOLS.dup
-          if skip_types.include?(:office)
-            tools_to_check.delete(:unoconv)
-            tools_to_check.delete(:soffice)
-          end
+          tools_to_check.delete(:unoconv) if skip_types.include?(:office) || office_tool.eql?(:soffice)
+          tools_to_check.delete(:soffice) if skip_types.include?(:office) || office_tool.eql?(:unoconv)
           # Check for binaries
           tools_to_check.each do |command_sym|
             silent_execute(command_sym, '-h')

data/lib/aspera/products/connect.rb

@@ -53,7 +53,7 @@ module Aspera
 
       # Base URL for CDN of Connect
       def cdn_api
-        Rest.new(base_url: CDN_BASE_URL)
+        Rest::Client.new(base_url: CDN_BASE_URL)
       end
 
       # Retrieve structure from cloud (CDN) with all versions available

data/lib/aspera/rainbow.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Load Rainbow with terminal detection (tty, TERM=dumb, CLICOLOR_FORCE)
+# and its String refinement.
+# Each file using colors must still activate it with: using Rainbow
+require 'rainbow'
+require 'rainbow/refinement'

data/lib/aspera/rest/aspera_errors.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'aspera/rest/error_analyzer'
+require 'aspera/log'
+require 'xmlsimple'
+
+module Aspera
+  module Rest
+    # REST error handlers for various Aspera REST APIs
+    class AsperaErrors
+      class << self
+        # handlers should probably be defined by plugins for modularity
+        def register_handlers
+          Log.log.debug('registering Aspera REST error handlers')
+          # Faspex 4: both user_message and internal_message, and code 200
+          # example: missing meta data on package creation
+          ErrorAnalyzer.instance.add_simple_handler(name: 'Type 1: error:user_message', path: %w[error user_message], always: true)
+          ErrorAnalyzer.instance.add_simple_handler(name: 'Type 2: error:description', path: %w[error description])
+          ErrorAnalyzer.instance.add_simple_handler(name: 'Type 3: error:internal_message', path: %w[error internal_message])
+          ErrorAnalyzer.instance.add_simple_handler(name: 'Type 5', path: ['error_description'])
+          ErrorAnalyzer.instance.add_simple_handler(name: 'Type 6', path: ['message'])
+          ErrorAnalyzer.instance.add_simple_handler(name: 'Type 6', path: ['failure'], always: true)
+          # AoC Automation
+          ErrorAnalyzer.instance.add_simple_handler(name: 'AoC Automation', path: ['error'])
+          ErrorAnalyzer.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 context[:data].key?('min_connect_version')
+            context[:data]['errors'].each do |k, v|
+              ErrorAnalyzer.add_error(context, type, "#{k}: #{v}")
+            end
+          end
+          # call to upload_setup and download_setup of node api
+          ErrorAnalyzer.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)
+              ErrorAnalyzer.add_error(context, type, r_err.values.join(': '))
+            end
+          end
+          ErrorAnalyzer.instance.add_simple_handler(name: 'T9:IBM cloud IAM', path: ['errorMessage'])
+          ErrorAnalyzer.instance.add_simple_handler(name: 'T10:faspex v4', path: ['user_message'])
+          ErrorAnalyzer.instance.add_handler('Orchestrator') do |type, context|
+            next if context[:response].code.start_with?('2')
+            data = context[:data]
+            if data.is_a?(String) && data.start_with?('<?xml')
+              parsed = XmlSimple.xml_in(data, {'ForceArray' => false}) rescue nil
+              if parsed.is_a?(Hash) && parsed['content'].is_a?(String)
+                ErrorAnalyzer.add_error(context, type, parsed['content'].gsub(/\A"|"\z/, ''))
+                parsed.each do |k, v|
+                  next if k.eql?('content')
+                  ErrorAnalyzer.add_error(context, "#{type}(sub)", "#{k}: #{v}") if [String, Integer].include?(v.class)
+                end
+              end
+              next
+            end
+            next unless data.is_a?(Hash)
+            work_order = data['work_order']
+            next unless work_order.is_a?(Hash)
+            ErrorAnalyzer.add_error(context, type, work_order['statusDetails'])
+            data['missing_parameters']&.each do |param|
+              ErrorAnalyzer.add_error(context, type, "missing parameter: #{param}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aspera/rest/call_error.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aspera
+  module Rest
+    # raised on error after REST call
+    class CallError < StandardError
+      def request
+        @context[:request]
+      end
+
+      def response
+        @context[:response]
+      end
+
+      def data
+        @context[:data]
+      end
+
+      # @param context [Hash,String] with keys :messages, :request, :response, :data
+      def initialize(context)
+        context = {messages: [context]} if context.is_a?(String)
+        @context = context
+        super(@context[:messages].join("\n"))
+      end
+    end
+  end
+end