aspera-cli 4.19.0 → 4.21.1

data/lib/aspera/keychain/macos_security.rb

@@ -4,7 +4,7 @@
 require 'aspera/cli/info'
 require 'aspera/log'
 require 'aspera/assert'
-require 'open3'
+require 'aspera/environment'
 
 # enhance the gem to support other key chains
 module Aspera
@@ -48,20 +48,15 @@ module Aspera
               options[:path] = uri.path unless ['', '/'].include?(uri.path)
               options[:port] = uri.port unless uri.port.eql?(443) && !url.include?(':443/')
             end
-            command_line = [SECURITY_UTILITY, command]
+            command_args = [command]
             options&.each do |k, v|
               Aspera.assert(supported.key?(k)){"unknown option: #{k}"}
               next if v.nil?
-              command_line.push("-#{supported[k]}")
-              command_line.push(v.shellescape) unless v.empty?
+              command_args.push("-#{supported[k]}")
+              command_args.push(v.shellescape) unless v.empty?
             end
-            command_line.push(last_opt) unless last_opt.nil?
-            Log.log.debug{"executing>>#{command_line.join(' ')}"}
-            stdout, stderr, status = Open3.capture3(*command_line)
-            Log.log.debug{"status=#{status}, stderr=#{stderr}"}
-            Log.log.trace1{"stdout=#{stdout}"}
-            raise "#{SECURITY_UTILITY} failed: #{status.exitstatus} : #{stderr}" unless status.success?
-            return stdout
+            command_args.push(last_opt) unless last_opt.nil?
+            return Environment.secure_capture(exec: SECURITY_UTILITY, args: command_args)
           end
 
           def key_chains(output)
@@ -78,7 +73,7 @@ module Aspera
 
           def list(options={})
             Aspera.assert_values(options[:domain], DOMAINS, exception_class: ArgumentError){'domain'} unless options[:domain].nil?
-            key_chains(execute('list-key_chains', options, LIST_OPTIONS))
+            key_chains(execute('list-keychains', options, LIST_OPTIONS))
           end
 
           def by_name(name)

data/lib/aspera/log.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'aspera/assert'
 require 'aspera/colors'
 require 'aspera/secret_hider'
 require 'logger'
@@ -73,8 +74,7 @@ module Aspera
             JSON.pretty_generate(object) rescue PP.pp(object, +'')
           when :ruby
             PP.pp(object, +'')
-          else
-            raise 'wrong parameter, expect ruby or json'
+          else error_unexpected_value(@@format){'dump format'}
           end
         "#{name.to_s.green} (#{@@format})=\n#{result}"
       end
@@ -127,8 +127,7 @@ module Aspera
           Syslog::Logger.make_methods(severity.downcase)
         end
         @logger = Syslog::Logger.new(@program_name, Syslog::LOG_LOCAL2)
-      else
-        raise "unknown log type: #{new_log_type}, use one of: #{LOG_TYPES.join(', ')}"
+      else error_unexpected_value(new_log_type){"log type (#{LOG_TYPES.join(', ')})"}
       end
       @logger.level = current_severity_integer
       @logger_type = new_log_type

data/lib/aspera/node_simulator.rb

@@ -7,28 +7,241 @@ 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 management port
+    def process_event(event)
+      case event['Type']
+      when 'NOP' then Aspera.Log.debug{"event not managed: #{event['Type']}"}
+      # rubocop:disable Lint/DuplicateBranch
+      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']}"}
+      # rubocop:enable Lint/DuplicateBranch
+      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 +249,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 +257,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 +312,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

@@ -3,64 +3,64 @@
 require 'aspera/oauth/factory'
 require 'aspera/log'
 require 'aspera/assert'
-require 'aspera/id_generator'
 require 'date'
 
 module Aspera
   module OAuth
-    # Implement OAuth 2 for the REST client and generate a bearer token
-    # bearer tokens are cached in memory and in a file cache for later re-use
+    # OAuth 2 client for the REST client
+    # Generate bearer token
+    # Bearer tokens are cached in memory and in a file cache for later re-use
     # https://tools.ietf.org/html/rfc6749
     class Base
-      # scope can be modified after creation
-      attr_writer :scope
-
-      # [M]=mandatory [D]=has default value [O]=Optional/nil
-      # @param base_url            [M] URL of authentication API
-      # @param auth                [O] basic auth parameters
-      # @param client_id           [O]
-      # @param client_secret       [O]
-      # @param scope               [O]
-      # @param path_token          [D] API end point to create a token
-      # @param token_field         [D] field in result that contains the token
+      # @param **             Parameters for REST
+      # @param client_id      [String, nil]
+      # @param client_secret  [String, nil]
+      # @param scope          [String, nil]
+      # @param use_query      [bool]        Provide parameters in query instead of body
+      # @param path_token     [String]      API end point to create a token
+      # @param token_field    [String]      Field in result that contains the token
+      # @param cache_ids      [Array, nil]  List of unique identifiers for cache id generation
       def initialize(
-        base_url:,
-        auth: nil,
         client_id: nil,
         client_secret: nil,
         scope: nil,
         use_query: false,
-        path_token:  'token',       # default endpoint for /token to generate token
-        token_field: 'access_token' # field with token in result of call to path_token
+        path_token:  'token',
+        token_field: Factory::TOKEN_FIELD,
+        cache_ids: nil,
+        **rest_params
       )
-        Aspera.assert_type(base_url, String)
         Aspera.assert(respond_to?(:create_token), 'create_token method must be defined', exception_class: InternalError)
-        @base_url = base_url
+        # this is the OAuth API
+        @api = Rest.new(**rest_params)
         @path_token = path_token
         @token_field = token_field
         @client_id = client_id
         @client_secret = client_secret
-        @scope = scope
         @use_query = use_query
-        @identifiers = []
-        @identifiers.push(auth[:username]) if auth.is_a?(Hash) && auth.key?(:username)
-        # this is the OAuth API
-        @api = Rest.new(
-          base_url:     @base_url,
-          redirect_max: 2,
-          auth:         auth)
+        @base_cache_ids = cache_ids.nil? ? [] : cache_ids.clone
+        Aspera.assert_type(@base_cache_ids, Array)
+        @base_cache_ids.push(@api.auth_params[:username]) if @api.auth_params.key?(:username)
+        @base_cache_ids.compact!
+        @base_cache_ids.freeze
+        self.scope = scope
+      end
+
+      # Scope can be modified after creation, then update identifier for cache
+      def scope=(scope)
+        @scope = scope
+        # generate token unique identifier for persistency (memory/disk cache)
+        @token_cache_id = Factory.cache_id(@api.base_url, self.class, @base_cache_ids, @scope)
       end
 
       # helper method to create token as per RFC
       def create_token_call(creation_params)
         Log.log.debug{'Generating a new token'.bg_green}
-        payload = {
-          body:      creation_params,
-          body_type: :www
-        }
+        payload = { body_type: :www }
         if @use_query
           payload[:query] = creation_params
-          payload[:body] = {}
+        else
+          payload[:body] = creation_params
         end
         return @api.call(
           operation: 'POST',
@@ -85,56 +85,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)
-        # generate token unique identifier for persistency (memory/disk cache)
-        token_id = IdGenerator.from_list(Factory.id(
-          @base_url,
-          Factory.class_to_id(self.class),
-          @identifiers,
-          @scope
-        ))
-
-        # get token_data from cache (or nil), token_data is what is returned by /token
-        token_data = Factory.instance.persist_mgr.get(token_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_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_id, json_data)
-            else
-              Log.log.debug{"refresh failed: #{resp[:http].body}".bg_red}
             end
           end
         end
@@ -144,7 +125,7 @@ module Aspera
           resp = create_token
           json_data = resp[:http].body
           token_data = JSON.parse(json_data)
-          Factory.instance.persist_mgr.put(token_id, json_data)
+          Factory.instance.persist_mgr.put(@token_cache_id, json_data)
         end
         Aspera.assert(token_data.key?(@token_field)){"API error: No such field in answer: #{@token_field}"}
         # ok we shall have a token here