aspera-cli 4.15.0 → 4.16.0

data/lib/aspera/log.rb

@@ -3,6 +3,7 @@
 require 'aspera/colors'
 require 'aspera/secret_hider'
 require 'aspera/environment'
+require 'aspera/assert'
 require 'logger'
 require 'pp'
 require 'json'
@@ -39,6 +40,7 @@ class Logger
       end
     EOM
   end
+  # declare methods for all levels
   Logger::Severity.constants.each { |severity| make_methods(severity) }
 end
 
@@ -97,8 +99,7 @@ module Aspera
       Logger::Severity.constants.each do |name|
         return name.downcase.to_sym if @logger.level.eql?(Logger::Severity.const_get(name))
       end
-      # should not happen
-      raise "INTERNAL ERROR: unexpected level #{@logger.level}"
+      error_unexpected_value(@logger.level){'log level'}
     end
 
     # change underlying logger, but keep log level
@@ -123,7 +124,7 @@ module Aspera
         end
         @logger = Syslog::Logger.new(@program_name, Syslog::LOG_LOCAL2)
       else
-        raise "unknown log type: #{new_log_type.class} #{new_log_type}"
+        raise "unknown log type: #{new_log_type}, use one of: #{LOG_TYPES.join(', ')}"
       end
       @logger.level = current_severity_integer
       @logger_type = new_log_type

data/lib/aspera/nagios.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'aspera/log'
+require 'aspera/assert'
 require 'date'
 
 module Aspera
@@ -21,8 +23,11 @@ module Aspera
     class << self
       # process results of a analysis and display status and exit with code
       def process(data)
-        raise 'INTERNAL ERROR, result must be list and not empty' unless data.is_a?(Array) && !data.empty?
-        %w[status component message].each{|c|raise "INTERNAL ERROR, result must have #{c}" unless data.first.key?(c)}
+        assert_type(data, Array)
+        assert(!data.empty?){'data is empty'}
+        %w[status component message].each do |c|
+          assert(data.first.key?(c)){"result must have #{c}"}
+        end
         res_errors = data.reject{|s|s['status'].eql?('ok')}
         # keep only errors in case of problem, other ok are assumed so
         data = res_errors unless res_errors.empty?

data/lib/aspera/node.rb

@@ -5,6 +5,7 @@ require 'aspera/fasp/transfer_spec'
 require 'aspera/rest'
 require 'aspera/oauth'
 require 'aspera/log'
+require 'aspera/assert'
 require 'aspera/environment'
 require 'zlib'
 require 'base64'
@@ -50,7 +51,7 @@ module Aspera
           end
           return lambda{|f|File.fnmatch(match_expression, f['name'], File::FNM_DOTMATCH)}
         when NilClass then return ->(_){true}
-        else raise Cli::BadArgument, "Invalid match expression type: #{match_expression.class}"
+        else error_unexpected_value(match_expression.class.name, exception_class: Cli::BadArgument)
         end
       end
 
@@ -65,8 +66,8 @@ module Aspera
 
       def decode_scope(scope)
         items = scope.split(SCOPE_SEPARATOR, 2)
-        raise "invalid scope: #{scope}" unless items.length.eql?(2)
-        raise "invalid scope: #{scope}" unless items[0].start_with?(SCOPE_PREFIX)
+        assert(items.length.eql?(2)){"invalid scope: #{scope}"}
+        assert(items[0].start_with?(SCOPE_PREFIX)){"invalid scope: #{scope}"}
         return {access_key: items[0][SCOPE_PREFIX.length..-1], scope: items[1]}
       end
 
@@ -74,11 +75,11 @@ module Aspera
       # @param payload [String] JSON payload to be included in the token
       # @param private_key [OpenSSL::PKey::RSA] Private key to sign the token
       def bearer_token(access_key:, payload:, private_key:)
-        raise 'payload shall be Hash' unless payload.is_a?(Hash)
-        raise 'missing user_id' unless payload.key?('user_id')
-        raise 'user_id must be a String' unless payload['user_id'].is_a?(String)
-        raise 'user_id must not be empty' if payload['user_id'].empty?
-        raise 'private_key shall be OpenSSL::PKey::RSA' unless private_key.is_a?(OpenSSL::PKey::RSA)
+        assert_type(payload, Hash)
+        assert(payload.key?('user_id'))
+        assert_type(payload['user_id'], String)
+        assert(!payload['user_id'].empty?)
+        assert_type(private_key, OpenSSL::PKey::RSA)
         # manage convenience parameters
         expiration_sec = payload['_validity'] || BEARER_TOKEN_VALIDITY_DEFAULT
         payload.delete('_validity')
@@ -104,7 +105,7 @@ module Aspera
         # if username is not provided, use the access key from the token
         if access_key.nil?
           access_key = Aspera::Node.decode_scope(Aspera::Node.decode_bearer_token(Oauth.bearer_extract(bearer_auth))['scope'])[:access_key]
-          raise "internal error #{access_key}" if access_key.nil?
+          assert(!access_key.nil?)
         end
         return {
           Aspera::Node::HEADER_X_ASPERA_ACCESS_KEY => access_key,
@@ -131,10 +132,10 @@ module Aspera
       @add_tspec = add_tspec
       if !@app_info.nil?
         REQUIRED_APP_INFO_FIELDS.each do |field|
-          raise "INTERNAL ERROR: app_info lacks field #{field}" unless @app_info.key?(field)
+          assert(@app_info.key?(field)){"app_info lacks field #{field}"}
         end
         REQUIRED_APP_API_METHODS.each do |method|
-          raise "INTERNAL ERROR: #{@app_info[:api].class} lacks method #{method}" unless @app_info[:api].respond_to?(method)
+          assert(@app_info[:api].respond_to?(method)){"#{@app_info[:api].class} lacks method #{method}"}
         end
       end
     end
@@ -165,8 +166,8 @@ module Aspera
     # @param top_file_path [String] path of top folder (default = /)
     # @param block [Proc] processing method, arguments: entry, path, state
     def process_folder_tree(state:, top_file_id:, top_file_path: '/', &block)
-      raise 'INTERNAL ERROR: top_file_path not set' if top_file_path.nil?
-      raise 'INTERNAL ERROR: Missing block' unless block
+      assert(!top_file_path.nil?){'top_file_path not set'}
+      assert(block){'Missing block'}
       # start at top folder
       folders_to_explore = [{id: top_file_id, path: top_file_path}]
       Log.log.debug{Log.dump(:folders_to_explore, folders_to_explore)}
@@ -207,7 +208,7 @@ module Aspera
     # @param path [String]  file path
     # @return [Hash] {.api,.file_id}
     def resolve_api_fid(top_file_id, path)
-      raise 'file id shall be String' unless top_file_id.is_a?(String)
+      assert_type(top_file_id, String)
       process_last_link = path.end_with?(PATH_SEPARATOR)
       path_elements = path.split(PATH_SEPARATOR).reject(&:empty?)
       return {api: self, file_id: top_file_id} if path_elements.empty?
@@ -276,14 +277,14 @@ module Aspera
       case params[:auth][:type]
       when :basic
         ak_name = params[:auth][:username]
-        raise 'ERROR: no secret in node object' unless params[:auth][:password]
+        assert(params[:auth][:password]){'no secret in node object'}
         ak_token = Rest.basic_token(params[:auth][:username], params[:auth][:password])
       when :oauth2
         ak_name = params[:headers][HEADER_X_ASPERA_ACCESS_KEY]
         # TODO: token_generation_lambda = lambda{|do_refresh|oauth_token(force_refresh: do_refresh)}
         # get bearer token, possibly use cache
         ak_token = oauth_token(force_refresh: false)
-      else raise "Unsupported auth method for node gen4: #{params[:auth][:type]}"
+      else error_unexpected_value(params[:auth][:type])
       end
       transfer_spec = {
         'direction' => direction,

data/lib/aspera/node_simulator.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'aspera/log'
+require 'aspera/fasp/installation'
+require 'aspera/fasp/agent_direct'
+require 'webrick'
+require 'json'
+
+module Aspera
+  # this class answers the Faspex /send API and creates a package on Aspera on Cloud
+  class NodeSimulatorServlet < WEBrick::HTTPServlet::AbstractServlet
+    PATH_TRANSFERS = '/ops/transfers'
+    PATH_ONE_TRANSFER = %r{/ops/transfers/(.+)$}
+    # @param app_api [Aspera::AoC]
+    # @param app_context [String]
+    def initialize(server, credentials, transfer)
+      super(server)
+      @credentials = credentials
+      @xfer_manager = Aspera::Fasp::AgentDirect.new
+    end
+
+    def do_POST(request, response)
+      case request.path
+      when PATH_TRANSFERS
+        job_id = @xfer_manager.start_transfer(JSON.parse(request.body))
+        session = @xfer_manager.sessions_by_job(job_id).first
+        result = session[:ts].clone
+        result['id'] = job_id
+        set_json_response(response, result)
+        Log.log.debug{">>> transfer started: #{job_id}"}
+      else
+        set_json_response(response, [{error: 'Bad request'}], code: 400)
+      end
+    end
+
+    def do_GET(request, response)
+      case request.path
+      when '/info'
+        info = Aspera::Fasp::Installation.instance.ascp_info
+        set_json_response(response, {
+          application:                           'node',
+          current_time:                          Time.now.utc.iso8601(0),
+          version:                               info['ascp_version'].gsub(/ .*$/, ''),
+          license_expiration_date:               info['expiration_date'],
+          license_max_rate:                      info['maximum_bandwidth'],
+          os:                                    %x(uname -srv).chomp,
+          aej_status:                            'disconnected',
+          async_reporting:                       'yes',
+          transfer_activity_reporting:           'yes',
+          transfer_user:                         'xfer',
+          docroot:                               'file:////data/aoc/eudemo-sedemo',
+          node_id:                               '2bbdcc39-f789-4d47-8163-6767fc14f421',
+          cluster_id:                            '6dae2844-d1a9-47a5-916d-9b3eac3ea466',
+          acls:                                  [],
+          access_key_configuration_capabilities: {
+            transfer: %w[
+              cipher
+              policy
+              target_rate_cap_kbps
+              target_rate_kbps
+              preserve_timestamps
+              content_protection_secret
+              aggressiveness
+              token_encryption_key
+              byok_enabled
+              bandwidth_flow_network_rc_module
+              file_checksum_type],
+            server:   %w[
+              activity_event_logging
+              activity_file_event_logging
+              recursive_counts
+              aej_logging
+              wss_enabled
+              activity_transfer_ignore_skipped_files
+              activity_files_max
+              access_key_credentials_encryption_type
+              discovery
+              auto_delete
+              allow
+              deny]
+          },
+          capabilities:                          [
+            {name:  'sync', value: true},
+            {name:  'watchfolder', value: true},
+            {name:  'symbolic_links', value: true},
+            {name:  'move_file', value: true},
+            {name:  'move_directory', value: true},
+            {name:  'filelock', value: false},
+            {name:  'ssh_fingerprint', value: false},
+            {name:  'aej_version', value: '1.0'},
+            {name:  'page', value: true},
+            {name:  'file_id_version', value: '2.0'},
+            {name:  'auto_delete', value: false}],
+          settings:                              [
+            {name:  'content_protection_required', value: false},
+            {name:  'content_protection_strong_pass_required', value: false},
+            {name:  'filelock_restriction', value: 'none'},
+            {name:  'ssh_fingerprint', value: nil},
+            {name:  'wss_enabled', value: false},
+            {name:  'wss_port', value: 443}
+          ]})
+      when PATH_TRANSFERS
+        result = @xfer_manager.sessions.map { |session| job_to_transfer(session) }
+        set_json_response(response, result)
+      when PATH_ONE_TRANSFER
+        job_id = request.path.match(PATH_ONE_TRANSFER)[1]
+        set_json_response(response, job_to_transfer(@xfer_manager.sessions_by_job(job_id).first))
+      else
+        set_json_response(response, [{error: 'Unknown request'}], code: 400)
+      end
+    end
+
+    def set_json_response(response, json, code: 200)
+      response.status = code
+      response['Content-Type'] = 'application/json'
+      response.body = json.to_json
+      Log.log.trace1{Log.dump('response', json)}
+    end
+
+    def job_to_transfer(job)
+      session = {
+        id:                    'bafc72b8-366c-4501-8095-47208183d6b8',
+        client_node_id:        '',
+        server_node_id:        '2bbdcc39-f789-4d47-8163-6767fc14f421',
+        client_ip_address:     '192.168.0.100',
+        server_ip_address:     '5.10.114.4',
+        status:                'running',
+        retry_timeout:         3600,
+        retry_count:           0,
+        start_time_usec:       1701094040000000,
+        end_time_usec:         nil,
+        elapsed_usec:          405312,
+        bytes_transferred:     26,
+        bytes_written:         26,
+        bytes_lost:            0,
+        files_completed:       1,
+        directories_completed: 0,
+        target_rate_kbps:      500000,
+        min_rate_kbps:         0,
+        calc_rate_kbps:        9900,
+        network_delay_usec:    40000,
+        avg_rate_kbps:         0.51,
+        error_code:            0,
+        error_desc:            '',
+        source_statistics:     {
+          args_scan_attempted:  1,
+          args_scan_completed:  1,
+          paths_scan_attempted: 1,
+          paths_scan_failed:    0,
+          paths_scan_skipped:   0,
+          paths_scan_excluded:  0,
+          dirs_scan_completed:  0,
+          files_scan_completed: 1,
+          dirs_xfer_attempted:  0,
+          dirs_xfer_fail:       0,
+          files_xfer_attempted: 1,
+          files_xfer_fail:      0,
+          files_xfer_noxfer:    0
+        },
+        precalc:               {
+          enabled:              true,
+          status:               'ready',
+          bytes_expected:       0,
+          directories_expected: 0,
+          files_expected:       0,
+          files_excluded:       0,
+          files_special:        0,
+          files_failed:         1
+        }}
+      return {
+        id:                    '609a667d-642e-4290-9312-b4d20d3c0159',
+        status:                'running',
+        start_spec:            job[:ts],
+        sessions:              [session],
+        bytes_transferred:     26,
+        bytes_written:         26,
+        bytes_lost:            0,
+        avg_rate_kbps:         0.51,
+        files_completed:       1,
+        files_skipped:         0,
+        directories_completed: 0,
+        start_time_usec:       1701094040000000,
+        end_time_usec:         1701094040405312,
+        elapsed_usec:          405312,
+        error_code:            0,
+        error_desc:            '',
+        precalc:               {
+          status:               'ready',
+          bytes_expected:       0,
+          files_expected:       0,
+          directories_expected: 0,
+          files_special:        0,
+          files_failed:         1
+        },
+        files:                 [{
+          id:              'd1b5c112-82b75425-860745fc-93851671-64541bdd',
+          path:            '/workspaces/45071/packages/bYA_ilq73g.asp-package/contents/data_file.bin',
+          start_time_usec: 1701094040000000,
+          elapsed_usec:    105616,
+          end_time_usec:   1701094040001355,
+          status:          'completed',
+          error_code:      0,
+          error_desc:      '',
+          size:            26,
+          type:            'file',
+          checksum_type:   'none',
+          checksum:        nil,
+          start_byte:      0,
+          bytes_written:   26,
+          session_id:      'bafc72b8-366c-4501-8095-47208183d6b8'}]
+      }
+    end
+  end # NodeSimulatorServlet
+end # Aspera

data/lib/aspera/oauth.rb

@@ -3,6 +3,8 @@
 require 'aspera/open_application'
 require 'aspera/web_auth'
 require 'aspera/id_generator'
+require 'aspera/log'
+require 'aspera/assert'
 require 'base64'
 require 'date'
 require 'socket'
@@ -55,7 +57,7 @@ module Aspera
       end
 
       def bearer_extract(token)
-        raise 'not a bearer token, wrong prefix' unless bearer?(token)
+        assert(bearer?(token)){'not a bearer token, wrong prefix'}
         return token[BEARER_PREFIX.length..-1]
       end
 
@@ -106,26 +108,28 @@ module Aspera
       # @param id_create called to generate unique id for token, for cache
       def register_token_creator(id, lambda_create, id_create)
         Log.log.debug{"registering token creator #{id}"}
-        raise 'ERROR: requites Symbol and 2 lambdas' unless id.is_a?(Symbol) && lambda_create.is_a?(Proc) && id_create.is_a?(Proc)
+        assert_type(id, Symbol)
+        assert_type(lambda_create, Proc)
+        assert_type(id_create, Proc)
         @create_handlers[id] = lambda_create
         @id_handlers[id] = id_create
       end
 
       # @return one of the registered creators for the given create type
       def token_creator(id)
-        raise "token grant method unknown: '#{id}' (#{id.class})" unless @create_handlers.key?(id)
+        assert(@create_handlers.key?(id)){"token grant method unknown: '#{id}' (#{id.class})"}
         @create_handlers[id]
       end
 
       # list of identifiers found in creation parameters that can be used to uniquely identify the token
       def id_creator(id)
-        raise "id creator type unknown: #{id}/#{id.class}" unless @id_handlers.key?(id)
+        assert(@id_handlers.key?(id)){"id creator type unknown: #{id}/#{id.class}"}
         @id_handlers[id]
       end
     end # self
 
     # JSON Web Signature (JWS) compact serialization: https://datatracker.ietf.org/doc/html/rfc7515
-    register_decoder lambda { |token| parts = token.split('.'); raise 'not aoc token' unless parts.length.eql?(3); JSON.parse(Base64.decode64(parts[1]))} # rubocop:disable Style/Semicolon, Layout/LineLength
+    register_decoder lambda { |token| parts = token.split('.'); assert(parts.length.eql?(3)){'not aoc token'}; JSON.parse(Base64.decode64(parts[1]))} # rubocop:disable Style/Semicolon, Layout/LineLength
 
     # generic token creation, parameters are provided in :generic
     register_token_creator :generic, lambda { |oauth|
@@ -152,7 +156,7 @@ module Aspera
       OpenApplication.instance.uri(login_page_url)
       # wait for code in request
       received_params = web_server.received_request
-      raise 'wrong received state' unless random_state.eql?(received_params['state'])
+      assert(random_state.eql?(received_params['state'])){'wrong received state'}
       # exchange code for token
       return oauth.create_token(oauth.optional_scope_client_id(add_secret: true).merge(
         grant_type:   'authorization_code',
@@ -169,7 +173,7 @@ module Aspera
       require 'jwt'
       seconds_since_epoch = Time.new.to_i
       Log.log.info{"seconds=#{seconds_since_epoch}"}
-      raise 'missing JWT payload' unless oauth.specific_parameters[:payload].is_a?(Hash)
+      assert(oauth.specific_parameters[:payload].is_a?(Hash)){'missing JWT payload'}
       jwt_payload = {
         exp: seconds_since_epoch + @@globals[:jwt_expiry_offset_sec], # expiration time
         nbf: seconds_since_epoch - @@globals[:jwt_accepted_offset_sec], # not before
@@ -191,14 +195,14 @@ module Aspera
     private
 
     # [M]=mandatory [D]=has default value [0]=accept nil
-    # :base_url            [M]  URL of authentication API
+    # :base_url            [M] URL of authentication API
     # :auth
-    # :grant_method        [M]  :generic, :web, :jwt, custom
+    # :grant_method        [M] :generic, :web, :jwt, [custom types]
     # :client_id           [0]
     # :client_secret       [0]
     # :scope               [0]
-    # :path_token          [D]  API end point to create a token
-    # :token_field         [D]  field in result that contains the token
+    # :path_token          [D] API end point to create a token
+    # :token_field         [D] field in result that contains the token
     # :jwt:private_key_obj [M] for type :jwt
     # :jwt:payload         [M] for type :jwt
     # :jwt:headers         [0] for type :jwt
@@ -207,18 +211,16 @@ module Aspera
     # :generic             [M] for type :generic
     def initialize(a_params)
       Log.log.debug{"auth=#{a_params}"}
-      # replace default values
+      # set default values if not set in parameters common to all types
       @generic_parameters = DEFAULT_CREATE_PARAMS.deep_merge(a_params)
-      # legacy
-      @generic_parameters[:grant_method] ||= @generic_parameters.delete(:crtype) if @generic_parameters.key?(:crtype) # cspell: disable-line
       # check that type is known
       self.class.token_creator(@generic_parameters[:grant_method])
       # specific parameters for the creation type
       @specific_parameters = @generic_parameters[@generic_parameters[:grant_method]]
       if @generic_parameters[:grant_method].eql?(:web) && @specific_parameters.key?(:redirect_uri)
         uri = URI.parse(@specific_parameters[:redirect_uri])
-        raise 'redirect_uri scheme must be http or https' unless %w[http https].include?(uri.scheme)
-        raise 'redirect_uri must have a port' if uri.port.nil?
+        assert(%w[http https].include?(uri.scheme)){'redirect_uri scheme must be http or https'}
+        assert(!uri.port.nil?){'redirect_uri must have a port'}
         # TODO: we could check that host is localhost or local address
       end
       rest_params = {
@@ -226,8 +228,9 @@ module Aspera
         redirect_max: 2
       }
       rest_params[:auth] = a_params[:auth] if a_params.key?(:auth)
+      # this is the OAuth API
       @api = Rest.new(rest_params)
-      # if needed use from api
+      # if those are needed use from @api
       @generic_parameters.delete(:base_url)
       @generic_parameters.delete(:auth)
       @generic_parameters.delete(@generic_parameters[:grant_method])
@@ -266,7 +269,7 @@ module Aspera
         @generic_parameters[:grant_method],
         self.class.id_creator(@generic_parameters[:grant_method]).call(self), # array, so we flatten later
         @generic_parameters[:scope],
-        @api.params.dig(%i[auth username])
+        @api.params.dig(*%i[auth username])
       ].flatten)
 
       # get token_data from cache (or nil), token_data is what is returned by /token
@@ -322,7 +325,7 @@ module Aspera
         token_data = JSON.parse(json_data)
         self.class.persist_mgr.put(token_id, json_data)
       end # if ! in_cache
-      raise "API error: No such field in answer: #{@generic_parameters[:token_field]}" unless token_data.key?(@generic_parameters[:token_field])
+      assert(token_data.key?(@generic_parameters[:token_field])){"API error: No such field in answer: #{@generic_parameters[:token_field]}"}
       # ok we shall have a token here
       return self.class.bearer_build(token_data[@generic_parameters[:token_field]])
     end

data/lib/aspera/persistency_action_once.rb

@@ -2,6 +2,7 @@
 
 require 'json'
 require 'aspera/log'
+require 'aspera/assert'
 
 module Aspera
   # Persist data on file system
@@ -13,21 +14,19 @@ module Aspera
     # @param :parse    Optional  parse method (default to JSON)
     # @param :format   Optional  dump method (default to JSON)
     # @param :merge    Optional  merge data from file to current data
-    def initialize(options)
-      Log.log.debug{"persistency: #{options}"}
-      raise 'options shall be Hash' unless options.is_a?(Hash)
-      raise 'mandatory :manager' if options[:manager].nil?
-      raise 'mandatory :data' if options[:data].nil?
-      raise 'mandatory :id (String)' unless options[:id].is_a?(String)
-      raise 'mandatory 1 element in :id' unless options[:id].length >= 1
-      @manager = options[:manager]
-      @persisted_object = options[:data]
-      @object_id = options[:id]
+    def initialize(manager:, data:, id:, delete: nil, parse: nil, format: nil, merge: nil)
+      assert(!manager.nil?)
+      assert(!data.nil?)
+      assert_type(id, String)
+      assert(!id.empty?)
+      @manager = manager
+      @persisted_object = data
+      @object_id = id
       # by default , at save time, file is deleted if data is nil
-      @delete_condition = options[:delete] || lambda{|d|d.empty?}
-      @persist_format = options[:format] || lambda {|h| JSON.generate(h)}
-      persist_parse = options[:parse] || lambda {|t| JSON.parse(t)}
-      persist_merge = options[:merge] || lambda {|current, file| current.concat(file).uniq rescue current}
+      @delete_condition = delete || lambda{|d|d.empty?}
+      @persist_format = format || lambda {|h| JSON.generate(h)}
+      persist_parse = parse || lambda {|t| JSON.parse(t)}
+      persist_merge = merge || lambda {|current, file| current.concat(file).uniq rescue current}
       value = @manager.get(@object_id)
       persist_merge.call(@persisted_object, persist_parse.call(value)) unless value.nil?
     end

data/lib/aspera/persistency_folder.rb

@@ -2,6 +2,7 @@
 
 require 'fileutils'
 require 'aspera/log'
+require 'aspera/assert'
 require 'aspera/environment'
 
 # search: persistency_folder PersistencyFolder
@@ -34,7 +35,7 @@ module Aspera
     end
 
     def put(object_id, value)
-      raise 'value: only String supported' unless value.is_a?(String)
+      assert_type(value, String)
       persist_filepath = id_to_filepath(object_id)
       Log.log.debug{"persistency saving: #{persist_filepath}"}
       FileUtils.rm_f(persist_filepath)
@@ -67,7 +68,7 @@ module Aspera
 
     # @param object_id String or Array
     def id_to_filepath(object_id)
-      raise 'object_id: only String supported' unless object_id.is_a?(String)
+      assert_type(object_id, String)
       FileUtils.mkdir_p(@folder)
       Environment.restrict_file_access(@folder)
       return File.join(@folder, "#{object_id}#{FILE_SUFFIX}")