@actions/artifact package

packages/artifact/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@actions/artifact",
+  "version": "0.1.0",
+  "preview": true,
+  "description": "Actions artifact lib",
+  "keywords": [
+    "github",
+    "actions",
+    "artifact"
+  ],
+  "homepage": "https://github.com/actions/toolkit/tree/master/packages/artifact",
+  "license": "MIT",
+  "main": "lib/artifact.js",
+  "types": "lib/artifact.d.ts",
+  "directories": {
+    "lib": "lib",
+    "test": "__tests__"
+  },
+  "files": [
+    "lib"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/actions/toolkit.git",
+    "directory": "packages/artifact"
+  },
+  "scripts": {
+    "audit-moderate": "npm install && npm audit --audit-level=moderate",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "tsc": "tsc"
+  },
+  "bugs": {
+    "url": "https://github.com/actions/toolkit/issues"
+  },
+  "dependencies": {
+    "@actions/core": "^1.2.1",
+    "@actions/glob": "^0.1.0",
+    "@actions/http-client": "^1.0.1"
+  }
+}

packages/artifact/src/artifact.ts

@@ -0,0 +1,111 @@
+import * as core from '@actions/core'
+import {CreateArtifactResponse} from './contracts'
+import {SearchResult, findFilesToUpload} from './search'
+import {
+  createArtifactInFileContainer,
+  uploadArtifactToFileContainer,
+  patchArtifactSize
+} from './upload-artifact-http-client'
+import {UploadInfo} from './upload-info'
+import {checkArtifactName} from './utils'
+
+/**
+ * Uploads an artifact
+ *
+ * @param name the name of the artifact, required
+ * @param path the directory, file, or glob pattern to denote what will be uploaded, required
+ * @returns single UploadInfo object
+ */
+export async function uploadArtifact(
+  name: string,
+  path: string
+): Promise<UploadInfo> {
+  // Check that the required inputs are valid
+  if (!name) {
+    throw new Error('Artifact name must be provided')
+  }
+
+  checkArtifactName(name)
+
+  if (!path) {
+    throw new Error('Upload path must be provided')
+  }
+
+  // Search for the items that will be uploaded
+  let filesToUpload: SearchResult[] = await findFilesToUpload(name, path)
+
+  if (filesToUpload === undefined) {
+    core.setFailed(
+      `Unable to succesfully search fo files to upload with the provided path: ${path}`
+    )
+  } else if (filesToUpload.length == 0) {
+    core.warning(
+      `No files were found for the provided path: ${path}. No artifacts will be uploaded.`
+    )
+  } else {
+    /**
+     * Step 1 of 3
+     * Create an entry for the artifact in the file container
+     */
+    const response: CreateArtifactResponse = await createArtifactInFileContainer(
+      name
+    )
+    if (!response.fileContainerResourceUrl) {
+      console.log(response)
+      throw new Error('Unable to get fileContainerResourceUrl')
+    }
+    core.debug(`We will be uploading to: ${response.fileContainerResourceUrl}`)
+
+    /**
+     * Step 2 of 3
+     * Upload each of the files that were found concurrently
+     */
+    let artfactSize: Promise<number> = Promise.resolve(
+      uploadArtifactToFileContainer(
+        response.fileContainerResourceUrl!,
+        filesToUpload
+      )
+    )
+    artfactSize.then(async size => {
+      console.log(`Size of what we just uploaded is ${size}`)
+      /**
+       * Step 3 of 3
+       * Update the size of the artifact to indicate we are done uploading
+       */
+      await patchArtifactSize(size, name)
+      return {
+        artifactName: name,
+        artifactItems: filesToUpload.map(item => item.absoluteFilePath),
+        size: size
+      } as UploadInfo
+    })
+  }
+
+  return {
+    artifactName: name,
+    artifactItems: filesToUpload.map(item => item.absoluteFilePath),
+    size: -1
+  } as UploadInfo
+}
+
+/*
+Downloads a single artifact associated with a run
+
+export async function downloadArtifact(
+    name: string,
+    path?: string,
+    createArtifactFolder?:boolean
+  ): Promise<DownloadInfo> {
+
+    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<DownloadInfo[]>{
+
+    TODO
+}
+*/

packages/artifact/src/contracts.ts

@@ -0,0 +1,28 @@
+export interface CreateArtifactResponse {
+  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
+}

packages/artifact/src/download-info.ts

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

packages/artifact/src/search.ts

@@ -0,0 +1,95 @@
+import {debug} from '@actions/core'
+import * as glob from '@actions/glob'
+import {lstatSync} from 'fs'
+import {join, basename} from 'path'
+
+export interface SearchResult {
+  absoluteFilePath: string
+  uploadFilePath: string
+}
+
+/**
+ * Searches the provided path and returns the files that will be uploaded as part of the artifact
+ * @param {string} searchPath Wildcard pattern, directory or individual file that is provided by the user to specify what should be uploaded
+ * @param {string} artifactName The name of the artifact, used as the root directory when uploading artifacts to glob storage
+ * @return A list of files that should be uploaded along with the paths they will be uploaded with
+ */
+export async function findFilesToUpload(
+  artifactName: string,
+  searchPath: string
+): Promise<SearchResult[]> {
+  let searchResults: SearchResult[] = []
+  let itemsToUpload: string[] = []
+  let options: glob.GlobOptions = {
+    followSymbolicLinks: true,
+    implicitDescendants: true,
+    omitBrokenSymbolicLinks: true
+  }
+  let globber = await glob.create(searchPath, options)
+
+  let rawSearchResults: string[] = await globber.glob()
+  /**
+   * Directories will be rejected if attempted to be uploaded. This includes just empty
+   * directories so filter any directories out from the raw search results
+   */
+
+  rawSearchResults.forEach(function(item) {
+    if (!lstatSync(item).isDirectory()) {
+      itemsToUpload.push(item)
+    } else {
+      debug(`Removing ${item} from rawSearchResults because it is a directory`)
+    }
+  })
+
+  if (itemsToUpload.length == 0) {
+    return searchResults
+  }
+  console.log(
+    `Found the following ${itemsToUpload.length} items that will be uploaded as part of the artifact:`
+  )
+  console.log(itemsToUpload)
+
+  /**
+   * Only a single search pattern is being included so only 1 searchResult is expected. In the future if multiple search patterns are
+   * simultaneously supported this will change
+   */
+  let searchPaths: string[] = await globber.getSearchPaths()
+  if (searchResults.length > 1) {
+    console.log(searchResults)
+    throw new Error('Only 1 search path should be returned')
+  }
+
+  /**
+   * Creates the path that the artifact will be uploaded with. The artifact name will always be the root directory so that
+   * it can be distinguished from other artifacts that are uploaded to the same file Container/glob storage during a run
+   */
+  if (itemsToUpload.length == 1) {
+    // A single artifact will be uploaded, the upload path will always be in the form ${artifactName}\${singleArtifactName}
+    searchResults.push({
+      absoluteFilePath: itemsToUpload[0],
+      uploadFilePath: join(artifactName, basename(searchPaths[0]))
+    })
+  } else {
+    /**
+     * multiple files will be uploaded as part of the artifact
+     * The search path denotes the base path that was used to find the file. It will be removed from the absolute path and
+     * the artifact name will be prepended to create the path used during upload
+     */
+    itemsToUpload.forEach(function(file) {
+      let uploadPath: string = file.replace(searchPaths[0], '')
+      searchResults.push({
+        absoluteFilePath: file,
+        uploadFilePath: artifactName.concat(uploadPath)
+      })
+    })
+  }
+
+  debug('SearchResult includes the following information:')
+  searchResults.forEach(function(item) {
+    debug(
+      `Absolute File Path: ${item.absoluteFilePath}\nUpload file path: ${item.uploadFilePath}`
+    )
+  })
+
+  return searchResults
+}