aspera-cli 4.24.1 → 4.25.0.pre

data/lib/aspera/ascp/installation.rb

@@ -33,25 +33,12 @@ module Aspera
     class Installation
       include Singleton
 
-      DEFAULT_ASPERA_CONF = <<~END_OF_CONFIG_FILE
-        <?xml version='1.0' encoding='UTF-8'?>
-        <CONF version="2">
-        <default>
-            <file_system>
-                <resume_suffix>.aspera-ckpt</resume_suffix>
-                <partial_file_suffix>.partial</partial_file_suffix>
-            </file_system>
-        </default>
-        </CONF>
-      END_OF_CONFIG_FILE
-      # all executable files from SDK
-      EXE_FILES = %i[ascp ascp4 async transferd].freeze
-      SDK_FILES = %i[ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].unshift(*EXE_FILES).freeze
-      TRANSFERD_ARCHIVE_LOCATION_URL = 'https://ibm.biz/sdk_location'
-      # filename for ascp with optional extension (Windows)
-      private_constant :DEFAULT_ASPERA_CONF, :SDK_FILES, :TRANSFERD_ARCHIVE_LOCATION_URL
       # options for SSH client private key
       CLIENT_SSH_KEY_OPTIONS = %i{dsa_rsa rsa per_client}.freeze
+      # prefix
+      USE_PRODUCT_PREFIX = 'product:'
+      # policy for product selection
+      FIRST_FOUND = 'FIRST'
 
       # Loads YAML from cloud with locations of SDK archives for all platforms
       # @return location structure
@@ -66,12 +53,13 @@ module Aspera
         end
       end
 
-      # set ascp executable path
+      # set ascp executable "location"
       def ascp_path=(v)
         Aspera.assert_type(v, String)
-        Aspera.assert(!v.empty?){'ascp path cannot be empty: check your config file'}
-        Aspera.assert(File.exist?(v)){"No such file: [#{v}]"}
-        @path_to_ascp = v
+        Aspera.assert(!v.empty?){'ascp location cannot be empty: check your config file'}
+        @ascp_location = v
+        @ascp_path = nil
+        return
       end
 
       def ascp_path
@@ -88,13 +76,12 @@ module Aspera
       def use_ascp_from_product(product_name)
         if product_name.eql?(FIRST_FOUND)
           pl = installed_products.first
-          raise "no Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf ascp install" if pl.nil?
+          raise "No Aspera transfer module or SDK found.\nRefer to the manual or install SDK with command:\nascli conf transferd install" if pl.nil?
         else
           pl = installed_products.find{ |i| i[:name].eql?(product_name)}
-          raise "no such product installed: #{product_name}" if pl.nil?
+          raise "No such product installed: #{product_name}" if pl.nil?
         end
-        self.ascp_path = pl[:ascp_path]
-        Log.log.debug{"ascp_path=#{@path_to_ascp}"}
+        @ascp_path = pl[:ascp_path]
       end
 
       # @return [Hash] with key = file name (String), and value = path to file
@@ -111,7 +98,9 @@ module Aspera
         end
       end
 
+      # TODO: if using another product than SDK, should use files from there
       def check_or_create_sdk_file(filename, force: false, &block)
+        FileUtils.mkdir_p(Products::Transferd.sdk_directory)
         return Environment.write_file_restricted(File.join(Products::Transferd.sdk_directory, filename), force: force, mode: 0o644, &block)
       end
 
@@ -127,10 +116,18 @@ module Aspera
           file = if k.eql?(:transferd)
             Products::Transferd.transferd_path
           else
-            # ensure at least ascp is found
-            use_ascp_from_product(FIRST_FOUND) if @path_to_ascp.nil?
+            # find ascp when needed
+            if @ascp_path.nil?
+              if @ascp_location.start_with?(USE_PRODUCT_PREFIX)
+                use_ascp_from_product(@ascp_location[USE_PRODUCT_PREFIX.length..-1])
+              else
+                @ascp_path = @ascp_location
+              end
+              Aspera.assert(File.exist?(@ascp_path)){"No such file: [#{@ascp_path}]"}
+              Log.log.debug{"ascp_path=#{@ascp_path}"}
+            end
             # NOTE: that there might be a .exe at the end
-            @path_to_ascp.gsub('ascp', k.to_s)
+            @ascp_path.gsub('ascp', k.to_s)
           end
         when :ssh_private_dsa, :ssh_private_rsa
           # assume last 3 letters are type
@@ -195,7 +192,9 @@ module Aspera
         return exe_version
       end
 
-      def ascp_pvcl_info
+      # Extract some stings from ascp logs
+      # Folder, PVCL, version, license information
+      def ascp_info_from_log
         data = {}
         # read PATHs from ascp directly, and pvcl modules as well
         Open3.popen3(ascp_path, '-DDL-') do |_stdin, _stdout, stderr, thread|
@@ -227,8 +226,9 @@ module Aspera
         return data
       end
 
-      # extract some stings from ascp binary
-      def ascp_ssl_info
+      # Extract some stings from ascp binary
+      # Openssl information
+      def ascp_info_from_file
         data = {}
         File.binread(ascp_path).scan(/[\x20-\x7E]{10,}/) do |bin_string|
           if (m = bin_string.match(/OPENSSLDIR.*"(.*)"/))
@@ -243,17 +243,17 @@ module Aspera
       # information for `ascp info`
       def ascp_info
         ascp_data = file_paths
-        ascp_data.merge!(ascp_pvcl_info)
-        ascp_data.merge!(ascp_ssl_info)
+        ascp_data.merge!(ascp_info_from_log)
+        ascp_data.merge!(ascp_info_from_file)
         return ascp_data
       end
 
       # @return the url for download of SDK archive for the given platform and version
       def sdk_url_for_platform(platform: nil, version: nil)
-        locations = sdk_locations
+        all_locations = sdk_locations
         platform = Environment.instance.architecture if platform.nil?
-        locations = locations.select{ |l| l['platform'].eql?(platform)}
-        raise "No SDK for platform: #{platform}" if locations.empty?
+        locations = all_locations.select{ |l| l['platform'].eql?(platform)}
+        raise "No SDK for platform: #{platform}, available: #{all_locations.map{ |i| i['platform']}.uniq}" if locations.empty?
         version = locations.max_by{ |entry| Gem::Version.new(entry['version'])}['version'] if version.nil?
         info = locations.select{ |entry| entry['version'].eql?(version)}
         raise "No such version: #{version} for #{platform}" if info.empty?
@@ -271,7 +271,9 @@ module Aspera
           Zip::File.open(sdk_archive_path) do |zip_file|
             zip_file.each do |entry|
               next if entry.name.end_with?('/')
-              yield(entry.name, entry.get_input_stream, nil)
+              entry.get_input_stream do |io|
+                yield(entry.name, io, nil)
+              end
             end
           end
         # Other Unixes use tar.gz
@@ -296,7 +298,7 @@ module Aspera
       # @param folder   [String] Destination folder path
       # @param backup   [Bool]   If destination folder exists, then rename
       # @param with_exe [Bool]   If false, only retrieves files, but do not generate or restrict access
-      # @param &block   [Proc]   A lambda that receives a file path from archive and tells detination sub folder(end with /) or file, or nil to not extract
+      # @param &block   [Proc]   A lambda that receives a file path from archive and tells destination sub folder(end with /) or file, or nil to not extract
       # @return ascp version (from execution)
       def install_sdk(url: nil, version: nil, folder: nil, backup: true, with_exe: true, &block)
         url = sdk_url_for_platform(version: version) if url.nil? || url.eql?('DEF')
@@ -308,6 +310,7 @@ module Aspera
             Products::Transferd::RUNTIME_FOLDERS.any?{ |i| name.match?(%r{^[^/]*/#{i}/})} ? '/' : nil
           end
         end
+        FileUtils.mkdir_p(folder)
         # rename old install
         if backup && !Dir.empty?(folder)
           Log.log.warn('Previous install exists, renaming folder.')
@@ -333,7 +336,7 @@ module Aspera
           end
         end
         return unless with_exe
-        # ensure necessary files are there, or generate them
+        # Ensure necessary files are there, or generate them
         SDK_FILES.each do |file_id_sym|
           file_path = path(file_id_sym)
           if file_path && EXE_FILES.include?(file_id_sym)
@@ -352,11 +355,27 @@ module Aspera
 
       private
 
-      # policy for product selection
-      FIRST_FOUND = 'FIRST'
+      DEFAULT_ASPERA_CONF = <<~END_OF_CONFIG_FILE
+        <?xml version='1.0' encoding='UTF-8'?>
+        <CONF version="2">
+        <default>
+            <file_system>
+                <resume_suffix>.aspera-ckpt</resume_suffix>
+                <partial_file_suffix>.partial</partial_file_suffix>
+            </file_system>
+        </default>
+        </CONF>
+      END_OF_CONFIG_FILE
+      # all executable files from SDK
+      EXE_FILES = %i[ascp ascp4 async transferd].freeze
+      SDK_FILES = %i[ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].unshift(*EXE_FILES).freeze
+      TRANSFERD_ARCHIVE_LOCATION_URL = 'https://ibm.biz/sdk_location'
+      # filename for ascp with optional extension (Windows)
+      private_constant :DEFAULT_ASPERA_CONF, :EXE_FILES, :SDK_FILES, :TRANSFERD_ARCHIVE_LOCATION_URL
 
       def initialize
-        @path_to_ascp = nil
+        @ascp_path = nil
+        @ascp_location = nil
         @sdk_dir = nil
         @found_products = nil
         @transferd_urls = TRANSFERD_ARCHIVE_LOCATION_URL
@@ -366,22 +385,18 @@ module Aspera
 
       # @return the list of installed products in format of product_locations_on_current_os
       def installed_products
-        if @found_products.nil?
-          # :expected  M app name is taken from the manifest if present, else defaults to this value
-          # :app_root  M main folder for the application
-          # :log_root  O location of log files (Linux uses syslog)
-          # :run_root  O only for Connect Client, location of http port file
-          # :sub_bin   O subfolder with executables, default : bin
-          scan_locations = Products::Transferd.locations.concat(
-            Products::Desktop.locations,
-            Products::Connect.locations,
-            Products::Other::LOCATION_ON_THIS_OS
-          )
-          # .each {|item| item.deep_do {|h, _k, _v, _m|h.freeze}}.freeze
-          # search installed products: with ascp
-          @found_products = Products::Other.find(scan_locations)
-        end
-        return @found_products
+        return @found_products unless @found_products.nil?
+        # :expected  M app name is taken from the manifest if present, else defaults to this value
+        # :app_root  M main folder for the application
+        # :log_root  O location of log files (Linux uses syslog)
+        # :run_root  O only for Connect Client, location of http port file
+        # :sub_bin   O subfolder with executables, default : bin
+        scan_locations = Products::Transferd.locations +
+          Products::Desktop.locations +
+          Products::Connect.locations +
+          Products::Other::LOCATION_ON_THIS_OS
+        # search installed products: with ascp
+        @found_products = Products::Other.find(scan_locations)
       end
     end
   end

data/lib/aspera/ascp/management.rb

@@ -6,6 +6,90 @@ module Aspera
   module Ascp
     # processing of ascp management port events
     class Management
+      # from https://www.google.com/search?q=FASP+error+codes
+      # Note that the fact that an error is retry-able is not internally defined by protocol, it's client-side responsibility
+      # rubocop:disable Layout/FirstHashElementLineBreak
+      ERRORS = {
+        # id   retry-able    mnemo/code                        message                                              additional info
+        0  => {r: false, c: 'UNKNOWN',                     m: 'unknown',                                        a: 'unknown'},
+        1  => {r: false, c: 'FASP_PROTO',                  m: 'Generic fasp(tm) protocol error',                a: 'fasp(tm) error'},
+        2  => {r: false, c: 'ASCP',                        m: 'Generic SCP error',                              a: 'ASCP error'},
+        3  => {r: false, c: 'AMBIGUOUS_TARGET',            m: 'Target incorrectly specified',                   a: 'Ambiguous target'},
+        4  => {r: false, c: 'NO_SUCH_FILE',                m: 'No such file or directory',                      a: 'No such file or directory'},
+        5  => {r: false, c: 'NO_PERMS',                    m: 'Insufficient permission to read or write',       a: 'Insufficient permissions'},
+        6  => {r: false, c: 'NOT_DIR',                     m: 'Target is not a directory',                      a: 'Target must be a directory'},
+        7  => {r: false, c: 'IS_DIR',                      m: 'File is a directory - expected regular file',    a: 'Expected regular file'},
+        8  => {r: false, c: 'USAGE',                       m: 'Incorrect usage of scp command',                 a: 'Incorrect usage of Aspera scp command'},
+        9  => {r: false, c: 'LIC_DUP',                     m: 'Duplicate license',                              a: 'Duplicate license'},
+        10 => {r: false, c: 'LIC_RATE_EXCEEDED',           m: 'Rate exceeds the cap imposed by license',        a: 'Rate exceeds cap imposed by license'},
+        11 => {r: false, c: 'INTERNAL_ERROR',              m: 'Internal error (unexpected error)',              a: 'Internal error'},
+        12 => {r: true,  c: 'TRANSFER_ERROR',              m: 'Error establishing control connection',
+                                                                a: 'Error establishing SSH connection (check SSH port and firewall)'},
+        13 => {r: true,  c: 'TRANSFER_TIMEOUT',            m: 'Timeout establishing control connection',
+                                                                a: 'Timeout establishing SSH connection (check SSH port and firewall)'},
+        14 => {r: true,  c: 'CONNECTION_ERROR',            m: 'Error establishing data connection',
+                                                                a: 'Error establishing UDP connection (check UDP port and firewall)'},
+        15 => {r: true,  c: 'CONNECTION_TIMEOUT',          m: 'Timeout establishing data connection',
+                                                                a: 'Timeout establishing UDP connection (check UDP port and firewall)'},
+        16 => {r: true,  c: 'CONNECTION_LOST',             m: 'Connection lost',                                a: 'Connection lost'},
+        17 => {r: true,  c: 'RCVR_SEND_ERROR',             m: 'Receiver fails to send feedback',                a: 'Network failure (receiver can\'t send feedback)'},
+        18 => {r: true,  c: 'RCVR_RECV_ERROR',             m: 'Receiver fails to receive data packets',         a: 'Network failure (receiver can\'t receive UDP data)'},
+        19 => {r: false, c: 'AUTH',                        m: 'Authentication failure',                         a: 'Authentication failure'},
+        20 => {r: false, c: 'NOTHING',                     m: 'Nothing to transfer',                            a: 'Nothing to transfer'},
+        21 => {r: false, c: 'NOT_REGULAR',                 m: 'Not a regular file (special file)',              a: 'Not a regular file'},
+        22 => {r: false, c: 'FILE_TABLE_OVR',              m: 'File table overflow',                            a: 'File table overflow'},
+        23 => {r: true,  c: 'TOO_MANY_FILES',              m: 'Too many files open',                            a: 'Too many files open'},
+        24 => {r: false, c: 'FILE_TOO_BIG',                m: 'File too big for file system',                   a: 'File too big for filesystem'},
+        25 => {r: false, c: 'NO_SPACE_LEFT',               m: 'No space left on disk',                          a: 'No space left on disk'},
+        26 => {r: false, c: 'READ_ONLY_FS',                m: 'Read only file system',                          a: 'Read only filesystem'},
+        27 => {r: false, c: 'SOME_FILE_ERRS',              m: 'Some individual files failed',                   a: 'One or more files failed'},
+        28 => {r: false, c: 'USER_CANCEL',                 m: 'Cancelled by user',                              a: 'Cancelled by user'},
+        29 => {r: false, c: 'LIC_NOLIC',                   m: 'License not found or unable to access',          a: 'Unable to access license info'},
+        30 => {r: false, c: 'LIC_EXPIRED',                 m: 'License expired',                                a: 'License expired'},
+        31 => {r: false, c: 'SOCK_SETUP',                  m: 'Unable to setup socket (create, bind, etc ...)', a: 'Unable to set up socket'},
+        32 => {r: true,  c: 'OUT_OF_MEMORY',               m: 'Out of memory, unable to allocate',              a: 'Out of memory'},
+        33 => {r: true,  c: 'THREAD_SPAWN',                m: 'Can\'t spawn thread',                            a: 'Unable to spawn thread'},
+        34 => {r: false, c: 'UNAUTHORIZED',                m: 'Unauthorized by external auth server',           a: 'Unauthorized'},
+        35 => {r: true,  c: 'DISK_READ',                   m: 'Error reading source file from disk',            a: 'Disk read error'},
+        36 => {r: true,  c: 'DISK_WRITE',                  m: 'Error writing to disk',                          a: 'Disk write error'},
+        37 => {r: true,  c: 'AUTHORIZATION',               m: 'Used interchangeably with ERR_UNAUTHORIZED',     a: 'Authorization failure'},
+        38 => {r: false, c: 'LIC_ILLEGAL',                 m: 'Operation not permitted by license',             a: 'Operation not permitted by license'},
+        39 => {r: true,  c: 'PEER_ABORTED_SESSION',        m: 'Remote peer terminated session',                 a: 'Peer aborted session'},
+        40 => {r: true,  c: 'DATA_TRANSFER_TIMEOUT',       m: 'Transfer stalled, timed out',                    a: 'Data transfer stalled, timed out'},
+        41 => {r: false, c: 'BAD_PATH',                    m: 'Path violates docroot containment',              a: 'File location is outside \'docroot\' hierarchy'},
+        42 => {r: false, c: 'ALREADY_EXISTS',              m: 'File or directory already exists',               a: 'File or directory already exists'},
+        43 => {r: false, c: 'STAT_FAILS',                  m: 'Cannot stat file',                               a: 'Cannot collect details about file or directory'},
+        44 => {r: true,  c: 'PMTU_BRTT_ERROR',             m: 'UDP session initiation fatal error',             a: 'UDP session initiation fatal error'},
+        45 => {r: true,  c: 'BWMEAS_ERROR',                m: 'Bandwidth measurement fatal error',              a: 'Bandwidth measurement fatal error'},
+        46 => {r: false, c: 'VLINK_ERROR',                 m: 'Virtual link error',                             a: 'Virtual link error'},
+        47 => {r: false, c: 'CONNECTION_ERROR_HTTP',       m: 'Error establishing HTTP connection',
+                                                            a: 'Error establishing HTTP connection (check HTTP port and firewall)'},
+        48 => {r: false, c: 'FILE_ENCRYPTION_ERROR',       m: 'File encryption error, e.g. corrupt file',
+                                                            a: 'File encryption/decryption error, e.g. corrupt file'},
+        49 => {r: false, c: 'FILE_DECRYPTION_PASS',        m: 'File encryption/decryption error, e.g. corrupt file', a: 'File decryption error, bad passphrase'},
+        50 => {r: false, c: 'BAD_CONFIGURATION',           m: 'Aspera.conf contains invalid data and was rejected',  a: 'Invalid configuration'},
+        51 => {r: false, c: 'INSECURE_CONNECTION',         m: 'Remote-host key check failure',                  a: 'Remote host is not who we expected'},
+        52 => {r: false, c: 'START_VALIDATION_FAILED',     m: 'File start validation failed',                   a: 'File start validation failed'},
+        53 => {r: false, c: 'STOP_VALIDATION_FAILED',      m: 'File stop validation failed',                    a: 'File stop validation failed'},
+        54 => {r: false, c: 'THRESHOLD_VALIDATION_FAILED', m: 'File threshold validation failed',               a: 'File threshold validation failed'},
+        55 => {r: false, c: 'FILEPATH_TOO_LONG',           m: 'File path/name too long for underlying file system', a: 'File path exceeds underlying file system limit'},
+        56 => {r: false, c: 'ILLEGAL_CHARS_IN_PATH',       m: 'Windows path contains illegal characters',
+                                                                a: 'Path being written to Windows file system contains illegal characters'},
+        57 => {r: false, c: 'CHUNK_MUST_MATCH_ALIGNMENT',  m: 'Chunk size/start must be aligned with storage',  a: 'Chunk size/start must be aligned with storage'},
+        58 => {r: false, c: 'VALIDATION_SESSION_ABORT',    m: 'Session aborted to due to validation error',     a: 'Session aborted to due validation error'},
+        59 => {r: false, c: 'REMOTE_STORAGE_ERROR',        m: 'Remote storage errored',                         a: 'Remote storage errored'},
+        60 => {r: false, c: 'LUA_SCRIPT_ABORTED_SESSION',  m: 'Session aborted due to Lua script abort',        a: 'Session aborted due to Lua script abort'},
+        61 => {r: true,  c: 'SSEAR_RETRYABLE',             m: 'Transfer failed because of a retryable Encryption at Rest error',
+                                                                a: 'Transfer failed because of a retryable Encryption at Rest error'},
+        62 => {r: false, c: 'SSEAR_FATAL',                 m: 'Transfer failed because of a fatal Encryption at Rest error',
+                                                                a: 'Transfer failed because of a fatal Encryption at Rest error'},
+        63 => {r: false, c: 'LINK_LOOP',                   m: 'Path refers to a symbolic link loop',            a: 'Path refers to a symbolic link loop'},
+        64 => {r: false, c: 'CANNOT_RENAME_PARTIAL_FILES', m: 'Can\'t rename a partial file',                   a: 'Can\'t rename a partial file.'},
+        65 => {r: false, c: 'CIPHER_NON_COMPAT_FIPS',      m: 'Can\'t use this cipher with FIPS mode enabled',  a: 'Can\'t use this cipher with FIPS mode enabled'},
+        66 => {r: false, c: 'PEER_REQUIRES_FIPS',          m: 'Peer rejects cipher due to FIPS mode enabled on peer',
+                                                                a: 'Peer rejects cipher due to FIPS mode enabled on peer'}
+      }.freeze
+      # rubocop:enable Layout/FirstHashElementLineBreak
       # cspell: disable
       OPERATIONS = %w[
         NOP
@@ -187,7 +271,8 @@ module Aspera
         ExtraCreatePolicy
       ]
       # Management port start message
-      MGT_HEADER = 'FASPMGR 2'
+      PROT_VERSION = '2'
+      MGT_HEADER = "FASPMGR #{PROT_VERSION}"
       # empty line is separator to end event information
       MGT_FRAME_SEPARATOR = ''
       # fields description for JSON generation
@@ -204,33 +289,44 @@ module Aspera
       # cspell: enable
 
       class << self
-        # translates mgt port event into (enhanced) typed event
-        def enhanced_event_format(event)
-          return event.keys.each_with_object({}) do |e, h|
-                   new_name =
-                     case e
-                     when 'Elapsedusec' then 'elapsed_usec'
-                     when 'Bytescont' then 'bytes_cont'
-                     else e.capital_to_snake
-                     end
-                   h[new_name] =
-                     if INTEGER_FIELDS.include?(e) then event[e].to_i
-                     elsif BOOLEAN_FIELDS.include?(e) then event[e].eql?(BOOLEAN_TRUE)
-                     else
-                       event[e]
-                     end
-                 end
+        # translate native event name to snake case
+        def field_native_to_snake(name)
+          case name
+          when 'Elapsedusec' then 'elapsed_usec'
+          when 'Bytescont' then 'bytes_cont'
+          else name.capital_to_snake
+          end
         end
 
-        # build command to send on management port
-        # @param data [Hash] {'type'=>'START','source'=>_path_,'destination'=>_path_}
+        # translate snake case event name to native
+        # @param name [String] Field name
+        def field_snake_to_native(name)
+          field = name.delete('_')
+          result = PARAMETERS.find{ |w| w.casecmp?(field)}
+          raise "No such field: #{name}" if result.nil?
+          result
+        end
+
+        # Translates mgt port event into (enhanced) typed event
+        def event_native_to_snake(event)
+          event.each_with_object({}) do |(key, value), h|
+            h[field_native_to_snake(key)] =
+              if INTEGER_FIELDS.include?(key) then value.to_i
+              elsif BOOLEAN_FIELDS.include?(key) then value.eql?(BOOLEAN_TRUE)
+              else
+                value
+              end
+          end
+        end
+
+        # Build command to send on management port
+        # @param data [Hash] e.g. {'type'=>'START','source'=>_path_,'destination'=>_path_}
+        # @return [String] frame to send on management port
         def command_to_stream(data)
-          # TODO: translate enhanced to capitalized ?
           data
-            .keys
-            .map{ |k| "#{k.capitalize}: #{data[k]}"}
+            .map{ |key, value| "#{field_snake_to_native(key)}: #{value}"}
             .unshift(MGT_HEADER)
-            .push('', '')
+            .push(MGT_FRAME_SEPARATOR, '')
             .join("\n")
         end
       end

data/lib/aspera/assert.rb

@@ -5,6 +5,10 @@ module Aspera
   class Error < StandardError
   end
 
+  # Any problem with parameter values
+  class ParameterError < Error
+  end
+
   # Error that shall not happen, else it's a bug
   class InternalError < Error
   end
@@ -12,8 +16,10 @@ module Aspera
   # An expected condition was not met
   class AssertError < Error
   end
+
   class << self
-    # Replace `raise`, allows sending exception, or just error log, when type is `:error`
+    # Replaces `raise` in assertion
+    # Allows sending exception, or just error log, when type is `:error`
     # @param type [Exception,Symbol] Send to log if symbol, else raise exception
     # @param message [String] Message for error.
     def report_error(type, message)
@@ -28,32 +34,54 @@ module Aspera
     # @param assertion [Bool]       Must be true
     # @param info      [String,nil] Fixed message in case assert fails, else use `block`
     # @param type      [Exception,Symbol] Exception to raise, or Symbol for Log.log
-    # @param block     [Proc]       Produces a string that desribes the problem for complex messages
+    # @param block     [Proc]       Produces a string that describes the problem for complex messages
     # The block is executed in the context of the Aspera module
     def assert(assertion, info = nil, type: AssertError)
       raise InternalError, 'bad assert: both info and block given' unless info.nil? || !block_given?
       return if assertion
       message = 'assertion failed'
       info = yield if block_given?
-      message = "#{message}: #{info}" if info
-      message = "#{message}: #{caller.find{ |call| !call.start_with?(__FILE__)}}"
+      message = type.eql?(AssertError) ? "#{message}: #{info}" : info if info
+      # message = "#{message}: #{caller.find{ |call| !call.start_with?(__FILE__)}}"
       report_error(type, message)
     end
 
     # Assert that value has the given type
-    # @param value   [Object]       The value to check
-    # @param classes [Class, Array] The expected type(s)
+    # @param value   [Object]           The value to check
+    # @param classes [Class, Array]     The expected type(s)
     # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
-    # @param block   [Proc]         Additional description in front of message
+    # @param block   [Proc]             Additional description in front of message
     def assert_type(value, *classes, type: AssertError)
-      assert(classes.any?{ |k| value.is_a?(k)}, type: type){"#{"#{yield}: " if block_given?}expecting #{classes.join(', ')}, but have #{value.inspect}"}
+      assert(classes.any?{ |k| value.is_a?(k)}, type: type){"#{"#{yield}: " if block_given?}expecting #{classes.join(', ')}, but have (#{value.class})#{value.inspect}"}
+    end
+
+    # Assert that all value of array are of the same specified type
+    # @param array   [Array]            The array to check
+    # @param klass   [Class]            The expected type of elements
+    # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block   [Proc]             Additional description in front of message
+    def assert_array_all(array, klass, type: AssertError)
+      assert_type(array, Array, type: type)
+      assert(array.all?(klass), type: type){"#{"#{yield}: " if block_given?}expecting all as #{klass}, but have #{array.map(&:class).uniq}"}
+    end
+
+    # Assert value is Hash, keys have type, and Values have type
+    # @param hash        [Hash]             The hash to check
+    # @param key_class   [Class]            The expected type of keys (or nil)
+    # @param value_class [Class]            The expected type of values (or nil)
+    # @param type        [Exception,Symbol] Exception to raise, or Symbol for Log.log
+    # @param block       [Proc]             Additional description in front of message
+    def assert_hash_all(hash, key_class, value_class, type: AssertError)
+      assert_type(hash, Hash, type: type)
+      assert_array_all(hash.keys, key_class, type: AssertError){"#{"#{yield}: " if block_given?}keys"} unless key_class.nil?
+      assert_array_all(hash.values, value_class, type: AssertError){"#{"#{yield}: " if block_given?}values"} unless value_class.nil?
     end
 
     # Assert that value is one of the given values
-    # @param value  [any]   value to check
-    # @param values [Array] accepted values
+    # @param value  [any]              Value to check
+    # @param values [Array]            Accepted values
     # @param type   [Exception,Symbol] Exception to raise, or Symbol for Log.log
-    # @param block  [Proc]         Additional description in front of message
+    # @param block  [Proc]             Additional description in front of message
     def assert_values(value, values, type: AssertError)
       assert(values.include?(value), type: type) do
         val_list = values.inspect

data/lib/aspera/cli/error.rb

@@ -6,11 +6,13 @@ module Aspera
     class Error < StandardError; end
     # Raised when an unexpected argument is provided.
     class BadArgument < Error; end
+    class MissingArgument < Error; end
     class NoSuchElement < Error; end
 
     class BadIdentifier < Error
-      def initialize(res_type, res_id)
-        super("#{res_type} with identifier #{res_id} not found")
+      def initialize(res_type, res_id, field: 'identifier', count: 0)
+        msg = count.eql?(0) ? 'not found' : "found #{count}"
+        super("#{res_type} with #{field}=#{res_id}: #{msg}")
       end
     end
   end