GitHub Actions Runner

src/Runner.Plugins/Artifact/BuildServer.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using GitHub.Runner.Sdk;
+using GitHub.Services.WebApi;
+using GitHub.Build.WebApi;
+
+namespace GitHub.Runner.Plugins.Artifact
+{
+    // A client wrapper interacting with Build's Artifact API
+    public class BuildServer
+    {
+        private readonly BuildHttpClient _buildHttpClient;
+
+        public BuildServer(VssConnection connection)
+        {
+            ArgUtil.NotNull(connection, nameof(connection));
+            _buildHttpClient = connection.GetClient<BuildHttpClient>();
+        }
+
+        // Associate the specified artifact with a build, along with custom data.
+        public async Task<BuildArtifact> AssociateArtifact(
+            Guid projectId,
+            int pipelineId,
+            string jobId,
+            string name,
+            string type,
+            string data,
+            Dictionary<string, string> propertiesDictionary,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            BuildArtifact artifact = new BuildArtifact()
+            {
+                Name = name,
+                Source = jobId,
+                Resource = new ArtifactResource()
+                {
+                    Data = data,
+                    Type = type,
+                    Properties = propertiesDictionary
+                }
+            };
+
+            return await _buildHttpClient.CreateArtifactAsync(artifact, projectId, pipelineId, cancellationToken: cancellationToken);
+        }
+
+        // Get named artifact from a build
+        public async Task<BuildArtifact> GetArtifact(
+            Guid projectId,
+            int pipelineId,
+            string name,
+            CancellationToken cancellationToken)
+        {
+            return await _buildHttpClient.GetArtifactAsync(projectId, pipelineId, name, cancellationToken: cancellationToken);
+        }
+    }
+}

src/Runner.Plugins/Artifact/DownloadArtifact.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using GitHub.Build.WebApi;
+using GitHub.Services.Common;
+using GitHub.Runner.Sdk;
+
+namespace GitHub.Runner.Plugins.Artifact
+{
+    public class DownloadArtifact : IRunnerActionPlugin
+    {
+
+        private static class DownloadArtifactInputNames
+        {
+            public static readonly string Name = "name";
+            public static readonly string ArtifactName = "artifact";
+            public static readonly string Path = "path";
+        }
+
+        public async Task RunAsync(
+            RunnerActionPluginExecutionContext context,
+            CancellationToken token)
+        {
+            ArgUtil.NotNull(context, nameof(context));
+            string artifactName = context.GetInput(DownloadArtifactInputNames.ArtifactName, required: false); // Back compat since we rename input `artifact` to `name`
+            if (string.IsNullOrEmpty(artifactName))
+            {
+                artifactName = context.GetInput(DownloadArtifactInputNames.Name, required: true);
+            }
+
+            string targetPath = context.GetInput(DownloadArtifactInputNames.Path, required: false);
+            string defaultWorkingDirectory = context.GetGitHubContext("workspace");
+
+            if (string.IsNullOrEmpty(targetPath))
+            {
+                targetPath = artifactName;
+            }
+
+            targetPath = Path.IsPathFullyQualified(targetPath) ? targetPath : Path.GetFullPath(Path.Combine(defaultWorkingDirectory, targetPath));
+
+            // Project ID
+            Guid projectId = new Guid(context.Variables.GetValueOrDefault(BuildVariables.TeamProjectId)?.Value ?? Guid.Empty.ToString());
+
+            // Build ID
+            string buildIdStr = context.Variables.GetValueOrDefault(BuildVariables.BuildId)?.Value ?? string.Empty;
+            if (!int.TryParse(buildIdStr, out int buildId))
+            {
+                throw new ArgumentException($"Run Id is not an Int32: {buildIdStr}");
+            }
+
+            context.Output($"Download artifact '{artifactName}' to: '{targetPath}'");
+
+            BuildServer buildHelper = new BuildServer(context.VssConnection);
+            BuildArtifact buildArtifact = await buildHelper.GetArtifact(projectId, buildId, artifactName, token);
+
+            if (string.Equals(buildArtifact.Resource.Type, "Container", StringComparison.OrdinalIgnoreCase))
+            {
+                string containerUrl = buildArtifact.Resource.Data;
+                string[] parts = containerUrl.Split(new[] { '/' }, 3);
+                if (parts.Length < 3 || !long.TryParse(parts[1], out long containerId))
+                {
+                    throw new ArgumentOutOfRangeException($"Invalid container url '{containerUrl}' for artifact '{buildArtifact.Name}'");
+                }
+
+                string containerPath = parts[2];
+                FileContainerServer fileContainerServer = new FileContainerServer(context.VssConnection, projectId, containerId, containerPath);
+                await fileContainerServer.DownloadFromContainerAsync(context, targetPath, token);
+            }
+            else
+            {
+                throw new NotSupportedException($"Invalid artifact type: {buildArtifact.Resource.Type}");
+            }
+
+            context.Output("Artifact download finished.");
+        }
+    }
+}

src/Runner.Plugins/Artifact/FileContainerServer.cs

@@ -0,0 +1,660 @@
+using GitHub.Services.FileContainer.Client;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Diagnostics;
+using GitHub.Services.WebApi;
+using System.Net.Http;
+using System.Net;
+using GitHub.Runner.Sdk;
+using GitHub.Services.FileContainer;
+using GitHub.Services.Common;
+
+namespace GitHub.Runner.Plugins.Artifact
+{
+    public class FileContainerServer
+    {
+        private const int _defaultFileStreamBufferSize = 4096;
+
+        //81920 is the default used by System.IO.Stream.CopyTo and is under the large object heap threshold (85k). 
+        private const int _defaultCopyBufferSize = 81920;
+
+        private readonly ConcurrentQueue<string> _fileUploadQueue = new ConcurrentQueue<string>();
+        private readonly ConcurrentQueue<DownloadInfo> _fileDownloadQueue = new ConcurrentQueue<DownloadInfo>();
+        private readonly ConcurrentDictionary<string, ConcurrentQueue<string>> _fileUploadTraceLog = new ConcurrentDictionary<string, ConcurrentQueue<string>>();
+        private readonly ConcurrentDictionary<string, ConcurrentQueue<string>> _fileUploadProgressLog = new ConcurrentDictionary<string, ConcurrentQueue<string>>();
+        private readonly FileContainerHttpClient _fileContainerHttpClient;
+
+        private CancellationTokenSource _uploadCancellationTokenSource;
+        private CancellationTokenSource _downloadCancellationTokenSource;
+        private TaskCompletionSource<int> _uploadFinished;
+        private TaskCompletionSource<int> _downloadFinished;
+        private Guid _projectId;
+        private long _containerId;
+        private string _containerPath;
+        private int _uploadFilesProcessed = 0;
+        private int _downloadFilesProcessed = 0;
+        private string _sourceParentDirectory;
+
+        public FileContainerServer(
+            VssConnection connection,
+            Guid projectId,
+            long containerId,
+            string containerPath)
+        {
+            _projectId = projectId;
+            _containerId = containerId;
+            _containerPath = containerPath;
+
+            // default file upload/download request timeout to 600 seconds
+            var fileContainerClientConnectionSetting = connection.Settings.Clone();
+            if (fileContainerClientConnectionSetting.SendTimeout < TimeSpan.FromSeconds(600))
+            {
+                fileContainerClientConnectionSetting.SendTimeout = TimeSpan.FromSeconds(600);
+            }
+
+            var fileContainerClientConnection = new VssConnection(connection.Uri, connection.Credentials, fileContainerClientConnectionSetting);
+            _fileContainerHttpClient = fileContainerClientConnection.GetClient<FileContainerHttpClient>();
+        }
+
+        public async Task DownloadFromContainerAsync(
+            RunnerActionPluginExecutionContext context,
+            String destination,
+            CancellationToken cancellationToken)
+        {
+            // Find out all container items need to be processed
+            List<FileContainerItem> containerItems = new List<FileContainerItem>();
+            int retryCount = 0;
+            while (retryCount < 3)
+            {
+                try
+                {
+                    containerItems = await _fileContainerHttpClient.QueryContainerItemsAsync(_containerId,
+                                                                                             _projectId,
+                                                                                             _containerPath,
+                                                                                             cancellationToken: cancellationToken);
+                    break;
+                }
+                catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
+                {
+                    context.Debug($"Container query has been cancelled.");
+                    throw;
+                }
+                catch (Exception ex) when (retryCount < 2)
+                {
+                    retryCount++;
+                    context.Warning($"Fail to query container items under #/{_containerId}/{_containerPath}, Error: {ex.Message}");
+                    context.Debug(ex.ToString());
+                }
+
+                var backOff = BackoffTimerHelper.GetRandomBackoff(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(15));
+                context.Warning($"Back off {backOff.TotalSeconds} seconds before retry.");
+                await Task.Delay(backOff);
+            }
+
+            if (containerItems.Count == 0)
+            {
+                context.Output($"There is nothing under #/{_containerId}/{_containerPath}");
+                return;
+            }
+
+            // container items will include both folders, files and even file with zero size
+            // Create all required empty folders and emptry files, gather a list of files that we need to download from server.
+            int foldersCreated = 0;
+            int emptryFilesCreated = 0;
+            List<DownloadInfo> downloadFiles = new List<DownloadInfo>();
+            foreach (var item in containerItems.OrderBy(x => x.Path))
+            {
+                if (!item.Path.StartsWith(_containerPath, StringComparison.OrdinalIgnoreCase))
+                {
+                    throw new ArgumentOutOfRangeException($"Item {item.Path} is not under #/{_containerId}/{_containerPath}");
+                }
+
+                var localRelativePath = item.Path.Substring(_containerPath.Length).TrimStart('/');
+                var localPath = Path.Combine(destination, localRelativePath);
+
+                if (item.ItemType == ContainerItemType.Folder)
+                {
+                    context.Debug($"Ensure folder exists: {localPath}");
+                    Directory.CreateDirectory(localPath);
+                    foldersCreated++;
+                }
+                else if (item.ItemType == ContainerItemType.File)
+                {
+                    if (item.FileLength == 0)
+                    {
+                        context.Debug($"Create empty file at: {localPath}");
+                        var parentDirectory = Path.GetDirectoryName(localPath);
+                        Directory.CreateDirectory(parentDirectory);
+                        IOUtil.DeleteFile(localPath);
+                        using (new FileStream(localPath, FileMode.Create))
+                        {
+                        }
+                        emptryFilesCreated++;
+                    }
+                    else
+                    {
+                        context.Debug($"Prepare download {item.Path} to {localPath}");
+                        downloadFiles.Add(new DownloadInfo(item.Path, localPath));
+                    }
+                }
+                else
+                {
+                    throw new NotSupportedException(item.ItemType.ToString());
+                }
+            }
+
+            if (foldersCreated > 0)
+            {
+                context.Output($"{foldersCreated} folders created.");
+            }
+
+            if (emptryFilesCreated > 0)
+            {
+                context.Output($"{emptryFilesCreated} empty files created.");
+            }
+
+            if (downloadFiles.Count == 0)
+            {
+                context.Output($"There is nothing to download");
+                return;
+            }
+
+            // Start multi-task to download all files.
+            using (_downloadCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
+            {
+                // try download all files for the first time.
+                DownloadResult downloadResult = await ParallelDownloadAsync(context, downloadFiles.AsReadOnly(), Math.Min(downloadFiles.Count, Environment.ProcessorCount), _downloadCancellationTokenSource.Token);
+                if (downloadResult.FailedFiles.Count == 0)
+                {
+                    // all files have been download succeed.
+                    context.Output($"{downloadFiles.Count} files download succeed.");
+                    return;
+                }
+                else
+                {
+                    context.Output($"{downloadResult.FailedFiles.Count} files failed to download, retry these files after a minute.");
+                }
+
+                // Delay 1 min then retry failed files.
+                for (int timer = 60; timer > 0; timer -= 5)
+                {
+                    context.Output($"Retry file download after {timer} seconds.");
+                    await Task.Delay(TimeSpan.FromSeconds(5), _uploadCancellationTokenSource.Token);
+                }
+
+                // Retry download all failed files.
+                context.Output($"Start retry {downloadResult.FailedFiles.Count} failed files upload.");
+                DownloadResult retryDownloadResult = await ParallelDownloadAsync(context, downloadResult.FailedFiles.AsReadOnly(), Math.Min(downloadResult.FailedFiles.Count, Environment.ProcessorCount), _downloadCancellationTokenSource.Token);
+                if (retryDownloadResult.FailedFiles.Count == 0)
+                {
+                    // all files have been download succeed after retry.
+                    context.Output($"{downloadResult.FailedFiles} files download succeed after retry.");
+                    return;
+                }
+                else
+                {
+                    throw new Exception($"{retryDownloadResult.FailedFiles.Count} files failed to download even after retry.");
+                }
+            }
+        }
+
+        public async Task<long> CopyToContainerAsync(
+            RunnerActionPluginExecutionContext context,
+            String source,
+            CancellationToken cancellationToken)
+        {
+            //set maxConcurrentUploads up to 2 until figure out how to use WinHttpHandler.MaxConnectionsPerServer modify DefaultConnectionLimit
+            int maxConcurrentUploads = Math.Min(Environment.ProcessorCount, 2);
+            //context.Output($"Max Concurrent Uploads {maxConcurrentUploads}");
+
+            List<String> files;
+            if (File.Exists(source))
+            {
+                files = new List<String>() { source };
+                _sourceParentDirectory = Path.GetDirectoryName(source);
+            }
+            else
+            {
+                files = Directory.EnumerateFiles(source, "*", SearchOption.AllDirectories).ToList();
+                _sourceParentDirectory = source.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+            }
+
+            context.Output($"Uploading {files.Count()} files");
+            using (_uploadCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
+            {
+                // hook up reporting event from file container client.
+                _fileContainerHttpClient.UploadFileReportTrace += UploadFileTraceReportReceived;
+                _fileContainerHttpClient.UploadFileReportProgress += UploadFileProgressReportReceived;
+
+                try
+                {
+                    // try upload all files for the first time.
+                    UploadResult uploadResult = await ParallelUploadAsync(context, files, maxConcurrentUploads, _uploadCancellationTokenSource.Token);
+
+                    if (uploadResult.FailedFiles.Count == 0)
+                    {
+                        // all files have been upload succeed.
+                        context.Output("File upload succeed.");
+                        return uploadResult.TotalFileSizeUploaded;
+                    }
+                    else
+                    {
+                        context.Output($"{uploadResult.FailedFiles.Count} files failed to upload, retry these files after a minute.");
+                    }
+
+                    // Delay 1 min then retry failed files.
+                    for (int timer = 60; timer > 0; timer -= 5)
+                    {
+                        context.Output($"Retry file upload after {timer} seconds.");
+                        await Task.Delay(TimeSpan.FromSeconds(5), _uploadCancellationTokenSource.Token);
+                    }
+
+                    // Retry upload all failed files.
+                    context.Output($"Start retry {uploadResult.FailedFiles.Count} failed files upload.");
+                    UploadResult retryUploadResult = await ParallelUploadAsync(context, uploadResult.FailedFiles, maxConcurrentUploads, _uploadCancellationTokenSource.Token);
+
+                    if (retryUploadResult.FailedFiles.Count == 0)
+                    {
+                        // all files have been upload succeed after retry.
+                        context.Output("File upload succeed after retry.");
+                        return uploadResult.TotalFileSizeUploaded + retryUploadResult.TotalFileSizeUploaded;
+                    }
+                    else
+                    {
+                        throw new Exception("File upload failed even after retry.");
+                    }
+                }
+                finally
+                {
+                    _fileContainerHttpClient.UploadFileReportTrace -= UploadFileTraceReportReceived;
+                    _fileContainerHttpClient.UploadFileReportProgress -= UploadFileProgressReportReceived;
+                }
+            }
+        }
+
+        private async Task<DownloadResult> ParallelDownloadAsync(RunnerActionPluginExecutionContext context, IReadOnlyList<DownloadInfo> files, int concurrentDownloads, CancellationToken token)
+        {
+            // return files that fail to download
+            var downloadResult = new DownloadResult();
+
+            // nothing needs to download
+            if (files.Count == 0)
+            {
+                return downloadResult;
+            }
+
+            // ensure the file download queue is empty.
+            if (!_fileDownloadQueue.IsEmpty)
+            {
+                throw new ArgumentOutOfRangeException(nameof(_fileDownloadQueue));
+            }
+
+            // enqueue file into download queue.
+            foreach (var file in files)
+            {
+                _fileDownloadQueue.Enqueue(file);
+            }
+
+            // Start download monitor task.
+            _downloadFilesProcessed = 0;
+            _downloadFinished = new TaskCompletionSource<int>();
+            Task downloadMonitor = DownloadReportingAsync(context, files.Count(), token);
+
+            // Start parallel download tasks.
+            List<Task<DownloadResult>> parallelDownloadingTasks = new List<Task<DownloadResult>>();
+            for (int downloader = 0; downloader < concurrentDownloads; downloader++)
+            {
+                parallelDownloadingTasks.Add(DownloadAsync(context, downloader, token));
+            }
+
+            // Wait for parallel download finish.
+            await Task.WhenAll(parallelDownloadingTasks);
+            foreach (var downloadTask in parallelDownloadingTasks)
+            {
+                // record all failed files.
+                downloadResult.AddDownloadResult(await downloadTask);
+            }
+
+            // Stop monitor task;
+            _downloadFinished.TrySetResult(0);
+            await downloadMonitor;
+
+            return downloadResult;
+        }
+
+        private async Task<UploadResult> ParallelUploadAsync(RunnerActionPluginExecutionContext context, IReadOnlyList<string> files, int concurrentUploads, CancellationToken token)
+        {
+            // return files that fail to upload and total artifact size
+            var uploadResult = new UploadResult();
+
+            // nothing needs to upload
+            if (files.Count == 0)
+            {
+                return uploadResult;
+            }
+
+            // ensure the file upload queue is empty.
+            if (!_fileUploadQueue.IsEmpty)
+            {
+                throw new ArgumentOutOfRangeException(nameof(_fileUploadQueue));
+            }
+
+            // enqueue file into upload queue.
+            foreach (var file in files)
+            {
+                _fileUploadQueue.Enqueue(file);
+            }
+
+            // Start upload monitor task.
+            _uploadFilesProcessed = 0;
+            _uploadFinished = new TaskCompletionSource<int>();
+            _fileUploadTraceLog.Clear();
+            _fileUploadProgressLog.Clear();
+            Task uploadMonitor = UploadReportingAsync(context, files.Count(), _uploadCancellationTokenSource.Token);
+
+            // Start parallel upload tasks.
+            List<Task<UploadResult>> parallelUploadingTasks = new List<Task<UploadResult>>();
+            for (int uploader = 0; uploader < concurrentUploads; uploader++)
+            {
+                parallelUploadingTasks.Add(UploadAsync(context, uploader, _uploadCancellationTokenSource.Token));
+            }
+
+            // Wait for parallel upload finish.
+            await Task.WhenAll(parallelUploadingTasks);
+            foreach (var uploadTask in parallelUploadingTasks)
+            {
+                // record all failed files.
+                uploadResult.AddUploadResult(await uploadTask);
+            }
+
+            // Stop monitor task;
+            _uploadFinished.TrySetResult(0);
+            await uploadMonitor;
+
+            return uploadResult;
+        }
+
+        private async Task<DownloadResult> DownloadAsync(RunnerActionPluginExecutionContext context, int downloaderId, CancellationToken token)
+        {
+            List<DownloadInfo> failedFiles = new List<DownloadInfo>();
+            Stopwatch downloadTimer = new Stopwatch();
+            while (_fileDownloadQueue.TryDequeue(out DownloadInfo fileToDownload))
+            {
+                token.ThrowIfCancellationRequested();
+                try
+                {
+                    int retryCount = 0;
+                    bool downloadFailed = false;
+                    while (true)
+                    {
+                        try
+                        {
+                            context.Debug($"Start downloading file: '{fileToDownload.ItemPath}' (Downloader {downloaderId})");
+                            downloadTimer.Restart();
+                            using (FileStream fs = new FileStream(fileToDownload.LocalPath, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: _defaultFileStreamBufferSize, useAsync: true))
+                            using (var downloadStream = await _fileContainerHttpClient.DownloadFileAsync(_containerId, fileToDownload.ItemPath, token, _projectId))
+                            {
+                                await downloadStream.CopyToAsync(fs, _defaultCopyBufferSize, token);
+                                await fs.FlushAsync(token);
+                                downloadTimer.Stop();
+                                context.Debug($"File: '{fileToDownload.LocalPath}' took {downloadTimer.ElapsedMilliseconds} milliseconds to finish download (Downloader {downloaderId})");
+                                break;
+                            }
+                        }
+                        catch (OperationCanceledException) when (token.IsCancellationRequested)
+                        {
+                            context.Debug($"Download has been cancelled while downloading {fileToDownload.ItemPath}. (Downloader {downloaderId})");
+                            throw;
+                        }
+                        catch (Exception ex)
+                        {
+                            retryCount++;
+                            context.Warning($"Fail to download '{fileToDownload.ItemPath}', error: {ex.Message} (Downloader {downloaderId})");
+                            context.Debug(ex.ToString());
+                        }
+
+                        if (retryCount < 3)
+                        {
+                            var backOff = BackoffTimerHelper.GetRandomBackoff(TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30));
+                            context.Warning($"Back off {backOff.TotalSeconds} seconds before retry. (Downloader {downloaderId})");
+                            await Task.Delay(backOff);
+                        }
+                        else
+                        {
+                            // upload still failed after 3 tries.
+                            downloadFailed = true;
+                            break;
+                        }
+                    }
+
+                    if (downloadFailed)
+                    {
+                        // tracking file that failed to download.
+                        failedFiles.Add(fileToDownload);
+                    }
+
+                    Interlocked.Increment(ref _downloadFilesProcessed);
+                }
+                catch (Exception ex)
+                {
+                    // We should never
+                    context.Error($"Error '{ex.Message}' when downloading file '{fileToDownload}'. (Downloader {downloaderId})");
+                    throw ex;
+                }
+            }
+
+            return new DownloadResult(failedFiles);
+        }
+
+        private async Task<UploadResult> UploadAsync(RunnerActionPluginExecutionContext context, int uploaderId, CancellationToken token)
+        {
+            List<string> failedFiles = new List<string>();
+            long uploadedSize = 0;
+            string fileToUpload;
+            Stopwatch uploadTimer = new Stopwatch();
+            while (_fileUploadQueue.TryDequeue(out fileToUpload))
+            {
+                token.ThrowIfCancellationRequested();
+                try
+                {
+                    using (FileStream fs = File.Open(fileToUpload, FileMode.Open, FileAccess.Read, FileShare.Read))
+                    {
+                        string itemPath = (_containerPath.TrimEnd('/') + "/" + fileToUpload.Remove(0, _sourceParentDirectory.Length + 1)).Replace('\\', '/');
+                        uploadTimer.Restart();
+                        bool catchExceptionDuringUpload = false;
+                        HttpResponseMessage response = null;
+                        try
+                        {
+                            response = await _fileContainerHttpClient.UploadFileAsync(_containerId, itemPath, fs, _projectId, cancellationToken: token, chunkSize: 4 * 1024 * 1024);
+                        }
+                        catch (OperationCanceledException) when (token.IsCancellationRequested)
+                        {
+                            context.Output($"File upload has been cancelled during upload file: '{fileToUpload}'.");
+                            if (response != null)
+                            {
+                                response.Dispose();
+                                response = null;
+                            }
+
+                            throw;
+                        }
+                        catch (Exception ex)
+                        {
+                            catchExceptionDuringUpload = true;
+                            context.Output($"Fail to upload '{fileToUpload}' due to '{ex.Message}'.");
+                            context.Output(ex.ToString());
+                        }
+
+                        uploadTimer.Stop();
+                        if (catchExceptionDuringUpload || (response != null && response.StatusCode != HttpStatusCode.Created))
+                        {
+                            if (response != null)
+                            {
+                                context.Output($"Unable to copy file to server StatusCode={response.StatusCode}: {response.ReasonPhrase}. Source file path: {fileToUpload}. Target server path: {itemPath}");
+                            }
+
+                            // output detail upload trace for the file.
+                            ConcurrentQueue<string> logQueue;
+                            if (_fileUploadTraceLog.TryGetValue(itemPath, out logQueue))
+                            {
+                                context.Output($"Detail upload trace for file that fail to upload: {itemPath}");
+                                string message;
+                                while (logQueue.TryDequeue(out message))
+                                {
+                                    context.Output(message);
+                                }
+                            }
+
+                            // tracking file that failed to upload.
+                            failedFiles.Add(fileToUpload);
+                        }
+                        else
+                        {
+                            context.Debug($"File: '{fileToUpload}' took {uploadTimer.ElapsedMilliseconds} milliseconds to finish upload");
+                            uploadedSize += fs.Length;
+                            // debug detail upload trace for the file.
+                            ConcurrentQueue<string> logQueue;
+                            if (_fileUploadTraceLog.TryGetValue(itemPath, out logQueue))
+                            {
+                                context.Debug($"Detail upload trace for file: {itemPath}");
+                                string message;
+                                while (logQueue.TryDequeue(out message))
+                                {
+                                    context.Debug(message);
+                                }
+                            }
+                        }
+
+                        if (response != null)
+                        {
+                            response.Dispose();
+                            response = null;
+                        }
+                    }
+
+                    Interlocked.Increment(ref _uploadFilesProcessed);
+                }
+                catch (Exception ex)
+                {
+                    context.Output($"File error '{ex.Message}' when uploading file '{fileToUpload}'.");
+                    throw ex;
+                }
+            }
+
+            return new UploadResult(failedFiles, uploadedSize);
+        }
+
+        private async Task UploadReportingAsync(RunnerActionPluginExecutionContext context, int totalFiles, CancellationToken token)
+        {
+            int traceInterval = 0;
+            while (!_uploadFinished.Task.IsCompleted && !token.IsCancellationRequested)
+            {
+                bool hasDetailProgress = false;
+                foreach (var file in _fileUploadProgressLog)
+                {
+                    string message;
+                    while (file.Value.TryDequeue(out message))
+                    {
+                        hasDetailProgress = true;
+                        context.Output(message);
+                    }
+                }
+
+                // trace total file progress every 25 seconds when there is no file level detail progress
+                if (++traceInterval % 2 == 0 && !hasDetailProgress)
+                {
+                    context.Output($"Total file: {totalFiles} ---- Processed file: {_uploadFilesProcessed} ({(_uploadFilesProcessed * 100) / totalFiles}%)");
+                }
+
+                await Task.WhenAny(_uploadFinished.Task, Task.Delay(5000, token));
+            }
+        }
+
+        private async Task DownloadReportingAsync(RunnerActionPluginExecutionContext context, int totalFiles, CancellationToken token)
+        {
+            int traceInterval = 0;
+            while (!_downloadFinished.Task.IsCompleted && !token.IsCancellationRequested)
+            {
+                // trace total file progress every 10 seconds when there is no file level detail progress
+                if (++traceInterval % 2 == 0)
+                {
+                    context.Output($"Total file: {totalFiles} ---- Downloaded file: {_downloadFilesProcessed} ({(_downloadFilesProcessed * 100) / totalFiles}%)");
+                }
+
+                await Task.WhenAny(_downloadFinished.Task, Task.Delay(5000, token));
+            }
+        }
+
+        private void UploadFileTraceReportReceived(object sender, ReportTraceEventArgs e)
+        {
+            ConcurrentQueue<string> logQueue = _fileUploadTraceLog.GetOrAdd(e.File, new ConcurrentQueue<string>());
+            logQueue.Enqueue(e.Message);
+        }
+
+        private void UploadFileProgressReportReceived(object sender, ReportProgressEventArgs e)
+        {
+            ConcurrentQueue<string> progressQueue = _fileUploadProgressLog.GetOrAdd(e.File, new ConcurrentQueue<string>());
+            progressQueue.Enqueue($"Uploading '{e.File}' ({(e.CurrentChunk * 100) / e.TotalChunks}%)");
+        }
+    }
+
+    public class UploadResult
+    {
+        public UploadResult()
+        {
+            FailedFiles = new List<string>();
+            TotalFileSizeUploaded = 0;
+        }
+
+        public UploadResult(List<string> failedFiles, long totalFileSizeUploaded)
+        {
+            FailedFiles = failedFiles;
+            TotalFileSizeUploaded = totalFileSizeUploaded;
+        }
+        public List<string> FailedFiles { get; set; }
+
+        public long TotalFileSizeUploaded { get; set; }
+
+        public void AddUploadResult(UploadResult resultToAdd)
+        {
+            this.FailedFiles.AddRange(resultToAdd.FailedFiles);
+            this.TotalFileSizeUploaded += resultToAdd.TotalFileSizeUploaded;
+        }
+    }
+
+    public class DownloadInfo
+    {
+        public DownloadInfo(string itemPath, string localPath)
+        {
+            this.ItemPath = itemPath;
+            this.LocalPath = localPath;
+        }
+
+        public string ItemPath { get; set; }
+        public string LocalPath { get; set; }
+    }
+
+    public class DownloadResult
+    {
+        public DownloadResult()
+        {
+            FailedFiles = new List<DownloadInfo>();
+        }
+
+        public DownloadResult(List<DownloadInfo> failedFiles)
+        {
+            FailedFiles = failedFiles;
+        }
+        public List<DownloadInfo> FailedFiles { get; set; }
+
+        public void AddDownloadResult(DownloadResult resultToAdd)
+        {
+            this.FailedFiles.AddRange(resultToAdd.FailedFiles);
+        }
+    }
+}

src/Runner.Plugins/Artifact/PublishArtifact.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using GitHub.Build.WebApi;
+using GitHub.Services.Common;
+using GitHub.DistributedTask.WebApi;
+using GitHub.Runner.Sdk;
+
+namespace GitHub.Runner.Plugins.Artifact
+{
+    public class PublishArtifact : IRunnerActionPlugin
+    {
+        private static class PublishArtifactInputNames
+        {
+            public static readonly string ArtifactName = "artifactName";
+            public static readonly string Name = "name";
+            public static readonly string Path = "path";
+        }
+
+        public async Task RunAsync(
+            RunnerActionPluginExecutionContext context,
+            CancellationToken token)
+        {
+            string artifactName = context.GetInput(PublishArtifactInputNames.ArtifactName, required: false);  // Back compat since we rename input `artifactName` to `name`
+            if (string.IsNullOrEmpty(artifactName))
+            {
+                artifactName = context.GetInput(PublishArtifactInputNames.Name, required: true);
+            }
+
+            string targetPath = context.GetInput(PublishArtifactInputNames.Path, required: true);
+            string defaultWorkingDirectory = context.GetGitHubContext("workspace");
+
+            targetPath = Path.IsPathFullyQualified(targetPath) ? targetPath : Path.GetFullPath(Path.Combine(defaultWorkingDirectory, targetPath));
+
+            if (String.IsNullOrWhiteSpace(artifactName))
+            {
+                throw new ArgumentException($"Artifact name can not be empty string");
+            }
+
+            if (Path.GetInvalidFileNameChars().Any(x => artifactName.Contains(x)))
+            {
+                throw new ArgumentException($"Artifact name is not valid: {artifactName}. It cannot contain '\\', '/', \"', ':', '<', '>', '|', '*', and '?'");
+            }
+
+            // Project ID
+            Guid projectId = new Guid(context.Variables.GetValueOrDefault(BuildVariables.TeamProjectId)?.Value ?? Guid.Empty.ToString());
+
+            // Build ID
+            string buildIdStr = context.Variables.GetValueOrDefault(BuildVariables.BuildId)?.Value ?? string.Empty;
+            if (!int.TryParse(buildIdStr, out int buildId))
+            {
+                throw new ArgumentException($"Run Id is not an Int32: {buildIdStr}");
+            }
+
+            string fullPath = Path.GetFullPath(targetPath);
+            bool isFile = File.Exists(fullPath);
+            bool isDir = Directory.Exists(fullPath);
+            if (!isFile && !isDir)
+            {
+                // if local path is neither file nor folder
+                throw new FileNotFoundException($"Path does not exist {targetPath}");
+            }
+
+            // Container ID
+            string containerIdStr = context.Variables.GetValueOrDefault(BuildVariables.ContainerId)?.Value ?? string.Empty;
+            if (!long.TryParse(containerIdStr, out long containerId))
+            {
+                throw new ArgumentException($"Container Id is not a Int64: {containerIdStr}");
+            }
+
+            context.Output($"Uploading artifact '{artifactName}' from '{fullPath}' for run #{buildId}");
+
+            FileContainerServer fileContainerHelper = new FileContainerServer(context.VssConnection, projectId, containerId, artifactName);
+            long size = await fileContainerHelper.CopyToContainerAsync(context, fullPath, token);
+            var propertiesDictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            propertiesDictionary.Add("artifactsize", size.ToString());
+
+            string fileContainerFullPath = StringUtil.Format($"#/{containerId}/{artifactName}");
+            context.Output($"Uploaded '{fullPath}' to server");
+
+            BuildServer buildHelper = new BuildServer(context.VssConnection);
+            string jobId = context.Variables.GetValueOrDefault(WellKnownDistributedTaskVariables.JobId).Value ?? string.Empty;
+            var artifact = await buildHelper.AssociateArtifact(projectId, buildId, jobId, artifactName, ArtifactResourceTypes.Container, fileContainerFullPath, propertiesDictionary, token);
+            context.Output($"Associated artifact {artifactName} ({artifact.Id}) with run #{buildId}");
+        }
+    }
+}