aspera-cli 4.26.1 → 4.27.0

data/lib/aspera/agent/node.rb

@@ -13,6 +13,38 @@ module Aspera
     # this singleton class is used by the CLI to provide a common interface to start a transfer
     # before using it, the use must set the `node_api` member.
     class Node < Base
+      class << self
+        # Re-query a previously started transfer via the Node REST API.
+        # agent_params must contain 'url', 'username', 'password' (and optionally 'root_id').
+        # @return [Hash] normalized status hash
+        def transfer_status(transfer_id, agent_params)
+          rest_params = {base_url: agent_params['url']}
+          if OAuth::Factory.bearer_auth?(agent_params['password'])
+            rest_params[:headers] = Api::Node.bearer_headers(agent_params['password'], access_key: agent_params['username'])
+          else
+            rest_params[:auth] = {type: :basic, username: agent_params['username'], password: agent_params['password']}
+          end
+          node_api = Rest.new(**rest_params)
+          data = node_api.read("ops/transfers/#{transfer_id}") || {'status' => 'unknown'}
+          normalize_status(data)
+        end
+
+        # Normalize a node API transfer hash into the standard async-transfer fields.
+        def normalize_status(data)
+          result = {'bytes_transferred' => data['bytes_transferred'].to_i}
+          case data['status']
+          when 'completed'
+            result['status'] = 'completed'
+            result['ended_at'] = Time.now.utc.iso8601
+          when 'failed'
+            result.merge!('status' => 'failed', 'ended_at' => Time.now.utc.iso8601, 'error' => data['error_desc'].to_s)
+          else
+            result['status'] = 'running'
+          end
+          result
+        end
+      end
+
       # @param url          [String] the base url of the node api
       # @param username     [String] the username to use for the node api
       # @param password     [String] the password to use for the node api
@@ -30,7 +62,7 @@ module Aspera
         @root_id = root_id
         rest_params = {base_url: url}
         if OAuth::Factory.bearer_auth?(password)
-          Aspera.assert(!@root_id.nil?){'root_id not allowed for access key'}
+          Aspera.assert(!@root_id.nil?, 'root_id not allowed for access key')
           rest_params[:headers] = Api::Node.bearer_headers(password, access_key: username)
         else
           rest_params[:auth] = {
@@ -117,7 +149,7 @@ module Aspera
 
       # used internally to ensure node api is set before using.
       def node_api_
-        Aspera.assert(!@node_api.nil?){'Before using this object, set the node_api attribute to a Aspera::Rest object'}
+        Aspera.assert(!@node_api.nil?, 'Before using this object, set the node_api attribute to a Aspera::Rest object')
         return @node_api
       end
     end

data/lib/aspera/agent/transferd.rb

@@ -21,6 +21,37 @@ module Aspera
 
       private_constant :LOCAL_SOCKET_ADDR, :PORT_SEP, :AUTO_LOCAL_TCP_PORT
 
+      class << self
+        # Re-query a previously started transfer from a running transferd daemon.
+        # agent_params must contain 'url' (the daemon endpoint, e.g. "127.0.0.1:12345").
+        # @return [Hash] normalized status hash
+        def transfer_status(transfer_id, agent_params)
+          client = ::Transferd::Api::TransferService::Stub.new(agent_params['url'], :this_channel_is_insecure)
+          result = {'bytes_transferred' => 0}
+          client.monitor_transfers(::Transferd::Api::RegistrationRequest.new(transferId: [transfer_id])) do |response|
+            result = case response.status
+            when :COMPLETED
+              {
+                'status' => 'completed', 'ended_at' => Time.now.utc.iso8601,
+                        'bytes_transferred' => response.transferInfo.bytesTransferred
+              }
+            when :FAILED, :CANCELED
+              {
+                'status' => response.status == :FAILED ? 'failed' : 'cancelled',
+                        'ended_at' => Time.now.utc.iso8601, 'bytes_transferred' => 0,
+                        'error' => JSON.parse(response.message.to_s)['Description']
+              }
+            else
+              {'status' => 'running', 'bytes_transferred' => response.transferInfo.bytesTransferred}
+            end
+            break
+          end
+          result
+        rescue StandardError => e
+          {'status' => 'running', 'bytes_transferred' => 0, 'error' => e.message}
+        end
+      end
+
       # @param url   [String]  URL of the transfer manager daemon
       # @param start [Boolean] If `false`, expect that an external daemon is already running
       # @param stop  [Boolean] If `false`, do not shutdown daemon on exit
@@ -35,9 +66,10 @@ module Aspera
         @transfer_id = nil
         @stop = stop
         is_local_auto_port = url.eql?(AUTO_LOCAL_TCP_PORT)
-        raise Error, 'Cannot set options `stop` or `start` to false with port zero' if is_local_auto_port && (!@stop || !start)
+        Aspera.assert(!(is_local_auto_port && (!@stop || !start)), type: Error){'Cannot set options `stop` or `start` to false with port zero'}
         # keep PID for optional shutdown
         @daemon_pid = nil
+        @daemon_endpoint = nil
         daemon_endpoint = url
         Log.dump(:daemon_endpoint, daemon_endpoint)
         # retry loop
@@ -48,6 +80,7 @@ module Aspera
           @transfer_client = ::Transferd::Api::TransferService::Stub.new(daemon_endpoint, :this_channel_is_insecure)
           # Initiate actual connection
           get_info_response = @transfer_client.get_info(::Transferd::Api::InstanceInfoRequest.new)
+          @daemon_endpoint = daemon_endpoint
           Log.log.debug{"Daemon info: #{get_info_response}"}
           Log.log.warn('Attached to existing daemon') unless @daemon_pid || !start || !@stop
           at_exit{shutdown}
@@ -55,7 +88,7 @@ module Aspera
           # if transferd is external: do not start it, or other error
           raise if !start || !e.message.include?('failed to connect')
           # we already tried to start a daemon, but it failed
-          Aspera.assert(@daemon_pid.nil?){"Daemon started with PID #{@daemon_pid}, but connection failed to #{daemon_endpoint}}"}
+          Aspera.assert(@daemon_pid.nil?){"Daemon started with PID #{@daemon_pid}, but connection failed to #{daemon_endpoint}"}
           Log.log.warn('no daemon present, starting daemon...') if !start
           # transferd only supports local ip and port
           daemon_uri = URI.parse("ipv4://#{daemon_endpoint}")
@@ -105,6 +138,9 @@ module Aspera
         end
       end
 
+      # Actual endpoint the daemon is listening on (resolved after connect, e.g. when port 0 was used)
+      attr_reader :daemon_endpoint
+
       # :reek:UnusedParameters token_regenerator
       def start_transfer(transfer_spec, token_regenerator: nil)
         Transfer::Spec.fix_transferd_resume_policy(transfer_spec)
@@ -116,7 +152,7 @@ module Aspera
         ) # transfer definition
         # send start transfer request to the transfer manager daemon
         start_response = @transfer_client.start_transfer(transfer_request)
-        raise Transfer::Error, start_response.error.description if start_response.status.eql?(:FAILED)
+        Aspera.assert(!start_response.status.eql?(:FAILED), type: Transfer::Error){start_response.error.description}
         Log.log.debug{"start transfer response #{start_response}"}
         @transfer_id = start_response.transferId
         Log.log.debug{"transfer started with id #{@transfer_id}"}

data/lib/aspera/api/alee.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'aspera/api/aoc.rb'
+require 'aspera/api/aoc'
 module Aspera
   module Api
     # Aspera License Entitlement Engine API client

data/lib/aspera/api/aoc.rb

@@ -25,23 +25,23 @@ module Aspera
 
       class AppInfo
         # @return [Aspera::Api::AoC] Rest Api object
-        attr_reader  :api
+        attr_reader :api
         # @return [Hash, nil] Package information, `"files"` or `"packages"`
-        attr_reader  :package
+        attr_reader :package
         # @return [Hash] Result of GET /nodes/:id
-        attr_reader  :node_info
+        attr_reader :node_info
         # @return [String] Workspace id
-        attr_reader  :workspace_id
+        attr_reader :workspace_id
         # @return [String] Workspace name
-        attr_reader  :workspace_name
+        attr_reader :workspace_name
         # @return [String, nil] "Share as" link name
         attr_accessor :opt_link_name
 
         # @param api [Api::Aoc] Rest Api object
         # @param package [Hash,nil] package information or nil
         # @param node_info [Hash] Result of GET /nodes/:id
-        # @param workspace_id [String]
-        # @param workspace_name [String]
+        # @param workspace_id   [String]     Workspace identifier
+        # @param workspace_name [String]     Workspace name
         def initialize(api, package, node_info, workspace_id, workspace_name)
           @api = api
           @package = package
@@ -68,8 +68,8 @@ module Aspera
       GLOBAL_CLIENT_APPS = DataRepository::ELEMENTS.select{ |i| i.to_s.start_with?(CLIENT_ID_PREFIX)}.freeze
       # cookie prefix so that console can decode identity
       COOKIE_PREFIX_CONSOLE_AOC = 'aspera.aoc'
-      # path in URL of public links
-      PUBLIC_LINK_PATHS = %w[/packages/public/receive /packages/public/send /files/public /public/files /public/package /public/send].freeze
+      # path in URL of public links (warning if not in list)
+      PUBLIC_LINK_PATHS = %w[/packages/public/receive /packages/public/send /files/public /public/files /public/files/ /public/package /public/send /public/send/package].freeze
       JWT_AUDIENCE = 'https://api.asperafiles.com/api/v1/oauth2/token'
       OAUTH_API_SUBPATH = 'api/v1/oauth2'
       # minimum fields for user info if retrieval fails
@@ -113,8 +113,10 @@ module Aspera
           return client_key, DataRepository.instance.item(client_key)
         end
 
-        # base API url depends on domain, which could be "qa.xxx" or self-managed domain
-        def api_base_url(api_domain: SAAS_DOMAIN_PROD)
+        # Base API url depends on domain, which could be "qa.xxx" or self-managed domain
+        # @param api_domain [String] the AoC domain (e.g. "ibmaspera.com" (SAAS_DOMAIN_PROD) or a self-managed domain)
+        # @return [String] the base URL for the AoC API
+        def api_base_url(api_domain)
           return "https://api.#{api_domain}"
         end
 
@@ -197,7 +199,7 @@ module Aspera
         # @option return [Integer] :total The total number of items
         def call_paging(query: {})
           Aspera.assert_type(query, Hash){'query'}
-          Aspera.assert(block_given?)
+          Aspera.assert(block_given?, 'block required for call_paging')
           # set default large page if user does not specify own parameters. AoC Caps to 1000 anyway
           query['per_page'] = 1000 unless query.key?('per_page')
           max_items = query.delete(RestList::MAX_ITEMS)
@@ -211,7 +213,7 @@ module Aspera
             new_query = query.clone
             new_query['page'] = current_page
             result_data, result_http = yield(new_query)
-            Aspera.assert(result_http)
+            Aspera.assert(result_http, 'expected HTTP result from paging block')
             total_count = result_http[HEADER_X_TOTAL_COUNT]&.to_i
             page_count += 1
             current_page += 1
@@ -271,7 +273,7 @@ module Aspera
         scope: nil,
         subpath: API_V1,
         secret_finder: nil,
-        # below: OAuth::AUTH_OPTIONS
+        # parameters below: OAuth::AUTH_OPTIONS
         url:,
         auth:,
         client_id: nil,
@@ -284,12 +286,18 @@ module Aspera
       )
         # Test here because link may set url
         Aspera.assert(url, 'Missing mandatory option: url', type: ParameterError)
-        Aspera.assert(scope, 'Missing mandatory option: scope', type: ParameterError)
+        # analyze type of url
+        url_info = self.class.link_info(url)
+        Log.dump(:url_info, url_info)
+        @private_link = url_info[:private_link]
+        Aspera.assert(auth, 'Missing mandatory option: auth', type: ParameterError) unless url_info.key?(:token)
+        # this is the base API url
+        api_url_base = self.class.api_base_url(url_info[:instance_domain])
+        Aspera.assert(scope, 'Missing mandatory option: scope', type: ParameterError) unless auth.eql?(:none)
         # default values for client id
         client_id, client_secret = self.class.get_client_info if client_id.nil?
         # access key secrets are provided out of band to get node api access
-        # key: access key
-        # value: associated secret
+        # maps access key (String) to its associated secret (String)
         @secret_finder = secret_finder
         @cache_user_info = nil
         @cache_url_token_info = nil
@@ -298,28 +306,21 @@ module Aspera
         # Used only for init: provided by user
         @ws_ids = {id: nil, name: nil}
         @home_info = nil
-        auth_params = {
-          type:   :oauth2,
-          params: {
-            client_id:     client_id,
-            client_secret: client_secret,
-            scope:         scope
+        base_args = {
+          base_url: "#{api_url_base}/#{subpath}",
+          auth:     {
+            type:         :oauth2,
+            grant_method: url_info.key?(:token) ? :url_json : auth,
+            base_url:     "#{api_url_base}/#{OAUTH_API_SUBPATH}/#{url_info[:organization]}",
+            params:       {
+              client_id:     client_id,
+              client_secret: client_secret,
+              scope:         scope
+            }
           }
         }
-        # analyze type of url
-        url_info = AoC.link_info(url)
-        Log.dump(:url_info, url_info)
-        @private_link = url_info[:private_link]
-        auth_params[:grant_method] = if url_info.key?(:token)
-          :url_json
-        else
-          Aspera.assert(auth, 'Missing mandatory option: auth', type: ParameterError)
-          auth
-        end
-        # this is the base API url
-        api_url_base = self.class.api_base_url(api_domain: url_info[:instance_domain])
-        # auth URL
-        auth_params[:base_url] = "#{api_url_base}/#{OAUTH_API_SUBPATH}/#{url_info[:organization]}"
+        # shortcut alias
+        auth_params = base_args[:auth]
         # fill other auth parameters based on OAuth method
         case auth_params[:grant_method]
         when :web
@@ -344,12 +345,16 @@ module Aspera
           auth_params[:json][:password] = password unless password.nil?
           # basic auth required for /token
           auth_params[:auth] = {type: :basic, username: client_id, password: client_secret}
-        else Aspera.error_unexpected_value(auth_params[:grant_method]){'auth, use one of: :web, :jwt'}
+        when :boot
+          # cookie is optional: if absent, existing cache is used
+          auth_params[:cookie] = password unless password.nil?
+          auth_params[:username] = username unless username.nil?
+        when :none
+          auth_params.clear
+          auth_params[:type] = :none
+        else Aspera.error_unexpected_value(auth_params[:grant_method]){'auth, use one of: web, jwt, boot'}
         end
-        super(
-          base_url: "#{api_url_base}/#{subpath}",
-          auth: auth_params
-          )
+        super(**base_args)
       end
 
       # Read using the query and paging
@@ -473,17 +478,17 @@ module Aspera
       # @param workspace_name [String,nil] workspace name
       # @param scope          [String,nil] e.g. Node::Scope::USER, or Node::Scope::ADMIN, or nil (requires secret)
       # @param package_info   [Hash,nil] created package information
-      # @returns [Node] a node API for access key
+      # @return [Node] a node API for access key
       def node_api_from(node_id:, workspace_id: nil, workspace_name: nil, scope: Node::Scope::USER, package_info: nil)
         Aspera.assert_type(node_id, String)
         node_info = read("nodes/#{node_id}")
         workspace_name = read("workspaces/#{workspace_id}")['name'] if workspace_name.nil? && !workspace_id.nil?
         app_info = AppInfo.new(self, package_info, node_info, workspace_id, workspace_name)
         node_params = {base_url: node_info['url']}
-        ak_secret = @secret_finder&.lookup_secret(url: node_info['url'], username: node_info['access_key'])
+        ak_secret = @secret_finder&.lookup(url: node_info['url'], username: node_info['access_key'])
         # If secret is available, or no scope, use basic auth
         if scope.nil? || ak_secret
-          Aspera.assert(ak_secret, "Secret not found for access key #{node_info['access_key']}@#{node_info['url']}", type: Error)
+          Aspera.assert(ak_secret, type: Error){"Secret not found for access key #{node_info['access_key']}@#{node_info['url']}"}
           node_params[:auth] = {
             type:     :basic,
             username: node_info['access_key'],
@@ -520,10 +525,10 @@ module Aspera
         Log.dump(:metadata, pkg_meta)
         pkg_meta.each do |field|
           Aspera.assert_type(field, Hash){'metadata field'}
-          Aspera.assert(field.key?('name')){'metadata field must have name'}
-          Aspera.assert(field.key?('values')){'metadata field must have values'}
+          Aspera.assert(field.key?('name'), 'metadata field must have name')
+          Aspera.assert(field.key?('values'), 'metadata field must have values')
           Aspera.assert_type(field['values'], Array){'metadata field values'}
-          Aspera.assert(!meta_schema.none?{ |i| i['name'].eql?(field['name'])}){"unknown metadata field: #{field['name']}"}
+          Aspera.assert(meta_schema.any?{ |i| i['name'].eql?(field['name'])}){"unknown metadata field: #{field['name']}"}
         end
         meta_schema.each do |field|
           provided = pkg_meta.select{ |i| i['name'].eql?(field['name'])}
@@ -538,7 +543,7 @@ module Aspera
       # @param package_data    [Hash]   The whole package creation payload
       # @param rcpt_lst_field  [String] The field in structure, i.e. recipients or bcc_recipients
       # @param new_user_option [Hash]   Additional fields for contact creation
-      # @return nil, `package_data` is modified
+      # @return [nil] `package_data` is modified in place
       def resolve_package_recipients(package_data, rcpt_lst_field, new_user_option)
         return unless package_data.key?(rcpt_lst_field)
         Aspera.assert_type(package_data[rcpt_lst_field], Array){rcpt_lst_field}
@@ -602,7 +607,7 @@ module Aspera
       # @param package_data [Hash] package creation (with extensions...)
       # @param validate_meta [TrueClass,FalseClass] true to validate parameters locally
       # @param new_user_option [Hash,NilClass] options if an unknown user is specified
-      # @return transfer spec, node api and package information
+      # @return [Array] transfer spec, node api and package information
       def create_package_simple(package_data, validate_meta, new_user_option)
         update_package_metadata_for_api(package_data)
         # list of files to include in package, optional
@@ -749,7 +754,7 @@ module Aspera
       # @param types [Array] event types
       def permissions_send_event(event_data:, app_info:, types: PERMISSIONS_CREATED)
         Aspera.assert_type(types, Array)
-        Aspera.assert(!types.empty?)
+        Aspera.assert(!types.empty?, 'types must not be empty')
         event_creation = {
           'types'        => types,
           'node_id'      => app_info.node_info['id'],

data/lib/aspera/api/cos_node.rb

@@ -24,7 +24,7 @@ module Aspera
           endpoints = Aspera::Rest.new(base_url: service_credentials['endpoints']).read('')
           Log.dump(:endpoints, endpoints)
           endpoint = endpoints.dig('service-endpoints', 'regional', bucket_region, 'public', bucket_region)
-          raise "no such region: #{bucket_region}" if endpoint.nil?
+          Aspera.assert(!endpoint.nil?){"no such region: #{bucket_region}"}
           return {
             instance_id: service_credentials['resource_instance_id'],
             api_key:     service_credentials['apikey'],
@@ -63,7 +63,7 @@ module Aspera
         ats_info = XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
         Log.dump(:ats_info, ats_info)
         Aspera.assert_hash_all(ats_info, String, nil){'ats_info'}
-        Aspera.assert((FASP_INFO_KEYS - ats_info.keys).empty?){'ats_info missing required keys'}
+        Aspera.assert((FASP_INFO_KEYS - ats_info.keys).empty?, 'ats_info missing required keys')
         Aspera.assert_hash_all(ats_info['AccessKey'], String, String){'ats_info'}
         @storage_credentials = {
           'type'  => 'token',

data/lib/aspera/api/faspex.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'aspera/assert'
 require 'aspera/rest'
 require 'aspera/oauth/base'
 require 'aspera/rest_list'
@@ -11,9 +12,9 @@ module Aspera
     class << self
       attr_accessor :additional_info
     end
-    # @param context         The `context` query parameter in public link
-    # @param redirect_uri    URI of web UI login
-    # @param path_authorize  Path to provide passcode
+    # @param context        [String] The `context` query parameter in public link
+    # @param redirect_uri   [String] URI of web UI login
+    # @param path_authorize [String] Path to provide passcode
     def initialize(
       context:,
       redirect_uri:,
@@ -45,7 +46,7 @@ module Aspera
       info = Rest.query_to_h(URI.parse(http['Location']).query)
       Log.dump(:info, info)
       raise Error, info['action_message'] if info['action_message']
-      Aspera.assert(info['code']){'Missing code in answer'}
+      Aspera.assert(info['code'], 'Missing code in answer')
       # Exchange code for token
       return create_token_call(base_params.merge(
         grant_type:   'authorization_code',
@@ -87,6 +88,7 @@ module Aspera
         email_notifications
         alternate_addresses
         webhooks
+        file_processing
       ].freeze
       # states for jobs not in final state
       JOB_RUNNING = %w[queued working].freeze
@@ -124,7 +126,7 @@ module Aspera
         mfa_code
       ]
       class << self
-        # @return true if the URL is a public link
+        # @return [Boolean] true if the URL is a public link
         def public_link?(url)
           url.include?('?context=')
         end
@@ -137,15 +139,15 @@ module Aspera
       end
       attr_reader :pub_link_context
 
-      # @param url             Faspex URL, can be a public link
-      # @param auth            Authentication method: :boot (token in header), :web (open browser), :jwt (client_id + private key), :public_link (context in URL)
-      # @param password        For :boot auth, the token copied directly from browser in developer mode
-      # @param client_id       For :web and :jwt auth, the client_id of web UI application
-      # @param client_secret   For :web auth, the client_secret of web UI application (not needed for :jwt)
-      # @param redirect_uri    For :web auth, the redirect_uri of web UI application (must be the same as in application configuration)
-      # @param username        For :jwt auth, the username of the user to impersonate
-      # @param private_key     For :jwt auth, the private key to sign JWT token
-      # @param passphrase      For :jwt auth, the passphrase of the private key
+      # @param url            [String] Faspex URL, can be a public link
+      # @param auth           [Symbol] Authentication method: :boot (token in header), :web (open browser), :jwt (client_id + private key), :public_link (context in URL)
+      # @param password       [String, nil] For :boot auth, the token copied directly from browser in developer mode
+      # @param client_id      [String, nil] For :web and :jwt auth, the client_id of web UI application
+      # @param client_secret  [String, nil] For :web auth, the client_secret of web UI application (not needed for :jwt)
+      # @param redirect_uri   [String, nil] For :web auth, the redirect_uri of web UI application (must be the same as in application configuration)
+      # @param username       [String, nil] For :jwt auth, the username of the user to impersonate
+      # @param private_key    [String, nil] For :jwt auth, the private key to sign JWT token
+      # @param passphrase     [String, nil] For :jwt auth, the passphrase of the private key
       def initialize(
         url:,
         auth:,
@@ -168,7 +170,7 @@ module Aspera
             Log.dump(:final_url, final_url, level: :trace1)
             # Get context from query
             encoded_context = Rest.query_to_h(URI.parse(final_url).query)['context']
-            raise ParameterError, 'Bad faspex5 public link, missing context in query' if encoded_context.nil?
+            Aspera.assert(!encoded_context.nil?, type: ParameterError){'Bad faspex5 public link, missing context in query'}
             # public link information (contains passcode and allowed usage)
             @pub_link_context = JSON.parse(Base64.decode64(encoded_context))
             Log.dump(:pub_link_context, @pub_link_context, level: :trace1)
@@ -193,15 +195,15 @@ module Aspera
             }
           # old: headers:  {'Passcode' => @pub_link_context['passcode']}
           when :boot
-            Aspera.assert(password, type: ParameterError){'Missing password'}
+            Aspera.assert(password, 'Missing password', type: ParameterError)
             # the password here is the token copied directly from browser in developer mode
             {
               base_url: "#{url}/#{root}",
               headers:  {'Authorization' => password}
             }
           when :web
-            Aspera.assert(client_id, type: ParameterError){'Missing client_id'}
-            Aspera.assert(redirect_uri, type: ParameterError){'Missing redirect_uri'}
+            Aspera.assert(client_id, 'Missing client_id', type: ParameterError)
+            Aspera.assert(redirect_uri, 'Missing redirect_uri', type: ParameterError)
             # opens a browser and ask user to auth using web
             {
               base_url: "#{url}/#{root}",
@@ -216,8 +218,8 @@ module Aspera
               }
             }
           when :jwt
-            Aspera.assert(client_id, type: ParameterError){'Missing client_id'}
-            Aspera.assert(private_key, type: ParameterError){'Missing private_key'}
+            Aspera.assert(client_id, 'Missing client_id', type: ParameterError)
+            Aspera.assert(private_key, 'Missing private_key', type: ParameterError)
             {
               base_url: "#{url}/#{root}",
               auth:     {

data/lib/aspera/api/httpgw.rb

@@ -81,7 +81,7 @@ module Aspera
       end
 
       # Check header ourself and give precise error message, as websocket will only throw error without details
-      # @param [String] Response Header
+      # @param header [String] Response Header
       # @return [String] Response Header
       def validated_ws_response_header(header)
         first_line = header.split("\r\n").first
@@ -210,7 +210,7 @@ module Aspera
             fileIndex:    file_index
           }
           file = file_to_send[:file]
-          file = File.open(file) unless file.is_a?(Transfer::FauxFile)
+          file = File.open(file) unless file.is_a?(Transfer::FauxFile) # rubocop:disable Style/FileOpen
           begin
             until file.eof?
               slice_bin_data = file.read(@upload_chunk_size)
@@ -291,7 +291,7 @@ module Aspera
         return @api_info
       end
 
-      # @return the base url of the gateway
+      # @return [String] the base url of the gateway
       def base_url
         return @gw_root_url
       end
@@ -308,7 +308,7 @@ module Aspera
         Log.dump(:gw_url, url)
         # add scheme if missing
         url = "https://#{url}" unless url.match?(%r{^[a-z]{1,6}://})
-        raise Error, 'GW URL shall be with scheme https' unless url.start_with?('https://')
+        Aspera.assert(url.start_with?('https://'), type: Error){'GW URL shall be with scheme https'}
         # remove trailing slash and version (o=only once) if present
         # TODO: issue warning ?
         url = url.chomp('/').gsub(%r{/#{API_V1}$}o, '')