aspera-cli 4.25.1 → 4.25.3

data/lib/aspera/rest.rb

@@ -53,14 +53,24 @@ module Aspera
   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
@@ -143,8 +153,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 +312,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 +383,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 +411,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]
+          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']}"}
           # 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,14 +449,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
+        if Mime.json?(result_mime)
           result_data = JSON.parse(result_http.body) rescue result_http.body
           Log.dump(:result_data, result_data)
-        else # when MIME_TEXT
+        else # Mime::TEXT
           result_data = result_http.body
         end
         RestErrorAnalyzer.instance.raise_on_error(req, result_data, result_http)
@@ -526,27 +536,27 @@ 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)
+      return call(operation: 'POST', subpath: subpath, headers: {'Accept' => Mime::JSON}, body: params, content_type: Mime::JSON, **kwargs)
     end
 
     # Read: `GET`
     def read(subpath, query = nil, **kwargs)
-      return call(operation: 'GET', subpath: subpath, headers: {'Accept' => MIME_JSON}, query: query, **kwargs)
+      return call(operation: 'GET', subpath: subpath, headers: {'Accept' => Mime::JSON}, 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)
+      return call(operation: 'PUT', subpath: subpath, headers: {'Accept' => Mime::JSON}, body: params, content_type: Mime::JSON, **kwargs)
     end
 
     # Delete: `DELETE`
     def delete(subpath, params = nil, **kwargs)
-      return call(operation: 'DELETE', subpath: subpath, headers: {'Accept' => MIME_JSON}, query: params, **kwargs)
+      return call(operation: 'DELETE', subpath: subpath, headers: {'Accept' => Mime::JSON}, query: params, **kwargs)
     end
 
     # Cancel: `CANCEL`
     def cancel(subpath, **kwargs)
-      return call(operation: 'CANCEL', subpath: subpath, headers: {'Accept' => MIME_JSON}, **kwargs)
+      return call(operation: 'CANCEL', subpath: subpath, headers: {'Accept' => Mime::JSON}, **kwargs)
     end
 
     # Query entity by general search (read with parameter `q`)
@@ -577,11 +587,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_call_error.rb

@@ -3,15 +3,23 @@
 module Aspera
   # raised on error after REST call
   class RestCallError < StandardError
-    attr_reader :request, :response
+    def request
+      @context[:request]
+    end
+
+    def response
+      @context[:response]
+    end
+
+    def data
+      @context[:data]
+    end
 
-    # @param req HTTP Request object
-    # @param resp HTTP Response object
-    # @param msg Error message
-    def initialize(msg, req = nil, resp = nil)
-      @request = req
-      @response = resp
-      super(msg)
+    # @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

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[:messages].join("\n"), call_context[:request], call_context[:response]) 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/resumer.rb

@@ -41,14 +41,14 @@ module Aspera
         Log.log.debug{"retries=#{remaining_resumes}"}
         # try to send the file until ascp is successful
         loop do
-          Log.log.debug('Transfer session starting')
+          Log.log.debug('Starting task execution')
           begin
             # Call provided block: execute transfer
             yield
             # Exit retry loop if success
             break
           rescue Error => e
-            Log.log.warn{"A transfer error occurred during transfer: #{e.message}"}
+            Log.log.warn{"An error occurred during task: #{e.message}"}
             Log.log.debug{"Retryable ? #{e.retryable?}"}
             # do not retry non-retryable
             raise unless e.retryable?

data/lib/aspera/yaml.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Aspera
+  module Yaml
+    # @param node [Psych::Nodes::Node] YAML node
+    # @param parent_path [Array<String>] Path of parent keys
+    # @param duplicate_keys [Array<Hash>] Accumulated duplicate keys
+    # @return [Array<String>] List of duplicate keys with their paths and occurrences
+    def find_duplicate_keys(node, parent_path = nil, duplicate_keys = nil)
+      duplicate_keys ||= []
+      parent_path ||= []
+      return duplicate_keys unless node.respond_to?(:children)
+      if node.is_a?(Psych::Nodes::Mapping)
+        counts = Hash.new(0)
+        key_nodes = Hash.new{ |h, k| h[k] = []}
+        node.children.each_slice(2) do |key_node, value_node|
+          if key_node&.value
+            counts[key_node.value] += 1
+            key_nodes[key_node.value] << key_node
+            find_duplicate_keys(value_node, parent_path + [key_node.value], duplicate_keys)
+          end
+        end
+        counts.each do |key_str, count|
+          next if count <= 1
+          path = (parent_path + [key_str]).join('.')
+          occurrences = key_nodes[key_str].map{ |kn| kn.start_line ? kn.start_line + 1 : 'unknown'}.map(&:to_s).join(', ')
+          duplicate_keys << "#{path}: #{occurrences}"
+        end
+      else
+        node.children.to_a.each{ |child| find_duplicate_keys(child, parent_path, duplicate_keys)}
+      end
+      duplicate_keys
+    end
+
+    # Safely load YAML content, raising an error if duplicate keys are found
+    # @param yaml [String] YAML content
+    # @return [Object] Parsed YAML content
+    # @raise [RuntimeError] If duplicate keys are found
+    def safe_load(yaml)
+      duplicate_keys = find_duplicate_keys(Psych.parse_stream(yaml))
+      raise "Duplicate keys: #{duplicate_keys.join('; ')}" unless duplicate_keys.empty?
+      YAML.safe_load(yaml)
+    end
+
+    module_function :find_duplicate_keys, :safe_load
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aspera-cli
 version: !ruby/object:Gem::Version
-  version: 4.25.1
+  version: 4.25.3
 platform: ruby
 authors:
 - Laurent Martin
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: marcel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: mime-types
   requirement: !ruby/object:Gem::Requirement
@@ -430,9 +444,9 @@ files:
 - lib/aspera/uri_reader.rb
 - lib/aspera/web_auth.rb
 - lib/aspera/web_server_simple.rb
+- lib/aspera/yaml.rb
 - lib/transferd_pb.rb
 - lib/transferd_services_pb.rb
-- release_notes.md
 homepage: https://github.com/IBM/aspera-cli
 licenses:
 - Apache-2.0
@@ -440,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: []

data/release_notes.md

@@ -1,8 +0,0 @@
-## 4.25.1
-
-Released: 2026-01-21
-
-### Issues Fixed
-
-* `build`: Fixed deploy workflow to use global rake instead of bundle exec.
-* `build`: Made rspec require conditional in test.rake for deploy environment.