aspera-cli 4.20.0 → 4.21.0

data/lib/aspera/node_simulator.rb

@@ -7,28 +7,239 @@ require 'webrick'
 require 'json'
 
 module Aspera
+  class NodeSimulator
+    def initialize
+      @agent = Agent::Direct.new(management_cb: ->(event){process_event(event)})
+      @sessions = {}
+    end
+
+    def start(ts)
+      @agent.start_transfer(ts)
+    end
+
+    def all_sessions
+      @agent.sessions.map { |session| session[:job_id] }.uniq.each.map{|job_id|job_to_transfer(job_id)}
+    end
+
+    # status: ('waiting', 'partially_completed', 'unknown', 'waiting(read error)',] 'running', 'completed', 'failed'
+    def job_to_transfer(job_id)
+      jobs = @agent.sessions_by_job(job_id)
+      ts = nil
+      sessions = jobs.map do |j|
+        ts ||= j[:ts]
+        {
+          id:                    j[:id],
+          client_node_id:        '',
+          server_node_id:        '2bbdcc39-f789-4d47-8163-6767fc14f421',
+          client_ip_address:     '192.168.0.100',
+          server_ip_address:     '5.10.114.4',
+          status:                'running',
+          retry_timeout:         3600,
+          retry_count:           0,
+          start_time_usec:       1701094040000000,
+          end_time_usec:         nil,
+          elapsed_usec:          405312,
+          bytes_transferred:     26,
+          bytes_written:         26,
+          bytes_lost:            0,
+          files_completed:       1,
+          directories_completed: 0,
+          target_rate_kbps:      500000,
+          min_rate_kbps:         0,
+          calc_rate_kbps:        9900,
+          network_delay_usec:    40000,
+          avg_rate_kbps:         0.51,
+          error_code:            0,
+          error_desc:            '',
+          source_statistics:     {
+            args_scan_attempted:  1,
+            args_scan_completed:  1,
+            paths_scan_attempted: 1,
+            paths_scan_failed:    0,
+            paths_scan_skipped:   0,
+            paths_scan_excluded:  0,
+            dirs_scan_completed:  0,
+            files_scan_completed: 1,
+            dirs_xfer_attempted:  0,
+            dirs_xfer_fail:       0,
+            files_xfer_attempted: 1,
+            files_xfer_fail:      0,
+            files_xfer_noxfer:    0
+          },
+          precalc:               {
+            enabled:              true,
+            status:               'ready',
+            bytes_expected:       0,
+            directories_expected: 0,
+            files_expected:       0,
+            files_excluded:       0,
+            files_special:        0,
+            files_failed:         1
+          }
+        }
+      end
+      ts ||= {}
+      result = {
+        id:                    job_id,
+        status:                'running',
+        start_spec:            ts,
+        sessions:              sessions,
+        bytes_transferred:     26,
+        bytes_written:         26,
+        bytes_lost:            0,
+        avg_rate_kbps:         0.51,
+        files_completed:       1,
+        files_skipped:         0,
+        directories_completed: 0,
+        start_time_usec:       1701094040000000,
+        end_time_usec:         1701094040405312,
+        elapsed_usec:          405312,
+        error_code:            0,
+        error_desc:            '',
+        precalc:               {
+          status:               'ready',
+          bytes_expected:       0,
+          files_expected:       0,
+          directories_expected: 0,
+          files_special:        0,
+          files_failed:         1
+        },
+        files:                 [{
+          id:              'd1b5c112-82b75425-860745fc-93851671-64541bdd',
+          path:            '/workspaces/45071/packages/bYA_ilq73g.asp-package/contents/data_file.bin',
+          start_time_usec: 1701094040000000,
+          elapsed_usec:    105616,
+          end_time_usec:   1701094040001355,
+          status:          'completed',
+          error_code:      0,
+          error_desc:      '',
+          size:            26,
+          type:            'file',
+          checksum_type:   'none',
+          checksum:        nil,
+          start_byte:      0,
+          bytes_written:   26,
+          session_id:      'bafc72b8-366c-4501-8095-47208183d6b8'}]
+      }
+      Log.log.trace2{Log.dump(:job, result)}
+      return result
+    end
+
+    # Process event from manegemtn port
+    def process_event(event)
+      case event['Type']
+      when 'NOP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'START' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'QUERY' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'QUERYRSP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'STATS' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'STOP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'ERROR' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'CANCEL' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'DONE' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'RATE' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'FILEERROR' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'SESSION' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'NOTIFICATION' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'INIT' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'VLINK' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'PUT' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'WRITE' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'CLOSE' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'SKIP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      when 'ARGSTOP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      else Aspera.error_unreachable_line
+      end
+    end
+  end
+
   # this class answers the Faspex /send API and creates a package on Aspera on Cloud
+  # a new instance is created for each request
   class NodeSimulatorServlet < WEBrick::HTTPServlet::AbstractServlet
     PATH_TRANSFERS = '/ops/transfers'
     PATH_ONE_TRANSFER = %r{/ops/transfers/(.+)$}
+    PATH_BROWSE = '/files/browse'
     # @param app_api [Api::AoC]
     # @param app_context [String]
-    def initialize(server, credentials, transfer)
+    def initialize(server, credentials, simulator)
       super(server)
       @credentials = credentials
-      @xfer_manager = Agent::Direct.new
+      @simulator = simulator
+    end
+
+    require 'json'
+    require 'time'
+
+    def folder_to_structure(folder_path)
+      raise "Path does not exist or is not a directory: #{folder_path}" unless Dir.exist?(folder_path)
+
+      # Build self structure
+      folder_stat = File.stat(folder_path)
+      structure = {
+        'self'  => {
+          'path'        => folder_path,
+          'basename'    => File.basename(folder_path),
+          'type'        => 'directory',
+          'size'        => folder_stat.size,
+          'mtime'       => folder_stat.mtime.utc.iso8601,
+          'permissions' => [
+            { 'name' => 'view' },
+            { 'name' => 'edit' },
+            { 'name' => 'delete' }
+          ]
+        },
+        'items' => []
+      }
+
+      # Iterate over folder contents
+      Dir.foreach(folder_path) do |entry|
+        next if entry == '.' || entry == '..' # Skip current and parent directory
+
+        item_path = File.join(folder_path, entry)
+        item_type = File.ftype(item_path) rescue 'unknown' # Get the type of file
+        item_stat = File.lstat(item_path) # Use lstat to handle symbolic links correctly
+
+        item = {
+          'path'        => item_path,
+          'basename'    => entry,
+          'type'        => item_type,
+          'size'        => item_stat.size,
+          'mtime'       => item_stat.mtime.utc.iso8601,
+          'permissions' => [
+            { 'name' => 'view' },
+            { 'name' => 'edit' },
+            { 'name' => 'delete' }
+          ]
+        }
+
+        # Add additional details for specific types
+        case item_type
+        when 'file'
+          item['partial_file'] = false
+        when 'link'
+          item['target'] = File.readlink(item_path) rescue nil # Add the target of the symlink
+        when 'unknown'
+          item['note'] = 'File type could not be determined'
+        end
+
+        structure['items'] << item
+      end
+
+      structure
     end
 
     def do_POST(request, response)
       case request.path
       when PATH_TRANSFERS
-        job_id = @xfer_manager.start_transfer(JSON.parse(request.body))
-        session = @xfer_manager.sessions_by_job(job_id).first
-        result = session[:ts].clone
-        result['id'] = job_id
-        set_json_response(response, result)
+        job_id = @simulator.start(JSON.parse(request.body))
+        sleep(0.5)
+        set_json_response(request, response, @simulator.job_to_transfer(job_id))
+      when PATH_BROWSE
+        req = JSON.parse(request.body)
+        # req['count']
+        set_json_response(request, response, folder_to_structure(req['path']))
       else
-        set_json_response(response, [{error: 'Bad request'}], code: 400)
+        set_json_response(request, response, [{error: 'Bad request'}], code: 400)
       end
     end
 
@@ -36,7 +247,7 @@ module Aspera
       case request.path
       when '/info'
         info = Ascp::Installation.instance.ascp_info
-        set_json_response(response, {
+        set_json_response(request, response, {
           application:                           'node',
           current_time:                          Time.now.utc.iso8601(0),
           version:                               info['sdk_ascp_version'].gsub(/ .*$/, ''),
@@ -44,13 +255,13 @@ module Aspera
           license_max_rate:                      info['maximum_bandwidth'],
           os:                                    %x(uname -srv).chomp,
           aej_status:                            'disconnected',
-          async_reporting:                       'yes',
-          transfer_activity_reporting:           'yes',
+          async_reporting:                       'no',
+          transfer_activity_reporting:           'no',
           transfer_user:                         'xfer',
           docroot:                               'file:////data/aoc/eudemo-sedemo',
           node_id:                               '2bbdcc39-f789-4d47-8163-6767fc14f421',
           cluster_id:                            '6dae2844-d1a9-47a5-916d-9b3eac3ea466',
-          acls:                                  [],
+          acls:                                  ['impersonation'],
           access_key_configuration_capabilities: {
             transfer: %w[
               cipher
@@ -99,115 +310,20 @@ module Aspera
             {name:  'wss_port', value: 443}
           ]})
       when PATH_TRANSFERS
-        result = @xfer_manager.sessions.map { |session| job_to_transfer(session) }
-        set_json_response(response, result)
+        set_json_response(request, response, @simulator.all_sessions)
       when PATH_ONE_TRANSFER
         job_id = request.path.match(PATH_ONE_TRANSFER)[1]
-        set_json_response(response, job_to_transfer(@xfer_manager.sessions_by_job(job_id).first))
+        set_json_response(request, response, @simulator.job_to_transfer(job_id))
       else
-        set_json_response(response, [{error: 'Unknown request'}], code: 400)
+        set_json_response(request, response, [{error: 'Unknown request'}], code: 400)
       end
     end
 
-    def set_json_response(response, json, code: 200)
+    def set_json_response(request, response, json, code: 200)
       response.status = code
       response['Content-Type'] = 'application/json'
       response.body = json.to_json
-      Log.log.trace1{Log.dump('response', json)}
-    end
-
-    def job_to_transfer(job)
-      session = {
-        id:                    'bafc72b8-366c-4501-8095-47208183d6b8',
-        client_node_id:        '',
-        server_node_id:        '2bbdcc39-f789-4d47-8163-6767fc14f421',
-        client_ip_address:     '192.168.0.100',
-        server_ip_address:     '5.10.114.4',
-        status:                'running',
-        retry_timeout:         3600,
-        retry_count:           0,
-        start_time_usec:       1701094040000000,
-        end_time_usec:         nil,
-        elapsed_usec:          405312,
-        bytes_transferred:     26,
-        bytes_written:         26,
-        bytes_lost:            0,
-        files_completed:       1,
-        directories_completed: 0,
-        target_rate_kbps:      500000,
-        min_rate_kbps:         0,
-        calc_rate_kbps:        9900,
-        network_delay_usec:    40000,
-        avg_rate_kbps:         0.51,
-        error_code:            0,
-        error_desc:            '',
-        source_statistics:     {
-          args_scan_attempted:  1,
-          args_scan_completed:  1,
-          paths_scan_attempted: 1,
-          paths_scan_failed:    0,
-          paths_scan_skipped:   0,
-          paths_scan_excluded:  0,
-          dirs_scan_completed:  0,
-          files_scan_completed: 1,
-          dirs_xfer_attempted:  0,
-          dirs_xfer_fail:       0,
-          files_xfer_attempted: 1,
-          files_xfer_fail:      0,
-          files_xfer_noxfer:    0
-        },
-        precalc:               {
-          enabled:              true,
-          status:               'ready',
-          bytes_expected:       0,
-          directories_expected: 0,
-          files_expected:       0,
-          files_excluded:       0,
-          files_special:        0,
-          files_failed:         1
-        }}
-      return {
-        id:                    '609a667d-642e-4290-9312-b4d20d3c0159',
-        status:                'running',
-        start_spec:            job[:ts],
-        sessions:              [session],
-        bytes_transferred:     26,
-        bytes_written:         26,
-        bytes_lost:            0,
-        avg_rate_kbps:         0.51,
-        files_completed:       1,
-        files_skipped:         0,
-        directories_completed: 0,
-        start_time_usec:       1701094040000000,
-        end_time_usec:         1701094040405312,
-        elapsed_usec:          405312,
-        error_code:            0,
-        error_desc:            '',
-        precalc:               {
-          status:               'ready',
-          bytes_expected:       0,
-          files_expected:       0,
-          directories_expected: 0,
-          files_special:        0,
-          files_failed:         1
-        },
-        files:                 [{
-          id:              'd1b5c112-82b75425-860745fc-93851671-64541bdd',
-          path:            '/workspaces/45071/packages/bYA_ilq73g.asp-package/contents/data_file.bin',
-          start_time_usec: 1701094040000000,
-          elapsed_usec:    105616,
-          end_time_usec:   1701094040001355,
-          status:          'completed',
-          error_code:      0,
-          error_desc:      '',
-          size:            26,
-          type:            'file',
-          checksum_type:   'none',
-          checksum:        nil,
-          start_byte:      0,
-          bytes_written:   26,
-          session_id:      'bafc72b8-366c-4501-8095-47208183d6b8'}]
-      }
+      Log.log.trace1{Log.dump("response for #{request.request_method} #{request.path}", json)}
     end
   end
 end

data/lib/aspera/oauth/base.rb

@@ -26,7 +26,7 @@ module Aspera
         scope: nil,
         use_query: false,
         path_token:  'token',
-        token_field: 'access_token',
+        token_field: Factory::TOKEN_FIELD,
         cache_ids: nil,
         **rest_params
       )
@@ -87,48 +87,37 @@ module Aspera
       # @param cache set to false to disable cache
       # @param refresh set to true to force refresh or re-generation (if previous failed)
       def token(cache: true, refresh: false)
-        # get token_data from cache (or nil), token_data is what is returned by /token
-        token_data = Factory.instance.persist_mgr.get(@token_cache_id) if cache
-        token_data = JSON.parse(token_data) unless token_data.nil?
-        # Optional optimization: check if node token is expired based on decoded content then force refresh if close enough
-        # might help in case the transfer agent cannot refresh himself
-        # `direct` agent is equipped with refresh code
-        if !refresh && !token_data.nil?
-          decoded_token = OAuth::Factory.instance.decode_token(token_data[@token_field])
-          Log.log.debug{Log.dump('decoded_token', decoded_token)} unless decoded_token.nil?
-          if decoded_token.is_a?(Hash)
-            expires_at_sec =
-              if    decoded_token['expires_at'].is_a?(String) then DateTime.parse(decoded_token['expires_at']).to_time
-              elsif decoded_token['exp'].is_a?(Integer)       then Time.at(decoded_token['exp'])
+        # get token info from cache (or nil), decoded with date and expiration status
+        token_info = Factory.instance.get_token_info(@token_cache_id) if cache
+        token_data = nil
+        unless token_info.nil?
+          token_data = token_info[:data]
+          # Optional optimization:
+          # check if node token is expired based on decoded content then force refresh if close enough
+          # might help in case the transfer agent cannot refresh himself
+          # `direct` agent is equipped with refresh code
+          # an API was already called, but failed, we need to regenerate or refresh
+          if refresh || token_info[:expired]
+            if token_data.key?('refresh_token') && token_data['refresh_token'].eql?('not_supported')
+              # save possible refresh token, before deleting the cache
+              refresh_token = token_data['refresh_token']
+            end
+            # delete cache
+            Factory.instance.persist_mgr.delete(@token_cache_id)
+            token_data = nil
+            # lets try the existing refresh token
+            if !refresh_token.nil?
+              Log.log.info{"refresh=[#{refresh_token}]".bg_green}
+              # NOTE: AoC admin token has no refresh, and lives by default 1800secs
+              resp = create_token_call(optional_scope_client_id.merge(grant_type: 'refresh_token', refresh_token: refresh_token))
+              if resp[:http].code.start_with?('2')
+                # save only if success
+                json_data = resp[:http].body
+                token_data = JSON.parse(json_data)
+                Factory.instance.persist_mgr.put(@token_cache_id, json_data)
+              else
+                Log.log.debug{"refresh failed: #{resp[:http].body}".bg_red}
               end
-            # force refresh if we see a token too close from expiration
-            refresh = true if expires_at_sec.is_a?(Time) && (expires_at_sec - Time.now) < OAuth::Factory.instance.parameters[:token_expiration_guard_sec]
-            Log.log.debug{"Expiration: #{expires_at_sec} / #{refresh}"}
-          end
-        end
-
-        # an API was already called, but failed, we need to regenerate or refresh
-        if refresh
-          if token_data.is_a?(Hash) && token_data.key?('refresh_token') && !token_data['refresh_token'].eql?('not_supported')
-            # save possible refresh token, before deleting the cache
-            refresh_token = token_data['refresh_token']
-          end
-          # delete cache
-          Factory.instance.persist_mgr.delete(@token_cache_id)
-          token_data = nil
-          # lets try the existing refresh token
-          if !refresh_token.nil?
-            Log.log.info{"refresh=[#{refresh_token}]".bg_green}
-            # try to refresh
-            # note: AoC admin token has no refresh, and lives by default 1800secs
-            resp = create_token_call(optional_scope_client_id.merge(grant_type: 'refresh_token', refresh_token: refresh_token))
-            if resp[:http].code.start_with?('2')
-              # save only if success
-              json_data = resp[:http].body
-              token_data = JSON.parse(json_data)
-              Factory.instance.persist_mgr.put(@token_cache_id, json_data)
-            else
-              Log.log.debug{"refresh failed: #{resp[:http].body}".bg_red}
             end
           end
         end

data/lib/aspera/oauth/factory.rb

@@ -13,6 +13,7 @@ module Aspera
       PERSIST_CATEGORY_TOKEN = 'token'
       # prefix for bearer token when in header
       BEARER_PREFIX = 'Bearer '
+      TOKEN_FIELD = 'access_token'
 
       private_constant :PERSIST_CATEGORY_TOKEN, :BEARER_PREFIX
 
@@ -87,7 +88,45 @@ module Aspera
 
       # delete all existing tokens
       def flush_tokens
-        persist_mgr.garbage_collect(PERSIST_CATEGORY_TOKEN, nil)
+        persist_mgr.garbage_collect(PERSIST_CATEGORY_TOKEN)
+      end
+
+      def persisted_tokens
+        data = persist_mgr.current_items(PERSIST_CATEGORY_TOKEN)
+        data.each.map do |k, v|
+          info = {id: k}
+          info.merge!(JSON.parse(v)) rescue nil
+          d = decode_token(info.delete(TOKEN_FIELD))
+          info.merge(d) if d
+          info
+        end
+      end
+
+      # get token information from cache
+      # @param id [String] identifier of token
+      # @return [Hash] token internal information , including Date object for `expiration_date`
+      def get_token_info(id)
+        token_raw_string = persist_mgr.get(id)
+        return nil if token_raw_string.nil?
+        token_data = JSON.parse(token_raw_string)
+        Aspera.assert_type(token_data, Hash)
+        decoded_token = decode_token(token_data[TOKEN_FIELD])
+        info = { data: token_data }
+        Log.log.debug{Log.dump('decoded_token', decoded_token)}
+        if decoded_token.is_a?(Hash)
+          info[:decoded] = decoded_token
+          # TODO: move date decoding to token decoder ?
+          expiration_date =
+            if    decoded_token['expires_at'].is_a?(String) then DateTime.parse(decoded_token['expires_at']).to_time
+            elsif decoded_token['exp'].is_a?(Integer)       then Time.at(decoded_token['exp'])
+            end
+          unless expiration_date.nil?
+            info[:expiration] = expiration_date
+            info[:ttl_sec] = expiration_date - Time.now
+            info[:expired] = info[:ttl_sec] < @parameters[:token_expiration_guard_sec]
+          end
+        end
+        return info
       end
 
       # register a bearer token decoder, mainly to inspect expiry date
@@ -125,6 +164,6 @@ module Aspera
       end
     end
     # JSON Web Signature (JWS) compact serialization: https://datatracker.ietf.org/doc/html/rfc7515
-    Factory.instance.register_decoder(lambda { |token| parts = token.split('.'); Aspera.assert(parts.length.eql?(3)){'not aoc token'}; JSON.parse(Base64.decode64(parts[1]))}) # rubocop:disable Style/Semicolon, Layout/LineLength
+    Factory.instance.register_decoder(lambda { |token| parts = token.split('.'); Aspera.assert(parts.length.eql?(3)){'not JWS token'}; JSON.parse(Base64.decode64(parts[1]))}) # rubocop:disable Style/Semicolon, Layout/LineLength
   end
 end

data/lib/aspera/persistency_folder.rb

@@ -18,7 +18,8 @@ module Aspera
       Log.log.debug{"persistency folder: #{@folder}"}
     end
 
-    # @return String or nil string on existing persist, else nil
+    # Get value of persisted item
+    # @return [String,nil] Value of persisted id
     def get(object_id)
       Log.log.debug{"persistency get: #{object_id}"}
       if @cache.key?(object_id)
@@ -34,6 +35,10 @@ module Aspera
       return @cache[object_id]
     end
 
+    # Set value of persisted item
+    # @param object_id [String] Identifier of persisted item
+    # @param value [String] Value of persisted item
+    # @return [nil]
     def put(object_id, value)
       Aspera.assert_type(value, String)
       persist_filepath = id_to_filepath(object_id)
@@ -42,8 +47,11 @@ module Aspera
       File.write(persist_filepath, value)
       Environment.restrict_file_access(persist_filepath)
       @cache[object_id] = value
+      nil
     end
 
+    # Delete persisted item
+    # @param object_id [String] Identifier of persisted item
     def delete(object_id)
       persist_filepath = id_to_filepath(object_id)
       Log.log.debug{"persistency deleting: #{persist_filepath}"}
@@ -51,8 +59,9 @@ module Aspera
       @cache.delete(object_id)
     end
 
+    # Delete persisted items
     def garbage_collect(persist_category, max_age_seconds=nil)
-      garbage_files = Dir[File.join(@folder, persist_category + '*' + FILE_SUFFIX)]
+      garbage_files = current_files(persist_category)
       if !max_age_seconds.nil?
         current_time = Time.now
         garbage_files.select! { |filepath| (current_time - File.stat(filepath).mtime).to_i > max_age_seconds}
@@ -61,9 +70,18 @@ module Aspera
         File.delete(filepath)
         Log.log.debug{"persistency deleted expired: #{filepath}"}
       end
+      @cache.clear
       return garbage_files
     end
 
+    def current_files(persist_category)
+      Dir[File.join(@folder, persist_category + '*' + FILE_SUFFIX)]
+    end
+
+    def current_items(persist_category)
+      current_files(persist_category).each_with_object({}) {|i, h| h[File.basename(i, FILE_SUFFIX)] = File.read(i)}
+    end
+
     private
 
     # @param object_id String or Array

data/lib/aspera/preview/generator.rb

@@ -66,7 +66,7 @@ module Aspera
           result_size = File.size(@destination_file_path)
           Log.log.warn{"preview size exceeds maximum allowed #{result_size} > #{@options.max_size}"} if result_size > @options.max_size
         rescue StandardError => e
-          Log.log.error{"Ignoring: #{e.message}"}
+          Log.log.error{"Ignoring: #{e.class} #{e.message}"}
           Log.log.debug(e.backtrace.join("\n").red)
           FileUtils.cp(File.expand_path(@preview_format_sym.eql?(:mp4) ? 'video_error.png' : 'image_error.png', File.dirname(__FILE__)), @destination_file_path)
         ensure

data/lib/aspera/preview/utils.rb

@@ -45,7 +45,7 @@ module Aspera
         # @return true if su
         def external_command(command_sym, command_args)
           Aspera.assert_values(command_sym, EXTERNAL_TOOLS){'command'}
-          return Environment.secure_capture(command_sym.to_s, *command_args)
+          return Environment.secure_capture(exec: command_sym.to_s, args: command_args.map(&:to_s))
         end
 
         def ffmpeg(a)

data/lib/aspera/products/alpha.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'aspera/environment'
+
+module Aspera
+  module Products
+    # Aspera Desktop Alpha Client
+    class Alpha
+      APP_NAME = 'IBM Aspera for Desktop'
+      APP_IDENTIFIER = 'com.ibm.software.aspera.desktop'
+      class << self
+        # standard folder locations
+        def locations
+          case Aspera::Environment.os
+          when Aspera::Environment::OS_MACOS then [{
+            app_root: File.join('', 'Applications', 'IBM Aspera.app'),
+            log_root: File.join(Dir.home, 'Library', 'Logs', APP_IDENTIFIER),
+            sub_bin:  File.join('Contents', 'Resources', 'transferd', 'bin')
+          }]
+          else []
+          end.map { |i| i.merge({ expected: APP_NAME }) }
+        end
+
+        def log_file
+          File.join(Dir.home, 'Library', 'Logs', APP_IDENTIFIER, 'ibm-aspera-desktop.log')
+        end
+      end
+    end
+  end
+end