aspera-cli 4.22.0 → 4.24.0

data/lib/aspera/api/node.rb

@@ -9,6 +9,9 @@ require 'aspera/assert'
 require 'aspera/environment'
 require 'zlib'
 require 'base64'
+require 'openssl'
+require 'pathname'
+require 'net/ssh/buffer'
 
 module Aspera
   module Api
@@ -35,6 +38,7 @@ module Aspera
       HEADER_X_NEXT_ITER_TOKEN = 'X-Aspera-Next-Iteration-Token'
       SCOPE_USER = 'user:all'
       SCOPE_ADMIN = 'admin:all'
+      # / in cloud
       PATH_SEPARATOR = '/'
 
       # register node special token decoder
@@ -49,6 +53,35 @@ module Aspera
         attr_accessor :use_standard_ports
         # set to false to bypass cache in redis
         attr_accessor :use_node_cache
+        attr_reader :use_dynamic_key
+
+        # set private key to be used
+        # @param pem_content [String] PEM encoded private key
+        def use_dynamic_key=(pem_content)
+          Aspera.assert_type(pem_content, String)
+          @dynamic_key = OpenSSL::PKey.read(pem_content)
+        end
+
+        # Adds fields `public_keys` in provided Hash, if dynamic key is set.
+        # @param h [Hash] Hash to add public key to
+        def add_public_key(h)
+          if @dynamic_key
+            ssh_key = Net::SSH::Buffer.from(:key, @dynamic_key)
+            # get pub key in OpenSSH public key format (authorized_keys)
+            h['public_keys'] = [
+              ssh_key.read_string,
+              Base64.strict_encode64(ssh_key.to_s)
+            ].join(' ')
+          end
+          return h
+        end
+
+        # Adds fields `ssh_private_key` in provided Hash, if dynamic key is set.
+        # @param h [Hash] Hash to add private key to
+        def add_private_key(h)
+          h['ssh_private_key'] = @dynamic_key.to_pem if @dynamic_key
+          return h
+        end
 
         # For access keys: provide expression to match entry in folder
         # @param match_expression one of supported types
@@ -60,7 +93,7 @@ module Aspera
           when String
             return ->(f){File.fnmatch(match_expression, f['name'], File::FNM_DOTMATCH)}
           when NilClass then return ->(_){true}
-          else Aspera.error_unexpected_value(match_expression.class.name, exception_class: Cli::BadArgument)
+          else Aspera.error_unexpected_value(match_expression.class.name, type: Cli::BadArgument)
           end
         end
 
@@ -68,6 +101,13 @@ module Aspera
           return file_matcher(options.get_next_argument('filter', validation: MATCH_TYPES, mandatory: false))
         end
 
+        # @return [Array] containing folder + inside folder/file
+        def split_folder(path)
+          folder = path.split(PATH_SEPARATOR)
+          inside = folder.pop
+          [folder.join(PATH_SEPARATOR), inside]
+        end
+
         # node API scopes
         def token_scope(access_key, scope)
           return [SCOPE_NODE_PREFIX, access_key, SCOPE_SEPARATOR, scope].join('')
@@ -115,7 +155,7 @@ module Aspera
         def bearer_headers(bearer_auth, access_key: nil)
           # if username is not provided, use the access key from the token
           if access_key.nil?
-            access_key = Node.decode_scope(Node.decode_bearer_token(OAuth::Factory.bearer_extract(bearer_auth))['scope'])[:access_key]
+            access_key = Node.decode_scope(Node.decode_bearer_token(OAuth::Factory.bearer_token(bearer_auth))['scope'])[:access_key]
             Aspera.assert(!access_key.nil?)
           end
           return {
@@ -135,6 +175,7 @@ module Aspera
       def initialize(app_info: nil, add_tspec: nil, **rest_args)
         # init Rest
         super(**rest_args)
+        @dynamic_key = nil
         @app_info = app_info
         # this is added to transfer spec, for instance to add tags (COS)
         @add_tspec = add_tspec
@@ -150,14 +191,15 @@ module Aspera
       end
 
       # Call node API, possibly adding cache control header, as globally specified
-      def read_with_cache(subpath, query=nil)
+      def read_with_cache(subpath, query = nil)
         headers = {'Accept' => Rest::MIME_JSON}
         headers[HEADER_X_CACHE_CONTROL] = 'no-cache' unless self.class.use_node_cache
         return call(
           operation: 'GET',
           subpath:   subpath,
           headers:   headers,
-          query:     query)[:data]
+          query:     query
+        )[:data]
       end
 
       # update transfer spec with special additional tags
@@ -173,10 +215,11 @@ module Aspera
           return @app_info[:api].node_api_from(
             node_id: node_id,
             workspace_id: @app_info[:workspace_id],
-            workspace_name: @app_info[:workspace_name])
+            workspace_name: @app_info[:workspace_name]
+          )
         end
         Log.log.warn{"Cannot resolve link with node id #{node_id}, no resolver"}
-        return nil
+        return
       end
 
       # Check if a link entry in folder has target information
@@ -201,12 +244,12 @@ module Aspera
       # @param state [Object] state object sent to processing method
       # @param top_file_id [String] file id to start at (default = access key root file id)
       # @param top_file_path [String] path of top folder (default = /)
-      def process_folder_tree(method_sym:, state:, top_file_id:, top_file_path: '/', query: nil)
+      def process_folder_tree(method_sym:, state:, top_file_id:, top_file_path: '/')
         Aspera.assert(!top_file_path.nil?){'top_file_path not set'}
         Log.log.debug{"process_folder_tree: node=#{@app_info ? @app_info[:node_info]['id'] : 'nil'}, file id=#{top_file_id},  path=#{top_file_path}"}
         # 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)}
+        Log.dump(:folders_to_explore, folders_to_explore)
         until folders_to_explore.empty?
           # consume first in job list
           current_item = folders_to_explore.shift
@@ -220,12 +263,10 @@ module Aspera
               Log.log.warn{"#{current_item[:path]}: #{e.class} #{e.message}"}
               []
             end
-          Log.log.debug{Log.dump(:folder_contents, folder_contents)}
+          Log.dump(:folder_contents, folder_contents)
           folder_contents.each do |entry|
             if entry.key?('error')
-              if entry['error'].is_a?(Hash) && entry['error'].key?('user_message')
-                Log.log.error(entry['error']['user_message'])
-              end
+              Log.log.error(entry['error']['user_message']) if entry['error'].is_a?(Hash) && entry['error'].key?('user_message')
               next
             end
             current_path = File.join(current_item[:path], entry['name'])
@@ -242,7 +283,8 @@ module Aspera
                   method_sym:    method_sym,
                   state:         state,
                   top_file_id:   entry['target_id'],
-                  top_file_path: current_path)
+                  top_file_path: current_path
+                )
               end
             end
           end
@@ -255,7 +297,7 @@ module Aspera
       # @param path [String] file or folder path (end with "/" is like setting process_last_link)
       # @param process_last_link [Boolean] if true, follow the last link
       # @return [Hash] {.api,.file_id}
-      def resolve_api_fid(top_file_id, path, process_last_link=false)
+      def resolve_api_fid(top_file_id, path, process_last_link = false)
         Aspera.assert_type(top_file_id, String)
         Aspera.assert_type(path, String)
         process_last_link ||= path.end_with?(PATH_SEPARATOR)
@@ -268,6 +310,50 @@ module Aspera
         return resolve_state[:result]
       end
 
+      # Given a list of paths, finds a common root and list of sub-paths
+      # @param top_file_id [String] Root file id
+      # @param paths [Array(Hash)] List of paths
+      # @return [Array] size=2: apfid, paths (Array(Hash))
+      def resolve_api_fid_paths(top_file_id, paths)
+        Aspera.assert_type(paths, Array)
+        Aspera.assert(paths.size.positive?)
+        split_sources = paths.map{ |p| Pathname(p['source']).each_filename.to_a}
+        root = []
+        split_sources.map(&:size).min.times do |i|
+          parts = split_sources.map{ |s| s[i]}
+          break unless parts.uniq.size == 1
+          root << parts.first
+        end
+        source_folder = File.join(root)
+        source_paths = paths.each_with_index.map do |p, i|
+          m = {'source' => File.join(split_sources[i][root.size..])}
+          m['destination'] = p['destination'] if p.key?('destination')
+          m
+        end
+        apifid = resolve_api_fid(top_file_id, source_folder, true)
+        # If a single item
+        if source_paths.size.eql?(1)
+          # Get precise info in this element
+          file_info = apifid[:api].read("files/#{apifid[:file_id]}")
+          source_paths =
+            case file_info['type']
+            when 'file'
+              # if the single source is a file, we need to split into folder path and filename
+              src_dir_elements = source_folder.split(Api::Node::PATH_SEPARATOR)
+              filename = src_dir_elements.pop
+              apifid = resolve_api_fid(top_file_id, src_dir_elements.join(Api::Node::PATH_SEPARATOR), true)
+              # filename is the last one, source folder is what remains
+              [{'source' => filename}]
+            when 'link', 'folder'
+              # single source is 'folder' or 'link'
+              # TODO: add this ? , 'destination'=>file_info['name']
+              [{'source' => '.'}]
+            else Aspera.error_unexpected_value(file_info['type']){'source type'}
+            end
+        end
+        [apifid, source_paths]
+      end
+
       def find_files(top_file_id, test_lambda)
         Log.log.debug{"find_files: file id=#{top_file_id}"}
         find_state = {found: [], test_lambda: test_lambda}
@@ -305,7 +391,7 @@ module Aspera
       # @param file_id destination or source folder (id)
       # @param direction one of Transfer::Spec::DIRECTION_SEND, Transfer::Spec::DIRECTION_RECEIVE
       # @param ts_merge additional transfer spec to merge
-      def transfer_spec_gen4(file_id, direction, ts_merge=nil)
+      def transfer_spec_gen4(file_id, direction, ts_merge = nil)
         ak_name = nil
         ak_token = nil
         case auth_params[:type]
@@ -347,9 +433,7 @@ module Aspera
           # by default: same address as node API
           transfer_spec['remote_host'] = URI.parse(base_url).host
           # AoC allows specification of other url
-          if !@app_info.nil? && !@app_info[:node_info]['transfer_url'].nil? && !@app_info[:node_info]['transfer_url'].empty?
-            transfer_spec['remote_host'] = @app_info[:node_info]['transfer_url']
-          end
+          transfer_spec['remote_host'] = @app_info[:node_info]['transfer_url'] if !@app_info.nil? && !@app_info[:node_info]['transfer_url'].nil? && !@app_info[:node_info]['transfer_url'].empty?
           info = read('info')
           # get the transfer user from info on access key
           transfer_spec['remote_user'] = info['transfer_user'] if info['transfer_user']
@@ -395,10 +479,8 @@ module Aspera
             if state[:process_last_link]
               # we found it
               other_node = nil
-              if entry_has_link_information(entry)
-                other_node = node_id_to_node(entry['target_node_id'])
-              end
-              raise 'Cannot resolve link' if other_node.nil?
+              other_node = node_id_to_node(entry['target_node_id']) if entry_has_link_information(entry)
+              raise Error, 'Cannot resolve link' if other_node.nil?
               state[:result] = {api: other_node, file_id: entry['target_id']}
             else
               # we found it but we do not process the link

data/lib/aspera/ascmd.rb

@@ -10,7 +10,7 @@ module Aspera
   # execute: "ascmd -h" to get syntax
   # Note: "ls" can take filters: as_ls -f *.txt -f *.bin /
   class AsCmd
-    # number of arguments for each operation
+    # number of arguments for each operation (to allow splitting into batches)
     OPS_ARGS = {
       cp:     2,
       df:     0,
@@ -23,17 +23,23 @@ module Aspera
       rm:     1
     }.freeze
 
-    # protocol is based on Type-Length-Value
-    # type start at one, but array index start at zero
+    # Protocol is based on Type-Length-Value
+    # Type start at one, but array index start at zero
     ENUM_START = 1
 
-    # description of result structures (see ascmdtypes.h).
+    # Description of result structures (see ascmdtypes.h).
     # Base types are big endian
     # key = name of type
-    # index in array `fields` is the type (minus ENUM_START)
+    # index in array `fields` is: the numerical type of TLV - `ENUM_START`. i.e. add `ENUM_START` to index, to get `T`
     # decoding always start at `result`
     # some fields have special handling indicated by `special`
     # field_list, list_tlv_list, list_tlv_restart are composed with a list of TLV
+    # decode:
+    # - :base : value
+    # - :buffer_list : an array of {btype,buffer}
+    # - :field_list : a hash, or array
+    # :check: ???
+    # rubocop:disable Layout/FirstHashElementLineBreak
     TYPES_DESCR = {
       result: {decode: :field_list,
                fields: [{name: :file, is_a: :stat}, {name: :dir, is_a: :stat, special: :list_tlv_list}, {name: :size, is_a: :size}, {name: :error, is_a: :error},
@@ -67,6 +73,7 @@ module Aspera
       zstr:   {decode: :base, unpack: 'Z*'},
       blist:  {decode: :buffer_list}
     }.freeze
+    # rubocop:enable Layout/FirstHashElementLineBreak
 
     private_constant :TYPES_DESCR, :ENUM_START, :OPS_ARGS
 
@@ -79,17 +86,25 @@ module Aspera
     end
 
     # execute an "as" command on a remote server
+    # Version 2 allows use of reverse proxy with multiple addresses.
     # @param [Symbol] one of OPERATIONS
     # @param [Array] parameters for "as" command
     # @return result of command, type depends on command (bool, array, hash)
-    def execute_single(action_sym, arguments)
+    def execute_single(action_sym, arguments, version: 1, host: nil)
       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')
+      remote_cmd = 'ascmd'
       # lines of commands (String's)
       command_lines = []
+      if version.eql?(2)
+        cmd = "as_session_init --protocol=#{version}"
+        cmd += " --host=#{host}" if host
+        command_lines.push(cmd)
+        remote_cmd += ' -V2'
+      end
       # add "as_" command
       main_command = "as_#{action_sym}"
       arg_batches =
@@ -114,11 +129,11 @@ module Aspera
       stdin_input = command_lines.join("\n")
       Log.log.trace1{"execute_single:#{stdin_input}"}
       # execute, get binary output
-      byte_buffer = @command_executor.execute('ascmd', stdin_input).unpack('C*')
-      raise 'ERROR: empty answer from server' if byte_buffer.empty?
+      byte_buffer = @command_executor.execute(remote_cmd, input: stdin_input).unpack('C*')
+      Aspera.assert(!byte_buffer.empty?){'empty answer from server'}
       # get hash or table result
       result = self.class.parse(byte_buffer, :result)
-      raise 'ERROR: unparsed bytes remaining' unless byte_buffer.empty?
+      Aspera.assert(byte_buffer.empty?){'unparsed bytes remaining'}
       # get and delete info,always present in results
       system_info = result[:info]
       result.delete(:info)
@@ -129,7 +144,7 @@ module Aspera
         result[:dir].each do |file|
           if file.key?(:smode)
             # Converts the first character of the file mode (see 'man ls') into a type.
-            file[:type] = case file[:smode][0, 1]; when 'd' then:directory; when '-' then:file; when 'l' then:link; else; :other; end # rubocop:disable Style/Semicolon
+            file[:type] = case file[:smode][0, 1]; when 'd' then:directory; when '-' then:file; when 'l' then:link; else; :other; end
           end
         end
       end
@@ -145,27 +160,26 @@ module Aspera
       return result
     end
 
-    # This exception is raised when +ascmd+ returns an error.
+    # This exception is raised when `ascmd` returns an error.
     class Error < StandardError
-      def initialize(errno, errstr, cmd, arguments)
-        super(); @errno = errno; @errstr = errstr; @command = cmd; @arguments = arguments; end # rubocop:disable Style/Semicolon
-
+      # rubocop:disable Style/Semicolon
+      def initialize(errno, errstr, cmd, arguments); super(); @errno = errno; @errstr = errstr; @command = cmd; @arguments = arguments; end
       def message; "ascmd: #{@errstr} (#{@errno})"; end
       def extended_message; "ascmd: errno=#{@errno} errstr=\"#{@errstr}\" command=#{@command} arguments=#{@arguments&.join(',')}"; end
+      # rubocop:enable Style/Semicolon
     end
 
     class << self
-      # get description of structure's field, @param struct_name, @param typed_buffer provides field name
+      # Get description of structure's field, @param struct_name, @param typed_buffer provides field name
       def field_description(struct_name, typed_buffer)
         result = TYPES_DESCR[struct_name][:fields][typed_buffer[:btype] - ENUM_START]
         raise "Unrecognized field for #{struct_name}: #{typed_buffer[:btype]}\n#{typed_buffer[:buffer]}" if result.nil?
         return result
       end
 
-      # decodes the provided buffer as provided type name
-      # @return a decoded type.
-      # :base : value, :buffer_list : an array of {btype,buffer}, :field_list : a hash, or array
-      def parse(buffer, type_name, indent_level=nil)
+      # Decodes the provided buffer as provided type name
+      # @return a decoded type: single, Array, or Hash
+      def parse(buffer, type_name, indent_level = nil)
         indent_level = (indent_level || -1) + 1
         type_descr = TYPES_DESCR[type_name]
         raise "Unexpected type #{type_name}" if type_descr.nil?
@@ -174,7 +188,7 @@ module Aspera
         case type_descr[:decode]
         when :base
           num_bytes = type_name.eql?(:zstr) ? buffer.length : type_descr[:size]
-          raise 'ERROR:not enough bytes' if buffer.length < num_bytes
+          Aspera.assert(buffer.length >= num_bytes){'not enough bytes'}
           byte_array = buffer.shift(num_bytes)
           byte_array = [byte_array] unless byte_array.is_a?(Array)
           result = byte_array.pack('C*').unpack1(type_descr[:unpack])
@@ -187,7 +201,7 @@ module Aspera
           until buffer.empty?
             btype = parse(buffer, :int8, indent_level)
             length = parse(buffer, :int32, indent_level)
-            raise 'ERROR:not enough bytes' if buffer.length < length
+            Aspera.assert(buffer.length >= length){'not enough bytes'}
             value = buffer.shift(length)
             result.push({btype: btype, buffer: value})
             Log.log.trace1{"#{'   .' * indent_level}:buffer_list[#{result.length - 1}] #{result.last}"}

data/lib/aspera/ascp/installation.rb

@@ -32,6 +32,7 @@ module Aspera
     # Installation.instance.ascp_path=""
     class Installation
       include Singleton
+
       DEFAULT_ASPERA_CONF = <<~END_OF_CONFIG_FILE
         <?xml version='1.0' encoding='UTF-8'?>
         <CONF version="2">
@@ -43,12 +44,12 @@ module Aspera
         </default>
         </CONF>
       END_OF_CONFIG_FILE
-      # all ascp files (in SDK)
-      EXE_FILES = %i[ascp ascp4 async].freeze
-      FILES = %i[transferd ssh_private_dsa ssh_private_rsa aspera_license aspera_conf fallback_certificate fallback_private_key].unshift(*EXE_FILES).freeze
-      TRANSFER_SDK_LOCATION_URL = 'https://ibm.biz/sdk_location'
+      # 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, :FILES, :TRANSFER_SDK_LOCATION_URL
+      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
 
@@ -98,7 +99,7 @@ module Aspera
 
       # @return [Hash] with key = file name (String), and value = path to file
       def file_paths
-        return FILES.each_with_object({}) do |v, m|
+        return SDK_FILES.each_with_object({}) do |v, m|
           m[v.to_s] =
             begin
               path(v)
@@ -114,19 +115,23 @@ module Aspera
         return Environment.write_file_restricted(File.join(Products::Transferd.sdk_directory, filename), force: force, mode: 0o644, &block)
       end
 
-      # get path of one resource file of currently activated product
+      # Get path of one resource file of currently activated product
       # keys and certs are generated locally... (they are well known values, arch. independent)
+      # @param k [Symbol] key of the resource file
+      # @return [String, nil] Full path to the resource file or nil if not found
       def path(k)
-        file_is_optional = false
+        file_is_required = true
         case k
         when *EXE_FILES
-          file_is_optional = k.eql?(:async)
-          use_ascp_from_product(FIRST_FOUND) if @path_to_ascp.nil?
-          # NOTE: that there might be a .exe at the end
-          file = @path_to_ascp.gsub('ascp', k.to_s)
-        when :transferd
-          file_is_optional = true
-          file = Products::Transferd.transferd_path
+          file_is_required = k.eql?(:ascp)
+          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?
+            # NOTE: that there might be a .exe at the end
+            @path_to_ascp.gsub('ascp', k.to_s)
+          end
         when :ssh_private_dsa, :ssh_private_rsa
           # assume last 3 letters are type
           type = k.to_s[-3..-1].to_sym
@@ -149,8 +154,8 @@ module Aspera
           file = k.eql?(:fallback_certificate) ? file_cert : file_key
         else Aspera.error_unexpected_value(k)
         end
-        return nil if file_is_optional && !File.exist?(file)
-        Aspera.assert(File.exist?(file), exception_class: Errno::ENOENT){"#{k} not found (#{file})"}
+        return unless file_is_required || File.exist?(file)
+        Aspera.assert(File.exist?(file), type: Errno::ENOENT){"#{k} not found (#{file})"}
         return file
       end
 
@@ -167,7 +172,7 @@ module Aspera
                when :dsa_rsa, :rsa
                  types.to_s.split('_').map{ |i| Installation.instance.path("ssh_private_#{i}".to_sym)}
                when :per_client
-                 raise 'Not yet implemented'
+                 Aspera.error_not_implemented
                end
       end
 
@@ -178,8 +183,9 @@ module Aspera
 
       # Check that specified path is ascp and get version
       def get_exe_version(exe_path, vers_arg)
-        raise 'ERROR: nil arg' if exe_path.nil?
-        return nil unless File.exist?(exe_path)
+        Aspera.assert_type(exe_path, String)
+        Aspera.assert_type(vers_arg, String)
+        return unless File.exist?(exe_path)
         exe_version = nil
         cmd_out = %x("#{exe_path}" #{vers_arg})
         raise "An error occurred when testing #{exe_path}: #{cmd_out}" unless $CHILD_STATUS == 0
@@ -196,6 +202,8 @@ module Aspera
           last_line = ''
           while (line = stderr.gets)
             line.chomp!
+            # skip lines that may have accents
+            next unless line.valid_encoding?
             last_line = line
             case line
             when /^DBG Path ([^ ]+) (dir|file) +: (.*)$/
@@ -211,12 +219,10 @@ module Aspera
               data['product_name'] = Regexp.last_match(1)
               data['product_version'] = Regexp.last_match(2)
             when /^LOG Initializing FASP version ([^,]+),/
-              data['sdk_ascp_version'] = Regexp.last_match(1)
+              data['ascp_version'] = Regexp.last_match(1)
             end
           end
-          if !thread.value.exitstatus.eql?(1) && !data.key?('root')
-            raise last_line
-          end
+          raise last_line if !thread.value.exitstatus.eql?(1) && !data.key?('root')
         end
         return data
       end
@@ -226,9 +232,9 @@ module Aspera
         data = {}
         File.binread(ascp_path).scan(/[\x20-\x7E]{10,}/) do |bin_string|
           if (m = bin_string.match(/OPENSSLDIR.*"(.*)"/))
-            data['openssldir'] = m[1]
+            data['ascp_openssl_dir'] = m[1]
           elsif (m = bin_string.match(/OpenSSL (\d[^ -]+)/))
-            data['openssl_version'] = m[1]
+            data['ascp_openssl_version'] = m[1]
           end
         end if File.file?(ascp_path)
         return data
@@ -245,7 +251,7 @@ module Aspera
       # @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
-        platform = Environment.architecture if platform.nil?
+        platform = Environment.instance.architecture if platform.nil?
         locations = locations.select{ |l| l['platform'].eql?(platform)}
         raise "No SDK for platform: #{platform}" if locations.empty?
         version = locations.max_by{ |entry| Gem::Version.new(entry['version'])}['version'] if version.nil?
@@ -256,7 +262,7 @@ module Aspera
 
       # @param &block called with entry information
       def extract_archive_files(sdk_archive_path)
-        raise 'missing block' unless block_given?
+        Aspera.assert(block_given?){'missing block'}
         case sdk_archive_path
         # Windows and Mac use zip
         when /\.zip$/
@@ -327,21 +333,15 @@ module Aspera
           end
         end
         return unless with_exe
-        # ensure license file are generated so that ascp invocation for version works
-        path(:aspera_license)
-        path(:aspera_conf)
-        sdk_ascp_file = Environment.exe_file('ascp')
-        sdk_ascp_path = File.join(folder, sdk_ascp_file)
-        raise "No #{sdk_ascp_file} found in SDK archive" unless File.exist?(sdk_ascp_path)
-        EXE_FILES.each do |exe_sym|
-          exe_path = sdk_ascp_path.gsub('ascp', exe_sym.to_s)
-          Environment.restrict_file_access(exe_path, mode: 0o755) if File.exist?(exe_path)
+        # 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)
+            Environment.restrict_file_access(file_path, mode: 0o755) if File.exist?(file_path)
+          end
         end
-        sdk_ascp_version = get_ascp_version(sdk_ascp_path)
-        transferd_exe_path = Products::Transferd.transferd_path
-        Log.log.warn{"No #{transferd_exe_path} in SDK archive"} unless File.exist?(transferd_exe_path)
-        Environment.restrict_file_access(transferd_exe_path, mode: 0o755) if File.exist?(transferd_exe_path)
-        transferd_version = get_exe_version(transferd_exe_path, 'version')
+        sdk_ascp_version = get_ascp_version(path(:ascp))
+        transferd_version = get_exe_version(path(:transferd), 'version')
         sdk_name = 'IBM Aspera Transfer SDK'
         sdk_version = transferd_version || sdk_ascp_version
         File.write(File.join(folder, Products::Other::INFO_META_FILE), "<product><name>#{sdk_name}</name><version>#{sdk_version}</version></product>")
@@ -359,7 +359,7 @@ module Aspera
         @path_to_ascp = nil
         @sdk_dir = nil
         @found_products = nil
-        @transferd_urls = TRANSFER_SDK_LOCATION_URL
+        @transferd_urls = TRANSFERD_ARCHIVE_LOCATION_URL
       end
 
       public

data/lib/aspera/ascp/management.rb

@@ -184,7 +184,8 @@ module Aspera
         ChunkSize
         PostTransferValidation
         OverwritePolicyCap
-        ExtraCreatePolicy]
+        ExtraCreatePolicy
+      ]
       # Management port start message
       MGT_HEADER = 'FASPMGR 2'
       # empty line is separator to end event information
@@ -252,17 +253,17 @@ module Aspera
           # begin event
           @event_build = {}
         when /^([^:]+): (.*)$/
-          raise 'mgt port: unexpected line: data without header' if @event_build.nil?
+          Aspera.assert_type(@event_build, Hash){'mgt port: unexpected line: data without header'}
           # event field
           @event_build[Regexp.last_match(1)] = Regexp.last_match(2)
         when MGT_FRAME_SEPARATOR
-          raise 'mgt port: unexpected line: end frame without header' if @event_build.nil?
+          Aspera.assert_type(@event_build, Hash){'mgt port: unexpected line: end frame without header'}
           @last_event = @event_build
           @event_build = nil
           return @last_event
         else Aspera.error_unexpected_value(line){'mgt port'}
         end
-        return nil
+        return
       end
     end
   end