aspera-cli 4.27.0 → 4.27.1

data/lib/aspera/api/node.rb

@@ -43,14 +43,11 @@ module Aspera
         SEPARATOR = ':'
         NODE_PREFIX = 'node.'
       end
-      # Accepted types in `file_matcher`
-      MATCH_TYPES = [String, Proc, Regexp, NilClass].freeze
       # Delimiter in decoded node token
       SIGNATURE_DELIMITER = '==SIGNATURE=='
       # Default validity when generating a bearer token "manually"
       BEARER_TOKEN_VALIDITY_DEFAULT = 86400
-      private_constant :MATCH_TYPES,
-        :SIGNATURE_DELIMITER, :BEARER_TOKEN_VALIDITY_DEFAULT
+      private_constant :SIGNATURE_DELIMITER, :BEARER_TOKEN_VALIDITY_DEFAULT
       # Node API permissions: delete list mkdir preview read rename write
       ACCESS_LEVELS = %w[delete list mkdir preview read rename write].freeze
       # Special HTTP Headers
@@ -63,7 +60,7 @@ module Aspera
       HEADER_X_TOTAL_COUNT = 'X-Total-Count'
 
       # Register node special token decoder
-      OAuth::Factory.instance.register_decoder(lambda{ |token| Node.decode_bearer_token(token)})
+      OAuth::Factory.instance.register_decoder(lambda { |token| Node.decode_bearer_token(token) })
 
       # Class instance variable, access with accessors on class
       @api_options = {
@@ -82,8 +79,8 @@ module Aspera
         def api_options=(options_hash)
           Aspera.assert_type(options_hash, Hash)
           options_hash.each do |key, val|
-            Aspera.assert(@api_options.key?(key.to_sym)){"unknown api option: #{key} (#{OPTIONS.join(', ')})"}
-            Aspera.assert_type(val, TrueClass, FalseClass){"api options value for #{key} should be boolean"}
+            Aspera.assert(@api_options.key?(key.to_sym)) { "unknown api option: #{key} (#{OPTIONS.join(', ')})" }
+            Aspera.assert_type(val, TrueClass, FalseClass) { "api options value for #{key} should be boolean" }
             @api_options[key.to_sym] = val
           end
         end
@@ -127,25 +124,6 @@ module Aspera
           return parameters
         end
 
-        # For access keys: provide expression to match entry in folder
-        # @param match_expression [Proc, Regexp, String] one of supported types
-        # @return [Proc] lambda function
-        def file_matcher(match_expression)
-          case match_expression
-          when Proc then return match_expression
-          when Regexp then return ->(f){f['name'].match?(match_expression)}
-          when String
-            return ->(f){File.fnmatch(match_expression, f['name'], File::FNM_DOTMATCH)}
-          when NilClass then return ->(_){true}
-          else Aspera.error_unexpected_value(match_expression.class.name, type: ParameterError)
-          end
-        end
-
-        # @return [Proc] lambda from provided CLI options
-        def file_matcher_from_argument(options)
-          return file_matcher(options.get_next_argument('filter', validation: MATCH_TYPES, mandatory: false))
-        end
-
         # Split path into folder + filename
         # @param path [String] file path to split
         # @return [Array(String, String)] containing folder + inside folder/file
@@ -166,8 +144,8 @@ module Aspera
         # @return [Hash] decoded scope with access key and scope parts
         def decode_scope(scope)
           items = scope.split(Scope::SEPARATOR, 2)
-          Aspera.assert(items.length.eql?(2)){"invalid scope: #{scope}"}
-          Aspera.assert(items[0].start_with?(Scope::NODE_PREFIX)){"invalid scope: #{scope}"}
+          Aspera.assert(items.length.eql?(2)) { "invalid scope: #{scope}" }
+          Aspera.assert(items[0].start_with?(Scope::NODE_PREFIX)) { "invalid scope: #{scope}" }
           return {access_key: items[0].delete_prefix(Scope::NODE_PREFIX), scope: items[1]}
         end
 
@@ -253,10 +231,10 @@ module Aspera
             workspace_name: @app_info.workspace_name
           )
         end
-        Log.log.warn{"Cannot resolve link with node id #{node_id}, no resolver"}
+        Log.log.warn { "Cannot resolve link with node id #{node_id}, no resolver" }
         return
       rescue RestCallError => e
-        Log.log.warn{"Cannot resolve link with node id #{node_id}: #{e.message}"}
+        Log.log.warn { "Cannot resolve link with node id #{node_id}: #{e.message}" }
         return
       end
 
@@ -271,7 +249,7 @@ module Aspera
           entry['target_id'] = link_entry['target_id']
         end
         return true unless entry['target_node_id'].nil? || entry['target_id'].nil?
-        Log.log.warn{"Missing target information for link: #{entry['name']}"}
+        Log.log.warn { "Missing target information for link: #{entry['name']}" }
         return false
       end
 
@@ -323,8 +301,8 @@ module Aspera
           end
         rescue StandardError => e
           raise e if exception
-          Log.log.warn{"#{path || file_id}: #{e.class} #{e.message}"}
-          Log.log.debug{(['Backtrace:'] + e.backtrace).join("\n")}
+          Log.log.warn { "#{path || file_id}: #{e.class} #{e.message}" }
+          Log.log.debug { (['Backtrace:'] + e.backtrace).join("\n") }
         ensure
           RestParameters.instance.spinner_cb.call(folder_items.count, action: :success)
         end
@@ -341,14 +319,14 @@ module Aspera
       # @para query [Hash, nil] optional query for `read`
       def process_folder_tree(method_sym:, state:, top_file_id:, top_file_path: '/', query: nil)
         Aspera.assert(!top_file_path.nil?, 'top_file_path not set')
-        Log.log.debug{"process_folder_tree: node=#{@app_info ? @app_info.node_info['id'] : 'nil'}, file id=#{top_file_id},  path=#{top_file_path}"}
+        Log.log.debug { "process_folder_tree: node=#{@app_info ? @app_info.node_info['id'] : 'nil'}, file id=#{top_file_id},  path=#{top_file_path}" }
         # Start at top folder
         folders_to_explore = [{id: top_file_id, path: top_file_path}]
         Log.dump(:folders_to_explore, folders_to_explore)
         until folders_to_explore.empty?
           # Consume first in job list
           current_item = folders_to_explore.shift
-          Log.log.debug{"Exploring #{current_item[:path]}".bg_green}
+          Log.log.debug { "Exploring #{current_item[:path]}".bg_green }
           # Get folder content
           folder_contents = read_folder_content(current_item[:id], query, exception: false, path: current_item[:path])
           Log.dump(:folder_contents, folder_contents)
@@ -358,7 +336,7 @@ module Aspera
               next
             end
             current_path = File.join(current_item[:path], entry['name'])
-            Log.log.debug{"process_folder_tree: checking #{current_path}"}
+            Log.log.debug { "process_folder_tree: checking #{current_path}" }
             # Call block, continue only if method returns true
             next unless send(method_sym, entry, current_path, state)
             # Entry type is file, folder or link
@@ -393,8 +371,8 @@ module Aspera
         return NodeFileId.new(self, top_file_id) if path_elements.empty?
         resolve_state = {path: path_elements, consumed: [], result: nil, process_last_link: process_last_link}
         process_folder_tree(method_sym: :process_api_fid, state: resolve_state, top_file_id: top_file_id)
-        Aspera.assert(!resolve_state[:result].nil?, type: ParameterError){"Entry not found: #{resolve_state[:path].first} in /#{resolve_state[:consumed].join(PATH_SEPARATOR)}"}
-        Log.log.debug{"resolve_api_fid: #{path} -> #{resolve_state[:result].node_api.base_url} #{resolve_state[:result].file_id}"}
+        Aspera.assert(!resolve_state[:result].nil?, type: ParameterError) { "Entry not found: #{resolve_state[:path].first} in /#{resolve_state[:consumed].join(PATH_SEPARATOR)}" }
+        Log.log.debug { "resolve_api_fid: #{path} -> #{resolve_state[:result].node_api.base_url} #{resolve_state[:result].file_id}" }
         return resolve_state[:result]
       end
 
@@ -409,10 +387,10 @@ module Aspera
       def resolve_api_fid_paths(top_file_id, paths)
         Aspera.assert_type(paths, Array)
         Aspera.assert(paths.size.positive?, 'paths must not be empty')
-        split_sources = paths.map{ |p| Pathname(p['source']).each_filename.to_a}
+        split_sources = paths.map { |p| Pathname(p['source']).each_filename.to_a }
         root = []
         split_sources.map(&:size).min.times do |i|
-          parts = split_sources.map{ |s| s[i]}
+          parts = split_sources.map { |s| s[i] }
           break unless parts.uniq.size == 1
           root << parts.first
         end
@@ -440,7 +418,7 @@ module Aspera
               # Single source is 'folder' or 'link'
               # TODO: add this ? , 'destination'=>file_info['name']
               [{'source' => '.'}]
-            else Aspera.error_unexpected_value(file_info['type']){'source type'}
+            else Aspera.error_unexpected_value(file_info['type']) { 'source type' }
             end
         end
         [apifid, source_paths]
@@ -450,7 +428,7 @@ module Aspera
       # @param top_file_id [String] Search root
       # @param test_lambda [Proc] Test function
       def find_files(top_file_id, test_lambda)
-        Log.log.debug{"find_files: file id=#{top_file_id}"}
+        Log.log.debug { "find_files: file id=#{top_file_id}" }
         find_state = {found: [], test_lambda: test_lambda}
         process_folder_tree(method_sym: :process_find_files, state: find_state, top_file_id: top_file_id)
         return find_state[:found]
@@ -535,7 +513,7 @@ module Aspera
           # Get the transfer user from info on access key
           transfer_spec['remote_user'] = info['transfer_user'] if info['transfer_user']
           # Get settings from name.value array to hash key.value
-          settings = info['settings']&.to_h{ |i| [i['name'], i['value']]}
+          settings = info['settings']&.to_h { |i| [i['name'], i['value']] }
           # Check WSS ports
           Transfer::Spec::WSS_FIELDS.each do |i|
             transfer_spec[i] = settings[i] if settings.key?(i)
@@ -543,7 +521,7 @@ module Aspera
         else
           transfer_spec.merge!(transport_params)
         end
-        Aspera.assert_values(transfer_spec['remote_user'], [Transfer::Spec::ACCESS_KEY_TRANSFER_USER], type: :warn){'transfer user'}
+        Aspera.assert_values(transfer_spec['remote_user'], [Transfer::Spec::ACCESS_KEY_TRANSFER_USER], type: :warn) { 'transfer user' }
         return transfer_spec
       end
 
@@ -552,8 +530,8 @@ module Aspera
       # @param call_args [Hash]    additional arguments to pass to `Rest.call`
       # @return [Array] list of items returned by the API call
       def read_with_paging(subpath, query = nil, iteration: nil, **call_args)
-        Aspera.assert_type(iteration, Array, NilClass){'iteration'}
-        Aspera.assert_type(query, Hash, NilClass){'query'}
+        Aspera.assert_type(iteration, Array, NilClass) { 'iteration' }
+        Aspera.assert_type(query, Hash, NilClass) { 'query' }
         Aspera.assert(!call_args.key?(:query), ':query must not be in call_args (use query parameter)')
         query = {} if query.nil?
         query[:iteration_token] = iteration[0] unless iteration.nil? || iteration[0].nil?
@@ -563,7 +541,7 @@ module Aspera
         item_list = []
         loop do
           data, http = read(subpath, query, **call_args, ret: :both)
-          Aspera.assert_type(data, Array){"Expected data to be an Array, got: #{data.class}"}
+          Aspera.assert_type(data, Array) { "Expected data to be an Array, got: #{data.class}" }
           # no data
           break if data.empty?
           item_list.concat(data)
@@ -583,7 +561,7 @@ module Aspera
               query_params = Rest.query_to_h(parsed_uri.query) if parsed_uri.query
               next_iteration_token = query_params['iteration_token'] if query_params
             rescue URI::InvalidURIError => e
-              Log.log.warn{"Invalid URI in Link header: #{next_url} - #{e.message}"}
+              Log.log.warn { "Invalid URI in Link header: #{next_url} - #{e.message}" }
             end
           end
           # Stop if no next token
@@ -622,8 +600,8 @@ module Aspera
           query['page'] += 1
         end
       rescue StandardError => e
-        Log.log.warn{"#{e.class} #{e.message}"}
-        Log.log.debug{(['Backtrace:'] + e.backtrace).join("\n")}
+        Log.log.warn { "#{e.class} #{e.message}" }
+        Log.log.debug { (['Backtrace:'] + e.backtrace).join("\n") }
       ensure
         RestParameters.instance.spinner_cb.call(items.count, action: :success)
         return items # rubocop:disable Lint/EnsureReturn
@@ -644,7 +622,7 @@ module Aspera
           # File must be terminal
           raise "#{entry['name']} is a file, expecting folder to find: #{state[:path]}" unless path_fully_consumed
           # It's terminal, we found it
-          Log.log.debug{"process_api_fid: found #{path} -> #{entry['id']}"}
+          Log.log.debug { "process_api_fid: found #{path} -> #{entry['id']}" }
           state[:result] = NodeFileId.new(self, entry['id'])
           return false
         when 'folder'
@@ -659,7 +637,7 @@ module Aspera
               # We found it
               other_node = nil
               other_node = node_id_to_node(entry['target_node_id']) if entry_has_link_information(entry)
-              Aspera.assert(!other_node.nil?, type: Error){'Cannot resolve link'}
+              Aspera.assert(!other_node.nil?, type: Error) { 'Cannot resolve link' }
               state[:result] = NodeFileId.new(other_node, entry['target_id'])
             else
               # We found it but we do not process the link
@@ -667,7 +645,7 @@ module Aspera
             end
             return false
           end
-        else Aspera.error_unexpected_value(entry['type'], type: :warn){'folder entry type'}
+        else Aspera.error_unexpected_value(entry['type'], type: :warn) { 'folder entry type' }
         end
         # Continue to dig folder
         return true

data/lib/aspera/ascmd.rb

@@ -89,11 +89,11 @@ module Aspera
     # @param action_sym [Symbol] one of OPERATIONS
     # @param arguments  [Array]  parameters for "as" command
     # @return [Boolean,Array,Hash] result of command, type depends on command
-    def execute_single(action_sym, arguments, version: 1, host: nil)
+    def execute_single(action_sym, arguments, version: 2, host: nil)
       arguments = [] if arguments.nil?
-      Log.log.debug{"execute_single:#{action_sym}:#{arguments}"}
+      Log.log.debug { "execute_single:#{action_sym}:#{arguments}" }
       Aspera.assert_type(action_sym, Symbol)
-      Aspera.assert_array_all(arguments, String){'arguments'}
+      Aspera.assert_array_all(arguments, String) { 'arguments' }
       remote_cmd = 'ascmd'
       # lines of commands (String's)
       command_lines = []
@@ -117,7 +117,7 @@ module Aspera
         # enclose arguments in double quotes, protect backslash and double quotes
         # ascmd uses space as token separator, and optional quotes ('") or \ to escape
         args.each do |v|
-          command.push(%Q{"#{v.gsub(/["\\]/){ |s| "\\#{s}"}}"})
+          command.push(%Q{"#{v.gsub(/["\\]/) { |s| "\\#{s}" }}"})
         end
         command_lines.push(command.join(' '))
       end
@@ -125,7 +125,7 @@ module Aspera
       command_lines.push('')
       # execute the main command and then exit
       stdin_input = command_lines.join("\n")
-      Log.log.trace1{"execute_single:#{stdin_input}"}
+      Log.log.trace1 { "execute_single:#{stdin_input}" }
       # execute, get binary output
       byte_buffer = @command_executor.execute(remote_cmd, input: stdin_input).unpack('C*')
       Aspera.assert(!byte_buffer.empty?, 'empty answer from server')
@@ -154,7 +154,7 @@ module Aspera
       end
       # raise error as exception
       raise Error.new(result[:errno], result[:errstr], action_sym, arguments) if
-        result.is_a?(Hash) && (result.keys.sort == TYPES_DESCR[:error][:fields].map{ |i| i[:name]}.sort)
+        result.is_a?(Hash) && (result.keys.sort == TYPES_DESCR[:error][:fields].map { |i| i[:name] }.sort)
       return result
     end
 
@@ -174,7 +174,7 @@ module Aspera
       # @return [Hash] field description
       def field_description(struct_name, typed_buffer)
         result = TYPES_DESCR[struct_name][:fields][typed_buffer[:btype] - ENUM_START]
-        Aspera.assert(!result.nil?){"Unrecognized field for #{struct_name}: #{typed_buffer[:btype]}\n#{typed_buffer[:buffer]}"}
+        Aspera.assert(!result.nil?) { "Unrecognized field for #{struct_name}: #{typed_buffer[:btype]}\n#{typed_buffer[:buffer]}" }
         return result
       end
 
@@ -183,8 +183,8 @@ module Aspera
       def parse(buffer, type_name, indent_level = nil)
         indent_level = (indent_level || -1) + 1
         type_descr = TYPES_DESCR[type_name]
-        Aspera.assert(!type_descr.nil?){"Unexpected type #{type_name}"}
-        Log.log.trace1{"#{'   .' * indent_level}parse:#{type_name}:#{type_descr[:decode]}:#{buffer[0, 16]}...".red}
+        Aspera.assert(!type_descr.nil?) { "Unexpected type #{type_name}" }
+        Log.log.trace1 { "#{'   .' * indent_level}parse:#{type_name}:#{type_descr[:decode]}:#{buffer[0, 16]}...".red }
         result = nil
         case type_descr[:decode]
         when :base
@@ -194,7 +194,7 @@ module Aspera
           byte_array = [byte_array] unless byte_array.is_a?(Array)
           result = byte_array.pack('C*').unpack1(type_descr[:unpack])
           result.force_encoding('UTF-8') if type_name.eql?(:zstr)
-          Log.log.trace1{"#{'   .' * indent_level}-> base:#{byte_array} -> #{result}"}
+          Log.log.trace1 { "#{'   .' * indent_level}-> base:#{byte_array} -> #{result}" }
           result = Time.at(result) if type_name.eql?(:epoch)
         when :buffer_list
           # return a list of type_buffer
@@ -205,7 +205,7 @@ module Aspera
             Aspera.assert(buffer.length >= length, 'not enough bytes')
             value = buffer.shift(length)
             result.push({btype: btype, buffer: value})
-            Log.log.trace1{"#{'   .' * indent_level}:buffer_list[#{result.length - 1}] #{result.last}"}
+            Log.log.trace1 { "#{'   .' * indent_level}:buffer_list[#{result.length - 1}] #{result.last}" }
           end
         when :field_list
           # by default the result is one struct
@@ -214,7 +214,7 @@ module Aspera
           parse(buffer, :blist, indent_level).each do |typed_buffer|
             # what type of field is it ?
             field_info = field_description(type_name, typed_buffer)
-            Log.log.trace1{"#{'   .' * indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green}
+            Log.log.trace1 { "#{'   .' * indent_level}+ field(special=#{field_info[:special]})=#{field_info[:name]}".green }
             case field_info[:special]
             when nil # normal case
               result[field_info[:name]] = parse(typed_buffer[:buffer], field_info[:is_a], indent_level)
@@ -224,7 +224,7 @@ module Aspera
               result[field_info[:name]] ||= []
               result[field_info[:name]].push(parse(typed_buffer[:buffer], field_info[:is_a], indent_level))
             when :list_tlv_list # field is an array of values in a list of buffers
-              result[field_info[:name]] = parse(typed_buffer[:buffer], :blist, indent_level).map{ |r| parse(r[:buffer], field_info[:is_a], indent_level)}
+              result[field_info[:name]] = parse(typed_buffer[:buffer], :blist, indent_level).map { |r| parse(r[:buffer], field_info[:is_a], indent_level) }
             when :list_tlv_restart # field is an array of values, but a new value is started on index 1
               fl = result[field_info[:name]] = []
               parse(typed_buffer[:buffer], :blist, indent_level).map do |tb|

data/lib/aspera/ascp/installation.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # cspell:ignore protobuf ckpt
+require 'aspera/yaml'
 require 'aspera/environment'
 require 'aspera/data_repository'
 require 'aspera/log'
@@ -46,9 +47,9 @@ module Aspera
       def sdk_locations
         location_url = @transferd_urls
         transferd_locations = UriReader.read(location_url)
-        Log.log.debug{"Retrieving SDK locations from #{location_url}"}
+        Log.log.debug { "Retrieving SDK locations from #{location_url}" }
         begin
-          return YAML.load(transferd_locations)
+          return Yaml.safe_load(transferd_locations)
         rescue Psych::SyntaxError
           raise "Error when parsing yaml data from: #{location_url}"
         end
@@ -60,23 +61,23 @@ module Aspera
       # - "product:PRODUCT_NAME" to use ascp from named product
       # - "product:FIRST" to use ascp from first found product
       def sdk_folder=(ascp_location)
-        Aspera.assert_type(ascp_location, String){'ascp_location'}
+        Aspera.assert_type(ascp_location, String) { 'ascp_location' }
         Aspera.assert(!ascp_location.empty?, 'ascp location cannot be empty: check your config file')
         folder =
           if ascp_location.start_with?(USE_PRODUCT_PREFIX)
             product_name = ascp_location.delete_prefix(USE_PRODUCT_PREFIX)
             if product_name.eql?(FIRST_FOUND)
               pl = installed_products.first
-              Aspera.assert(!pl.nil?){"No Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf transferd install"}
+              Aspera.assert(!pl.nil?) { "No Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf transferd install" }
             else
-              pl = installed_products.find{ |i| i[:name].eql?(product_name)}
-              Aspera.assert(!pl.nil?){"No such product installed: #{product_name}"}
+              pl = installed_products.find { |i| i[:name].eql?(product_name) }
+              Aspera.assert(!pl.nil?) { "No such product installed: #{product_name}" }
             end
             File.dirname(pl[:ascp_path])
           else
             ascp_location.include?('/ascp') ? File.dirname(ascp_location) : ascp_location
           end
-        Log.log.debug{"ascp_folder=#{folder}"}
+        Log.log.debug { "ascp_folder=#{folder}" }
         Products::Transferd.sdk_directory = folder
         nil
       end
@@ -118,11 +119,11 @@ module Aspera
         when :ssh_private_dsa, :ssh_private_rsa
           # assume last 3 letters are type
           type = file_type.to_s[-3..].to_sym
-          file = check_or_create_sdk_file("aspera_bypass_#{type}.pem"){DataRepository.instance.item(type)}
+          file = check_or_create_sdk_file("aspera_bypass_#{type}.pem") { DataRepository.instance.item(type) }
         when :aspera_license
-          file = check_or_create_sdk_file('aspera-license'){DataRepository.instance.item(:license)}
+          file = check_or_create_sdk_file('aspera-license') { DataRepository.instance.item(:license) }
         when :aspera_conf
-          file = check_or_create_sdk_file('aspera.conf'){DEFAULT_ASPERA_CONF}
+          file = check_or_create_sdk_file('aspera.conf') { DEFAULT_ASPERA_CONF }
         when :fallback_certificate, :fallback_private_key
           file_key = File.join(Products::Transferd.sdk_directory, 'aspera_fallback_cert_private_key.pem')
           file_cert = File.join(Products::Transferd.sdk_directory, 'aspera_fallback_cert.pem')
@@ -131,14 +132,14 @@ module Aspera
             # create new self signed certificate for http fallback
             private_key = OpenSSL::PKey::RSA.new(4096)
             cert = WebServerSimple.self_signed_cert(private_key)
-            check_or_create_sdk_file('aspera_fallback_cert_private_key.pem', force: true){private_key.to_pem}
-            check_or_create_sdk_file('aspera_fallback_cert.pem', force: true){cert.to_pem}
+            check_or_create_sdk_file('aspera_fallback_cert_private_key.pem', force: true) { private_key.to_pem }
+            check_or_create_sdk_file('aspera_fallback_cert.pem', force: true) { cert.to_pem }
           end
           file = file_type.eql?(:fallback_certificate) ? file_cert : file_key
         else Aspera.error_unexpected_value(file_type)
         end
         return unless file_is_required || File.exist?(file)
-        Aspera.assert(File.exist?(file), type: Errno::ENOENT){"#{file_type} not found (#{file})"}
+        Aspera.assert(File.exist?(file), type: Errno::ENOENT) { "#{file_type} not found (#{file})" }
         return file
       end
 
@@ -155,7 +156,7 @@ module Aspera
         Aspera.assert_values(types, CLIENT_SSH_KEY_OPTIONS)
         return case types
                when :dsa_rsa, :rsa
-                 types.to_s.split('_').map{ |i| Installation.instance.path("ssh_private_#{i}".to_sym)}
+                 types.to_s.split('_').map { |i| Installation.instance.path("ssh_private_#{i}".to_sym) }
                when :per_client
                  Aspera.error_not_implemented
                end
@@ -237,26 +238,26 @@ module Aspera
       def sdk_url_for_platform(platform: nil, version: nil)
         all_locations = sdk_locations
         platform = Environment.instance.architecture if platform.nil?
-        locations = all_locations.select{ |l| l['platform'].eql?(platform)}
-        Aspera.assert(!locations.empty?){"No SDK for platform: #{platform}, available: #{all_locations.map{ |i| i['platform']}.uniq}"}
-        version = locations.max_by{ |entry| Gem::Version.new(entry['version'])}['version'] if version.nil?
-        info = locations.select{ |entry| entry['version'].eql?(version)}
-        Aspera.assert(!info.empty?){"No such version: #{version} for #{platform}"}
+        locations = all_locations.select { |l| l['platform'].eql?(platform) }
+        Aspera.assert(!locations.empty?) { "No SDK for platform: #{platform}, available: #{all_locations.map { |i| i['platform'] }.uniq}" }
+        version = locations.max_by { |entry| Gem::Version.new(entry['version']) }['version'] if version.nil?
+        info = locations.select { |entry| entry['version'].eql?(version) }
+        Aspera.assert(!info.empty?) { "No such version: #{version} for #{platform}" }
         return info.first['url']
       end
 
-      # @param sdk_archive_path [String] path to SDK archive
+      # @param url         [String] URL or filename used to detect archive format
+      # @param archive_io  [StringIO] archive content as an in-memory IO stream
       # @yieldparam entry_name [String] File path in archive
       # @yieldparam entry_stream [IO, Gem::Package::TarReader::Entry] Data stream
       # @yieldparam link_target [String, nil] Link target if symlink, nil otherwise
-      def extract_archive_files(sdk_archive_path)
+      def extract_archive_files(url, archive_io)
         Aspera.assert(block_given?, 'missing block')
-        case sdk_archive_path
+        case url
         # Windows and Mac use zip
         when /\.zip$/
           require 'zip'
-          # extract files from archive
-          Zip::File.open(sdk_archive_path) do |zip_file|
+          Zip::File.open_buffer(archive_io) do |zip_file|
             zip_file.each do |entry|
               next if entry.name.end_with?('/')
               entry.get_input_stream do |io|
@@ -268,7 +269,7 @@ module Aspera
         when /\.tar\.gz/
           require 'zlib'
           require 'rubygems/package'
-          Zlib::GzipReader.open(sdk_archive_path) do |gzip|
+          Zlib::GzipReader.wrap(archive_io) do |gzip|
             Gem::Package::TarReader.new(gzip) do |tar|
               tar.each do |entry|
                 next if entry.directory?
@@ -277,7 +278,7 @@ module Aspera
             end
           end
         else
-          raise "unknown archive extension: #{sdk_archive_path}"
+          raise "unknown archive extension: #{url}"
         end
       end
 
@@ -301,13 +302,19 @@ module Aspera
         extracted_files = {}
         # Security: Get canonical path of installation directory for boundary checks
         install_boundary = File.realpath(folder)
-        sdk_archive_path = UriReader.read_as_file(url)
-        extract_archive_files(sdk_archive_path) do |entry_name, entry_stream, link_target|
+        archive_io = StringIO.new
+        if UriReader.file?(url)
+          archive_io.write(File.binread(UriReader.file_path(url)))
+        else
+          Rest.new(base_url: url, redirect_max: 3).call(operation: 'GET', save_to: archive_io)
+          archive_io.rewind
+        end
+        extract_archive_files(url, archive_io) do |entry_name, entry_stream, link_target|
           dest_folder = if block_given?
             yield(entry_name)
           else
             # default files to extract directly to main folder if in selected source folders
-            Products::Transferd::RUNTIME_FOLDERS.any?{ |i| entry_name.match?(%r{^[^/]*/#{i}/})} ? '/' : nil
+            Products::Transferd::RUNTIME_FOLDERS.any? { |i| entry_name.match?(%r{^[^/]*/#{i}/}) } ? '/' : nil
           end
           next if dest_folder.nil?
           dest_folder = File.join(folder, dest_folder)
@@ -320,7 +327,7 @@ module Aspera
           # Security: Detect basename collisions that could overwrite symlinks
           file_basename = File.basename(dest_file)
           if extracted_files.key?(file_basename)
-            Log.log.warn{"Rejecting file with duplicate basename: #{entry_name} (basename: #{file_basename}, previous: #{extracted_files[file_basename]})"}
+            Log.log.warn { "Rejecting file with duplicate basename: #{entry_name} (basename: #{file_basename}, previous: #{extracted_files[file_basename]})" }
             next
           end
           extracted_files[file_basename] = entry_name
@@ -328,7 +335,7 @@ module Aspera
           if link_target.nil?
             # Security: Check if destination already exists
             if File.exist?(dest_file)
-              Log.log.warn{"Rejecting write to existing file or link: #{dest_file}"}
+              Log.log.warn { "Rejecting write to existing file or link: #{dest_file}" }
               next
             end
             # Security: Verify the resolved path stays within installation boundary
@@ -338,17 +345,17 @@ module Aspera
               # Check where the file would resolve to (handles existing symlinks in path)
               resolved_dest = File.realpath(File.dirname(dest_file))
               unless resolved_dest.start_with?(install_boundary)
-                Log.log.warn{"Rejecting file outside installation directory: #{dest_file} resolves to #{resolved_dest}"}
+                Log.log.warn { "Rejecting file outside installation directory: #{dest_file} resolves to #{resolved_dest}" }
                 next
               end
             rescue Errno::ENOENT
               # Directory doesn't exist yet, verify the intended path
               unless dest_file.start_with?(folder)
-                Log.log.warn{"Rejecting file with path outside installation directory: #{dest_file}"}
+                Log.log.warn { "Rejecting file with path outside installation directory: #{dest_file}" }
                 next
               end
             end
-            File.open(dest_file, 'wb'){ |output_stream| IO.copy_stream(entry_stream, output_stream)}
+            File.open(dest_file, 'wb') { |output_stream| IO.copy_stream(entry_stream, output_stream) }
           else
             # Security: Validate symlink target stays within installation boundary
             # Resolve the symlink target relative to its location
@@ -362,7 +369,7 @@ module Aspera
             end
             # Check if resolved target would be outside installation directory
             unless resolved_target.start_with?(install_boundary)
-              Log.log.warn{"Rejecting symlink pointing outside installation directory: #{entry_name} -> #{link_target} (resolves to #{resolved_target})"}
+              Log.log.warn { "Rejecting symlink pointing outside installation directory: #{entry_name} -> #{link_target} (resolves to #{resolved_target})" }
               next
             end
             File.symlink(link_target, dest_file)
@@ -419,7 +426,7 @@ module Aspera
       # all executable files from SDK
       EXE_FILES = %i[ascp ascp4 async transferd].freeze
       # IDs of files present in SDK
-      SDK_FILES = %i[ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].unshift(*EXE_FILES).freeze
+      SDK_FILES = (EXE_FILES + %i[ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key]).freeze
       TRANSFERD_ARCHIVE_LOCATION_URL = 'https://ibm.biz/sdk_location'
       # filename for ascp with optional extension (Windows)
       private_constant :DEFAULT_ASPERA_CONF, :EXE_FILES, :SDK_FILES, :TRANSFERD_ARCHIVE_LOCATION_URL

data/lib/aspera/ascp/management.rb

@@ -305,8 +305,8 @@ module Aspera
         # @param name [String] Field name
         def field_snake_to_native(name)
           field = name.delete('_')
-          result = PARAMETERS.find{ |w| w.casecmp?(field)}
-          Aspera.assert(!result.nil?){"No such field: #{name}"}
+          result = PARAMETERS.find { |w| w.casecmp?(field) }
+          Aspera.assert(!result.nil?) { "No such field: #{name}" }
           result
         end
 
@@ -327,7 +327,7 @@ module Aspera
         # @return [String] frame to send on management port
         def command_to_stream(data)
           data
-            .map{ |key, value| "#{field_snake_to_native(key)}: #{value}"}
+            .map { |key, value| "#{field_snake_to_native(key)}: #{value}" }
             .unshift(MGT_HEADER)
             .push(MGT_FRAME_SEPARATOR, '')
             .join("\n")
@@ -352,15 +352,15 @@ module Aspera
           # begin event
           @event_build = {}
         when /^([^:]+): (.*)$/
-          Aspera.assert_type(@event_build, Hash){'mgt port: unexpected line: data without header'}
+          Aspera.assert_type(@event_build, Hash) { 'mgt port: unexpected line: data without header' }
           # event field
           @event_build[Regexp.last_match(1)] = Regexp.last_match(2)
         when MGT_FRAME_SEPARATOR
-          Aspera.assert_type(@event_build, Hash){'mgt port: unexpected line: end frame without header'}
+          Aspera.assert_type(@event_build, Hash) { 'mgt port: unexpected line: end frame without header' }
           @last_event = @event_build
           @event_build = nil
           return @last_event
-        else Aspera.error_unexpected_value(line){'mgt port'}
+        else Aspera.error_unexpected_value(line) { 'mgt port' }
         end
         return
       end