aspera-cli 4.24.2 → 4.25.0.pre

data/lib/aspera/api/aoc.rb

@@ -73,7 +73,7 @@ module Aspera
         # split host of URL into organization and domain
         def split_org_domain(uri)
           Aspera.assert_type(uri, URI)
-          raise "No host found in URL.Please check URL format: https://myorg.#{SAAS_DOMAIN_PROD}" if uri.host.nil?
+          Aspera.assert(!uri.host.nil?){"No host found in URL. Please check URL format: https://myorg.#{SAAS_DOMAIN_PROD}"}
           parts = uri.host.split('.', 2)
           Aspera.assert(parts.length == 2){"expecting a public FQDN for #{PRODUCT_NAME}"}
           parts[0] = nil if parts[0].eql?('api')
@@ -89,7 +89,7 @@ module Aspera
         # @param url [String] URL of AoC public link
         # @return [Hash] information about public link, or nil if not a public link
         def link_info(url)
-          final_uri = Rest.new(base_url: url, redirect_max: MAX_AOC_URL_REDIRECT).call(operation: 'GET')[:http].uri
+          final_uri = Rest.new(base_url: url, redirect_max: MAX_AOC_URL_REDIRECT).call(operation: 'GET', ret: :resp).uri
           Log.dump(:final_uri, final_uri, level: :trace1)
           org_domain = split_org_domain(final_uri)
           if (m = final_uri.path.match(%r{/oauth2/([^/]+)/login$}))
@@ -97,7 +97,7 @@ module Aspera
           else
             Log.log.debug{"path=#{final_uri.path} does not end with /login"}
           end
-          raise Error, 'AoC shall redirect to login page with a query' if final_uri.query.nil?
+          Aspera.assert(!final_uri.query.nil?, 'AoC shall redirect to login page with a query', type: Error)
           query = Rest.query_to_h(final_uri.query)
           Log.dump(:query, query, level: :trace1)
           # is that a public link ?
@@ -141,9 +141,10 @@ module Aspera
         end
 
         # Call block with same query using paging and response information.
-        # Block must return a hash with :data and :http keys
+        # Block must return an Array with data and http response
         # @return [Hash] {items: , total: }
-        def call_paging(query: {}, formatter: nil)
+        def call_paging(query: nil, formatter: nil)
+          query = {} if query.nil?
           Aspera.assert_type(query, Hash){'query'}
           Aspera.assert(block_given?)
           # set default large page if user does not specify own parameters. AoC Caps to 1000 anyway
@@ -158,33 +159,62 @@ module Aspera
           loop do
             new_query = query.clone
             new_query['page'] = current_page
-            result = yield(new_query)
-            Aspera.assert(result[:data])
-            Aspera.assert(result[:http])
-            total_count = result[:http]['X-Total-Count']
+            result_data, result_http = yield(new_query)
+            Aspera.assert(result_http)
+            total_count = result_http['X-Total-Count']&.to_i
             page_count += 1
             current_page += 1
-            add_items = result[:data]
+            add_items = result_data
+            break if add_items.nil?
             break if add_items.empty?
             # append new items to full list
             item_list += add_items
             break if !max_items.nil? && item_list.count >= max_items
             break if !max_pages.nil? && page_count >= max_pages
+            break if total_count&.<=(item_list.count)
             formatter&.long_operation_running("#{item_list.count} / #{total_count}") unless total_count.eql?(item_list.count.to_s)
           end
           formatter&.long_operation_terminated
           item_list = item_list[0..max_items - 1] if !max_items.nil? && item_list.count > max_items
           return {items: item_list, total: total_count}
         end
+
+        # @param id [String] Identifier or workspace
+        # @return [Hash] suitable for permission filtering
+        def workspace_access(id)
+          {
+            'access_type' => 'user',
+            'access_id'   => "#{ID_AK_ADMIN}_WS_#{id}"
+          }
+        end
+
+        # @param permission [Hash] Shared folder information
+        # @return [Boolean] `true` if internal access
+        def workspace_access?(permission)
+          permission['access_id'].start_with?("#{ID_AK_ADMIN}_WS_")
+        end
       end
 
       attr_reader :private_link
 
-      def initialize(url:, auth:, subpath: API_V1, client_id: nil, client_secret: nil, scope: nil, redirect_uri: nil, private_key: nil, passphrase: nil, username: nil,
-        password: nil, workspace: nil, secret_finder: nil)
-        # test here because link may set url
-        raise ParameterError, 'Missing mandatory option: url' if url.nil?
-        raise ParameterError, 'Missing mandatory option: scope' if scope.nil?
+      def initialize(
+        url:,
+        auth:,
+        subpath: API_V1,
+        client_id: nil,
+        client_secret: nil,
+        scope: nil,
+        redirect_uri: nil,
+        private_key: nil,
+        passphrase: nil,
+        username: nil,
+        password: nil,
+        workspace: nil,
+        secret_finder: nil
+      )
+        # 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)
         # 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
@@ -209,7 +239,7 @@ module Aspera
         auth_params[:grant_method] = if url_info.key?(:token)
           :url_json
         else
-          raise ParameterError, 'Missing mandatory option: auth' if auth.nil?
+          Aspera.assert(auth, 'Missing mandatory option: auth', type: ParameterError)
           auth
         end
         # this is the base API url
@@ -219,11 +249,11 @@ module Aspera
         # fill other auth parameters based on OAuth method
         case auth_params[:grant_method]
         when :web
-          raise ParameterError, 'Missing mandatory option: redirect_uri' if redirect_uri.nil?
+          Aspera.assert(redirect_uri, 'Missing mandatory option: redirect_uri', type: ParameterError)
           auth_params[:redirect_uri] = redirect_uri
         when :jwt
-          raise ParameterError, 'Missing mandatory option: private_key' if private_key.nil?
-          raise ParameterError, 'Missing mandatory option: username' if username.nil?
+          Aspera.assert(private_key, 'Missing mandatory option: private_key', type: ParameterError)
+          Aspera.assert(username, 'Missing mandatory option: username', type: ParameterError)
           auth_params[:private_key_obj] = OpenSSL::PKey::RSA.new(private_key, passphrase)
           auth_params[:payload] = {
             iss: auth_params[:client_id], # issuer
@@ -250,10 +280,9 @@ module Aspera
 
       # read using the query and paging
       # @return [Hash] {items: , total: }
-      def read_with_paging(subpath, query: {}, formatter: nil)
+      def read_with_paging(subpath, query = nil, formatter: nil)
         return self.class.call_paging(query: query, formatter: formatter) do |paged_query|
-          # Use `call` instead of `read` to get headers
-          call(operation: 'GET', subpath: subpath, headers: {'Accept' => Rest::MIME_JSON}, query: paged_query)
+          read(subpath, query: paged_query, ret: :both)
         end
       end
 
@@ -352,7 +381,7 @@ module Aspera
               file_id: user_info['read_only_home_file_id']
             }
           end
-        raise "Cannot get user's home node id, check your default workspace or specify one" if @home_info[:node_id].to_s.empty?
+        Aspera.assert(!@home_info[:node_id].to_s.empty?, "Cannot get user's home node id, check your default workspace or specify one", type: Error)
         Log.dump(:context, @home_info)
         @home_info
       end
@@ -423,37 +452,38 @@ module Aspera
         end
         meta_schema.each do |field|
           provided = pkg_meta.select{ |i| i['name'].eql?(field['name'])}
-          raise "only one field with name #{field['name']} allowed" if provided.count > 1
-          raise "missing mandatory field: #{field['name']}" if field['required'] && provided.empty?
+          Aspera.assert(provided.count <= 1, type: Error){"only one field with name #{field['name']} allowed"}
+          Aspera.assert(!provided.empty?, type: Error){"missing mandatory field: #{field['name']}"} if field['required']
         end
       end
 
       # Normalize package creation recipient lists as expected by AoC API
       # AoC expects {type: , id: }, but ascli allows providing either the native values or just a name
       # in that case, the name is resolved and replaced with {type: , id: }
-      # @param package_data The whole package creation payload
-      # @param recipient_list_field The field in structure, i.e. recipients or bcc_recipients
-      # @return nil package_data is modified
-      def resolve_package_recipients(package_data, ws_id, recipient_list_field, new_user_option)
-        return unless package_data.key?(recipient_list_field)
-        Aspera.assert_type(package_data[recipient_list_field], Array){recipient_list_field}
+      # @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]   Additionnal fields for contact creation
+      # @return nil, `package_data` is modified
+      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}
         new_user_option = {'package_contact' => true} if new_user_option.nil?
         Aspera.assert_type(new_user_option, Hash){'new_user_option'}
+        ws_id = package_data['workspace_id']
         # list with resolved elements
         resolved_list = []
-        package_data[recipient_list_field].each do |short_recipient_info|
+        package_data[rcpt_lst_field].each do |short_recipient_info|
           case short_recipient_info
           when Hash # native API information, check keys
-            Aspera.assert(short_recipient_info.keys.sort.eql?(%w[id type])){"#{recipient_list_field} element shall have fields: id and type"}
+            Aspera.assert(short_recipient_info.keys.sort.eql?(%w[id type])){"#{rcpt_lst_field} element shall have fields: id and type"}
           when String # CLI helper: need to resolve provided name to type/id
             # email: user, else dropbox
             entity_type = short_recipient_info.include?('@') ? 'contacts' : 'dropboxes'
             begin
               full_recipient_info = lookup_by_name(entity_type, short_recipient_info, query: {'current_workspace_id' => ws_id})
-            rescue RuntimeError => e
-              raise e unless e.message.start_with?(ENTITY_NOT_FOUND)
+            rescue EntityNotFound
               # dropboxes cannot be created on the fly
-              raise "No such shared inbox in workspace #{ws_id}" if entity_type.eql?('dropboxes')
+              Aspera.assert_values(entity_type, 'contacts', type: Error){"No such shared inbox in workspace #{ws_id}"}
               # unknown user: create it as external user
               full_recipient_info = create('contacts', {
                 'current_workspace_id' => ws_id,
@@ -465,14 +495,13 @@ module Aspera
             else
               {'id' => full_recipient_info['source_id'], 'type' => full_recipient_info['source_type']}
             end
-          else # unexpected extended value, must be String or Hash
-            raise "#{recipient_list_field} item must be a String (email, shared inbox) or Hash (id,type)"
+          else Aspera.error_unexpected_value(short_recipient_info.class.name){"#{rcpt_lst_field} item must be a String (email, shared inbox) or Hash (id,type)"}
           end
           # add original or resolved recipient info
           resolved_list.push(short_recipient_info)
         end
         # replace with resolved elements
-        package_data[recipient_list_field] = resolved_list
+        package_data[rcpt_lst_field] = resolved_list
         return
       end
 
@@ -505,8 +534,8 @@ module Aspera
         # package_data['file_names']||=[..list of filenames to transfer...]
 
         # lookup users
-        resolve_package_recipients(package_data, package_data['workspace_id'], 'recipients', new_user_option)
-        resolve_package_recipients(package_data, package_data['workspace_id'], 'bcc_recipients', new_user_option)
+        resolve_package_recipients(package_data, 'recipients', new_user_option)
+        resolve_package_recipients(package_data, 'bcc_recipients', new_user_option)
 
         validate_metadata(package_data) if validate_meta
 
@@ -622,8 +651,7 @@ module Aspera
         when NilClass
         when ''
           # workspace shared folder
-          perm_data['access_type'] = 'user'
-          perm_data['access_id'] = "#{ID_AK_ADMIN}_WS_#{app_info[:workspace_id]}"
+          perm_data.merge!(self.class.workspace_access(app_info[:workspace_id]))
           tag_workspace['shared_with_name'] = perm_data['access_id']
         else
           entity_info = lookup_by_name('contacts', shared_with, query: {'current_workspace_id' => app_info[:workspace_id]})

data/lib/aspera/api/cos_node.rb

@@ -55,8 +55,9 @@ module Aspera
           operation: 'GET',
           subpath:   bucket,
           headers:   {'Accept' => 'application/xml'},
-          query:     {'faspConnectionInfo' => nil}
-        )[:http].body
+          query:     {'faspConnectionInfo' => nil},
+          ret:       :resp
+        ).body
         ats_info = XmlSimple.xml_in(xml_result_text, {'ForceArray' => false})
         Log.dump(:ats_info, ats_info)
         @storage_credentials = {

data/lib/aspera/api/faspex.rb

@@ -28,7 +28,7 @@ module Aspera
 
     def create_token
       # Exchange context (passcode) for code
-      resp = api.call(
+      http = api.call(
         operation: 'GET',
         subpath:   @path_authorize,
         query: {
@@ -37,10 +37,11 @@ module Aspera
           client_id:     client_id,
           redirect_uri:  @redirect_uri
         },
-        exception: false
+        exception: false,
+        ret:       :resp
       )
       # code / state located in redirected URL query
-      info = Rest.query_to_h(URI.parse(resp[:http]['Location']).query)
+      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'}
@@ -133,7 +134,7 @@ module Aspera
           case auth
           when :public_link
             # Get URL of final redirect of public link
-            redir_url = Rest.new(base_url: url, redirect_max: 3).call(operation: 'GET')[:http].uri.to_s
+            redir_url = Rest.new(base_url: url, redirect_max: 3).call(operation: 'GET', ret: :resp).uri.to_s
             Log.dump(:redir_url, redir_url, level: :trace1)
             # get context from query
             encoded_context = Rest.query_to_h(URI.parse(redir_url).query)['context']
@@ -145,7 +146,7 @@ module Aspera
             base_url = redir_url.gsub(%r{/public/.*}, '').gsub(/\?.*/, '')
             # Get web UI client_id and redirect_uri
             # TODO: change this for something more reliable
-            config = JSON.parse(Rest.new(base_url: "#{base_url}/config.js", redirect_max: 3).call(operation: 'GET')[:data].sub(/^[^=]+=/, '').gsub(/([a-z_]+):/, '"\1":').delete("\n ").tr("'", '"')).symbolize_keys
+            config = JSON.parse(Rest.new(base_url: "#{base_url}/config.js", redirect_max: 3).call(operation: 'GET').sub(/^[^=]+=/, '').gsub(/([a-z_]+):/, '"\1":').delete("\n ").tr("'", '"')).symbolize_keys
             Log.dump(:configjs, config)
             {
               base_url: "#{base_url}/#{PATH_API_V5}",

data/lib/aspera/api/node.rb

@@ -386,21 +386,19 @@ module Aspera
         return oauth.authorization(refresh: true)
       end
 
+      # Get a base download transfer spec (gen3)
+      # @return [Hash] Base transfer spec
+      def base_spec
+        create(
+          'files/download_setup',
+          {transfer_requests: [{transfer_request: {paths: [{source: '/'}]}}]}
+        )['transfer_specs'].first['transfer_spec']
+      end
+
       # Get generic part of transfer spec with transport parameters only
       # @return [Hash] Base transfer spec
       def transport_params
-        if @std_t_spec_cache.nil?
-          # Retrieve values from API (and keep a copy/cache)
-          full_spec = create(
-            'files/download_setup',
-            {transfer_requests: [{transfer_request: {paths: [{source: '/'}]}}]}
-          )['transfer_specs'].first['transfer_spec']
-          # Set available fields
-          @std_t_spec_cache = Transfer::Spec::TRANSPORT_FIELDS.each_with_object({}) do |i, h|
-            h[i] = full_spec[i] if full_spec.key?(i)
-          end
-        end
-        return @std_t_spec_cache
+        @std_t_spec_cache ||= base_spec.slice(*Transfer::Spec::TRANSPORT_FIELDS).freeze
       end
 
       # Create transfer spec for gen4

data/lib/aspera/ascmd.rb

@@ -94,8 +94,7 @@ module Aspera
       arguments = [] if arguments.nil?
       Log.log.debug{"execute_single:#{action_sym}:#{arguments}"}
       Aspera.assert_type(action_sym, Symbol)
-      Aspera.assert_type(arguments, Array)
-      Aspera.assert(arguments.all?(String), 'arguments must be strings')
+      Aspera.assert_array_all(arguments, String){'arguments'}
       remote_cmd = 'ascmd'
       # lines of commands (String's)
       command_lines = []

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
@@ -93,8 +81,7 @@ module Aspera
           pl = installed_products.find{ |i| i[:name].eql?(product_name)}
           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?
@@ -355,13 +355,27 @@ module Aspera
 
       private
 
-      # policy for product selection
-      FIRST_FOUND = 'FIRST'
-
-      private_constant :FIRST_FOUND
+      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

data/lib/aspera/assert.rb

@@ -41,8 +41,8 @@ module Aspera
       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
 
@@ -52,7 +52,29 @@ module Aspera
     # @param type    [Exception,Symbol] Exception to raise, or Symbol for Log.log
     # @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

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