@actions/artifact package (#304)

* Initial commit for @actions/artifact package

packages/artifact/src/__mocks__/internal-config-variables.ts

@@ -0,0 +1,30 @@
+/**
+ *  Mocks default limits for easier testing
+ */
+export function getUploadFileConcurrency(): number {
+  return 1
+}
+
+export function getUploadChunkConcurrency(): number {
+  return 1
+}
+
+export function getUploadChunkSize(): number {
+  return 4 * 1024 * 1024 // 4 MB Chunks
+}
+/**
+ * Mocks the 'ACTIONS_RUNTIME_TOKEN', 'ACTIONS_RUNTIME_URL' and 'GITHUB_RUN_ID' env variables
+ * that are only available from a node context on the runner. This allows for tests to run
+ * locally without the env variables actually being set
+ */
+export function getRuntimeToken(): string {
+  return 'totally-valid-token'
+}
+
+export function getRuntimeUrl(): string {
+  return 'https://www.example.com/'
+}
+
+export function getWorkFlowRunId(): string {
+  return '15'
+}

packages/artifact/src/artifact-client.ts

@@ -0,0 +1,9 @@
+import {ArtifactClient, DefaultArtifactClient} from './internal-artifact-client'
+export {ArtifactClient}
+
+/**
+ * Constructs an ArtifactClient
+ */
+export function create(): ArtifactClient {
+  return DefaultArtifactClient.create()
+}

packages/artifact/src/internal-artifact-client.ts

@@ -0,0 +1,124 @@
+import * as core from '@actions/core'
+import {
+  UploadSpecification,
+  getUploadSpecification
+} from './internal-upload-specification'
+import {
+  createArtifactInFileContainer,
+  uploadArtifactToFileContainer,
+  patchArtifactSize
+} from './internal-upload-http-client'
+import {UploadResponse} from './internal-upload-response'
+import {UploadOptions} from './internal-upload-options'
+import {checkArtifactName} from './internal-utils'
+
+export {UploadResponse, UploadOptions}
+
+export interface ArtifactClient {
+  /**
+   * Uploads an artifact
+   *
+   * @param name the name of the artifact, required
+   * @param files a list of absolute or relative paths that denote what files should be uploaded
+   * @param rootDirectory an absolute or relative file path that denotes the root parent directory of the files being uploaded
+   * @param options extra options for customizing the upload behavior
+   * @returns single UploadInfo object
+   */
+  uploadArtifact(
+    name: string,
+    files: string[],
+    rootDirectory: string,
+    options?: UploadOptions
+  ): Promise<UploadResponse>
+}
+
+export class DefaultArtifactClient implements ArtifactClient {
+  /**
+   * Constructs a DefaultArtifactClient
+   */
+  static create(): DefaultArtifactClient {
+    return new DefaultArtifactClient()
+  }
+
+  /**
+   * Uploads an artifact
+   */
+  async uploadArtifact(
+    name: string,
+    files: string[],
+    rootDirectory: string,
+    options?: UploadOptions | undefined
+  ): Promise<UploadResponse> {
+    checkArtifactName(name)
+
+    // Get specification for the files being uploaded
+    const uploadSpecification: UploadSpecification[] = getUploadSpecification(
+      name,
+      rootDirectory,
+      files
+    )
+    const uploadResponse: UploadResponse = {
+      artifactName: name,
+      artifactItems: [],
+      size: 0,
+      failedItems: []
+    }
+
+    if (uploadSpecification.length === 0) {
+      core.warning(`No files found that can be uploaded`)
+    } else {
+      // Create an entry for the artifact in the file container
+      const response = await createArtifactInFileContainer(name)
+      if (!response.fileContainerResourceUrl) {
+        core.debug(response.toString())
+        throw new Error(
+          'No URL provided by the Artifact Service to upload an artifact to'
+        )
+      }
+      core.debug(`Upload Resource URL: ${response.fileContainerResourceUrl}`)
+
+      // Upload each of the files that were found concurrently
+      const uploadResult = await uploadArtifactToFileContainer(
+        response.fileContainerResourceUrl,
+        uploadSpecification,
+        options
+      )
+
+      //Update the size of the artifact to indicate we are done uploading
+      await patchArtifactSize(uploadResult.size, name)
+
+      core.info(
+        `Finished uploading artifact ${name}. Reported size is ${uploadResult.size} bytes. There were ${uploadResult.failedItems.length} items that failed to upload`
+      )
+
+      uploadResponse.artifactItems = uploadSpecification.map(
+        item => item.absoluteFilePath
+      )
+      uploadResponse.size = uploadResult.size
+      uploadResponse.failedItems = uploadResult.failedItems
+    }
+    return uploadResponse
+  }
+
+  /*
+  Downloads a single artifact associated with a run
+
+  export async function downloadArtifact(
+      name: string,
+      path?: string,
+      options?: DownloadOptions
+    ): Promise<DownloadResponse> {
+
+    TODO
+  }
+
+  Downloads all artifacts associated with a run. Because there are multiple artifacts being downloaded, a folder will be created for each one in the specified or default directory
+
+  export async function downloadAllArtifacts(
+      path?: string
+    ): Promise<DownloadResponse[]>{
+
+      TODO
+  }
+  */
+}

packages/artifact/src/internal-config-variables.ts

@@ -0,0 +1,35 @@
+export function getUploadFileConcurrency(): number {
+  return 2
+}
+
+export function getUploadChunkConcurrency(): number {
+  return 1
+}
+
+export function getUploadChunkSize(): number {
+  return 4 * 1024 * 1024 // 4 MB Chunks
+}
+
+export function getRuntimeToken(): string {
+  const token = process.env['ACTIONS_RUNTIME_TOKEN']
+  if (!token) {
+    throw new Error('Unable to get ACTIONS_RUNTIME_TOKEN env variable')
+  }
+  return token
+}
+
+export function getRuntimeUrl(): string {
+  const runtimeUrl = process.env['ACTIONS_RUNTIME_URL']
+  if (!runtimeUrl) {
+    throw new Error('Unable to get ACTIONS_RUNTIME_URL env variable')
+  }
+  return runtimeUrl
+}
+
+export function getWorkFlowRunId(): string {
+  const workFlowRunId = process.env['GITHUB_RUN_ID']
+  if (!workFlowRunId) {
+    throw new Error('Unable to get GITHUB_RUN_ID env variable')
+  }
+  return workFlowRunId
+}

packages/artifact/src/internal-contracts.ts

@@ -0,0 +1,33 @@
+export interface ArtifactResponse {
+  containerId: string
+  size: number
+  signedContent: string
+  fileContainerResourceUrl: string
+  type: string
+  name: string
+  url: string
+}
+
+export interface CreateArtifactParameters {
+  Type: string
+  Name: string
+}
+
+export interface PatchArtifactSize {
+  Size: number
+}
+
+export interface PatchArtifactSizeSuccessResponse {
+  containerId: number
+  size: number
+  signedContent: string
+  type: string
+  name: string
+  url: string
+  uploadUrl: string
+}
+
+export interface UploadResults {
+  size: number
+  failedItems: string[]
+}

packages/artifact/src/internal-download-options.ts

@@ -0,0 +1,7 @@
+export interface DownloadOptions {
+  /**
+   * Specifies if a folder is created for the artifact that is downloaded (contents downloaded into this folder),
+   * defaults to false if not specified
+   * */
+  createArtifactFolder?: boolean
+}

packages/artifact/src/internal-download-response.ts

@@ -0,0 +1,11 @@
+export interface DownloadResponse {
+  /**
+   * The name of the artifact that was downloaded
+   */
+  artifactName: string
+
+  /**
+   * The full Path to where the artifact was downloaded
+   */
+  downloadPath: string
+}

packages/artifact/src/internal-upload-http-client.ts

@@ -0,0 +1,322 @@
+import {debug, warning, info} from '@actions/core'
+import {HttpClientResponse, HttpClient} from '@actions/http-client/index'
+import {IHttpClientResponse} from '@actions/http-client/interfaces'
+import {
+  ArtifactResponse,
+  CreateArtifactParameters,
+  PatchArtifactSize,
+  UploadResults
+} from './internal-contracts'
+import * as fs from 'fs'
+import {UploadSpecification} from './internal-upload-specification'
+import {UploadOptions} from './internal-upload-options'
+import {URL} from 'url'
+import {
+  createHttpClient,
+  getArtifactUrl,
+  getContentRange,
+  getRequestOptions,
+  isRetryableStatusCode,
+  isSuccessStatusCode
+} from './internal-utils'
+import {
+  getUploadChunkConcurrency,
+  getUploadChunkSize,
+  getUploadFileConcurrency
+} from './internal-config-variables'
+
+/**
+ * Creates a file container for the new artifact in the remote blob storage/file service
+ * @param {string} artifactName Name of the artifact being created
+ * @returns The response from the Artifact Service if the file container was successfully created
+ */
+export async function createArtifactInFileContainer(
+  artifactName: string
+): Promise<ArtifactResponse> {
+  const parameters: CreateArtifactParameters = {
+    Type: 'actions_storage',
+    Name: artifactName
+  }
+  const data: string = JSON.stringify(parameters, null, 2)
+  const artifactUrl = getArtifactUrl()
+  const client = createHttpClient()
+  const requestOptions = getRequestOptions('application/json')
+
+  const rawResponse = await client.post(artifactUrl, data, requestOptions)
+  const body: string = await rawResponse.readBody()
+
+  if (isSuccessStatusCode(rawResponse.message.statusCode) && body) {
+    return JSON.parse(body)
+  } else {
+    // eslint-disable-next-line no-console
+    console.log(rawResponse)
+    throw new Error(
+      `Unable to create a container for the artifact ${artifactName}`
+    )
+  }
+}
+
+/**
+ * Concurrently upload all of the files in chunks
+ * @param {string} uploadUrl Base Url for the artifact that was created
+ * @param {SearchResult[]} filesToUpload A list of information about the files being uploaded
+ * @returns The size of all the files uploaded in bytes
+ */
+export async function uploadArtifactToFileContainer(
+  uploadUrl: string,
+  filesToUpload: UploadSpecification[],
+  options?: UploadOptions
+): Promise<UploadResults> {
+  const client = createHttpClient()
+  const FILE_CONCURRENCY = getUploadFileConcurrency()
+  const CHUNK_CONCURRENCY = getUploadChunkConcurrency()
+  const MAX_CHUNK_SIZE = getUploadChunkSize()
+  debug(
+    `File Concurrency: ${FILE_CONCURRENCY}, Chunk Concurrency: ${CHUNK_CONCURRENCY} and Chunk Size: ${MAX_CHUNK_SIZE}`
+  )
+
+  const parameters: UploadFileParameters[] = []
+
+  // by default, file uploads will continue if there is an error unless specified differently in the options
+  let continueOnError = true
+  if (options) {
+    if (options.continueOnError === false) {
+      continueOnError = false
+    }
+  }
+
+  // Prepare the necessary parameters to upload all the files
+  for (const file of filesToUpload) {
+    const resourceUrl = new URL(uploadUrl)
+    resourceUrl.searchParams.append('itemPath', file.uploadFilePath)
+    parameters.push({
+      file: file.absoluteFilePath,
+      resourceUrl: resourceUrl.toString(),
+      restClient: client,
+      concurrency: CHUNK_CONCURRENCY,
+      maxChunkSize: MAX_CHUNK_SIZE,
+      continueOnError
+    })
+  }
+
+  const parallelUploads = [...new Array(FILE_CONCURRENCY).keys()]
+  const failedItemsToReport: string[] = []
+  let uploadedFiles = 0
+  let fileSizes = 0
+  let abortPendingFileUploads = false
+
+  // Only allow a certain amount of files to be uploaded at once, this is done to reduce potential errors
+  await Promise.all(
+    parallelUploads.map(async () => {
+      while (uploadedFiles < filesToUpload.length) {
+        const currentFileParameters = parameters[uploadedFiles]
+        uploadedFiles += 1
+        if (abortPendingFileUploads) {
+          failedItemsToReport.push(currentFileParameters.file)
+          continue
+        }
+
+        const uploadFileResult = await uploadFileAsync(currentFileParameters)
+        fileSizes += uploadFileResult.successfulUploadSize
+        if (uploadFileResult.isSuccess === false) {
+          failedItemsToReport.push(currentFileParameters.file)
+          if (!continueOnError) {
+            // Existing uploads will be able to finish however all pending uploads will fail fast
+            abortPendingFileUploads = true
+          }
+        }
+      }
+    })
+  )
+
+  info(`Total size of all the files uploaded is ${fileSizes} bytes`)
+  return {
+    size: fileSizes,
+    failedItems: failedItemsToReport
+  }
+}
+
+/**
+ * Asynchronously uploads a file. If the file is bigger than the max chunk size it will be uploaded via multiple calls
+ * @param {UploadFileParameters} parameters Information about the file that needs to be uploaded
+ * @returns The size of the file that was uploaded in bytes along with any failed uploads
+ */
+async function uploadFileAsync(
+  parameters: UploadFileParameters
+): Promise<UploadFileResult> {
+  const fileSize: number = fs.statSync(parameters.file).size
+  const parallelUploads = [...new Array(parameters.concurrency).keys()]
+  let offset = 0
+  let isUploadSuccessful = true
+  let failedChunkSizes = 0
+  let abortFileUpload = false
+
+  await Promise.all(
+    parallelUploads.map(async () => {
+      while (offset < fileSize) {
+        const chunkSize = Math.min(fileSize - offset, parameters.maxChunkSize)
+        if (abortFileUpload) {
+          // if we don't want to continue on error, any pending upload chunk will be marked as failed
+          failedChunkSizes += chunkSize
+          continue
+        }
+
+        const start = offset
+        const end = offset + chunkSize - 1
+        offset += parameters.maxChunkSize
+        const chunk: NodeJS.ReadableStream = fs.createReadStream(
+          parameters.file,
+          {
+            start,
+            end,
+            autoClose: false
+          }
+        )
+
+        const result = await uploadChunk(
+          parameters.restClient,
+          parameters.resourceUrl,
+          chunk,
+          start,
+          end,
+          fileSize
+        )
+
+        if (!result) {
+          /**
+           * Chunk failed to upload, report as failed and do not continue uploading any more chunks for the file. It is possible that part of a chunk was
+           * successfully uploaded so the server may report a different size for what was uploaded
+           **/
+          isUploadSuccessful = false
+          failedChunkSizes += chunkSize
+          warning(`Aborting upload for ${parameters.file} due to failure`)
+          abortFileUpload = true
+        }
+      }
+    })
+  )
+  return {
+    isSuccess: isUploadSuccessful,
+    successfulUploadSize: fileSize - failedChunkSizes
+  }
+}
+
+/**
+ * Uploads a chunk of an individual file to the specified resourceUrl. If the upload fails and the status code
+ * indicates a retryable status, we try to upload the chunk as well
+ * @param {HttpClient} restClient RestClient that will be making the appropriate HTTP call
+ * @param {string} resourceUrl Url of the resource that the chunk will be uploaded to
+ * @param {NodeJS.ReadableStream} data Stream of the file that will be uploaded
+ * @param {number} start Starting byte index of file that the chunk belongs to
+ * @param {number} end Ending byte index of file that the chunk belongs to
+ * @param {number} totalSize Total size of the file in bytes that is being uploaded
+ * @returns if the chunk was successfully uploaded
+ */
+async function uploadChunk(
+  restClient: HttpClient,
+  resourceUrl: string,
+  data: NodeJS.ReadableStream,
+  start: number,
+  end: number,
+  totalSize: number
+): Promise<boolean> {
+  info(
+    `Uploading chunk of size ${end -
+      start +
+      1} bytes at offset ${start} with content range: ${getContentRange(
+      start,
+      end,
+      totalSize
+    )}`
+  )
+
+  const requestOptions = getRequestOptions(
+    'application/octet-stream',
+    totalSize,
+    getContentRange(start, end, totalSize)
+  )
+
+  const uploadChunkRequest = async (): Promise<IHttpClientResponse> => {
+    return await restClient.sendStream('PUT', resourceUrl, data, requestOptions)
+  }
+
+  const response = await uploadChunkRequest()
+  if (isSuccessStatusCode(response.message.statusCode)) {
+    debug(
+      `Chunk for ${start}:${end} was successfully uploaded to ${resourceUrl}`
+    )
+    return true
+  } else if (isRetryableStatusCode(response.message.statusCode)) {
+    info(
+      `Received http ${response.message.statusCode} during chunk upload, will retry at offset ${start} after 10 seconds.`
+    )
+    await new Promise(resolve => setTimeout(resolve, 10000))
+    const retryResponse = await uploadChunkRequest()
+    if (isSuccessStatusCode(retryResponse.message.statusCode)) {
+      return true
+    } else {
+      info(`Unable to upload chunk even after retrying`)
+      // eslint-disable-next-line no-console
+      console.log(response)
+      return false
+    }
+  }
+
+  // Upload must have failed spectacularly somehow, log full result for diagnostic purposes
+  // eslint-disable-next-line no-console
+  console.log(response)
+  return false
+}
+
+/**
+ * Updates the size of the artifact from -1 which was initially set when the container was first created for the artifact.
+ * Updating the size indicates that we are done uploading all the contents of the artifact. A server side check will be run
+ * to check that the artifact size is correct for billing purposes
+ */
+export async function patchArtifactSize(
+  size: number,
+  artifactName: string
+): Promise<void> {
+  const client = createHttpClient()
+  const requestOptions = getRequestOptions('application/json')
+  const resourceUrl = new URL(getArtifactUrl())
+  resourceUrl.searchParams.append('artifactName', artifactName)
+
+  const parameters: PatchArtifactSize = {Size: size}
+  const data: string = JSON.stringify(parameters, null, 2)
+  debug(`URL is ${resourceUrl.toString()}`)
+
+  const rawResponse: HttpClientResponse = await client.patch(
+    resourceUrl.toString(),
+    data,
+    requestOptions
+  )
+  const body: string = await rawResponse.readBody()
+
+  if (isSuccessStatusCode(rawResponse.message.statusCode)) {
+    debug(
+      `Artifact ${artifactName} has been successfully uploaded, total size ${size}`
+    )
+    debug(body)
+  } else if (rawResponse.message.statusCode === 404) {
+    throw new Error(`An Artifact with the name ${artifactName} was not found`)
+  } else {
+    // eslint-disable-next-line no-console
+    console.log(body)
+    throw new Error(`Unable to finish uploading artifact ${artifactName}`)
+  }
+}
+
+interface UploadFileParameters {
+  file: string
+  resourceUrl: string
+  restClient: HttpClient
+  concurrency: number
+  maxChunkSize: number
+  continueOnError: boolean
+}
+
+interface UploadFileResult {
+  isSuccess: boolean
+  successfulUploadSize: number
+}

packages/artifact/src/internal-upload-options.ts

@@ -0,0 +1,18 @@
+export interface UploadOptions {
+  /**
+   * Indicates if the artifact upload should continue if file or chunk fails to upload from any error.
+   * If there is a error during upload, a partial artifact will always be associated and available for
+   * download at the end. The size reported will be the amount of storage that the user or org will be
+   * charged for the partial artifact. Defaults to true if not specified
+   *
+   * If set to false, and an error is encountered, all other uploads will stop and any files or chunks
+   * that were queued will not be attempted to be uploaded. The partial artifact available will only
+   * include files and chunks up until the failure
+   *
+   * If set to true and an error is encountered, the failed file will be skipped and ignored and all
+   * other queued files will be attempted to be uploaded. The partial artifact at the end will have all
+   * files with the exception of the problematic files(s)/chunks(s) that failed to upload
+   *
+   */
+  continueOnError?: boolean
+}

packages/artifact/src/internal-upload-response.ts

@@ -0,0 +1,22 @@
+export interface UploadResponse {
+  /**
+   * The name of the artifact that was uploaded
+   */
+  artifactName: string
+
+  /**
+   * A list of all items that are meant to be uploaded as part of the artifact
+   */
+  artifactItems: string[]
+
+  /**
+   * Total size of the artifact in bytes that was uploaded
+   */
+  size: number
+
+  /**
+   * A list of items that were not uploaded as part of the artifact (includes queued items that were not uploaded if
+   * continueOnError is set to false). This is a subset of artifactItems.
+   */
+  failedItems: string[]
+}

packages/artifact/src/internal-upload-specification.ts

@@ -0,0 +1,92 @@
+import * as fs from 'fs'
+import {debug} from '@actions/core'
+import {join, normalize, resolve} from 'path'
+import {checkArtifactName} from './internal-utils'
+
+export interface UploadSpecification {
+  absoluteFilePath: string
+  uploadFilePath: string
+}
+
+/**
+ * Creates a specification that describes how each file that is part of the artifact will be uploaded
+ * @param artifactName the name of the artifact being uploaded. Used during upload to denote where the artifact is stored on the server
+ * @param rootDirectory an absolute file path that denotes the path that should be removed from the beginning of each artifact file
+ * @param artifactFiles a list of absolute file paths that denote what should be uploaded as part of the artifact
+ */
+export function getUploadSpecification(
+  artifactName: string,
+  rootDirectory: string,
+  artifactFiles: string[]
+): UploadSpecification[] {
+  checkArtifactName(artifactName)
+
+  const specifications: UploadSpecification[] = []
+
+  if (!fs.existsSync(rootDirectory)) {
+    throw new Error(`Provided rootDirectory ${rootDirectory} does not exist`)
+  }
+  if (!fs.lstatSync(rootDirectory).isDirectory()) {
+    throw new Error(
+      `Provided rootDirectory ${rootDirectory} is not a valid directory`
+    )
+  }
+  // Normalize and resolve, this allows for either absolute or relative paths to be used
+  rootDirectory = normalize(rootDirectory)
+  rootDirectory = resolve(rootDirectory)
+
+  /*
+     Example to demonstrate behavior
+     
+     Input:
+       artifactName: my-artifact
+       rootDirectory: '/home/user/files/plz-upload'
+       artifactFiles: [
+         '/home/user/files/plz-upload/file1.txt',
+         '/home/user/files/plz-upload/file2.txt',
+         '/home/user/files/plz-upload/dir/file3.txt'
+       ]
+     
+     Output:
+       specifications: [
+         ['/home/user/files/plz-upload/file1.txt', 'my-artifact/file1.txt'],
+         ['/home/user/files/plz-upload/file1.txt', 'my-artifact/file2.txt'],
+         ['/home/user/files/plz-upload/file1.txt', 'my-artifact/dir/file3.txt']
+       ]
+  */
+  for (let file of artifactFiles) {
+    if (!fs.existsSync(file)) {
+      throw new Error(`File ${file} does not exist`)
+    }
+
+    if (!fs.lstatSync(file).isDirectory()) {
+      // Normalize and resolve, this allows for either absolute or relative paths to be used
+      file = normalize(file)
+      file = resolve(file)
+      if (!file.startsWith(rootDirectory)) {
+        throw new Error(
+          `The rootDirectory: ${rootDirectory} is not a parent directory of the file: ${file}`
+        )
+      }
+
+      /*
+        uploadFilePath denotes where the file will be uploaded in the file container on the server. During a run, if multiple artifacts are uploaded, they will all
+        be saved in the same container. The artifact name is used as the root directory in the container to separate and distinguish uploaded artifacts
+
+        path.join handles all the following cases and would return 'artifact-name/file-to-upload.txt
+          join('artifact-name/', 'file-to-upload.txt')
+          join('artifact-name/', '/file-to-upload.txt')
+          join('artifact-name', 'file-to-upload.txt')
+          join('artifact-name', '/file-to-upload.txt')
+      */
+      specifications.push({
+        absoluteFilePath: file,
+        uploadFilePath: join(artifactName, file.replace(rootDirectory, ''))
+      })
+    } else {
+      // Directories are rejected by the server during upload
+      debug(`Removing ${file} from rawSearchResults because it is a directory`)
+    }
+  }
+  return specifications
+}

packages/artifact/src/internal-utils.ts

@@ -0,0 +1,115 @@
+import {debug} from '@actions/core'
+import {HttpCodes, HttpClient} from '@actions/http-client'
+import {BearerCredentialHandler} from '@actions/http-client/auth'
+import {IHeaders} from '@actions/http-client/interfaces'
+import {
+  getRuntimeToken,
+  getRuntimeUrl,
+  getWorkFlowRunId
+} from './internal-config-variables'
+
+/**
+ * Parses a env variable that is a number
+ */
+export function parseEnvNumber(key: string): number | undefined {
+  const value = Number(process.env[key])
+  if (Number.isNaN(value) || value < 0) {
+    return undefined
+  }
+  return value
+}
+
+/**
+ * Various utility functions to help with the necessary API calls
+ */
+export function getApiVersion(): string {
+  return '6.0-preview'
+}
+
+export function isSuccessStatusCode(statusCode?: number): boolean {
+  if (!statusCode) {
+    return false
+  }
+  return statusCode >= 200 && statusCode < 300
+}
+
+export function isRetryableStatusCode(statusCode?: number): boolean {
+  if (!statusCode) {
+    return false
+  }
+
+  const retryableStatusCodes = [
+    HttpCodes.BadGateway,
+    HttpCodes.ServiceUnavailable,
+    HttpCodes.GatewayTimeout
+  ]
+  return retryableStatusCodes.includes(statusCode)
+}
+
+export function getContentRange(
+  start: number,
+  end: number,
+  total: number
+): string {
+  // Format: `bytes start-end/fileSize
+  // start and end are inclusive
+  // For a 200 byte chunk starting at byte 0:
+  // Content-Range: bytes 0-199/200
+  return `bytes ${start}-${end}/${total}`
+}
+
+export function getRequestOptions(
+  contentType?: string,
+  contentLength?: number,
+  contentRange?: string
+): IHeaders {
+  const requestOptions: IHeaders = {
+    Accept: `application/json;api-version=${getApiVersion()}`
+  }
+  if (contentType) {
+    requestOptions['Content-Type'] = contentType
+  }
+  if (contentLength) {
+    requestOptions['Content-Length'] = contentLength
+  }
+  if (contentRange) {
+    requestOptions['Content-Range'] = contentRange
+  }
+  return requestOptions
+}
+
+export function createHttpClient(): HttpClient {
+  return new HttpClient('action/artifact', [
+    new BearerCredentialHandler(getRuntimeToken())
+  ])
+}
+
+export function getArtifactUrl(): string {
+  const artifactUrl = `${getRuntimeUrl()}_apis/pipelines/workflows/${getWorkFlowRunId()}/artifacts?api-version=${getApiVersion()}`
+  debug(`Artifact Url: ${artifactUrl}`)
+  return artifactUrl
+}
+
+/**
+ * Invalid characters that cannot be in the artifact name or an uploaded file. Will be rejected
+ * from the server if attempted to be sent over. These characters are not allowed due to limitations with certain
+ * file systems such as NTFS. To maintain platform-agnostic behavior, all characters that are not supported by an
+ * individual filesystem/platform will not be supported on all fileSystems/platforms
+ */
+const invalidCharacters = ['\\', '/', '"', ':', '<', '>', '|', '*', '?', ' ']
+
+/**
+ * Scans the name of the item being uploaded to make sure there are no illegal characters
+ */
+export function checkArtifactName(name: string): void {
+  if (!name) {
+    throw new Error(`Artifact name: ${name}, is incorrectly provided`)
+  }
+  for (const invalidChar of invalidCharacters) {
+    if (name.includes(invalidChar)) {
+      throw new Error(
+        `Artifact name is not valid: ${name}. Contains character: "${invalidChar}". Invalid characters include: ${invalidCharacters.toString()}.`
+      )
+    }
+  }
+}