aspera-cli 4.19.0 → 4.21.1

data/lib/aspera/rest.rb

@@ -10,7 +10,8 @@ require 'net/http'
 require 'net/https'
 require 'json'
 require 'base64'
-require 'cgi'
+require 'singleton'
+require 'securerandom'
 
 # Cancel method for HTTP
 class Net::HTTP::Cancel < Net::HTTPRequest # rubocop:disable Style/ClassAndModuleChildren
@@ -20,22 +21,34 @@ class Net::HTTP::Cancel < Net::HTTPRequest # rubocop:disable Style/ClassAndModul
 end
 
 module Aspera
+  # Global settings for Rest object
+  # For example to remove certificate verification globally:
+  # `RestParameters.instance.session_cb = lambda{|http|http.verify_mode=OpenSSL::SSL::VERIFY_NONE}`
+  # @param user_agent [String] HTTP request header: 'User-Agent'
+  # @param download_partial_suffix [String] suffix for partial download
+  # @param session_cb [lambda] lambda called on new HTTP session. Takes the Net::HTTP as arg. Used to change parameters on creation.
+  # @param progress_bar [Object] progress bar object called for file transfer
+  class RestParameters
+    include Singleton
+
+    attr_accessor :user_agent, :download_partial_suffix, :retry_on_error, :retry_sleep, :session_cb, :progress_bar
+
+    private
+
+    def initialize
+      @user_agent = 'RubyAsperaRest'
+      @download_partial_suffix = '.http_partial'
+      @retry_on_error = 0
+      @retry_sleep = nil
+      @session_cb = nil
+      @progress_bar = nil
+    end
+  end
+
   # a simple class to make HTTP calls, equivalent to rest-client
   # rest call errors are raised as exception RestCallError
   # and error are analyzed in RestErrorAnalyzer
   class Rest
-    # Global settings also valid for any subclass
-    # @param user_agent [String] HTTP request header: 'User-Agent'
-    # @param download_partial_suffix [String] suffix for partial download
-    # @param session_cb [lambda] lambda called on new HTTP session. Takes the Net::HTTP as arg. Used to change parameters on creation.
-    # @param progress_bar [Object] progress bar object
-    @@global = { # rubocop:disable Style/ClassVars
-      user_agent:              'RubyAsperaRest',
-      download_partial_suffix: '.http_partial',
-      session_cb:              nil,
-      progress_bar:            nil
-    }
-
     # flag for array parameters prefixed with []
     ARRAY_PARAMS = '[]'
 
@@ -61,37 +74,45 @@ module Aspera
         return values.first.eql?(ARRAY_PARAMS)
       end
 
-      # Build URI from URL and parameters and check it is http or https, encode array [] parameters
-      def build_uri(url, query_hash=nil)
+      # Build URI from URL and parameters and check it is http or https
+      # encode array [] parameters
+      # @param query [Hash,Array]
+      def build_uri(url, query=nil)
         uri = URI.parse(url)
         Aspera.assert(%w[http https].include?(uri.scheme)){"REST endpoint shall be http/s not #{uri.scheme}"}
-        return uri if query_hash.nil?
-        Log.log.debug{Log.dump('query', query_hash)}
-        Aspera.assert_type(query_hash, Hash)
-        return uri if query_hash.empty?
-        query = []
-        query_hash.each do |k, v|
-          case v
-          when Array
-            # support array for query parameter, there is no standard. Either p[]=1&p[]=2, or p=1&p=2
-            suffix = array_params?(v) ? v.shift : ''
-            v.each do |e|
-              query.push(["#{k}#{suffix}", e])
+        return uri if query.nil? || query.respond_to?(:empty?) && query.empty?
+        Log.log.debug{Log.dump('query', query)}
+        query_array = []
+        case query
+        when Hash
+          query.each do |k, v|
+            case v
+            when Array
+              # support array for query parameter, there is no standard. Either p[]=1&p[]=2, or p=1&p=2
+              suffix = array_params?(v) ? v.shift : ''
+              v.each do |e|
+                query_array.push(["#{k}#{suffix}", e])
+              end
+            else
+              query_array.push([k, v])
             end
-          else
-            query.push([k, v])
           end
+        when Array
+          Aspera.assert(query.all?{|i| i.is_a?(Array) && i.length.eql?(2)}) {'Query must be array of arrays or 2 elements'}
+          query_array = query
+        else
+          raise "Query must be Hash or Array, not #{query.class}"
         end
         # [] is allowed in url parameters
-        uri.query = URI.encode_www_form(query).gsub('%5B%5D=', '[]=')
+        uri.query = URI.encode_www_form(query_array).gsub('%5B%5D=', '[]=')
         return uri
       end
 
-      # decode query string as hash
+      # Decode query string as Hash
       # Does not support arrays in query string, no standard, e.g. PHP's way is p[]=1&p[]=2
-      # @param query [String] query string
+      # @param query [String] query string as in URI.query
       # @return [Hash] decoded query
-      def decode_query(query)
+      def query_to_h(query)
         URI.decode_www_form(query).each_with_object({}) do |pair, h|
           key = pair.first
           raise "Array not supported in query string: #{key}" if key.include?('[]') || h.key?(key)
@@ -108,7 +129,7 @@ module Aspera
         http_session = Net::HTTP.new(uri.host, uri.port)
         http_session.use_ssl = uri.scheme.eql?('https')
         # set http options in callback, such as timeout and cert. verification
-        @@global[:session_cb]&.call(http_session)
+        RestParameters.instance.session_cb&.call(http_session)
         # manually start session for keep alive (if supported by server, else, session is closed every time)
         http_session.start
         return http_session
@@ -142,19 +163,6 @@ module Aspera
         return result
       end
 
-      # set global parameters
-      def set_parameters(**options)
-        options.each do |key, value|
-          Aspera.assert(@@global.key?(key)){"Unknown Rest option #{key}"}
-          @@global[key] = value
-        end
-      end
-
-      # @return [String] HTTP agent name
-      def user_agent
-        return @@global[:user_agent]
-      end
-
       def parse_header(header)
         type, *params = header.split(/;\s*/)
         parameters = params.map do |param|
@@ -179,19 +187,23 @@ module Aspera
 
     public
 
-    attr_reader :auth_params
     attr_reader :base_url
+    attr_reader :auth_params
 
+    # @return creation parameters
     def params
       return {
-        base_url:       @base_url,
-        auth:           @auth_params,
-        not_auth_codes: @not_auth_codes,
-        redirect_max:   @redirect_max,
-        headers:        @headers
+        base_url:       @base_url,       # String
+        auth:           @auth_params,    # Hash
+        not_auth_codes: @not_auth_codes, # Array
+        redirect_max:   @redirect_max,   # Integer
+        headers:        @headers         # Hash
       }
     end
 
+    # Create a REST object for API calls
+    # HTTP sessions parameters can be modified using global parameters in RestParameters
+    # For example, TLS verification can be skipped.
     # @param base_url [String] base URL of REST API
     # @param auth [Hash] authentication parameters:
     #     :type (:none, :basic, :url, :oauth2)
@@ -199,14 +211,15 @@ module Aspera
     #     :password   [:basic]
     #     :url_query  [:url]    a hash
     #     :*          [:oauth2] see OAuth::Factory class
-    # @param not_auth_codes [Array] codes that trigger a refresh/regeneration of bearer token
-    # @param redirect_max [int] max redirection allowed
+    # @param not_auth_codes [Array]   codes that trigger a refresh/regeneration of bearer token
+    # @param redirect_max   [Integer] max redirection allowed
+    # @param headers        [Hash]    default headers to include in all calls
     def initialize(
       base_url:,
-      auth: nil,
-      not_auth_codes: nil,
+      auth: {type: :none},
+      not_auth_codes: ['401'],
       redirect_max: 0,
-      headers: nil
+      headers: {}
     )
       Aspera.assert_type(base_url, String)
       # base url with no trailing slashes (note: string may be frozen)
@@ -216,19 +229,20 @@ module Aspera
       @base_url = @base_url.gsub(/:80$/, '') if @base_url.start_with?('http://')
       Log.log.debug{"Rest.new(#{@base_url})"}
       # default is no auth
-      @auth_params = auth.nil? ? {type: :none} : auth
+      @auth_params = auth
       Aspera.assert_type(@auth_params, Hash)
       Aspera.assert(@auth_params.key?(:type)){'no auth type defined'}
-      @not_auth_codes = not_auth_codes.nil? ? ['401'] : not_auth_codes
+      @not_auth_codes = not_auth_codes
       Aspera.assert_type(@not_auth_codes, Array)
       # persistent session
       @http_session = nil
-      # OAuth object (created on demand)
-      @oauth = nil
       @redirect_max = redirect_max
-      @headers = headers.nil? ? {} : headers
+      Aspera.assert_type(@redirect_max, Integer)
+      @headers = headers
       Aspera.assert_type(@headers, Hash)
-      @headers['User-Agent'] ||= @@global[:user_agent]
+      @headers['User-Agent'] ||= RestParameters.instance.user_agent
+      # OAuth object (created on demand)
+      @oauth = nil
     end
 
     # @return the OAuth object (create, or cached if already created)
@@ -263,6 +277,8 @@ module Aspera
     )
       subpath = subpath.to_s if subpath.is_a?(Symbol)
       subpath = '' if subpath.nil?
+      Log.log.debug{"#{operation} [#{subpath}]".red.bold.bg_green}
+      Log.log.debug{Log.dump(:body, body)}
       Aspera.assert_type(subpath, String)
       if headers.nil?
         headers = @headers.clone
@@ -272,7 +288,6 @@ module Aspera
         headers.merge!(h)
       end
       Aspera.assert_type(headers, Hash)
-      Log.log.debug{"#{operation} [#{subpath}]".red.bold.bg_green}
       case @auth_params[:type]
       when :none
         # no auth
@@ -322,11 +337,13 @@ module Aspera
         end
         # :type = :basic
         req.basic_auth(@auth_params[:username], @auth_params[:password]) if @auth_params[:type].eql?(:basic)
-        Log.log.debug{Log.dump(:req_body, req.body)}
+        Log.log.trace1{Log.dump(:req_body, req.body)}
         # we try the call, and will retry only if oauth, as we can, first with refresh, and then re-auth if refresh is bad
         oauth_tries ||= 2
+        timeout_tries ||= 5
+        general_tries ||= 1 + RestParameters.instance.retry_on_error
         # initialize with number of initial retries allowed, nil gives zero
-        tries_remain_redirect = @redirect_max.to_i if tries_remain_redirect.nil?
+        tries_remain_redirect = @redirect_max if tries_remain_redirect.nil?
         Log.log.debug("send request (retries=#{tries_remain_redirect})")
         result_mime = nil
         file_saved = false
@@ -350,38 +367,44 @@ module Aspera
               end
             end
             # download with temp filename
-            target_file_tmp = "#{target_file}#{@@global[:download_partial_suffix]}"
+            target_file_tmp = "#{target_file}#{RestParameters.instance.download_partial_suffix}"
             Log.log.debug{"saving to: #{target_file}"}
             written_size = 0
-            @@global[:progress_bar]&.event(session_id: 1, type: :session_start)
-            @@global[:progress_bar]&.event(session_id: 1, type: :session_size, info: total_size)
+            session_id = SecureRandom.uuid.freeze
+            RestParameters.instance.progress_bar&.event(:session_start, session_id: session_id)
+            RestParameters.instance.progress_bar&.event(:session_size, session_id: session_id, info: total_size)
             File.open(target_file_tmp, 'wb') do |file|
               result[:http].read_body do |fragment|
                 file.write(fragment)
                 written_size += fragment.length
-                @@global[:progress_bar]&.event(session_id: 1, type: :transfer, info: written_size)
+                RestParameters.instance.progress_bar&.event(:transfer, session_id: session_id, info: written_size)
               end
             end
-            @@global[:progress_bar]&.event(session_id: 1, type: :end)
+            RestParameters.instance.progress_bar&.event(:end, session_id: session_id)
             # rename at the end
             File.rename(target_file_tmp, target_file)
             file_saved = true
           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 ?
         # result[:http].body.force_encoding('UTF-8') if result[:http].body.is_a?(String)
         # Log.log.debug{"result: body=#{result[:http].body}"}
-        result[:data] = case result_mime
+        case result_mime
         when *JSON_DECODE
-          JSON.parse(result[:http].body) rescue result[:http].body
+          result[:data] = JSON.parse(result[:http].body) rescue result[:http].body
+          Log.log.debug{Log.dump('result_data', result[:data])}
         else # when 'text/plain'
-          result[:http].body
+          result[:data] = result[:http].body
         end
-        Log.log.debug{"result: code=#{result[:http].code} mime=#{result_mime}"}
-        Log.log.debug{Log.dump('data', result[:data])}
         RestErrorAnalyzer.instance.raise_on_error(req, result)
-        File.write(save_to_file, result[:http].body) unless file_saved || save_to_file.nil?
+        File.write(save_to_file, result[:http].body, binmode: true) unless file_saved || save_to_file.nil?
       rescue RestCallError => e
+        do_retry = false
+        # AoC have some timeout , like Connect to platform.bss.asperasoft.com:443 ...
+        do_retry = true if e.response.body.include?('failed: connect timed out') && (timeout_tries -= 1).positive?
+        # possibility to retry anything if it fails
+        do_retry = true if (general_tries -= 1).positive?
         # not authorized: oauth token expired
         if @not_auth_codes.include?(result[:http].code.to_s) && @auth_params[:type].eql?(:oauth2)
           begin
@@ -394,7 +417,11 @@ module Aspera
             req['Authorization'] = oauth.token(refresh: true)
           end
           Log.log.debug{"using new token=#{headers['Authorization']}"}
-          retry if (oauth_tries -= 1).nonzero?
+          do_retry = true if (oauth_tries -= 1).positive?
+        end
+        if do_retry
+          sleep(RestParameters.instance.retry_sleep) unless RestParameters.instance.retry_sleep.nil?
+          retry
         end
         # redirect ? (any code beginning with 3)
         if e.response.is_a?(Net::HTTPRedirection) && tries_remain_redirect.positive?
@@ -420,27 +447,28 @@ module Aspera
     end
 
     #
-    # CRUD methods here
+    # CRUD simplified methods here
+    # If specific elements are needed, then use the full `call` method
     #
 
     def create(subpath, params)
-      return call(operation: 'POST', subpath: subpath, headers: {'Accept' => 'application/json'}, body: params, body_type: :json)
+      return call(operation: 'POST', subpath: subpath, headers: {'Accept' => 'application/json'}, body: params, body_type: :json)[:data]
     end
 
     def read(subpath, query=nil)
-      return call(operation: 'GET', subpath: subpath, headers: {'Accept' => 'application/json'}, query: query)
+      return call(operation: 'GET', subpath: subpath, headers: {'Accept' => 'application/json'}, query: query)[:data]
     end
 
     def update(subpath, params)
-      return call(operation: 'PUT', subpath: subpath, headers: {'Accept' => 'application/json'}, body: params, body_type: :json)
+      return call(operation: 'PUT', subpath: subpath, headers: {'Accept' => 'application/json'}, body: params, body_type: :json)[:data]
     end
 
     def delete(subpath, params=nil)
-      return call(operation: 'DELETE', subpath: subpath, headers: {'Accept' => 'application/json'}, query: params)
+      return call(operation: 'DELETE', subpath: subpath, headers: {'Accept' => 'application/json'}, query: params)[:data]
     end
 
     def cancel(subpath)
-      return call(operation: 'CANCEL', subpath: subpath, headers: {'Accept' => 'application/json'})
+      return call(operation: 'CANCEL', subpath: subpath, headers: {'Accept' => 'application/json'})[:data]
     end
 
     # Query entity by general search (read with parameter `q`)
@@ -449,9 +477,10 @@ module Aspera
     # @param search_name name of searched entity
     # @param query additional search query parameters
     # @returns [Hash] A single entity matching the search, or an exception if not found or multiple found
-    def lookup_by_name(subpath, search_name, query={})
+    def lookup_by_name(subpath, search_name, query: nil)
+      query = {} if query.nil?
       # returns entities matching the query (it matches against several fields in case insensitive way)
-      matching_items = read(subpath, query.merge({'q' => search_name}))[:data]
+      matching_items = read(subpath, query.merge({'q' => search_name}))
       # API style: {totalcount:, ...} cspell: disable-line
       matching_items = matching_items[subpath] if matching_items.is_a?(Hash)
       Aspera.assert_type(matching_items, Array)

data/lib/aspera/secret_hider.rb

@@ -20,6 +20,8 @@ module Aspera
     KEY_FALSE_POSITIVES = [/^access_key$/, /^fallback_private_key$/].freeze
     # regex that define named captures :begin and :end
     REGEX_LOG_REPLACES = [
+      # private key values (place first)
+      /(?<begin>--+BEGIN [^-]+ KEY--+)[[:ascii:]]+?(?<end>--+?END [^-]+ KEY--+)\n*/,
       # CLI manager get/set options
       /(?<begin>[sg]et (?:#{KEY_SECRETS.join('|')})=).*(?<end>)/,
       # env var ascp exec
@@ -28,8 +30,6 @@ module Aspera
       /(?<begin>(?:(?<quote>["'])|:)[^"':=]*(?:#{ALL_SECRETS.join('|')})[^"':=]*\k<quote>?(?:=>|:) *")[^"]+(?<end>")/,
       # logged data
       /(?<begin>(?:#{ALL_SECRETS2.join('|')})[ =:]+).*(?<end>$)/,
-      # private key values
-      /(?<begin>--+BEGIN [^-]+ KEY--+)[[:ascii:]]+?(?<end>--+?END [^-]+ KEY--+)/,
       # cred in http dump
       /(?<begin>(?:#{HTTP_SECRETS.join('|')}): )[^\\]+(?<end>\\)/i
     ].freeze

data/lib/aspera/ssh.rb

@@ -1,33 +1,41 @@
 # frozen_string_literal: true
 
 require 'net/ssh'
-
-if ENV.fetch('ASCLI_ENABLE_ED25519', 'false').eql?('false')
-  # HACK: deactivate ed25519 and ecdsa private keys from SSH identities, as it usually causes problems
-  old_verbose = $VERBOSE
-  $VERBOSE = nil
-  begin
-    module Net; module SSH; module Authentication; class Session; private; def default_keys; %w[~/.ssh/id_dsa ~/.ssh/id_rsa ~/.ssh2/id_dsa ~/.ssh2/id_rsa]; end; end; end; end; end # rubocop:disable Layout/AccessModifierIndentation, Layout/EmptyLinesAroundAccessModifier, Layout/LineLength, Style/Semicolon
-  rescue StandardError
-    # ignore errors
-  end
-  $VERBOSE = old_verbose
-end
-
-if defined?(JRUBY_VERSION) && ENV.fetch('ASCLI_ENABLE_ECDSHA2', 'false').eql?('false')
-  Net::SSH::Transport::Algorithms::ALGORITHMS.each_value { |a| a.reject! { |a| a =~ /^ecd(sa|h)-sha2/ } }
-  Net::SSH::KnownHosts::SUPPORTED_TYPE.reject! { |t| t =~ /^ecd(sa|h)-sha2/ }
-end
+require 'aspera/assert'
+require 'aspera/log'
 
 module Aspera
   # A simple wrapper around Net::SSH
   # executes one command and get its result from stdout
   class Ssh
+    class << self
+      def disable_ed25519_keys
+        Log.log.debug('Disabling SSH ed25519 user keys')
+        old_verbose = $VERBOSE
+        $VERBOSE = nil
+        Net::SSH::Authentication::Session.class_eval do
+          define_method(:default_keys) do
+            %w[~/.ssh/id_dsa ~/.ssh/id_rsa ~/.ssh2/id_dsa ~/.ssh2/id_rsa].freeze
+          end
+          private(:default_keys)
+        end rescue nil
+        $VERBOSE = old_verbose
+      end
+
+      def disable_ecd_sha2_algorithms
+        Log.log.debug('Disabling SSH ecdsa')
+        Net::SSH::Transport::Algorithms::ALGORITHMS.each_value { |a| a.reject! { |a| a =~ /^ecd(sa|h)-sha2/ } }
+        Net::SSH::KnownHosts::SUPPORTED_TYPE.reject! { |t| t =~ /^ecd(sa|h)-sha2/ }
+      end
+    end
     # ssh_options: same as Net::SSH.start
     # see: https://net-ssh.github.io/net-ssh/classes/Net/SSH.html#method-c-start
     def initialize(host, username, ssh_options)
       Log.log.debug{"ssh:#{username}@#{host}"}
       Log.log.debug{"ssh_options:#{ssh_options}"}
+      Aspera.assert_type(host, String)
+      Aspera.assert_type(username, String)
+      Aspera.assert_type(ssh_options, Hash)
       @host = host
       @username = username
       @ssh_options = ssh_options
@@ -35,10 +43,7 @@ module Aspera
     end
 
     def execute(cmd, input=nil)
-      if cmd.is_a?(Array)
-        # concatenate arguments, enclose in double quotes
-        cmd = cmd.map{|v|%Q("#{v}")}.join(' ')
-      end
+      Aspera.assert_type(cmd, String)
       Log.log.debug{"cmd=#{cmd}"}
       response = []
       Net::SSH.start(@host, @username, @ssh_options) do |session|
@@ -49,9 +54,7 @@ module Aspera
           channel.on_extended_data do |_chan, _type, data|
             error_message = "#{cmd}: [#{data.chomp}]"
             # Happens when windows user hasn't logged in and created home account.
-            if data.include?('Could not chdir to home directory')
-              error_message += "\nHint: home not created in Windows?"
-            end
+            error_message += "\nHint: home not created in Windows?" if data.include?('Could not chdir to home directory')
             raise error_message
           end
           # send command to SSH channel (execute) cspell: disable-next-line
@@ -67,3 +70,7 @@ module Aspera
     end
   end
 end
+
+# HACK: deactivate ed25519 and ecdsa private keys from SSH identities, as it usually causes problems
+Aspera::Ssh.disable_ed25519_keys if ENV.fetch('ASCLI_ENABLE_ED25519', 'false').eql?('false')
+Aspera::Ssh.disable_ecd_sha2_algorithms if defined?(JRUBY_VERSION) && ENV.fetch('ASCLI_ENABLE_ECDSHA2', 'false').eql?('false')

data/lib/aspera/transfer/faux_file.rb

@@ -13,16 +13,16 @@ module Aspera
         # @return nil if not a faux: scheme, else a FauxFile instance
         def create(name)
           return nil unless name.start_with?(PREFIX)
-          url_parts = name[PREFIX.length..-1].split('?')
-          raise 'Format: #{PREFIX}<file path>?<size>' unless url_parts.length.eql?(2)
-          raise "Format: <integer>[#{SUFFIX.join(',')}]" unless (m = url_parts[1].downcase.match(/^(\d+)([#{SUFFIX.join('')}])$/))
+          name_params = name[PREFIX.length..-1].split('?', 2)
+          raise 'Format: #{PREFIX}<file path>?<size>' unless name_params.length.eql?(2)
+          raise "Format: <integer>[#{SUFFIX.join(',')}]" unless (m = name_params[1].downcase.match(/^(\d+)([#{SUFFIX.join('')}])$/))
           size = m[1].to_i
           suffix = m[2]
           SUFFIX.each do |s|
             size *= 1024
             break if s.eql?(suffix)
           end
-          return FauxFile.new(url_parts[0], size)
+          return FauxFile.new(name_params[0], size)
         end
       end
       attr_reader :path, :size

data/lib/aspera/transfer/parameters.rb

@@ -8,6 +8,7 @@ require 'aspera/transfer/error'
 require 'aspera/transfer/spec'
 require 'aspera/ascp/installation'
 require 'aspera/cli/formatter'
+require 'aspera/agent/base'
 require 'aspera/rest'
 require 'securerandom'
 require 'base64'
@@ -20,7 +21,7 @@ module Aspera
     # translate transfer specification to ascp parameter list
     class Parameters
       # Agents shown in manual for parameters (sub list)
-      SUPPORTED_AGENTS = %i[direct node connect trsdk httpgw].freeze
+      SUPPORTED_AGENTS = Agent::Base.agent_list.freeze
       FILE_LIST_OPTIONS = ['--file-list', '--file-pair-list'].freeze
       # Short names of columns in manual
       SUPPORTED_AGENTS_SHORT = SUPPORTED_AGENTS.map{|agent_sym|agent_sym.to_s[0].to_sym}
@@ -29,10 +30,21 @@ module Aspera
       private_constant :SUPPORTED_AGENTS, :FILE_LIST_OPTIONS
 
       class << self
+        # temp file list files are created here
+        def file_list_folder=(value)
+          @file_list_folder = value
+          return if @file_list_folder.nil?
+
+          FileUtils.mkdir_p(@file_list_folder)
+          TempFileManager.instance.cleanup_expired(@file_list_folder)
+        end
+
         # Temp folder for file lists, must contain only file lists
         # because of garbage collection takes any file there
-        # this could be refined, as , for instance, on macos, temp folder is already user specific
-        @file_list_folder = TempFileManager.instance.new_file_path_global('asession_filelists') # cspell:disable-line
+        # this could be refined, as, for example, on macos, temp folder is already user specific
+        def file_list_folder
+          @file_list_folder ||= TempFileManager.instance.new_file_path_global('asession_filelists')
+        end
 
         # @param formatter [Cli::Formatter] formatter to use
         # @return a table suitable to display in manual
@@ -67,9 +79,7 @@ module Aspera
               else
                 param[:d].eql?(tick_yes) ? '' : 'n/a'
               end
-            if options.key?(:enum)
-              param[:description] += "\nAllowed values: #{options[:enum].join(', ')}"
-            end
+            param[:description] += "\nAllowed values: #{options[:enum].join(', ')}" if options.key?(:enum)
             # replace "solidus" HTML entity with its text value
             param[:description] = param[:description].gsub('&sol;', '\\')
             result.push(param)
@@ -91,17 +101,6 @@ module Aspera
         def ascp_args_file_list?(ascp_args)
           ascp_args&.any?{|i|FILE_LIST_OPTIONS.include?(i)}
         end
-
-        # temp file list files are created here
-        def file_list_folder=(value)
-          @file_list_folder = value
-          return if @file_list_folder.nil?
-          FileUtils.mkdir_p(@file_list_folder)
-          TempFileManager.instance.cleanup_expired(@file_list_folder)
-        end
-
-        # static methods
-        attr_reader :file_list_folder
       end
 
       # @param options [Hash] key: :wss: bool, :ascp_args: array of strings

data/lib/aspera/transfer/spec.rb

@@ -10,34 +10,30 @@ module Aspera
     class Spec
       # default transfer username for access key based transfers
       ACCESS_KEY_TRANSFER_USER = 'xfer'
+      # default ports for SSH and UDP
       SSH_PORT = 33_001
       UDP_PORT = 33_001
+      # base transfer spec for access keys
       AK_TSPEC_BASE = {
         'remote_user' => ACCESS_KEY_TRANSFER_USER,
         'ssh_port'    => SSH_PORT,
         'fasp_port'   => UDP_PORT
       }.freeze
-      # fields for transport
-      TRANSPORT_FIELDS = %w[remote_host remote_user ssh_port fasp_port wss_enabled wss_port].freeze
+      # fields for WSS
+      WSS_FIELDS = %w[wss_enabled wss_port].freeze
+      # all fields for transport
+      TRANSPORT_FIELDS = %w[remote_host remote_user ssh_port fasp_port].concat(WSS_FIELDS).freeze
       # reserved tag for Aspera
       TAG_RESERVED = 'aspera'
       class << self
         # translate upload/download to send/receive
         def transfer_type_to_direction(transfer_type)
-          case transfer_type.to_sym
-          when :upload then DIRECTION_SEND
-          when :download then DIRECTION_RECEIVE
-          else Aspera.error_unexpected_value(transfer_type.to_sym)
-          end
+          XFER_TYPE_TO_DIR.fetch(transfer_type)
         end
 
         # translate send/receive to upload/download
         def direction_to_transfer_type(direction)
-          case direction
-          when DIRECTION_SEND then :upload
-          when DIRECTION_RECEIVE then :download
-          else Aspera.error_unexpected_value(direction)
-          end
+          XFER_DIR_TO_TYPE.fetch(direction)
         end
       end
       DESCRIPTION = CommandLineBuilder.normalize_description(YAML.load_file("#{__FILE__[0..-3]}yaml"))
@@ -49,6 +45,10 @@ module Aspera
           const_set("#{name.to_s.upcase}_#{enum.upcase.gsub(/[^A-Z0-9]/, '_')}", enum.freeze)
         end
       end
+      # DIRECTION_* are read from yaml
+      XFER_TYPE_TO_DIR = {upload: DIRECTION_SEND, download: DIRECTION_RECEIVE}.freeze
+      XFER_DIR_TO_TYPE = XFER_TYPE_TO_DIR.invert.freeze
+      private_constant :XFER_TYPE_TO_DIR, :XFER_DIR_TO_TYPE
     end
   end
 end