aspera-cli 4.20.0 → 4.21.1

data/lib/aspera/cli/version.rb

@@ -4,6 +4,6 @@ module Aspera
   module Cli
     # for beta add extension : .beta1
     # for dev version add extension : .pre
-    VERSION = '4.20.0'
+    VERSION = '4.21.1'
   end
 end

data/lib/aspera/command_line_builder.rb

@@ -77,7 +77,7 @@ module Aspera
       @param_hash.each_pair{|key, val|Log.log.warn{"unrecognized parameter: #{key} = \"#{val}\""} if !@used_param_names.include?(key)}
       # set result
       env_args[:env].merge!(@result[:env])
-      env_args[:args].push(*@result[:args])
+      env_args[:args].concat(@result[:args])
       return nil
     end
 

data/lib/aspera/environment.rb

@@ -46,8 +46,7 @@ module Aspera
           return OS_LINUX
         when /aix/
           return OS_AIX
-        else
-          raise "Unknown OS: #{RbConfig::CONFIG['host_os']}"
+        else Aspera.error_unexpected_value(RbConfig::CONFIG['host_os']){'host_os'}
         end
       end
 
@@ -62,8 +61,8 @@ module Aspera
           return CPU_S390
         when /arm/, /aarch64/
           return CPU_ARM64
+        else Aspera.error_unexpected_value(RbConfig::CONFIG['host_cpu']){'host_cpu'}
         end
-        raise "Unknown CPU: #{RbConfig::CONFIG['host_cpu']}"
       end
 
       # normalized architecture name
@@ -73,9 +72,9 @@ module Aspera
       end
 
       # executable file extension for current OS
-      def exe_extension
-        return '.exe' if os.eql?(OS_WINDOWS)
-        return ''
+      def exe_file(name='')
+        return "#{name}.exe" if os.eql?(OS_WINDOWS)
+        return name
       end
 
       # on Windows, the env var %USERPROFILE% provides the path to user's home more reliably than %HOMEDRIVE%%HOMEPATH%
@@ -96,25 +95,60 @@ module Aspera
         Kernel.send('lave'.reverse, code, empty_binding, file, line)
       end
 
-      def log_spawn(env:, exec:, args:)
+      # Generate log line for external program with arguments
+      # @param env [Hash, nil]   environment variables
+      # @param exec [String]     path to executable
+      # @param args [Array, nil] arguments
+      # @return [String] log line with environment, program and arguments
+      def log_spawn(exec:, args: nil, env: nil)
         [
           'execute:'.red,
-          env.map{|k, v| "#{k}=#{Shellwords.shellescape(v)}"},
+          env&.map{|k, v| "#{k}=#{Shellwords.shellescape(v)}"},
           Shellwords.shellescape(exec),
-          args.map{|a|Shellwords.shellescape(a)}
-        ].flatten.join(' ')
+          args&.map{|a|Shellwords.shellescape(a)}
+        ].compact.flatten.join(' ')
       end
 
       # start process in background, or raise exception
       # caller can call Process.wait on returned value
-      def secure_spawn(exec:, args: [], env: [])
-        Log.log.debug {log_spawn(env: env, exec: exec, args: args)}
+      # @param env [Hash, nil]   environment variables
+      # @param exec [String]     path to executable
+      # @param args [Array, nil] arguments
+      # @return [String] PID of process
+      def secure_spawn(exec:, args: nil, env: nil)
+        Aspera.assert_type(exec, String)
+        Aspera.assert_type(args, Array) unless args.nil?
+        Aspera.assert_type(env, Hash) unless env.nil?
+        Log.log.debug {log_spawn(exec: exec, args: args, env: env)}
         # start ascp in separate process
-        ascp_pid = Process.spawn(env, [exec, exec], *args, close_others: true)
+        spawn_args = []
+        spawn_args.push(env) unless env.nil?
+        spawn_args.push([exec, exec])
+        spawn_args.concat(args) unless args.nil?
+        ascp_pid = Process.spawn(*spawn_args, close_others: true)
         Log.log.debug{"pid: #{ascp_pid}"}
         return ascp_pid
       end
 
+      # start process and wait for completion
+      # @param env [Hash, nil]   environment variables
+      # @param exec [String]     path to executable
+      # @param args [Array, nil] arguments
+      # @return [String] PID of process
+      def secure_execute(exec:, args: nil, env: nil)
+        Aspera.assert_type(exec, String)
+        Aspera.assert_type(args, Array) unless args.nil?
+        Aspera.assert_type(env, Hash) unless env.nil?
+        Log.log.debug {log_spawn(exec: exec, args: args, env: env)}
+        # start ascp in separate process
+        spawn_args = []
+        spawn_args.push(env) unless env.nil?
+        spawn_args.push([exec, exec])
+        spawn_args.concat(args) unless args.nil?
+        Kernel.system(*spawn_args, exception: true)
+        nil
+      end
+
       # @param exec [String] path to executable
       # @param args [Array] arguments to executable
       # @param opts [Hash] options to capture3
@@ -123,7 +157,7 @@ module Aspera
         Aspera.assert_type(exec, String)
         Aspera.assert_type(args, Array)
         Aspera.assert_type(opts, Hash)
-        Log.log.debug {log_spawn(env: {}, exec: exec, args: args)}
+        Log.log.debug {log_spawn(exec: exec, args: args)}
         stdout, stderr, status = Open3.capture3(exec, *args, **opts)
         Log.log.debug{"status=#{status}, stderr=#{stderr}"}
         Log.log.trace1{"stdout=#{stdout}"}

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

@@ -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
       )
@@ -38,12 +38,10 @@ module Aspera
         @client_id = client_id
         @client_secret = client_secret
         @use_query = use_query
-        @base_cache_ids = cache_ids.clone
-        @base_cache_ids = [] if @base_cache_ids.nil?
+        @base_cache_ids = cache_ids.nil? ? [] : cache_ids.clone
         Aspera.assert_type(@base_cache_ids, Array)
-        if @api.auth_params.key?(:username)
-          cache_ids.push(@api.auth_params[:username])
-        end
+        @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
@@ -87,48 +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)
-        # 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