Add cache service v2 client

packages/cache/src/internal/cacheHttpClient.ts

@@ -1,16 +1,13 @@
 import * as core from '@actions/core'
-import {HttpClient} from '@actions/http-client'
-import {BearerCredentialHandler} from '@actions/http-client/lib/auth'
+import { HttpClient } from '@actions/http-client'
+import { BearerCredentialHandler } from '@actions/http-client/lib/auth'
 import {
   RequestOptions,
   TypedResponse
 } from '@actions/http-client/lib/interfaces'
-import * as crypto from 'crypto'
 import * as fs from 'fs'
-import {URL} from 'url'
-
+import { URL } from 'url'
 import * as utils from './cacheUtils'
-import {CompressionMethod} from './constants'
 import {
   ArtifactCacheEntry,
   InternalCacheOptions,
@@ -36,9 +33,7 @@ import {
   retryHttpClientResponse,
   retryTypedResponse
 } from './requestUtils'
-import {CacheUrl} from './constants'
-
-const versionSalt = '1.0'
+import { CacheUrl } from './constants'
 
 function getCacheApiUrl(resource: string): string {
   const baseUrl: string = CacheUrl || ''
@@ -76,43 +71,18 @@ function createHttpClient(): HttpClient {
   )
 }
 
-export function getCacheVersion(
-  paths: string[],
-  compressionMethod?: CompressionMethod,
-  enableCrossOsArchive = false
-): string {
-  // don't pass changes upstream
-  const components = paths.slice()
-
-  // Add compression method to cache version to restore
-  // compressed cache as per compression method
-  if (compressionMethod) {
-    components.push(compressionMethod)
-  }
-
-  // Only check for windows platforms if enableCrossOsArchive is false
-  if (process.platform === 'win32' && !enableCrossOsArchive) {
-    components.push('windows-only')
-  }
-
-  // Add salt to cache version to support breaking changes in cache entry
-  components.push(versionSalt)
-
-  return crypto.createHash('sha256').update(components.join('|')).digest('hex')
-}
-
 export async function getCacheEntry(
   keys: string[],
   paths: string[],
   options?: InternalCacheOptions
 ): Promise<ArtifactCacheEntry | null> {
   const httpClient = createHttpClient()
-  const version = getCacheVersion(
+  const version = utils.getCacheVersion(
     paths,
     options?.compressionMethod,
     options?.enableCrossOsArchive
   )
-  
+
   const resource = `cache?keys=${encodeURIComponent(
     keys.join(',')
   )}&version=${version}`
@@ -209,7 +179,7 @@ export async function reserveCache(
   options?: InternalCacheOptions
 ): Promise<ITypedResponseWithError<ReserveCacheResponse>> {
   const httpClient = createHttpClient()
-  const version = getCacheVersion(
+  const version = utils.getCacheVersion(
     paths,
     options?.compressionMethod,
     options?.enableCrossOsArchive
@@ -246,8 +216,7 @@ async function uploadChunk(
   end: number
 ): Promise<void> {
   core.debug(
-    `Uploading chunk of size ${
-      end - start + 1
+    `Uploading chunk of size ${end - start + 1
     } bytes at offset ${start} with content range: ${getContentRange(
       start,
       end
@@ -343,7 +312,7 @@ async function commitCache(
   cacheId: number,
   filesize: number
 ): Promise<TypedResponse<null>> {
-  const commitCacheRequest: CommitCacheRequest = {size: filesize}
+  const commitCacheRequest: CommitCacheRequest = { size: filesize }
   return await retryTypedResponse('commitCache', async () =>
     httpClient.postJson<null>(
       getCacheApiUrl(`caches/${cacheId.toString()}`),

packages/cache/src/internal/cacheTwirpClient.ts

@@ -1,197 +1,196 @@
-import {HttpClient, HttpClientResponse, HttpCodes} from '@actions/http-client'
-import {BearerCredentialHandler} from '@actions/http-client/lib/auth'
-import {info, debug} from '@actions/core'
-import {BlobCacheServiceClientJSON} from '../generated/results/api/v1/blobcache.twirp'
-import {CacheUrl} from './constants'
-import {getRuntimeToken} from './config'
+import { HttpClient, HttpClientResponse, HttpCodes } from '@actions/http-client'
+import { BearerCredentialHandler } from '@actions/http-client/lib/auth'
+import { info, debug } from '@actions/core'
+import { CacheServiceClientJSON } from '../generated/results/api/v1/cache.twirp'
+import { CacheUrl } from './constants'
+import { getRuntimeToken } from './config'
 // import {getUserAgentString} from './user-agent'
 // import {NetworkError, UsageError} from './errors'
 
 // The twirp http client must implement this interface
 interface Rpc {
-  request(
-    service: string,
-    method: string,
-    contentType: 'application/json' | 'application/protobuf',
-    data: object | Uint8Array
-  ): Promise<object | Uint8Array>
+    request(
+        service: string,
+        method: string,
+        contentType: 'application/json' | 'application/protobuf',
+        data: object | Uint8Array
+    ): Promise<object | Uint8Array>
 }
 
-class BlobCacheServiceClient implements Rpc {
-  private httpClient: HttpClient
-  private baseUrl: string
-  private maxAttempts = 5
-  private baseRetryIntervalMilliseconds = 3000
-  private retryMultiplier = 1.5
+class CacheServiceClient implements Rpc {
+    private httpClient: HttpClient
+    private baseUrl: string
+    private maxAttempts = 5
+    private baseRetryIntervalMilliseconds = 3000
+    private retryMultiplier = 1.5
 
-  constructor(
-    userAgent: string,
-    maxAttempts?: number,
-    baseRetryIntervalMilliseconds?: number,
+    constructor(
+        userAgent: string,
+        maxAttempts?: number,
+        baseRetryIntervalMilliseconds?: number,
+        retryMultiplier?: number
+    ) {
+        const token = getRuntimeToken()
+        this.baseUrl = CacheUrl
+        if (maxAttempts) {
+            this.maxAttempts = maxAttempts
+        }
+        if (baseRetryIntervalMilliseconds) {
+            this.baseRetryIntervalMilliseconds = baseRetryIntervalMilliseconds
+        }
+        if (retryMultiplier) {
+            this.retryMultiplier = retryMultiplier
+        }
+
+        this.httpClient = new HttpClient(userAgent, [
+            new BearerCredentialHandler(token)
+        ])
+    }
+
+    // This function satisfies the Rpc interface. It is compatible with the JSON
+    // JSON generated client.
+    async request(
+        service: string,
+        method: string,
+        contentType: 'application/json' | 'application/protobuf',
+        data: object | Uint8Array
+    ): Promise<object | Uint8Array> {
+        const url = new URL(`/twirp/${service}/${method}`, this.baseUrl).href
+        debug(`[Request] ${method} ${url}`)
+        const headers = {
+            'Content-Type': contentType
+        }
+        try {
+            const { body } = await this.retryableRequest(async () =>
+                this.httpClient.post(url, JSON.stringify(data), headers)
+            )
+
+            return body
+        } catch (error) {
+            throw new Error(`Failed to ${method}: ${error.message}`)
+        }
+    }
+
+    async retryableRequest(
+        operation: () => Promise<HttpClientResponse>
+    ): Promise<{ response: HttpClientResponse; body: object }> {
+        let attempt = 0
+        let errorMessage = ''
+        let rawBody = ''
+        while (attempt < this.maxAttempts) {
+            let isRetryable = false
+
+            try {
+                const response = await operation()
+                const statusCode = response.message.statusCode
+                rawBody = await response.readBody()
+                debug(`[Response] - ${response.message.statusCode}`)
+                debug(`Headers: ${JSON.stringify(response.message.headers, null, 2)}`)
+                const body = JSON.parse(rawBody)
+                debug(`Body: ${JSON.stringify(body, null, 2)}`)
+                if (this.isSuccessStatusCode(statusCode)) {
+                    return { response, body }
+                }
+                isRetryable = this.isRetryableHttpStatusCode(statusCode)
+                errorMessage = `Failed request: (${statusCode}) ${response.message.statusMessage}`
+                if (body.msg) {
+                    //   if (UsageError.isUsageErrorMessage(body.msg)) {
+                    //     throw new UsageError()
+                    //   }
+
+                    errorMessage = `${errorMessage}: ${body.msg}`
+                }
+            } catch (error) {
+                if (error instanceof SyntaxError) {
+                    debug(`Raw Body: ${rawBody}`)
+                }
+
+                // if (error instanceof UsageError) {
+                //   throw error
+                // }
+
+                // if (NetworkError.isNetworkErrorCode(error?.code)) {
+                //   throw new NetworkError(error?.code)
+                // }
+
+                isRetryable = true
+                errorMessage = error.message
+            }
+
+            if (!isRetryable) {
+                throw new Error(`Received non-retryable error: ${errorMessage}`)
+            }
+
+            if (attempt + 1 === this.maxAttempts) {
+                throw new Error(
+                    `Failed to make request after ${this.maxAttempts} attempts: ${errorMessage}`
+                )
+            }
+
+            const retryTimeMilliseconds =
+                this.getExponentialRetryTimeMilliseconds(attempt)
+            info(
+                `Attempt ${attempt + 1} of ${this.maxAttempts
+                } failed with error: ${errorMessage}. Retrying request in ${retryTimeMilliseconds} ms...`
+            )
+            await this.sleep(retryTimeMilliseconds)
+            attempt++
+        }
+
+        throw new Error(`Request failed`)
+    }
+
+    isSuccessStatusCode(statusCode?: number): boolean {
+        if (!statusCode) return false
+        return statusCode >= 200 && statusCode < 300
+    }
+
+    isRetryableHttpStatusCode(statusCode?: number): boolean {
+        if (!statusCode) return false
+
+        const retryableStatusCodes = [
+            HttpCodes.BadGateway,
+            HttpCodes.GatewayTimeout,
+            HttpCodes.InternalServerError,
+            HttpCodes.ServiceUnavailable,
+            HttpCodes.TooManyRequests
+        ]
+
+        return retryableStatusCodes.includes(statusCode)
+    }
+
+    async sleep(milliseconds: number): Promise<void> {
+        return new Promise(resolve => setTimeout(resolve, milliseconds))
+    }
+
+    getExponentialRetryTimeMilliseconds(attempt: number): number {
+        if (attempt < 0) {
+            throw new Error('attempt should be a positive integer')
+        }
+
+        if (attempt === 0) {
+            return this.baseRetryIntervalMilliseconds
+        }
+
+        const minTime =
+            this.baseRetryIntervalMilliseconds * this.retryMultiplier ** attempt
+        const maxTime = minTime * this.retryMultiplier
+
+        // returns a random number between minTime and maxTime (exclusive)
+        return Math.trunc(Math.random() * (maxTime - minTime) + minTime)
+    }
+}
+
+export function internalCacheTwirpClient(options?: {
+    maxAttempts?: number
+    retryIntervalMs?: number
     retryMultiplier?: number
-  ) {
-    const token = getRuntimeToken()
-    this.baseUrl = CacheUrl
-    if (maxAttempts) {
-      this.maxAttempts = maxAttempts
-    }
-    if (baseRetryIntervalMilliseconds) {
-      this.baseRetryIntervalMilliseconds = baseRetryIntervalMilliseconds
-    }
-    if (retryMultiplier) {
-      this.retryMultiplier = retryMultiplier
-    }
-
-    this.httpClient = new HttpClient(userAgent, [
-      new BearerCredentialHandler(token)
-    ])
-  }
-
-  // This function satisfies the Rpc interface. It is compatible with the JSON
-  // JSON generated client.
-  async request(
-    service: string,
-    method: string,
-    contentType: 'application/json' | 'application/protobuf',
-    data: object | Uint8Array
-  ): Promise<object | Uint8Array> {
-    const url = new URL(`/twirp/${service}/${method}`, this.baseUrl).href
-    debug(`[Request] ${method} ${url}`)
-    const headers = {
-      'Content-Type': contentType
-    }
-    try {
-      const {body} = await this.retryableRequest(async () =>
-        this.httpClient.post(url, JSON.stringify(data), headers)
-      )
-
-      return body
-    } catch (error) {
-      throw new Error(`Failed to ${method}: ${error.message}`)
-    }
-  }
-
-  async retryableRequest(
-    operation: () => Promise<HttpClientResponse>
-  ): Promise<{response: HttpClientResponse; body: object}> {
-    let attempt = 0
-    let errorMessage = ''
-    let rawBody = ''
-    while (attempt < this.maxAttempts) {
-      let isRetryable = false
-
-      try {
-        const response = await operation()
-        const statusCode = response.message.statusCode
-        rawBody = await response.readBody()
-        debug(`[Response] - ${response.message.statusCode}`)
-        debug(`Headers: ${JSON.stringify(response.message.headers, null, 2)}`)
-        const body = JSON.parse(rawBody)
-        debug(`Body: ${JSON.stringify(body, null, 2)}`)
-        if (this.isSuccessStatusCode(statusCode)) {
-          return {response, body}
-        }
-        isRetryable = this.isRetryableHttpStatusCode(statusCode)
-        errorMessage = `Failed request: (${statusCode}) ${response.message.statusMessage}`
-        if (body.msg) {
-        //   if (UsageError.isUsageErrorMessage(body.msg)) {
-        //     throw new UsageError()
-        //   }
-
-          errorMessage = `${errorMessage}: ${body.msg}`
-        }
-      } catch (error) {
-        if (error instanceof SyntaxError) {
-          debug(`Raw Body: ${rawBody}`)
-        }
-
-        // if (error instanceof UsageError) {
-        //   throw error
-        // }
-
-        // if (NetworkError.isNetworkErrorCode(error?.code)) {
-        //   throw new NetworkError(error?.code)
-        // }
-
-        isRetryable = true
-        errorMessage = error.message
-      }
-
-      if (!isRetryable) {
-        throw new Error(`Received non-retryable error: ${errorMessage}`)
-      }
-
-      if (attempt + 1 === this.maxAttempts) {
-        throw new Error(
-          `Failed to make request after ${this.maxAttempts} attempts: ${errorMessage}`
-        )
-      }
-
-      const retryTimeMilliseconds =
-        this.getExponentialRetryTimeMilliseconds(attempt)
-      info(
-        `Attempt ${attempt + 1} of ${
-          this.maxAttempts
-        } failed with error: ${errorMessage}. Retrying request in ${retryTimeMilliseconds} ms...`
-      )
-      await this.sleep(retryTimeMilliseconds)
-      attempt++
-    }
-
-    throw new Error(`Request failed`)
-  }
-
-  isSuccessStatusCode(statusCode?: number): boolean {
-    if (!statusCode) return false
-    return statusCode >= 200 && statusCode < 300
-  }
-
-  isRetryableHttpStatusCode(statusCode?: number): boolean {
-    if (!statusCode) return false
-
-    const retryableStatusCodes = [
-      HttpCodes.BadGateway,
-      HttpCodes.GatewayTimeout,
-      HttpCodes.InternalServerError,
-      HttpCodes.ServiceUnavailable,
-      HttpCodes.TooManyRequests
-    ]
-
-    return retryableStatusCodes.includes(statusCode)
-  }
-
-  async sleep(milliseconds: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, milliseconds))
-  }
-
-  getExponentialRetryTimeMilliseconds(attempt: number): number {
-    if (attempt < 0) {
-      throw new Error('attempt should be a positive integer')
-    }
-
-    if (attempt === 0) {
-      return this.baseRetryIntervalMilliseconds
-    }
-
-    const minTime =
-      this.baseRetryIntervalMilliseconds * this.retryMultiplier ** attempt
-    const maxTime = minTime * this.retryMultiplier
-
-    // returns a random number between minTime and maxTime (exclusive)
-    return Math.trunc(Math.random() * (maxTime - minTime) + minTime)
-  }
-}
-
-export function internalBlobCacheTwirpClient(options?: {
-  maxAttempts?: number
-  retryIntervalMs?: number
-  retryMultiplier?: number
-}): BlobCacheServiceClientJSON {
-  const client = new BlobCacheServiceClient(
-    'actions/cache',
-    options?.maxAttempts,
-    options?.retryIntervalMs,
-    options?.retryMultiplier
-  )
-  return new BlobCacheServiceClientJSON(client)
+}): CacheServiceClientJSON {
+    const client = new CacheServiceClient(
+        'actions/cache',
+        options?.maxAttempts,
+        options?.retryIntervalMs,
+        options?.retryMultiplier
+    )
+    return new CacheServiceClientJSON(client)
 }

packages/cache/src/internal/cacheUtils.ts

@@ -6,13 +6,16 @@ import * as fs from 'fs'
 import * as path from 'path'
 import * as semver from 'semver'
 import * as util from 'util'
-import {v4 as uuidV4} from 'uuid'
+import { v4 as uuidV4 } from 'uuid'
+import * as crypto from 'crypto'
 import {
   CacheFilename,
   CompressionMethod,
   GnuTarPathOnWindows
 } from './constants'
 
+const versionSalt = '1.0'
+
 // From https://github.com/actions/toolkit/blob/main/packages/tool-cache/src/tool-cache.ts#L23
 export async function createTempDirectory(): Promise<string> {
   const IS_WINDOWS = process.platform === 'win32'
@@ -143,3 +146,28 @@ export function isGhes(): boolean {
 
   return !isGitHubHost && !isGheHost
 }
+
+export function getCacheVersion(
+  paths: string[],
+  compressionMethod?: CompressionMethod,
+  enableCrossOsArchive = false
+): string {
+  // don't pass changes upstream
+  const components = paths.slice()
+
+  // Add compression method to cache version to restore
+  // compressed cache as per compression method
+  if (compressionMethod) {
+    components.push(compressionMethod)
+  }
+
+  // Only check for windows platforms if enableCrossOsArchive is false
+  if (process.platform === 'win32' && !enableCrossOsArchive) {
+    components.push('windows-only')
+  }
+
+  // Add salt to cache version to support breaking changes in cache entry
+  components.push(versionSalt)
+
+  return crypto.createHash('sha256').update(components.join('|')).digest('hex')
+}

packages/cache/src/internal/v2/upload-cache.ts

@@ -1,13 +1,14 @@
 import * as core from '@actions/core'
-import {GetCacheBlobUploadURLResponse} from '../../generated/results/api/v1/blobcache'
-import {ZipUploadStream} from '@actions/artifact/lib/internal/upload/zip'
-import {NetworkError} from '@actions/artifact/'
-import {TransferProgressEvent} from '@azure/core-http'
+import { CreateCacheEntryResponse } from '../../generated/results/api/v1/cache'
+import { ZipUploadStream } from '@actions/artifact/lib/internal/upload/zip'
+import { NetworkError } from '@actions/artifact/'
+import { TransferProgressEvent } from '@azure/core-http'
 import * as stream from 'stream'
 import * as crypto from 'crypto'
+
 import {
-  BlobClient, 
-  BlockBlobClient, 
+  BlobClient,
+  BlockBlobClient,
   BlockBlobUploadStreamOptions,
   BlockBlobParallelUploadOptions
 } from '@azure/storage-blob'
@@ -55,7 +56,7 @@ export async function UploadCacheStream(
   }
 
   const options: BlockBlobUploadStreamOptions = {
-    blobHTTPHeaders: {blobContentType: 'zip'},
+    blobHTTPHeaders: { blobContentType: 'zip' },
     onProgress: uploadCallback
   }
 
@@ -89,7 +90,7 @@ export async function UploadCacheStream(
   }
 
   core.info('Finished uploading cache content to blob storage!')
-  
+
   hashStream.end()
   sha256Hash = hashStream.read() as string
   core.info(`SHA256 hash of uploaded artifact zip is ${sha256Hash}`)
@@ -107,11 +108,11 @@ export async function UploadCacheStream(
 }
 
 export async function UploadCacheFile(
-  uploadURL: GetCacheBlobUploadURLResponse,
+  uploadURL: CreateCacheEntryResponse,
   archivePath: string,
 ): Promise<{}> {
   core.info(`Uploading ${archivePath} to: ${JSON.stringify(uploadURL)}`)
-  
+
   // Specify data transfer options
   const uploadOptions: BlockBlobParallelUploadOptions = {
     blockSize: 4 * 1024 * 1024, // 4 MiB max block size
@@ -119,8 +120,7 @@ export async function UploadCacheFile(
     maxSingleShotSize: 8 * 1024 * 1024, // 8 MiB initial transfer size
   };
 
-  // const blobClient: BlobClient = new BlobClient(uploadURL.urls[0])
-  const blobClient: BlobClient = new BlobClient(uploadURL.urls[0].url)
+  const blobClient: BlobClient = new BlobClient(uploadURL.signedUploadUrl)
   const blockBlobClient: BlockBlobClient = blobClient.getBlockBlobClient()
 
   core.info(`BlobClient: ${JSON.stringify(blobClient)}`)