aspera-cli 4.24.0 → 4.24.2

data/bin/ascli

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+# This is the main script to execute the Aspera CLI
+
 old_verbose = $VERBOSE
 $VERBOSE = nil
 # internal representation of strings (ruby) is UTF-8
@@ -9,9 +11,26 @@ Encoding.default_internal = Encoding::UTF_8
 Encoding.default_external = Encoding::UTF_8
 $VERBOSE = old_verbose
 
+require 'aspera/log'
+require 'aspera/cli/info'
+
+# Early debug for parser
+# Note: does not accept short option names, nor extended values
+Aspera::Log.instance.program_name = Aspera::Cli::Info::CMD_NAME
+ARGV.each do |arg|
+  case arg
+  when '--' then break
+  when /^--log-level=(.*)/ then Aspera::Log.instance.level = Regexp.last_match(1).to_sym
+  when /^--log-format=(.*)/ then Aspera::Log.instance.formatter = Regexp.last_match(1) unless Regexp.last_match(1).start_with?('@ruby:')
+  when /^--logger=(.*)/ then Aspera::Log.instance.logger_type = Regexp.last_match(1).to_sym
+  end
+rescue => e
+  $stderr.puts("Error: #{e}") # rubocop:disable Style/StderrPuts
+  Process.exit(1)
+end
+
 require 'aspera/coverage'
 require 'aspera/environment'
 require 'aspera/cli/main'
-Aspera::Cli::Main.early_debug_setup(ARGV)
 Aspera::Environment.instance.fix_home
 Aspera::Cli::Main.new(ARGV).process_command_line

data/bin/asession

@@ -7,16 +7,16 @@ require 'aspera/cli/extended_value'
 require 'aspera/products/transferd'
 require 'aspera/log'
 require 'json'
-# extended transfer spec parameter (only used in asession)
+# Extended transfer spec parameter (only used in asession)
 PARAM_SPEC = 'spec'
-# log level
+# Log level
 PARAM_LOG_LEVEL = 'loglevel'
-# transfer agent options
+# Transfer agent options
 PARAM_AGENT = 'agent'
-# by default go to /tmp/username.filelist
+# By default go to /tmp/username.filelist
 PARAM_TMP_FILE_LIST_FOLDER = 'file_list_folder'
 PARAM_SDK = 'sdk'
-# place transfer spec in that
+# Place transfer spec in that
 SAMPLE_DEMO = '"remote_host":"demo.asperasoft.com","remote_user":"asperaweb","ssh_port":33001,"remote_password":"demoaspera"'
 SAMPLE_DEMO2 = '"direction":"receive","destination_root":"./test.dir"'
 def assert_usage(assertion, error_message)
@@ -52,27 +52,27 @@ def assert_usage(assertion, error_message)
   Process.exit(0)
 end
 parameter_source_err_msg = ' (argument), did you specify: "@json:" ?'
-# by default assume JSON input on stdin if no argument
+# By default assume JSON input on stdin if no argument
 if ARGV.empty?
   ARGV.push('@json:@stdin')
   parameter_source_err_msg = ' (JSON on stdin)'
 end
-# anyway expect only one argument: session information
+# Anyway expect only one argument: session information
 assert_usage(ARGV.length.eql?(1), 'exactly one argument is expected')
 assert_usage(!['-h', '--help'].include?(ARGV.first), nil)
-# parse transfer spec
+# Parse transfer spec
 begin
   session_argument = ARGV.pop
   session_spec = Aspera::Cli::ExtendedValue.instance.evaluate(session_argument)
 rescue
   assert_usage(false, "Cannot parse argument: #{session_argument}")
 end
-# ensure right type
+# Ensure right type for parameter
 assert_usage(session_spec.is_a?(Hash), "The value must be a Hash#{parameter_source_err_msg}")
 assert_usage(session_spec[PARAM_SPEC].is_a?(Hash), "The value must contain key #{PARAM_SPEC} with Hash value")
-# additional debug capability
-Aspera::Log.instance.level = session_spec[PARAM_LOG_LEVEL] if session_spec.key?(PARAM_LOG_LEVEL)
-# possibly override temp folder
+# Additional debug capability
+Aspera::Log.instance.level = session_spec[PARAM_LOG_LEVEL].to_sym if session_spec.key?(PARAM_LOG_LEVEL)
+# Possibly override temp folder
 Aspera::Transfer::Parameters.file_list_folder = session_spec[PARAM_TMP_FILE_LIST_FOLDER] if session_spec.key?(PARAM_TMP_FILE_LIST_FOLDER)
 session_spec[PARAM_SDK] = File.join(Dir.home, '.aspera', 'sdk') unless session_spec.key?(PARAM_SDK)
 Aspera::Products::Transferd.sdk_directory = session_spec[PARAM_SDK]
@@ -80,25 +80,21 @@ session_spec[PARAM_AGENT] = {} unless session_spec.key?(PARAM_AGENT)
 agent_params = session_spec[PARAM_AGENT]
 agent_params['quiet'] = true
 agent_params['management_cb'] = ->(event) do
-  puts JSON.generate(Aspera::Ascp::Management.enhanced_event_format(event))
+  puts JSON.generate(Aspera::Ascp::Management.event_native_to_snake(event))
 end
-# get local agent (ascp), disable ascp output on stdout to not mix with JSON events
+# Get local agent (ascp), disable ascp output on stdout to not mix with JSON events
 client = Aspera::Agent::Direct.new(**agent_params.symbolize_keys)
-# start transfer (asynchronous)
-job_id = client.start_transfer(session_spec[PARAM_SPEC])
-# async commands
+# Start transfer (asynchronous)
+client.start_transfer(session_spec[PARAM_SPEC])
+# commands to ascp on mgt port
 Thread.new do
-  # we assume here a single session
-  session_id = client.sessions_by_job(job_id).first
-  begin
-    loop do
-      data = JSON.parse($stdin.gets)
-      client.send_command(session_id, data)
-    end
-  rescue
-    Process.exit(1)
+  loop do
+    data = JSON.parse($stdin.gets)
+    client.send_command(data)
   end
+rescue
+  Process.exit(1)
 end
-# no exit code: status is success (0)
+# No exit code: status is success (0)
 client.wait_for_transfers_completion
 client.shutdown

data/lib/aspera/agent/base.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'aspera/log'
 require 'aspera/assert'
 module Aspera
   module Agent
@@ -10,25 +9,6 @@ module Aspera
     # - `wait_for_transfers_completion` : waits for all transfer sessions to finish
     # - `notify_progress` : called back by transfer agent to notify transfer progress
     class Base
-      RUBY_EXT = '.rb'
-      private_constant :RUBY_EXT
-      class << self
-        def factory_create(agent, options)
-          # Aspera.assert_values(agent, agent_list)
-          require "aspera/agent/#{agent}"
-          Aspera::Agent.const_get(agent.to_s.capitalize).new(**options)
-        end
-
-        # discover available agents
-        # @return [Array] list of symbols of agents
-        def agent_list
-          base_class = File.basename(__FILE__)
-          Dir.entries(File.dirname(File.expand_path(__FILE__))).select do |file|
-            file.end_with?(RUBY_EXT) && !file.eql?(base_class)
-          end.map{ |file| file[0..(-1 - RUBY_EXT.length)].to_sym}
-        end
-      end
-
       # Wait for all sessions to terminate and return the status of each session
       def wait_for_completion
         # list of: :success or "error message string"
@@ -48,8 +28,17 @@ module Aspera
         nil
       end
 
-      def initialize(progress: nil)
+      attr_reader :config_dir
+
+      # Base transfer agent object
+      # @param progress   [Object] Progress bar
+      # @param config_dir [String] Config folder
+      def initialize(
+        progress: nil,
+        config_dir: nil
+      )
         @progress = progress
+        @config_dir = config_dir
       end
 
       def notify_progress(*pos_args, **kw_args)

data/lib/aspera/agent/connect.rb

@@ -24,6 +24,7 @@ module Aspera
         raise Error, 'Using connect requires a graphical environment' unless Environment.instance.graphical?
         method_index = 0
         begin
+          # raise exception if connect not started and file does not exist
           connect_url = connect_api_url
           Log.log.debug{"found: #{connect_url}"}
           @connect_api = Rest.new(
@@ -135,9 +136,7 @@ module Aspera
 
       # @return the file path of local connect where API's URI can be read
       def connect_api_url
-        connect_locations = Products::Other.find(Products::Connect.locations).first
-        raise "Product: #{name} not found, please install." if connect_locations.nil?
-        folder = File.join(connect_locations[:run_root], 'var', 'run')
+        folder = File.join(Products::Other.find(Products::Connect.locations).first[:run_root], 'var', 'run')
         ['', 's'].each do |ext|
           uri_file = File.join(folder, "http#{ext}.uri")
           Log.log.debug{"checking connect port file: #{uri_file}"}

data/lib/aspera/agent/desktop.rb

@@ -102,7 +102,7 @@ module Aspera
 
       # @return [String] the url where transferd is listening
       def aspera_client_api_url
-        log_file = Products::Desktop.log_file
+        log_file = File.join(Products::Other.find(Products::Desktop.locations).first[:log_root], Products::Desktop::LOG_FILENAME)
         url = 'http://127.0.0.1:33024'
         File.open(log_file, 'r') do |file|
           file.each_line do |line|
@@ -111,7 +111,7 @@ module Aspera
               url = "http://#{m[1]}"
             end
           end
-        end
+        end if File.exist?(log_file)
         # raise StandardError, "Unable to find the JSON-RPC server URL in #{log_file}" if url.nil?
         return url
       end

data/lib/aspera/agent/direct.rb

@@ -6,7 +6,7 @@ require 'aspera/ascp/management'
 require 'aspera/transfer/parameters'
 require 'aspera/transfer/error'
 require 'aspera/transfer/spec'
-require 'aspera/resumer'
+require 'aspera/transfer/resumer'
 require 'aspera/log'
 require 'aspera/assert'
 require 'socket'
@@ -24,18 +24,18 @@ module Aspera
       SELECT_AVAILABLE_PORT = 0
       private_constant :LISTEN_LOCAL_ADDRESS, :SELECT_AVAILABLE_PORT
 
-      # options for initialize (same as values in option transfer_info)
-      # @param ascp_args         [Array]   additional arguments to ascp
-      # @param wss               [Boolean] true: if both SSH and wss in ts: prefer wss
-      # @param quiet             [Boolean] by default no native ascp progress bar
-      # @param monitor           [Boolean] set to false to eliminate management port
-      # @param trusted_certs     [Array,NilClass] list of files with trusted certificates (stores)
-      # @param client_ssh_key    [String]  client ssh key option (from CLIENT_SSH_KEY_OPTIONS)
-      # @param check_ignore_cb   [Proc]    callback with host,port
-      # @param spawn_timeout_sec [Integer] timeout for ascp spawn
-      # @param spawn_delay_sec   [Integer] optional delay to start between sessions
-      # @param multi_incr_udp    [Boolean,NilClass] true: increment udp port for each session
-      # @param resume            [Hash,NilClass] resume policy
+      # Options: same as values in option `transfer_info`
+      # @param ascp_args         [Array]   (Params) Optional Additional arguments to ascp
+      # @param wss               [Boolean] (Params) `true`: if both SSH and wss in ts: prefer wss
+      # @param quiet             [Boolean] (Params) By default no native `ascp` progress bar
+      # @param monitor           [Boolean] (Params) Set to `false` to eliminate management port
+      # @param trusted_certs     [Array]   (Params) Optional list of files with trusted certificates (stores)
+      # @param client_ssh_key    [String]  (Params) Client SSH key option (from CLIENT_SSH_KEY_OPTIONS)
+      # @param check_ignore_cb   [Proc]    (Params) Callback with host,port
+      # @param spawn_timeout_sec [Integer] Timeout for ascp spawn
+      # @param spawn_delay_sec   [Integer] Optional delay to start between sessions
+      # @param multi_incr_udp    [Boolean] Optional `true`: increment UDP port for each session
+      # @param resume            [Hash]    Optional Resume policy
       # @param management_cb     [Proc]    callback for management events
       # @param base_options      [Hash]    other options for base class
       def initialize(
@@ -54,7 +54,7 @@ module Aspera
         **base_options
       )
         super(**base_options)
-        # special transfer parameters
+        # Special transfer parameters provided
         @tr_opts = {
           ascp_args:       ascp_args,
           wss:             wss,
@@ -69,19 +69,22 @@ module Aspera
         @multi_incr_udp = multi_incr_udp.nil? ? Environment.instance.os.eql?(Environment::OS_WINDOWS) : multi_incr_udp
         @monitor = monitor
         @management_cb = management_cb
-        @resume_policy = Resumer.new(resume.nil? ? {} : resume.symbolize_keys)
+        resume = {} if resume.nil?
+        Aspera.assert_type(resume, Hash){'resume'}
+        @resume_policy = Transfer::Resumer.new(**resume.symbolize_keys)
         # all transfer jobs, key = SecureRandom.uuid, protected by mutex, cond var on change
         @sessions = []
         # mutex protects global data accessed by threads
         @mutex = Mutex.new
         @pre_calc_sent = false
         @pre_calc_last_size = nil
+        @command_file = File.join(config_dir || '.', "send_#{$PROCESS_ID}")
       end
 
-      # start ascp transfer(s) (non blocking), single or multi-session
-      # session information added to @sessions
-      # @param transfer_spec [Hash] aspera transfer specification
-      # @param token_regenerator [Object] object with method refreshed_transfer_token
+      # Start `ascp` transfer(s) (non blocking), single or multi-session
+      # Session information added to @sessions
+      # @param transfer_spec     [Hash]   Aspera transfer specification
+      # @param token_regenerator [Object] Object with method refreshed_transfer_token
       def start_transfer(transfer_spec, token_regenerator: nil)
         # clone transfer spec because we modify it (first level keys)
         transfer_spec = transfer_spec.clone
@@ -188,16 +191,23 @@ module Aspera
         @sessions.select{ |session| session[:job_id].eql?(job_id)}
       end
 
-      # send command to management port of command (used in `asession)
-      # @param job_id identified transfer process
-      # @param session_index index of session (for multi session)
-      # @param data command on mgt port, examples:
+      # Send command to management port of command (used in `asession).
+      # Examples:
       # {'type'=>'START','source'=>_path_,'destination'=>_path_}
       # {'type'=>'DONE'}
-      def send_command(job_id, data)
-        session = @sessions.find{ |session| session[:job_id].eql?(job_id)}
-        Log.log.debug{"command: #{data}"}
-        session[:io].puts(Ascp::Management.command_to_stream(data))
+      # @param data [Hash]   Command on mgt port
+      # @param id   [String] Optional identifier or transfer session
+      def send_command(data, id: nil)
+        Log.dump(:command, data)
+        sessions = id ? @sessions.select{ |session| session[:job_id].eql?(id)} : @sessions
+        if sessions.empty?
+          Log.log.warn('No transfer session')
+          return
+        end
+        message = Ascp::Management.command_to_stream(data)
+        sessions.each do |session|
+          session[:io].puts(message)
+        end
       end
 
       private
@@ -301,6 +311,14 @@ module Aspera
             session[:id] = event['SessionId'] if event['Type'].eql?('INIT')
             @management_cb&.call(event)
             process_progress(event)
+            next unless File.exist?(@command_file)
+            begin
+              commands = JSON.parse(File.read(@command_file))
+              send_command(commands)
+            rescue => e
+              Log.log.error{e.to_s}
+            end
+            File.delete(@command_file)
           end
           Log.log.debug('management io closed')
           # check that last status was received before process exit
@@ -317,7 +335,7 @@ module Aspera
               Log.log.warn('Regenerating token for transfer')
               env['ASPERA_SCP_TOKEN'] = session[:token_regenerator].refreshed_transfer_token
             end
-            raise Transfer::Error.new(last_event['Description'], last_event['Code'].to_i)
+            raise Transfer::Error.new(last_event['Description'], code: last_event['Code'].to_i)
           else Aspera.error_unexpected_value(last_event['Type'], :error){'last event type'}
           end
         rescue SystemCallError => e
@@ -347,7 +365,7 @@ module Aspera
             # status is nil if an exception occurred before starting command
             if !status&.success?
               message = "#{name} failed (#{status})"
-              # raise error only if there was not already an exception (ERROR_INFO)
+              # raise error only if there was not already an exception (`$ERROR_INFO`)
               raise Transfer::Error, message unless $ERROR_INFO
               # else display this message also, as main exception is already here
               Log.log.error(message)
@@ -361,9 +379,8 @@ module Aspera
 
       attr_reader :sessions
 
-      # notify progress to callback
-      # @param event management port event
-      # @param session sessin object
+      # Notify progress to callback
+      # @param event [Hash] management port event
       def process_progress(event)
         session_id = event['SessionId']
         case event['Type']

data/lib/aspera/agent/factory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'aspera/log'
+require 'aspera/environment'
+module Aspera
+  module Agent
+    # Factory for Agents
+    class Factory
+      include Singleton
+
+      # Create new agent
+      def create(agent, options)
+        Log.dump(:options, options)
+        require "aspera/agent/#{agent}"
+        Aspera::Agent.const_get(agent.to_s.capitalize).new(**options)
+      end
+
+      # Discover available agents
+      # @return [Array] list of symbols of agents
+      def list
+        Dir.children(File.dirname(File.expand_path(__FILE__)))
+          .select{ |file| file.end_with?(Environment::RB_EXT)}
+          .map{ |file| File.basename(file, Environment::RB_EXT).to_sym}
+          .reject{ |item| IGNORED_ITEMS.include?(item)}
+      end
+      IGNORED_ITEMS = %i[factory base]
+      private_constant :IGNORED_ITEMS
+    end
+  end
+end

data/lib/aspera/api/aoc.rb

@@ -8,11 +8,10 @@ require 'aspera/data_repository'
 require 'aspera/transfer/spec'
 require 'aspera/api/node'
 require 'base64'
-require 'cgi'
 
 module Aspera
   module Api
-    class AoC < Aspera::Rest
+    class AoC < Rest
       PRODUCT_NAME = 'Aspera on Cloud'
       # use default workspace if it is set, else none
       DEFAULT_WORKSPACE = ''
@@ -140,6 +139,43 @@ module Aspera
             organization:    org_domain[:organization]
           }
         end
+
+        # Call block with same query using paging and response information.
+        # Block must return a hash with :data and :http keys
+        # @return [Hash] {items: , total: }
+        def call_paging(query: {}, formatter: 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
+          query['per_page'] = 1000 unless query.key?('per_page')
+          max_items = query.delete(Rest::MAX_ITEMS)
+          max_pages = query.delete(Rest::MAX_PAGES)
+          item_list = []
+          total_count = nil
+          current_page = query['page']
+          current_page = 1 if current_page.nil?
+          page_count = 0
+          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']
+            page_count += 1
+            current_page += 1
+            add_items = result[:data]
+            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
+            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
       end
 
       attr_reader :private_link
@@ -147,8 +183,8 @@ module Aspera
       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 ArgumentError, 'Missing mandatory option: url' if url.nil?
-        raise ArgumentError, 'Missing mandatory option: scope' if scope.nil?
+        raise ParameterError, 'Missing mandatory option: url' if url.nil?
+        raise ParameterError, 'Missing mandatory option: scope' if scope.nil?
         # 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
@@ -173,22 +209,21 @@ module Aspera
         auth_params[:grant_method] = if url_info.key?(:token)
           :url_json
         else
-          raise ArgumentError, 'Missing mandatory option: auth' if auth.nil?
+          raise ParameterError, 'Missing mandatory option: auth' if auth.nil?
           auth
         end
         # this is the base API url
         api_url_base = self.class.api_base_url(api_domain: url_info[:instance_domain])
         # auth URL
         auth_params[:base_url] = "#{api_url_base}/#{OAUTH_API_SUBPATH}/#{url_info[:organization]}"
-
         # fill other auth parameters based on OAuth method
         case auth_params[:grant_method]
         when :web
-          raise ArgumentError, 'Missing mandatory option: redirect_uri' if redirect_uri.nil?
+          raise ParameterError, 'Missing mandatory option: redirect_uri' if redirect_uri.nil?
           auth_params[:redirect_uri] = redirect_uri
         when :jwt
-          raise ArgumentError, 'Missing mandatory option: private_key' if private_key.nil?
-          raise ArgumentError, 'Missing mandatory option: username' if username.nil?
+          raise ParameterError, 'Missing mandatory option: private_key' if private_key.nil?
+          raise ParameterError, 'Missing mandatory option: username' if username.nil?
           auth_params[:private_key_obj] = OpenSSL::PKey::RSA.new(private_key, passphrase)
           auth_params[:payload] = {
             iss: auth_params[:client_id], # issuer
@@ -205,7 +240,7 @@ module Aspera
           auth_params[:json][:password] = password unless password.nil?
           # basic auth required for /token
           auth_params[:auth] = {type: :basic, username: auth_params[:client_id], password: auth_params[:client_secret]}
-        else Aspera.error_unexpected_value(auth_params[:grant_method])
+        else Aspera.error_unexpected_value(auth_params[:grant_method]){'auth, use one of: :web, :jwt'}
         end
         super(
           base_url: "#{api_url_base}/#{subpath}",
@@ -213,12 +248,13 @@ module Aspera
           )
       end
 
-      def public_link
-        return unless auth_params[:grant_method].eql?(:url_json)
-        return @cache_url_token_info unless @cache_url_token_info.nil?
-        # TODO: can there be several in list ?
-        @cache_url_token_info = read('url_tokens').first
-        return @cache_url_token_info
+      # read using the query and paging
+      # @return [Hash] {items: , total: }
+      def read_with_paging(subpath, query: {}, 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)
+        end
       end
 
       def assert_public_link_types(expected)
@@ -230,7 +266,17 @@ module Aspera
         return [] # TODO : public_link['id'] ?
       end
 
-      # cached user information
+      # Cached public link information
+      # @return [Hash, nil] token info if public link or nil
+      def public_link
+        return unless auth_params[:grant_method].eql?(:url_json)
+        return @cache_url_token_info unless @cache_url_token_info.nil?
+        # TODO: can there be several in list ?
+        @cache_url_token_info = read('url_tokens').first
+        return @cache_url_token_info
+      end
+
+      # Cached user information
       def current_user_info(exception: false)
         return @cache_user_info unless @cache_user_info.nil?
         # get our user's default information
@@ -246,21 +292,9 @@ module Aspera
         return @cache_user_info
       end
 
+      # Cached workspace information
       def workspace
-        Aspera.assert(!@workspace_info.nil?){'AoC workspace context is not set'}
-        @workspace_info
-      end
-
-      def home
-        Aspera.assert(!@home_info.nil?){'AoC home context is not set'}
-        @home_info
-      end
-
-      # Set the application context
-      # @param application [Symbol,NilClass] :files or :packages
-      # @return [Hash] current context information: workspace, and home node/file if app is "Files"
-      def context=(application)
-        Aspera.assert_values(application, %i[files packages])
+        return @workspace_info unless @workspace_info.nil?
         ws_id =
           if !public_link.nil?
             Log.log.debug('Using workspace of public link')
@@ -278,26 +312,21 @@ module Aspera
           else
             lookup_by_name('workspaces', @workspace_name)['id']
           end
-        ws_info =
-          if ws_id.nil?
-            nil
-          else
-            read("workspaces/#{ws_id}")
-          end
         @workspace_info =
-          if ws_info.nil?
+          if ws_id.nil?
             {
-              id:   nil,
-              name: "Shared #{application}"
+              name: 'Shared (no workspace)'
             }
           else
-            {
-              id:   ws_info['id'],
-              name: ws_info['name']
-            }
+            read("workspaces/#{ws_id}").slice('id', 'name', 'home_node_id', 'home_file_id').symbolize_keys
           end
-        Log.dump(:context, @workspace_info)
-        return unless application.eql?(:files)
+        Log.dump(:workspace_info, @workspace_info)
+        @workspace_info
+      end
+
+      # Cached Home information for current user in Files app
+      def home
+        return @home_info unless @home_info.nil?
         @home_info =
           if !public_link.nil?
             assert_public_link_types(['view_shared_file'])
@@ -310,10 +339,10 @@ module Aspera
               node_id: private_link[:node_id],
               file_id: private_link[:file_id]
             }
-          elsif ws_info
+          elsif workspace[:home_node_id] && workspace[:home_file_id]
             {
-              node_id: ws_info['home_node_id'],
-              file_id: ws_info['home_file_id']
+              node_id: workspace[:home_node_id],
+              file_id: workspace[:home_file_id]
             }
           else
             # not part of any workspace, but has some folder shared
@@ -325,6 +354,7 @@ module Aspera
           end
         raise "Cannot get user's home node id, check your default workspace or specify one" if @home_info[:node_id].to_s.empty?
         Log.dump(:context, @home_info)
+        @home_info
       end
 
       # @param node_id [String] identifier of node in AoC