aspera-cli 4.22.0 → 4.23.0

data/lib/aspera/cli/plugins/node.rb

@@ -21,6 +21,7 @@ module Aspera
     module Plugins
       class Node < Cli::BasicAuthPlugin
         include SyncActions
+
         class << self
           # directory: node, container: shares
           FOLDER_TYPES = %w[directory container].freeze
@@ -849,7 +850,6 @@ module Aspera
             case command
             when :list
               transfer_filter = query_read_delete(default: {})
-              last_iteration_token = nil
               iteration_persistency = nil
               if options.get_option(:once_only, mandatory: true)
                 iteration_persistency = PersistencyActionOnce.new(
@@ -865,35 +865,10 @@ module Aspera
                   iteration_persistency.save
                   return Main.result_status('Persistency reset')
                 end
-                last_iteration_token = iteration_persistency.data.first
               end
               raise Cli::BadArgument, 'reset only with once_only' if transfer_filter.key?('reset') && iteration_persistency.nil?
               max_items = transfer_filter.delete(MAX_ITEMS)
-              transfers_data = []
-              loop do
-                transfer_filter['iteration_token'] = last_iteration_token unless last_iteration_token.nil?
-                result = @api_node.call(operation: 'GET', subpath: 'ops/transfers', query: transfer_filter)
-                # no data
-                break if result[:data].empty?
-                # get next iteration token from link
-                next_iteration_token = nil
-                link_info = result[:http]['Link']
-                unless link_info.nil?
-                  m = link_info.match(/<([^>]+)>/)
-                  raise "Cannot parse iteration in Link: #{link_info}" if m.nil?
-                  next_iteration_token = CGI.parse(URI.parse(m[1]).query)['iteration_token']&.first
-                end
-                # same as last iteration: stop
-                break if next_iteration_token&.eql?(last_iteration_token)
-                last_iteration_token = next_iteration_token
-                transfers_data.concat(result[:data])
-                if max_items&.<=(transfers_data.length)
-                  transfers_data = transfers_data.slice(0, max_items)
-                  break
-                end
-                break if last_iteration_token.nil?
-              end
-              iteration_persistency&.data&.[]=(0, last_iteration_token)
+              transfers_data = call_with_iteration(api: @api_node, operation: 'GET', subpath: 'ops/transfers', max: max_items, query: transfer_filter, iteration: iteration_persistency&.data)
               iteration_persistency&.save
               return {
                 type:   :object_list,
@@ -1077,7 +1052,7 @@ module Aspera
             return Main.result_status('Simulator terminated')
           when :telemetry
             parameters = value_create_modify(command: command, default: {}).symbolize_keys
-            %i[url apikey].each do |psym|
+            %i[url key].each do |psym|
               raise Cli::BadArgument, "Missing parameter: #{psym}" unless parameters.key?(psym)
             end
             require 'socket'
@@ -1085,79 +1060,69 @@ module Aspera
             parameters[:hostname] = Socket.gethostname unless parameters.key?(:hostname)
             interval = parameters[:interval].to_f
             raise Cli::BadArgument, 'Interval must be a positive number in seconds' if interval <= 0
-            backend_api = Rest.new(
+            otel_api = Rest.new(
               base_url: "#{parameters[:url]}/v1",
               headers: {
-                # 'Authorization'  => "apiToken #{parameters[:apikey]}",
-                'x-instana-key'  => parameters[:apikey],
+                # 'Authorization'  => "apiToken #{parameters[:key]}",
+                'x-instana-key'  => parameters[:key],
                 'x-instana-host' => parameters[:hostname]
               }
             )
-
-            loop do
-              start_time = Time.now
-              transfer_filter = {active_only: true}
-              transfers_data = []
-              loop do
-                result = @api_node.call(operation: 'GET', subpath: 'ops/transfers', query: transfer_filter)
-                # no data
-                break if result[:data].empty?
-                # get next iteration token from link
-                next_iteration_token = nil
-                link_info = result[:http]['Link']
-                unless link_info.nil?
-                  m = link_info.match(/<([^>]+)>/)
-                  Aspera.assert(m){"Cannot parse iteration in Link: #{link_info}"}
-                  next_iteration_token = CGI.parse(URI.parse(m[1]).query)['iteration_token']&.first
-                end
-                # same as last iteration: stop
-                break if next_iteration_token&.eql?(transfer_filter[:iteration_token])
-                transfer_filter[:iteration_token] = next_iteration_token
-                transfers_data.concat(result[:data])
-                break if next_iteration_token.nil?
-              end
-              puts("#{transfers_data.length} active transfers")
-              epoch_nsec = start_time.to_i * 1_000_000_000 + start_time.nsec
-              # https://www.ibm.com/docs/en/instana-observability/current?topic=instana-backend
-              backend_api.create('metrics', {
-                resourceMetrics: [
-                  {
-                    resource:     {
-                      attributes: [
+            datapoint = {
+              attributes:   [
+                {
+                  key:   'server.name',
+                  value: {
+                    stringValue: 'HSTS1'
+                  }
+                }
+              ],
+              asInt:        nil,
+              timeUnixNano: nil
+            }
+            # https://opentelemetry.io/docs/specs/otel/metrics/data-model/#gauge
+            metrics = {
+              resourceMetrics: [
+                {
+                  resource:     {
+                    attributes: [
+                      {
+                        key:   'service.name',
+                        value: {
+                          stringValue: 'IBMAspera'
+                        }
+                      }
+                    ]
+                  },
+                  scopeMetrics: [
+                    {
+                      metrics: [
                         {
-                          key:   'service.name',
-                          value: {
-                            stringValue: 'mycurl5'
+                          name:        'active.transfers',
+                          description: 'Number of active transfers',
+                          unit:        '1',
+                          gauge:       {
+                            dataPoints: [
+                              datapoint
+                            ]
                           }
                         }
                       ]
-                    },
-                    scopeMetrics: [
-                      {
-                        metrics: [
-                          {
-                            name:        'tutur2',
-                            unit:        '1',
-                            description: '',
-                            sum:         {
-                              aggregationTemporality: 1,
-                              isMonotonic:            true,
-                              dataPoints:             [
-                                {
-                                  asDouble:          4,
-                                  startTimeUnixNano: epoch_nsec,
-                                  timeUnixNano:      epoch_nsec
-                                }
-                              ]
-                            }
-                          }
-                        ]
-                      }
-                    ]
-                  }
-                ]
-              })
-              sleep([0, interval - (Time.now - start_time)].max)
+                    }
+                  ]
+                }
+              ]
+            }
+            loop do
+              timestamp = Time.now
+              transfers_data = call_with_iteration(api: @api_node, operation: 'GET', subpath: 'ops/transfers', query: {active_only: true})
+              datapoint[:asInt] = transfers_data.length
+              datapoint[:timeUnixNano] = timestamp.to_i * 1_000_000_000 + timestamp.nsec
+              Log.log.info("#{datapoint[:asInt]} active transfers")
+              # https://www.ibm.com/docs/en/instana-observability/current?topic=instana-backend
+              otel_api.create('metrics', metrics)
+              break if interval.eql?(0.0)
+              sleep([0.0, interval - (Time.now - timestamp)].max)
             end
           end
           Aspera.error_unreachable_line
@@ -1178,6 +1143,45 @@ module Aspera
           return path_arg if @prefix_path.nil?
           return File.join(@prefix_path, path_arg)
         end
+
+        # Executes the provided API call in loop
+        # @param api [Rest]  the API to call
+        # @param iteration [Array] a single element array with the iteration token or nil
+        # @param max [Integer] maximum number of items to return, or nil for no limit
+        # @param query [Hash] query parameters to use for the API call
+        # @param call_args [Hash] additional arguments to pass to the API call
+        # @return [Array] list of items returned by the API call
+        def call_with_iteration(api:, iteration: nil, max: nil, query: nil, **call_args)
+          query_token = query.clone || {}
+          item_list = []
+          query_token[:iteration_token] = iteration.first if iteration.is_a?(Array)
+          loop do
+            result = api.call(**call_args, query: query_token)
+            Aspera.assert_type(result[:data], Array){"Expected data to be an Array, got: #{result[:data].class}"}
+            # no data
+            break if result[:data].empty?
+            # get next iteration token from link
+            next_iteration_token = nil
+            link_info = result[:http]['Link']
+            unless link_info.nil?
+              m = link_info.match(/<([^>]+)>/)
+              Aspera.assert(m){"Cannot parse iteration in Link: #{link_info}"}
+              next_iteration_token = CGI.parse(URI.parse(m[1]).query)['iteration_token']&.first
+            end
+            # same as last iteration: stop
+            break if next_iteration_token&.eql?(query_token[:iteration_token])
+            query_token[:iteration_token] = next_iteration_token
+            item_list.concat(result[:data])
+            if max&.<=(item_list.length)
+              item_list = item_list.slice(0, max)
+              break
+            end
+            break if next_iteration_token.nil?
+          end
+          # save iteration token if needed
+          iteration[0] = query_token[:iteration_token] unless iteration.nil?
+          item_list
+        end
       end
     end
   end

data/lib/aspera/cli/plugins/server.rb

@@ -19,6 +19,7 @@ module Aspera
       # implement basic remote access with FASP/SSH
       class Server < Cli::BasicAuthPlugin
         include SyncActions
+
         SSH_SCHEME = 'ssh'
         LOCAL_SCHEME = 'local'
         HTTPS_SCHEME = 'https'

data/lib/aspera/cli/transfer_agent.rb

@@ -88,14 +88,6 @@ module Aspera
       # add other transfer spec parameters
       def option_transfer_spec_deep_merge(ts); @transfer_spec_command_line.deep_merge!(ts); end
 
-      # @return [Hash] transfer spec with updated values from command line, including removed values
-      def updated_ts(transfer_spec={})
-        transfer_spec.deep_merge!(@transfer_spec_command_line)
-        # recursively remove values that are nil (user wants to delete)
-        transfer_spec.deep_do{ |hash, key, value, _unused| hash.delete(key) if value.nil?}
-        return transfer_spec
-      end
-
       attr_reader :transfer_info
 
       # multiple option are merged
@@ -173,9 +165,10 @@ module Aspera
 
       # This is how the list of files to be transferred is specified
       # get paths suitable for transfer spec from command line
+      # @param default [String] if set, used as default file for --sources=@args
       # @return [Hash] {source: (mandatory), destination: (optional)}
       # computation is done only once, cache is kept in @transfer_paths
-      def ts_source_paths
+      def ts_source_paths(default: nil)
         # return cache if set
         return @transfer_paths unless @transfer_paths.nil?
         # start with lower priority : get paths from transfer spec on command line
@@ -185,8 +178,9 @@ module Aspera
         case file_list
         when nil, FILE_LIST_FROM_ARGS
           Log.log.debug('getting file list as parameters')
+          Aspera.assert_type(default, Array) unless default.nil?
           # get remaining arguments
-          file_list = @opt_mgr.get_next_argument('source file list', multiple: true)
+          file_list = @opt_mgr.get_next_argument('source file list', multiple: true, default: default)
           raise Cli::BadArgument, 'specify at least one file on command line or use ' \
             "--sources=#{FILE_LIST_FROM_TRANSFER_SPEC} to use transfer spec" if !file_list.is_a?(Array) || file_list.empty?
         when FILE_LIST_FROM_TRANSFER_SPEC
@@ -252,7 +246,9 @@ module Aspera
         # update command line paths, unless destination already has one
         @transfer_spec_command_line['paths'] = transfer_spec['paths'] || ts_source_paths
         # updated transfer spec with command line
-        updated_ts(transfer_spec)
+        transfer_spec.deep_merge!(@transfer_spec_command_line)
+        # recursively remove values that are nil (user wants to delete)
+        transfer_spec.deep_do{ |hash, key, value, _unused| hash.delete(key) if value.nil?}
         # if TS from app has content_protection (e.g. F5), that means content is protected: ask password if not provided
         if transfer_spec['content_protection'].eql?('decrypt') && !transfer_spec.key?('content_protection_password')
           transfer_spec['content_protection_password'] = @opt_mgr.prompt_user_input('content protection password', sensitive: true)

data/lib/aspera/cli/version.rb

@@ -4,6 +4,6 @@ module Aspera
   module Cli
     # for beta add extension : .beta1
     # for dev version add extension : .pre
-    VERSION = '4.22.0'
+    VERSION = '4.23.0'
   end
 end

data/lib/aspera/data_repository.rb

@@ -8,6 +8,7 @@ module Aspera
   # a simple binary data repository
   class DataRepository
     include Singleton
+
     # in same order as elements in folder
     ELEMENTS = %i[dsa rsa uuid aspera.global-cli-client aspera.drive license]
     START_INDEX = 1

data/lib/aspera/environment.rb

@@ -13,6 +13,7 @@ module Aspera
   # detect OS, architecture, and specific stuff
   class Environment
     include Singleton
+
     USER_INTERFACES = %i[text graphical].freeze
 
     OS_WINDOWS = :windows

data/lib/aspera/log.rb

@@ -48,6 +48,7 @@ module Aspera
   # Singleton object for logging
   class Log
     include Singleton
+
     # Where logs are sent to
     LOG_TYPES = %i[stderr stdout syslog].freeze
     @@format = :json # rubocop:disable Style/ClassVars

data/lib/aspera/oauth/base.rb

@@ -54,6 +54,8 @@ module Aspera
         @token_cache_id = Factory.cache_id(@api.base_url, self.class, @base_cache_ids, @scope)
       end
 
+      attr_reader :scope
+
       # helper method to create token as per RFC
       def create_token_call(creation_params)
         Log.log.debug{'Generating a new token'.bg_green}

data/lib/aspera/oauth/factory.rb

@@ -9,6 +9,7 @@ module Aspera
     # Factory to create tokens and manage their cache
     class Factory
       include Singleton
+
       # a prefix for persistency of tokens (simplify garbage collect)
       PERSIST_CATEGORY_TOKEN = 'token'
       # prefix for bearer token when in header

data/lib/aspera/preview/file_types.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'aspera/log'
+require 'aspera/assert'
 require 'singleton'
 require 'mime/types'
 
@@ -9,6 +10,7 @@ module Aspera
     # function conversion_type returns one of the types: CONVERSION_TYPES
     class FileTypes
       include Singleton
+
       # values for conversion_type : input format
       CONVERSION_TYPES = %i[image office pdf plaintext video].freeze
 
@@ -22,6 +24,8 @@ module Aspera
         'application/mxf'                    => :video,
         'application/mac-binhex40'           => :office,
         'application/msword'                 => :office,
+        'application/vnd.ms-excel'           => :office,
+        'application/vnd.ms-powerpoint'      => :office,
         'application/rtf'                    => :office,
         'application/x-abiword'              => :office,
         'application/x-mspublisher'          => :office,
@@ -56,17 +60,43 @@ module Aspera
       end
 
       # @param mimetype [String] mime type
-      # @return file type, one of enum CONVERSION_TYPES
+      # @return file type, one of enum CONVERSION_TYPES, or nil if not found
       def mime_to_type(mimetype)
+        Aspera.assert_type(mimetype, String)
         return SUPPORTED_MIME_TYPES[mimetype] if SUPPORTED_MIME_TYPES.key?(mimetype)
-        return :office if mimetype.start_with?('application/vnd.')
+        return :office if mimetype.start_with?('application/vnd.ms-')
+        return :office if mimetype.start_with?('application/vnd.openxmlformats-officedocument')
         return :video if mimetype.start_with?('video/')
         return :image if mimetype.start_with?('image/')
         return nil
       end
 
-      # use mime magic to find mime type based on file content (magic numbers)
-      def file_to_mime(filepath)
+      # @param filepath [String] full path to file
+      # @param mimetype [String] provided by node API
+      # @return 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})"}
+        mimetype = nil if mimetype.is_a?(String) && (mimetype == 'application/octet-stream' || mimetype.empty?)
+        # Use mimemagic if available
+        mimetype ||= mime_using_mimemagic(filepath)
+        mimetype ||= mime_using_file(filepath)
+        # from extensions, using local mapping
+        mimetype ||= MIME::Types.of(File.basename(filepath)).first
+        raise "no MIME type found for #{File.basename(filepath)}" if mimetype.nil?
+        conversion_type = mime_to_type(mimetype)
+        raise "no conversion type found for #{File.basename(filepath)}" if conversion_type.nil?
+        Log.log.trace1{"conversion_type(#{File.basename(filepath)}): #{conversion_type.class.name} [#{conversion_type}]"}
+        return conversion_type
+      end
+
+      private
+
+      # Use mime magic to find mime type based on file content (magic numbers)
+      # @param filepath [String] full path to file
+      # @return [String] mime type, or nil if not found
+      def mime_using_mimemagic(filepath)
+        return unless @use_mimemagic
         # moved here, as `mimemagic` can cause installation issues
         require 'mimemagic'
         require 'mimemagic/version'
@@ -83,35 +113,12 @@ module Aspera
         return detected_mime
       end
 
-      # @param filepath [String] full path to file
-      # @param mimetype [String] provided by node API
-      # @return 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},m=#{mimetype},t=#{@use_mimemagic})"}
-        # 1- get type from provided mime type, using local mapping
-        conversion_type = mime_to_type(mimetype) if !mimetype.nil?
-        # 2- else, from computed mime type (if available)
-        if conversion_type.nil? && @use_mimemagic
-          detected_mime = file_to_mime(filepath)
-          if !detected_mime.nil?
-            conversion_type = mime_to_type(detected_mime)
-            if !mimetype.nil?
-              if mimetype.eql?(detected_mime)
-                Log.log.debug('matching mime type per magic number')
-              else
-                # NOTE: detected can be nil
-                Log.log.debug{"non matching mime types: node=[#{mimetype}], magic=[#{detected_mime}]"}
-              end
-            end
-          end
-        end
-        # 3- else, from extensions, using local mapping
-        mime_by_ext = MIME::Types.of(File.basename(filepath)).first
-        conversion_type = mime_to_type(mime_by_ext.to_s) if conversion_type.nil? && !mime_by_ext.nil?
-        raise "no conversion type found for #{File.basename(filepath)}" if conversion_type.nil?
-        Log.log.trace1{"conversion_type(#{File.basename(filepath)}): #{conversion_type.class.name} [#{conversion_type}]"}
-        return conversion_type
+      # Use 'file' command to find mime type based on file content (Unix)
+      def mime_using_file(filepath)
+        return Environment.secure_capture(exec: 'file', args: ['--mime-type', '--brief', filepath]).strip
+      rescue => e
+        Log.log.error{"error using 'file' command: #{e.message}"}
+        return nil
       end
     end
   end

data/lib/aspera/preview/generator.rb

@@ -240,7 +240,7 @@ module Aspera
       # text to png
       def convert_plaintext_to_png
         # get 100 first lines of text file
-        first_lines = File.open(@source_file_path){ |f| Array.new(100){f.readline rescue ''}.join}
+        first_lines = File.foreach(@source_file_path).first(100).join
         Utils.external_command(:magick, [
           'convert',
           '-size', "#{@options.thumb_img_size}x#{@options.thumb_img_size}",

data/lib/aspera/products/connect.rb

@@ -7,6 +7,7 @@ module Aspera
   module Products
     class Connect
       include Singleton
+
       APP_NAME = 'IBM Aspera Connect'
 
       class << self

data/lib/aspera/rest.rb

@@ -6,12 +6,14 @@ require 'aspera/log'
 require 'aspera/assert'
 require 'aspera/oauth'
 require 'aspera/hash_ext'
+require 'aspera/timer_limiter'
 require 'net/http'
 require 'net/https'
 require 'json'
 require 'base64'
 require 'singleton'
 require 'securerandom'
+require 'fileutils'
 
 # Cancel method for HTTP
 class Net::HTTP::Cancel < Net::HTTPRequest # rubocop:disable Style/ClassAndModuleChildren
@@ -172,6 +174,10 @@ module Aspera
         return result
       end
 
+      # Parse a header string as returned by HTTP
+      # @param header [String] header string, e.g. "application/json; charset=utf-8"
+      # @return [Hash] parsed header with type and parameters
+      #   {type: 'application/json', parameters: {charset: 'utf-8'}}
       def parse_header(header)
         type, *params = header.split(/;\s*/)
         parameters = params.map do |param|
@@ -358,18 +364,18 @@ module Aspera
         http_session.request(req) do |response|
           result[:http] = response
           result_mime = self.class.parse_header(result[:http]['Content-Type'] || MIME_TEXT)[:type]
+          Log.log.debug{"response: code=#{result[:http].code}, mime=#{result_mime}, mime2= #{response['Content-Type']}"}
           # 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') &&
-              !result[:http]['Content-Length'].nil? &&
               !JSON_DECODE.include?(result_mime)
-            total_size = result[:http]['Content-Length'].to_i
+            total_size = result[:http]['Content-Length']&.to_i
             Log.log.debug('before write file')
             target_file = save_to_file
             # override user's path to path in header
             if !response['Content-Disposition'].nil?
               disposition = self.class.parse_header(response['Content-Disposition'])
-              if disposition[:parameters].key?(:filename)
+              if disposition[:parameters].key?(:filename) && !disposition[:parameters][:filename].eql?('.')
                 target_file = File.join(File.dirname(target_file), disposition[:parameters][:filename])
               end
             end
@@ -379,12 +385,14 @@ module Aspera
             written_size = 0
             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)
+            RestParameters.instance.progress_bar&.event(:session_size, session_id: session_id, info: total_size) if total_size
+            FileUtils.mkdir_p(File.dirname(target_file_tmp))
+            limiter = TimerLimiter.new(0.5)
             File.open(target_file_tmp, 'wb') do |file|
               result[:http].read_body do |fragment|
                 file.write(fragment)
                 written_size += fragment.length
-                RestParameters.instance.progress_bar&.event(:transfer, session_id: session_id, info: written_size)
+                RestParameters.instance.progress_bar&.event(:transfer, session_id: session_id, info: written_size) if limiter.trigger?
               end
             end
             RestParameters.instance.progress_bar&.event(:end, session_id: session_id)
@@ -405,7 +413,10 @@ module Aspera
           result[:data] = result[:http].body
         end
         RestErrorAnalyzer.instance.raise_on_error(req, result)
-        File.write(save_to_file, result[:http].body, binmode: true) unless file_saved || save_to_file.nil?
+        unless file_saved || save_to_file.nil?
+          FileUtils.mkdir_p(File.dirname(save_to_file))
+          File.write(save_to_file, result[:http].body, binmode: true)
+        end
       rescue RestCallError => e
         do_retry = false
         # AoC have some timeout , like Connect to platform.bss.asperasoft.com:443 ...
@@ -451,7 +462,7 @@ module Aspera
         # raise exception if could not retry and not return error in result
         raise e unless return_error
       end
-      Log.log.debug{"result=#{result}"}
+      Log.log.debug{"result=http:#{result[:http]}, data:#{result[:data].class}"}
       return result
     end
 

data/lib/aspera/rest_error_analyzer.rb

@@ -8,6 +8,7 @@ module Aspera
   # analyze error codes returned by REST calls and raise ruby exception
   class RestErrorAnalyzer
     include Singleton
+
     attr_accessor :log_file
 
     # the singleton object is registered with application specific handlers

data/lib/aspera/ssh.rb

@@ -55,7 +55,7 @@ module Aspera
             error_message = "#{cmd}: [#{data.chomp}]"
             # Happens when windows user hasn't logged in and created home account.
             error_message += "\nHint: home not created in Windows?" if data.include?('Could not chdir to home directory')
-            raise error_message
+            Log.log.debug(error_message)
           end
           # send command to SSH channel (execute) cspell: disable-next-line
           channel.send('cexe'.reverse, cmd){ |_ch, _success| channel.send_data(input) unless input.nil?}

data/lib/aspera/temp_file_manager.rb

@@ -14,6 +14,7 @@ module Aspera
     FILE_LIST_AGE_MAX_SEC = SEC_IN_DAY * 5
     private_constant :SEC_IN_DAY, :FILE_LIST_AGE_MAX_SEC
     include Singleton
+
     attr_accessor :cleanup_on_exit
 
     def initialize

data/lib/aspera/timer_limiter.rb

@@ -1,20 +1,22 @@
 # frozen_string_literal: true
 
 module Aspera
-  # used to throttle logs
+  # trigger returns true only if the delay has passed since the last trigger
   class TimerLimiter
     # @param delay in seconds (float)
     def initialize(delay)
       @delay = delay
-      @last_time = nil
+      @last_trigger_time = nil
       @count = 0
     end
 
+    # Check if the trigger condition is met
+    # @return [Boolean] true if the trigger condition is met, false otherwise
     def trigger?
-      old_time = @last_time
-      @last_time = Time.now.to_f
+      current_time = Time.now.to_f
       @count += 1
-      if old_time.nil? || ((@last_time - old_time) > @delay)
+      if @last_trigger_time.nil? || ((current_time - @last_trigger_time) > @delay)
+        @last_trigger_time = current_time
         @count = 0
         return true
       end