Merge pull request #558 from dhadka/dhadka/fix-error-handling

Handle errors representing non-successful http responses in retry logic

packages/cache/RELEASES.md

@@ -21,3 +21,8 @@
 
 ### 1.0.2
 - Use posix archive format to add support for some tools
+
+### 1.0.3
+- Use http-client v1.0.9
+- Fixes error handling so retries are not attempted on non-retryable errors (409 Conflict, for example)
+- Adds 5 second delay between retry attempts

packages/cache/__tests__/requestUtils.test.ts

@@ -1,27 +1,48 @@
 import {retry} from '../src/internal/requestUtils'
+import {HttpClientError} from '@actions/http-client'
 
-interface TestResponse {
+interface ITestResponse {
   statusCode: number
   result: string | null
+  error: Error | null
+}
+
+function TestResponse(
+  action: number | Error,
+  result: string | null = null
+): ITestResponse {
+  if (action instanceof Error) {
+    return {
+      statusCode: -1,
+      result,
+      error: action
+    }
+  } else {
+    return {
+      statusCode: action,
+      result,
+      error: null
+    }
+  }
 }
 
 async function handleResponse(
-  response: TestResponse | undefined
-): Promise<TestResponse> {
+  response: ITestResponse | undefined
+): Promise<ITestResponse> {
   if (!response) {
     // eslint-disable-next-line no-undef
     fail('Retry method called too many times')
   }
 
-  if (response.statusCode === 999) {
-    throw Error('Test Error')
+  if (response.error) {
+    throw response.error
   } else {
     return Promise.resolve(response)
   }
 }
 
 async function testRetryExpectingResult(
-  responses: TestResponse[],
+  responses: ITestResponse[],
   expectedResult: string | null
 ): Promise<void> {
   responses = responses.reverse() // Reverse responses since we pop from end
@@ -29,14 +50,44 @@ async function testRetryExpectingResult(
   const actualResult = await retry(
     'test',
     async () => handleResponse(responses.pop()),
-    (response: TestResponse) => response.statusCode
+    (response: ITestResponse) => response.statusCode,
+    2, // maxAttempts
+    0 // delay
   )
 
   expect(actualResult.result).toEqual(expectedResult)
 }
 
+async function testRetryConvertingErrorToResult(
+  responses: ITestResponse[],
+  expectedStatus: number,
+  expectedResult: string | null
+): Promise<void> {
+  responses = responses.reverse() // Reverse responses since we pop from end
+
+  const actualResult = await retry(
+    'test',
+    async () => handleResponse(responses.pop()),
+    (response: ITestResponse) => response.statusCode,
+    2, // maxAttempts
+    0, // delay
+    (e: Error) => {
+      if (e instanceof HttpClientError) {
+        return {
+          statusCode: e.statusCode,
+          result: null,
+          error: null
+        }
+      }
+    }
+  )
+
+  expect(actualResult.statusCode).toEqual(expectedStatus)
+  expect(actualResult.result).toEqual(expectedResult)
+}
+
 async function testRetryExpectingError(
-  responses: TestResponse[]
+  responses: ITestResponse[]
 ): Promise<void> {
   responses = responses.reverse() // Reverse responses since we pop from end
 
@@ -44,97 +95,54 @@ async function testRetryExpectingError(
     retry(
       'test',
       async () => handleResponse(responses.pop()),
-      (response: TestResponse) => response.statusCode
+      (response: ITestResponse) => response.statusCode,
+      2, // maxAttempts,
+      0 // delay
     )
   ).rejects.toBeInstanceOf(Error)
 }
 
 test('retry works on successful response', async () => {
-  await testRetryExpectingResult(
-    [
-      {
-        statusCode: 200,
-        result: 'Ok'
-      }
-    ],
-    'Ok'
-  )
+  await testRetryExpectingResult([TestResponse(200, 'Ok')], 'Ok')
 })
 
 test('retry works after retryable status code', async () => {
   await testRetryExpectingResult(
-    [
-      {
-        statusCode: 503,
-        result: null
-      },
-      {
-        statusCode: 200,
-        result: 'Ok'
-      }
-    ],
+    [TestResponse(503), TestResponse(200, 'Ok')],
     'Ok'
   )
 })
 
 test('retry fails after exhausting retries', async () => {
   await testRetryExpectingError([
-    {
-      statusCode: 503,
-      result: null
-    },
-    {
-      statusCode: 503,
-      result: null
-    },
-    {
-      statusCode: 200,
-      result: 'Ok'
-    }
+    TestResponse(503),
+    TestResponse(503),
+    TestResponse(200, 'Ok')
   ])
 })
 
 test('retry fails after non-retryable status code', async () => {
-  await testRetryExpectingError([
-    {
-      statusCode: 500,
-      result: null
-    },
-    {
-      statusCode: 200,
-      result: 'Ok'
-    }
-  ])
+  await testRetryExpectingError([TestResponse(500), TestResponse(200, 'Ok')])
 })
 
 test('retry works after error', async () => {
   await testRetryExpectingResult(
-    [
-      {
-        statusCode: 999,
-        result: null
-      },
-      {
-        statusCode: 200,
-        result: 'Ok'
-      }
-    ],
+    [TestResponse(new Error('Test error')), TestResponse(200, 'Ok')],
     'Ok'
   )
 })
 
 test('retry returns after client error', async () => {
   await testRetryExpectingResult(
-    [
-      {
-        statusCode: 400,
-        result: null
-      },
-      {
-        statusCode: 200,
-        result: 'Ok'
-      }
-    ],
+    [TestResponse(400), TestResponse(200, 'Ok')],
+    null
+  )
+})
+
+test('retry converts errors to response object', async () => {
+  await testRetryConvertingErrorToResult(
+    [TestResponse(new HttpClientError('Test error', 409))],
+    409,
     null
   )
 })

packages/cache/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/cache",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "preview": true,
   "description": "Actions cache lib",
   "keywords": [
@@ -40,7 +40,7 @@
     "@actions/core": "^1.2.4",
     "@actions/exec": "^1.0.1",
     "@actions/glob": "^0.1.0",
-    "@actions/http-client": "^1.0.8",
+    "@actions/http-client": "^1.0.9",
     "@actions/io": "^1.0.1",
     "@azure/ms-rest-js": "^2.0.7",
     "@azure/storage-blob": "^12.1.2",

packages/cache/src/internal/constants.ts

@@ -11,6 +11,12 @@ export enum CompressionMethod {
   Zstd = 'zstd'
 }
 
+// The default number of retry attempts.
+export const DefaultRetryAttempts = 2
+
+// The default delay in milliseconds between retry attempts.
+export const DefaultRetryDelay = 5000
+
 // Socket timeout in milliseconds during download.  If no traffic is received
 // over the socket during this period, the socket is destroyed and the download
 // is aborted.

packages/cache/src/internal/requestUtils.ts

@@ -1,9 +1,10 @@
 import * as core from '@actions/core'
-import {HttpCodes} from '@actions/http-client'
+import {HttpCodes, HttpClientError} from '@actions/http-client'
 import {
   IHttpClientResponse,
   ITypedResponse
 } from '@actions/http-client/interfaces'
+import {DefaultRetryDelay, DefaultRetryAttempts} from './constants'
 
 export function isSuccessStatusCode(statusCode?: number): boolean {
   if (!statusCode) {
@@ -31,32 +32,48 @@ export function isRetryableStatusCode(statusCode?: number): boolean {
   return retryableStatusCodes.includes(statusCode)
 }
 
+async function sleep(milliseconds: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, milliseconds))
+}
+
 export async function retry<T>(
   name: string,
   method: () => Promise<T>,
   getStatusCode: (arg0: T) => number | undefined,
-  maxAttempts = 2
+  maxAttempts = DefaultRetryAttempts,
+  delay = DefaultRetryDelay,
+  onError: ((arg0: Error) => T | undefined) | undefined = undefined
 ): Promise<T> {
-  let response: T | undefined = undefined
-  let statusCode: number | undefined = undefined
-  let isRetryable = false
   let errorMessage = ''
   let attempt = 1
 
   while (attempt <= maxAttempts) {
+    let response: T | undefined = undefined
+    let statusCode: number | undefined = undefined
+    let isRetryable = false
+
     try {
       response = await method()
+    } catch (error) {
+      if (onError) {
+        response = onError(error)
+      }
+
+      isRetryable = true
+      errorMessage = error.message
+    }
+
+    if (response) {
       statusCode = getStatusCode(response)
 
       if (!isServerErrorStatusCode(statusCode)) {
         return response
       }
+    }
 
+    if (statusCode) {
       isRetryable = isRetryableStatusCode(statusCode)
       errorMessage = `Cache service responded with ${statusCode}`
-    } catch (error) {
-      isRetryable = true
-      errorMessage = error.message
     }
 
     core.debug(
@@ -68,6 +85,7 @@ export async function retry<T>(
       break
     }
 
+    await sleep(delay)
     attempt++
   }
 
@@ -77,25 +95,42 @@ export async function retry<T>(
 export async function retryTypedResponse<T>(
   name: string,
   method: () => Promise<ITypedResponse<T>>,
-  maxAttempts = 2
+  maxAttempts = DefaultRetryAttempts,
+  delay = DefaultRetryDelay
 ): Promise<ITypedResponse<T>> {
   return await retry(
     name,
     method,
     (response: ITypedResponse<T>) => response.statusCode,
-    maxAttempts
+    maxAttempts,
+    delay,
+    // If the error object contains the statusCode property, extract it and return
+    // an ITypedResponse<T> so it can be processed by the retry logic.
+    (error: Error) => {
+      if (error instanceof HttpClientError) {
+        return {
+          statusCode: error.statusCode,
+          result: null,
+          headers: {}
+        }
+      } else {
+        return undefined
+      }
+    }
   )
 }
 
 export async function retryHttpClientResponse<T>(
   name: string,
   method: () => Promise<IHttpClientResponse>,
-  maxAttempts = 2
+  maxAttempts = DefaultRetryAttempts,
+  delay = DefaultRetryDelay
 ): Promise<IHttpClientResponse> {
   return await retry(
     name,
     method,
     (response: IHttpClientResponse) => response.message.statusCode,
-    maxAttempts
+    maxAttempts,
+    delay
   )
 }