.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,18 +1,12 @@
 ---
-name: 🛑 Report a bug in the runner application
-about: If you have issues with GitHub Actions, please follow the "support for GitHub Actions" link, below.
+name: Bug report
+about: Create a report to help us improve
 title: ''
 labels: bug
 assignees: ''
 
 ---
 
-<!--
-👋 You're opening a bug report against the GitHub Actions **runner application**.
-
-🛑 Please stop if you're not certain that the bug you're seeing is in the runner application - if you have general problems with actions, workflows, or runners, please see the [GitHub Community Support Forum](https://github.community/c/code-to-cloud/52) which is actively monitored.  Using the forum ensures that we route your problem to the correct team.  😃
--->
-
 **Describe the bug**
 A clear and concise description of what the bug is.
 

.github/ISSUE_TEMPLATE/config.yml

@@ -1,11 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: ✅ Support for GitHub Actions
-    url: https://github.community/c/code-to-cloud/52
-    about: If you have questions about GitHub Actions or need support writing workflows, please ask in the GitHub Community Support forum.
-  - name: ✅ Feedback and suggestions for GitHub Actions
-    url: https://github.com/github/feedback/discussions/categories/actions-and-packages-feedback
-    about: If you have feedback or suggestions about GitHub Actions, please open a discussion (or add to an existing one) in the GitHub Actions Feedback.  GitHub Actions Product Managers and Engineers monitor the feedback forum.
-  - name: ‼️ GitHub Security Bug Bounty
-    url: https://bounty.github.com/
-    about: Please report security vulnerabilities here.

.github/ISSUE_TEMPLATE/enhancement_request.md

@@ -1,24 +1,19 @@
 ---
-name: 🛑 Request a feature in the runner application 
-about: If you have feature requests for GitHub Actions, please use the "feedback and suggestions for GitHub Actions" link below.
+name: Feature Request
+about: Create a request to help us improve
 title: ''
 labels: enhancement
 assignees: ''
 
 ---
 
-<!--
-👋 You're opening a request for an enhancement in the GitHub Actions **runner application**.
+Thank you 🙇‍♀ for wanting to create a feature in this repository. Before you do, please ensure you are filing the issue in the right place. Issues should only be opened on if the issue **relates to code in this repository**.  
 
-🛑 Please stop if you're not certain that the feature you want is in the runner application - if you have a suggestion for improving GitHub Actions, please see the [GitHub Actions Feedback](https://github.com/github/feedback/discussions/categories/actions-and-packages-feedback) discussion forum which is actively monitored.  Using the forum ensures that we route your problem to the correct team.  😃
-
-Some additional useful links:
 * If you have found a security issue [please submit it here](https://hackerone.com/github)
 * If you have questions or issues with the service, writing workflows or actions, then please [visit the GitHub Community Forum's Actions Board](https://github.community/t5/GitHub-Actions/bd-p/actions)
-* If you are having an issue or have a question about GitHub Actions then please [contact customer support](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/about-github-actions#contacting-support)
+* If you are having an issue or question about GitHub Actions then please [contact customer support](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/about-github-actions#contacting-support)
 
 If you have a feature request that is relevant to this repository, the runner, then please include the information below:
--->
 
 **Describe the enhancement**
 A clear and concise description of what the features or enhancement you need.

.github/workflows/codeql.yml

@@ -1,12 +1,7 @@
 name: "Code Scanning - Action"
 
-permissions:
-  security-events: write
-
 on:
   push:
-    branches: 
-      - main
   pull_request:
   schedule:
     - cron: '0 0 * * 0'

releaseNote.md

@@ -1,21 +1,15 @@
 ## Features
 
-- Bump runtime to dotnet 6 (#1471)
-- Show service container logs on teardown (#1563)
+- n/a
 
 ## Bugs
 
-- Add masks for multiline secrets from ::add-mask:: (#1521)
-- fix Log size and retention settings not work (#1507)
-- Refactor SelfUpdater adding L0 tests. (#1564)
-- Fix test failure: /bin/sleep on Macos 11 (Monterey) does not accept the suffix s. (#1472)
+- Revert node12 version due to fs.copyFileSync hang #1537
 
 
 ## Misc
 
-- Update dependency check for dotnet 6. (#1551)
-- Produce trimmed down runner packages. (#1556)
-- Deleted extra background in github-praph.png, which is displayed in README.md (#1432)
+- n/a
 
 
 ## Windows x64

releaseVersion

@@ -1 +1 @@
-2.286.0
+<Update to ./src/runnerversion when creating release>

src/Runner.Listener/SelfUpdater.cs

@@ -29,14 +29,24 @@ namespace GitHub.Runner.Listener
     public class SelfUpdater : RunnerService, ISelfUpdater
     {
         private static string _packageType = "agent";
+        private static string _dotnetRuntime = "dotnetRuntime";
+        private static string _externals = "externals";
         private static string _platform = BuildConstants.RunnerPackage.PackageName;
+        private readonly Dictionary<string, string> _contentHash = new Dictionary<string, string>()
+        {
+            {_dotnetRuntime, ""},
+            {_externals, ""}
+        };
 
         private PackageMetadata _targetPackage;
         private ITerminal _terminal;
         private IRunnerServer _runnerServer;
         private int _poolId;
         private int _agentId;
-        private readonly List<string> _updateTrace = new List<string>();
+        private Task _cloneAndCalculateContentHashTask;
+        private string _dotnetRuntimeCloneDirectory;
+        private string _externalsCloneDirectory;
+        private List<string> _updateTrace = new List<string>();
 
         public bool Busy { get; private set; }
 
@@ -50,6 +60,8 @@ namespace GitHub.Runner.Listener
             var settings = configStore.GetSettings();
             _poolId = settings.PoolId;
             _agentId = settings.AgentId;
+            _dotnetRuntimeCloneDirectory = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Work), "__dotnet_runtime__");
+            _externalsCloneDirectory = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Work), "__externals__");
         }
 
         public async Task<bool> SelfUpdate(AgentRefreshMessage updateMessage, IJobDispatcher jobDispatcher, bool restartInteractiveRunner, CancellationToken token)
@@ -59,6 +71,11 @@ namespace GitHub.Runner.Listener
             {
                 var totalUpdateTime = Stopwatch.StartNew();
 
+                // Copy dotnet runtime and externals of current runner to a temp folder
+                // So we can re-use them with trim down runner package, if possible.
+                // This process is best effort, if we can't use trim down runner package, we will just go with the full package.
+                _cloneAndCalculateContentHashTask = CloneAndCalculateAssertsHash(_dotnetRuntimeCloneDirectory, _externalsCloneDirectory);
+
                 if (!await UpdateNeeded(updateMessage.TargetVersion, token))
                 {
                     Trace.Info($"Can't find available update package.");
@@ -67,11 +84,14 @@ namespace GitHub.Runner.Listener
 
                 Trace.Info($"An update is available.");
                 _updateTrace.Add($"RunnerPlatform: {_targetPackage.Platform}");
+                _updateTrace.Add($"DotnetRuntimeHash: {_contentHash[_dotnetRuntime]}");
+                _updateTrace.Add($"ExternalsHash: {_contentHash[_externals]}");
 
                 // Print console line that warn user not shutdown runner.
                 await UpdateRunnerUpdateStateAsync("Runner update in progress, do not shutdown runner.");
                 await UpdateRunnerUpdateStateAsync($"Downloading {_targetPackage.Version} runner");
 
+                await _cloneAndCalculateContentHashTask;
                 await DownloadLatestRunner(token);
                 Trace.Info($"Download latest runner and unzip into runner root.");
 
@@ -108,23 +128,77 @@ namespace GitHub.Runner.Listener
 
                 totalUpdateTime.Stop();
 
+                _updateTrace.Add($"RestartInteractiveRunner: {restartInteractiveRunner}");
                 _updateTrace.Add($"TotalUpdateTime: {totalUpdateTime.ElapsedMilliseconds}ms");
                 await UpdateRunnerUpdateStateAsync("Runner will exit shortly for update, should be back online within 10 seconds.");
 
                 return true;
             }
-            catch (Exception ex)
-            {
-                _updateTrace.Add(ex.ToString());
-                throw;
-            }
             finally
             {
-                await UpdateRunnerUpdateStateAsync("Runner update process finished.");
                 Busy = false;
             }
         }
 
+        private async Task CloneAndCalculateAssertsHash(string dotnetRuntimeCloneDirectory, string externalsCloneDirectory)
+        {
+            var runtimeCloneTask = CloneDotnetRuntime(dotnetRuntimeCloneDirectory);
+            var externalsCloneTask = CloneExternals(externalsCloneDirectory);
+
+            var waitingTasks = new List<Task>()
+            {
+                runtimeCloneTask,
+                externalsCloneTask
+            };
+
+            while (waitingTasks.Count > 0)
+            {
+                var completedTask = await Task.WhenAny(waitingTasks);
+                if (completedTask == runtimeCloneTask)
+                {
+                    try
+                    {
+                        if (await runtimeCloneTask)
+                        {
+                            var runtimeHash = await HashFiles(dotnetRuntimeCloneDirectory);
+                            Trace.Info($"Runtime content hash: {runtimeHash}");
+                            _contentHash[_dotnetRuntime] = runtimeHash;
+                        }
+                        else
+                        {
+                            Trace.Error($"Skip compute hash since clone dotnet runtime failed.");
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Trace.Error($"Fail to hash runtime content: {ex.Message}");
+                    }
+                }
+                else if (completedTask == externalsCloneTask)
+                {
+                    try
+                    {
+                        if (await externalsCloneTask)
+                        {
+                            var externalsHash = await HashFiles(externalsCloneDirectory);
+                            Trace.Info($"Externals content hash: {externalsHash}");
+                            _contentHash[_externals] = externalsHash;
+                        }
+                        else
+                        {
+                            Trace.Error($"Skip compute hash since clone externals failed.");
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Trace.Error($"Fail to hash externals content: {ex.Message}");
+                    }
+                }
+
+                waitingTasks.Remove(completedTask);
+            }
+        }
+
         private async Task<bool> UpdateNeeded(string targetVersion, CancellationToken token)
         {
             // when talk to old version server, always prefer latest package.
@@ -158,62 +232,6 @@ namespace GitHub.Runner.Listener
             return serverVersion.CompareTo(runnerVersion) > 0;
         }
 
-        /// <summary>
-        /// _work
-        ///     \_update
-        ///            \bin
-        ///            \externals
-        ///            \run.sh
-        ///            \run.cmd
-        ///            \package.zip //temp download .zip/.tar.gz
-        /// </summary>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        private async Task DownloadLatestRunner(CancellationToken token)
-        {
-            string latestRunnerDirectory = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Work), Constants.Path.UpdateDirectory);
-            IOUtil.DeleteDirectory(latestRunnerDirectory, token);
-            Directory.CreateDirectory(latestRunnerDirectory);
-
-            string archiveFile = null;
-            var packageDownloadUrl = _targetPackage.DownloadUrl;
-            var packageHashValue = _targetPackage.HashValue;
-            _updateTrace.Add($"DownloadUrl: {packageDownloadUrl}");
-
-            try
-            {
-                archiveFile = await DownLoadRunner(latestRunnerDirectory, packageDownloadUrl, packageHashValue, token);
-
-                if (string.IsNullOrEmpty(archiveFile))
-                {
-                    throw new TaskCanceledException($"Runner package '{packageDownloadUrl}' failed after {Constants.RunnerDownloadRetryMaxAttempts} download attempts");
-                }
-
-                await ValidateRunnerHash(archiveFile, packageHashValue);
-
-                await ExtractRunnerPackage(archiveFile, latestRunnerDirectory, token);
-            }
-            finally
-            {
-                try
-                {
-                    // delete .zip file
-                    if (!string.IsNullOrEmpty(archiveFile) && File.Exists(archiveFile))
-                    {
-                        Trace.Verbose("Deleting latest runner package zip: {0}", archiveFile);
-                        IOUtil.DeleteFile(archiveFile);
-                    }
-                }
-                catch (Exception ex)
-                {
-                    //it is not critical if we fail to delete the .zip file
-                    Trace.Warning("Failed to delete runner package zip '{0}'. Exception: {1}", archiveFile, ex);
-                }
-            }
-
-            await CopyLatestRunnerToRoot(latestRunnerDirectory, token);
-        }
-
         private async Task<string> DownLoadRunner(string downloadDirectory, string packageDownloadUrl, string packageHashValue, CancellationToken token)
         {
             var stopWatch = Stopwatch.StartNew();
@@ -281,7 +299,6 @@ namespace GitHub.Runner.Listener
                             }
 
                             Trace.Info($"Downloading {packageDownloadUrl}");
-
                             using (FileStream fs = new FileStream(archiveFile, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 4096, useAsync: true))
                             using (Stream result = await httpClient.GetStreamAsync(packageDownloadUrl))
                             {
@@ -319,6 +336,26 @@ namespace GitHub.Runner.Listener
 
             if (downloadSucceeded)
             {
+                // Validate Hash Matches if it is provided
+                using (FileStream stream = File.OpenRead(archiveFile))
+                {
+                    if (!string.IsNullOrEmpty(packageHashValue))
+                    {
+                        using (SHA256 sha256 = SHA256.Create())
+                        {
+                            byte[] srcHashBytes = await sha256.ComputeHashAsync(stream);
+                            var hash = PrimitiveExtensions.ConvertToHexString(srcHashBytes);
+                            if (hash != packageHashValue)
+                            {
+                                // Hash did not match, we can't recover from this, just throw
+                                throw new Exception($"Computed runner hash {hash} did not match expected Runner Hash {packageHashValue} for {_targetPackage.Filename}");
+                            }
+
+                            Trace.Info($"Validated Runner Hash matches {_targetPackage.Filename} : {packageHashValue}");
+                        }
+                    }
+                }
+
                 return archiveFile;
             }
             else
@@ -327,32 +364,6 @@ namespace GitHub.Runner.Listener
             }
         }
 
-        private async Task ValidateRunnerHash(string archiveFile, string packageHashValue)
-        {
-            var stopWatch = Stopwatch.StartNew();
-            // Validate Hash Matches if it is provided
-            using (FileStream stream = File.OpenRead(archiveFile))
-            {
-                if (!string.IsNullOrEmpty(packageHashValue))
-                {
-                    using (SHA256 sha256 = SHA256.Create())
-                    {
-                        byte[] srcHashBytes = await sha256.ComputeHashAsync(stream);
-                        var hash = PrimitiveExtensions.ConvertToHexString(srcHashBytes);
-                        if (hash != packageHashValue)
-                        {
-                            // Hash did not match, we can't recover from this, just throw
-                            throw new Exception($"Computed runner hash {hash} did not match expected Runner Hash {packageHashValue} for {_targetPackage.Filename}");
-                        }
-
-                        stopWatch.Stop();
-                        Trace.Info($"Validated Runner Hash matches {_targetPackage.Filename} : {packageHashValue}");
-                        _updateTrace.Add($"ValidateHashTime: {stopWatch.ElapsedMilliseconds}ms");
-                    }
-                }
-            }
-        }
-
         private async Task ExtractRunnerPackage(string archiveFile, string extractDirectory, CancellationToken token)
         {
             var stopWatch = Stopwatch.StartNew();
@@ -405,10 +416,232 @@ namespace GitHub.Runner.Listener
             Trace.Info($"Finished getting latest runner package at: {extractDirectory}.");
             _updateTrace.Add($"PackageExtractTime: {stopWatch.ElapsedMilliseconds}ms");
         }
-
-        private Task CopyLatestRunnerToRoot(string latestRunnerDirectory, CancellationToken token)
+        /// <summary>
+        /// _work
+        ///     \_update
+        ///            \bin
+        ///            \externals
+        ///            \run.sh
+        ///            \run.cmd
+        ///            \package.zip //temp download .zip/.tar.gz
+        /// </summary>
+        /// <param name="token"></param>
+        /// <returns></returns>
+        private async Task DownloadLatestRunner(CancellationToken token)
         {
+            string latestRunnerDirectory = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Work), Constants.Path.UpdateDirectory);
+            IOUtil.DeleteDirectory(latestRunnerDirectory, token);
+            Directory.CreateDirectory(latestRunnerDirectory);
+
+            string archiveFile = null;
             var stopWatch = Stopwatch.StartNew();
+            var packageDownloadUrl = _targetPackage.DownloadUrl;
+            var packageHashValue = _targetPackage.HashValue;
+            var runtimeTrimmed = false;
+            var externalsTrimmed = false;
+
+            if (_contentHash.Count > 0 && _targetPackage.TrimmedPackages.Count > 0)
+            {
+                Trace.Info($"Trimmed packages info: {JsonUtility.ToString(_targetPackage.TrimmedPackages)}");
+                // Try to see whether we can use any size trimmed down package to speed up runner updates.
+                foreach (var trimmedPackage in _targetPackage.TrimmedPackages)
+                {
+                    string trimmedRuntimeHash;
+                    string trimmedExternalsHash;
+                    if (trimmedPackage.TrimmedContents.Count == 2 &&
+                        trimmedPackage.TrimmedContents.TryGetValue(_dotnetRuntime, out trimmedRuntimeHash) &&
+                        trimmedRuntimeHash == _contentHash[_dotnetRuntime] &&
+                        trimmedPackage.TrimmedContents.TryGetValue(_externals, out trimmedExternalsHash) &&
+                        trimmedExternalsHash == _contentHash[_externals])
+                    {
+                        Trace.Info($"Use trimmed (runtime+externals) package '{trimmedPackage.DownloadUrl}' to update runner.");
+                        packageDownloadUrl = trimmedPackage.DownloadUrl;
+                        packageHashValue = trimmedPackage.HashValue;
+                        runtimeTrimmed = true;
+                        externalsTrimmed = true;
+                        break;
+                    }
+                    else if (trimmedPackage.TrimmedContents.Count == 1 &&
+                             trimmedPackage.TrimmedContents.TryGetValue(_dotnetRuntime, out trimmedRuntimeHash) &&
+                             trimmedRuntimeHash == _contentHash[_dotnetRuntime])
+                    {
+                        Trace.Info($"Use trimmed (runtime) package '{trimmedPackage.DownloadUrl}' to update runner.");
+                        packageDownloadUrl = trimmedPackage.DownloadUrl;
+                        packageHashValue = trimmedPackage.HashValue;
+                        runtimeTrimmed = true;
+                        break;
+                    }
+                    else if (trimmedPackage.TrimmedContents.Count == 1 &&
+                             trimmedPackage.TrimmedContents.TryGetValue(_externals, out trimmedExternalsHash) &&
+                             trimmedExternalsHash == _contentHash[_externals])
+                    {
+                        Trace.Info($"Use trimmed (externals) package '{trimmedPackage.DownloadUrl}' to update runner.");
+                        packageDownloadUrl = trimmedPackage.DownloadUrl;
+                        packageHashValue = trimmedPackage.HashValue;
+                        externalsTrimmed = true;
+                        break;
+                    }
+                    else
+                    {
+                        Trace.Info($"Can't use trimmed package from '{trimmedPackage.DownloadUrl}' since the current runner does not carry those trimmed content.");
+                    }
+                }
+            }
+
+            _updateTrace.Add($"DownloadUrl: {packageDownloadUrl}");
+            _updateTrace.Add($"RuntimeTrimmed: {runtimeTrimmed}");
+            _updateTrace.Add($"ExternalsTrimmed: {externalsTrimmed}");
+
+            try
+            {
+                archiveFile = await DownLoadRunner(latestRunnerDirectory, packageDownloadUrl, packageHashValue, token);
+
+                if (string.IsNullOrEmpty(archiveFile))
+                {
+                    throw new TaskCanceledException($"Runner package '{archiveFile}' failed after {Constants.RunnerDownloadRetryMaxAttempts} download attempts");
+                }
+
+                await ExtractRunnerPackage(archiveFile, latestRunnerDirectory, token);
+            }
+            finally
+            {
+                try
+                {
+                    // delete .zip file
+                    if (!string.IsNullOrEmpty(archiveFile) && File.Exists(archiveFile))
+                    {
+                        Trace.Verbose("Deleting latest runner package zip: {0}", archiveFile);
+                        IOUtil.DeleteFile(archiveFile);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    //it is not critical if we fail to delete the .zip file
+                    Trace.Warning("Failed to delete runner package zip '{0}'. Exception: {1}", archiveFile, ex);
+                }
+            }
+
+            if (runtimeTrimmed || externalsTrimmed)
+            {
+                stopWatch.Restart();
+            }
+
+            bool trimmedRuntimeBroken = false;
+            bool trimmedExternalsBroken = false;
+            // Copy the current runner's dotnet runtime if we are using a dotnet runtime trimmed package
+            // Execute the runner.listener to make sure the copied runtime is working.
+            if (runtimeTrimmed)
+            {
+                Trace.Info($"Copy {_dotnetRuntimeCloneDirectory} to {Path.Combine(latestRunnerDirectory, Constants.Path.BinDirectory)}.");
+                IOUtil.CopyDirectory(_dotnetRuntimeCloneDirectory, Path.Combine(latestRunnerDirectory, Constants.Path.BinDirectory), token);
+
+                // try run the runner executable to see if current dotnet runtime + future runner binary works fine.
+                var newRunnerBinary = Path.Combine(latestRunnerDirectory, Constants.Path.BinDirectory, "Runner.Listener");
+                using (var p = HostContext.CreateService<IProcessInvoker>())
+                {
+                    p.ErrorDataReceived += (_, data) =>
+                    {
+                        if (!string.IsNullOrEmpty(data.Data))
+                        {
+                            Trace.Error(data.Data);
+                        }
+                    };
+                    p.OutputDataReceived += (_, data) =>
+                    {
+                        if (!string.IsNullOrEmpty(data.Data))
+                        {
+                            Trace.Info(data.Data);
+                        }
+                    };
+                    var exitCode = await p.ExecuteAsync(HostContext.GetDirectory(WellKnownDirectory.Root), newRunnerBinary, "--version", null, token);
+                    if (exitCode != 0)
+                    {
+                        Trace.Error($"{newRunnerBinary} --version failed with exit code {exitCode}");
+                        trimmedRuntimeBroken = true;
+                    }
+                }
+            }
+
+            // Copy the current runner's externals if we are using a externals trimmed package
+            // Execute the node.js to make sure the copied externals is working.
+            if (externalsTrimmed && !trimmedRuntimeBroken)
+            {
+                Trace.Info($"Copy {_externalsCloneDirectory} to {Path.Combine(latestRunnerDirectory, Constants.Path.ExternalsDirectory)}.");
+                IOUtil.CopyDirectory(_externalsCloneDirectory, Path.Combine(latestRunnerDirectory, Constants.Path.ExternalsDirectory), token);
+
+                // try run node.js to see if current node.js works fine after copy over to new location.
+                var newNodeBinary = Path.Combine(latestRunnerDirectory, Constants.Path.ExternalsDirectory, "node12", "bin", $"node{IOUtil.ExeExtension}");
+                using (var p = HostContext.CreateService<IProcessInvoker>())
+                {
+                    p.ErrorDataReceived += (_, data) =>
+                    {
+                        if (!string.IsNullOrEmpty(data.Data))
+                        {
+                            Trace.Error(data.Data);
+                        }
+                    };
+                    p.OutputDataReceived += (_, data) =>
+                    {
+                        if (!string.IsNullOrEmpty(data.Data))
+                        {
+                            Trace.Info(data.Data);
+                        }
+                    };
+                    var exitCode = await p.ExecuteAsync(HostContext.GetDirectory(WellKnownDirectory.Root), newNodeBinary, "--version", null, token);
+                    if (exitCode != 0)
+                    {
+                        Trace.Error($"{newNodeBinary} --version failed with exit code {exitCode}");
+                        trimmedExternalsBroken = true;
+                    }
+                }
+            }
+
+            if (trimmedExternalsBroken || trimmedRuntimeBroken)
+            {
+                Trace.Error($"The trimmed down runner package is not working properly, fail back to re-download the full runner package.");
+                IOUtil.DeleteDirectory(latestRunnerDirectory, token);
+                Directory.CreateDirectory(latestRunnerDirectory);
+
+                packageDownloadUrl = _targetPackage.DownloadUrl;
+                packageHashValue = _targetPackage.HashValue;
+
+                try
+                {
+                    archiveFile = await DownLoadRunner(latestRunnerDirectory, packageDownloadUrl, packageHashValue, token);
+
+                    if (string.IsNullOrEmpty(archiveFile))
+                    {
+                        throw new TaskCanceledException($"Runner package '{archiveFile}' failed after {Constants.RunnerDownloadRetryMaxAttempts} download attempts");
+                    }
+
+                    await ExtractRunnerPackage(archiveFile, latestRunnerDirectory, token);
+                }
+                finally
+                {
+                    try
+                    {
+                        // delete .zip file
+                        if (!string.IsNullOrEmpty(archiveFile) && File.Exists(archiveFile))
+                        {
+                            Trace.Verbose("Deleting latest runner package zip: {0}", archiveFile);
+                            IOUtil.DeleteFile(archiveFile);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        //it is not critical if we fail to delete the .zip file
+                        Trace.Warning("Failed to delete runner package zip '{0}'. Exception: {1}", archiveFile, ex);
+                    }
+                }
+            }
+
+            if (runtimeTrimmed || externalsTrimmed)
+            {
+                stopWatch.Stop();
+                _updateTrace.Add($"VerifyTrimmedPackageTime: {stopWatch.ElapsedMilliseconds}ms");
+            }
+
+            stopWatch.Restart();
             // copy latest runner into runner root folder
             // copy bin from _work/_update -> bin.version under root
             string binVersionDir = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Root), $"{Constants.Path.BinDirectory}.{_targetPackage.Version}");
@@ -437,7 +670,6 @@ namespace GitHub.Runner.Listener
 
             stopWatch.Stop();
             _updateTrace.Add($"CopyRunnerToRootTime: {stopWatch.ElapsedMilliseconds}ms");
-            return Task.CompletedTask;
         }
 
         private void DeletePreviousVersionRunnerBackup(CancellationToken token)
@@ -585,5 +817,120 @@ namespace GitHub.Runner.Listener
                 Trace.Info($"Catch exception during report update state, ignore this error and continue auto-update.");
             }
         }
+
+        private async Task<bool> CloneDotnetRuntime(string runtimeDir)
+        {
+            try
+            {
+                Trace.Info($"Cloning dotnet runtime to {runtimeDir}");
+                IOUtil.DeleteDirectory(runtimeDir, CancellationToken.None);
+                Directory.CreateDirectory(runtimeDir);
+
+                var assembly = Assembly.GetExecutingAssembly();
+                var assertsContent = default(string);
+                using (var stream = assembly.GetManifestResourceStream("GitHub.Runner.Listener.runnercoreassets"))
+                using (var streamReader = new StreamReader(stream))
+                {
+                    assertsContent = await streamReader.ReadToEndAsync();
+                }
+
+                var runnerCoreAssets = assertsContent.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
+                if (runnerCoreAssets.Length > 0)
+                {
+                    var binDir = HostContext.GetDirectory(WellKnownDirectory.Bin);
+                    IOUtil.CopyDirectory(binDir, runtimeDir, CancellationToken.None);
+
+                    var clonedFile = 0;
+                    foreach (var file in Directory.EnumerateFiles(runtimeDir, "*", SearchOption.AllDirectories))
+                    {
+                        if (runnerCoreAssets.Any(x => file.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar).EndsWith(x.Trim())))
+                        {
+                            Trace.Verbose($"{file} is part of the runner core, delete from cloned runtime directory.");
+                            IOUtil.DeleteFile(file);
+                        }
+                        else
+                        {
+                            clonedFile++;
+                        }
+                    }
+
+                    Trace.Info($"Successfully cloned dotnet runtime to {runtimeDir}. Total files: {clonedFile}");
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                Trace.Error($"Fail to clone dotnet runtime to {runtimeDir}");
+                Trace.Error(ex);
+            }
+
+            return false;
+        }
+
+        private Task<bool> CloneExternals(string externalsDir)
+        {
+            try
+            {
+                Trace.Info($"Cloning externals to {externalsDir}");
+                IOUtil.DeleteDirectory(externalsDir, CancellationToken.None);
+                Directory.CreateDirectory(externalsDir);
+                IOUtil.CopyDirectory(HostContext.GetDirectory(WellKnownDirectory.Externals), externalsDir, CancellationToken.None);
+                Trace.Info($"Successfully cloned externals to {externalsDir}.");
+                return Task.FromResult(true);
+            }
+            catch (Exception ex)
+            {
+                Trace.Error($"Fail to clone externals to {externalsDir}");
+                Trace.Error(ex);
+                return Task.FromResult(false);
+            }
+        }
+
+        private async Task<string> HashFiles(string fileFolder)
+        {
+            string binDir = HostContext.GetDirectory(WellKnownDirectory.Bin);
+            string node = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Externals), "node12", "bin", $"node{IOUtil.ExeExtension}");
+            string hashFilesScript = Path.Combine(binDir, "hashFiles");
+            var hashResult = string.Empty;
+
+            using (var processInvoker = HostContext.CreateService<IProcessInvoker>())
+            {
+                processInvoker.ErrorDataReceived += (_, data) =>
+                {
+                    if (!string.IsNullOrEmpty(data.Data) && data.Data.StartsWith("__OUTPUT__") && data.Data.EndsWith("__OUTPUT__"))
+                    {
+                        hashResult = data.Data.Substring(10, data.Data.Length - 20);
+                        Trace.Info($"Hash result: '{hashResult}'");
+                    }
+                    else
+                    {
+                        Trace.Info(data.Data);
+                    }
+                };
+
+                processInvoker.OutputDataReceived += (_, data) =>
+                {
+                    Trace.Verbose(data.Data);
+                };
+
+                var env = new Dictionary<string, string>();
+                env["patterns"] = "**";
+
+
+                int exitCode = await processInvoker.ExecuteAsync(workingDirectory: fileFolder,
+                                              fileName: node,
+                                              arguments: $"\"{hashFilesScript.Replace("\"", "\\\"")}\"",
+                                              environment: env,
+                                              requireExitCodeZero: false,
+                                              cancellationToken: CancellationToken.None);
+
+                if (exitCode != 0)
+                {
+                    Trace.Error($"hashFiles returns '{exitCode}' failed. Fail to hash files under directory '{fileFolder}'");
+                }
+
+                return hashResult;
+            }
+        }
     }
 }

src/Runner.Worker/ContainerOperationProvider.cs

@@ -338,18 +338,6 @@ namespace GitHub.Runner.Worker
 
             if (!string.IsNullOrEmpty(container.ContainerId))
             {
-                if(!container.IsJobContainer)
-                {
-                    // Print logs for service container jobs (not the "action" job itself b/c that's already logged).
-                    executionContext.Output($"Print service container logs: {container.ContainerDisplayName}");
-                    
-                    int logsExitCode = await _dockerManager.DockerLogs(executionContext, container.ContainerId);
-                    if (logsExitCode != 0)
-                    {
-                        executionContext.Warning($"Docker logs fail with exit code {logsExitCode}");
-                    }
-                }
-
                 executionContext.Output($"Stop and remove container: {container.ContainerDisplayName}");
 
                 int rmExitCode = await _dockerManager.DockerRemove(executionContext, container.ContainerId);

src/Sdk/DTWebApi/WebApi/PackageMetadata.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Runtime.Serialization;
 
@@ -110,5 +111,43 @@ namespace GitHub.DistributedTask.WebApi
             get;
             set;
         }
+
+        /// <summary>
+        /// A set of trimmed down packages:
+        /// - the package without 'externals'
+        /// - the package without 'dotnet runtime'
+        /// - the package without 'dotnet runtime' and 'externals'
+        /// </summary>
+        [DataMember(EmitDefaultValue = false)]
+        public List<TrimmedPackageMetadata> TrimmedPackages
+        {
+            get;
+            set;
+        }
+    }
+
+    [DataContract]
+    public class TrimmedPackageMetadata
+    {
+        [DataMember(EmitDefaultValue = false)]
+        public string HashValue { get; set; }
+
+        [DataMember(EmitDefaultValue = false)]
+        public string DownloadUrl { get; set; }
+
+        public Dictionary<string, string> TrimmedContents
+        {
+            get
+            {
+                if (m_trimmedContents == null)
+                {
+                    m_trimmedContents = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+                }
+                return m_trimmedContents;
+            }
+        }
+
+        [DataMember(Name = "TrimmedContents", EmitDefaultValue = false)]
+        private Dictionary<string, string> m_trimmedContents;
     }
 }

src/Test/L0/Listener/SelfUpdaterL0.cs

@@ -1,178 +0,0 @@
-using GitHub.DistributedTask.WebApi;
-using GitHub.Runner.Listener;
-using GitHub.Runner.Sdk;
-using Moq;
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using Xunit;
-using System.IO;
-
-namespace GitHub.Runner.Common.Tests.Listener
-{
-    public sealed class SelfUpdaterL0
-    {
-        private Mock<IRunnerServer> _runnerServer;
-        private Mock<ITerminal> _term;
-        private Mock<IConfigurationStore> _configStore;
-        private Mock<IJobDispatcher> _jobDispatcher;
-        private AgentRefreshMessage _refreshMessage = new AgentRefreshMessage(1, "2.299.0");
-
-#if !OS_WINDOWS
-        private string _packageUrl = $"https://github.com/actions/runner/releases/download/v2.285.1/actions-runner-{BuildConstants.RunnerPackage.PackageName}-2.285.1.tar.gz";
-#else
-        private string _packageUrl = $"https://github.com/actions/runner/releases/download/v2.285.1/actions-runner-{BuildConstants.RunnerPackage.PackageName}-2.285.1.zip";
-#endif
-        public SelfUpdaterL0()
-        {
-            _runnerServer = new Mock<IRunnerServer>();
-            _term = new Mock<ITerminal>();
-            _configStore = new Mock<IConfigurationStore>();
-            _jobDispatcher = new Mock<IJobDispatcher>();
-            _configStore.Setup(x => x.GetSettings()).Returns(new RunnerSettings() { PoolId = 1, AgentId = 1 });
-
-            _runnerServer.Setup(x => x.GetPackageAsync("agent", BuildConstants.RunnerPackage.PackageName, "2.299.0", true, It.IsAny<CancellationToken>()))
-                         .Returns(Task.FromResult(new PackageMetadata() { Platform = BuildConstants.RunnerPackage.PackageName, Version = new PackageVersion("2.299.0"), DownloadUrl = _packageUrl }));
-        }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Runner")]
-        public async void TestSelfUpdateAsync()
-        {
-            using (var hc = new TestHostContext(this))
-            {
-                //Arrange
-                var updater = new Runner.Listener.SelfUpdater();
-                hc.SetSingleton<ITerminal>(_term.Object);
-                hc.SetSingleton<IRunnerServer>(_runnerServer.Object);
-                hc.SetSingleton<IConfigurationStore>(_configStore.Object);
-                hc.SetSingleton<IHttpClientHandlerFactory>(new HttpClientHandlerFactory());
-
-                var p = new ProcessInvokerWrapper();
-                p.Initialize(hc);
-                hc.EnqueueInstance<IProcessInvoker>(p);
-                updater.Initialize(hc);
-
-                _runnerServer.Setup(x => x.UpdateAgentUpdateStateAsync(1, 1, It.IsAny<string>(), It.IsAny<string>()))
-                             .Callback((int p, int a, string s, string t) =>
-                             {
-                                 hc.GetTrace().Info(t);
-                             })
-                             .Returns(Task.FromResult(new TaskAgent()));
-
-                try
-                {
-                    var result = await updater.SelfUpdate(_refreshMessage, _jobDispatcher.Object, true, hc.RunnerShutdownToken);
-                    Assert.True(result);
-                    Assert.True(Directory.Exists(Path.Combine(hc.GetDirectory(WellKnownDirectory.Root), "bin.2.299.0")));
-                    Assert.True(Directory.Exists(Path.Combine(hc.GetDirectory(WellKnownDirectory.Root), "externals.2.299.0")));
-                }
-                finally
-                {
-                    IOUtil.DeleteDirectory(Path.Combine(hc.GetDirectory(WellKnownDirectory.Root), "bin.2.299.0"), CancellationToken.None);
-                    IOUtil.DeleteDirectory(Path.Combine(hc.GetDirectory(WellKnownDirectory.Root), "externals.2.299.0"), CancellationToken.None);
-                }
-            }
-        }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Runner")]
-        public async void TestSelfUpdateAsync_NoUpdateOnOldVersion()
-        {
-            using (var hc = new TestHostContext(this))
-            {
-                //Arrange
-                var updater = new Runner.Listener.SelfUpdater();
-                hc.SetSingleton<ITerminal>(_term.Object);
-                hc.SetSingleton<IRunnerServer>(_runnerServer.Object);
-                hc.SetSingleton<IConfigurationStore>(_configStore.Object);
-                updater.Initialize(hc);
-
-                _runnerServer.Setup(x => x.GetPackageAsync("agent", BuildConstants.RunnerPackage.PackageName, "2.200.0", true, It.IsAny<CancellationToken>()))
-                         .Returns(Task.FromResult(new PackageMetadata() { Platform = BuildConstants.RunnerPackage.PackageName, Version = new PackageVersion("2.200.0"), DownloadUrl = _packageUrl }));
-
-                _runnerServer.Setup(x => x.UpdateAgentUpdateStateAsync(1, 1, It.IsAny<string>(), It.IsAny<string>()))
-                             .Callback((int p, int a, string s, string t) =>
-                             {
-                                 hc.GetTrace().Info(t);
-                             })
-                             .Returns(Task.FromResult(new TaskAgent()));
-
-                var result = await updater.SelfUpdate(new AgentRefreshMessage(1, "2.200.0"), _jobDispatcher.Object, true, hc.RunnerShutdownToken);
-                Assert.False(result);
-            }
-        }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Runner")]
-        public async void TestSelfUpdateAsync_DownloadRetry()
-        {
-            using (var hc = new TestHostContext(this))
-            {
-                //Arrange
-                var updater = new Runner.Listener.SelfUpdater();
-                hc.SetSingleton<ITerminal>(_term.Object);
-                hc.SetSingleton<IRunnerServer>(_runnerServer.Object);
-                hc.SetSingleton<IConfigurationStore>(_configStore.Object);
-                hc.SetSingleton<IHttpClientHandlerFactory>(new HttpClientHandlerFactory());
-
-                _runnerServer.Setup(x => x.GetPackageAsync("agent", BuildConstants.RunnerPackage.PackageName, "2.299.0", true, It.IsAny<CancellationToken>()))
-                         .Returns(Task.FromResult(new PackageMetadata() { Platform = BuildConstants.RunnerPackage.PackageName, Version = new PackageVersion("2.299.0"), DownloadUrl = $"https://github.com/actions/runner/notexists" }));
-
-                var p = new ProcessInvokerWrapper();
-                p.Initialize(hc);
-                hc.EnqueueInstance<IProcessInvoker>(p);
-                updater.Initialize(hc);
-
-                _runnerServer.Setup(x => x.UpdateAgentUpdateStateAsync(1, 1, It.IsAny<string>(), It.IsAny<string>()))
-                             .Callback((int p, int a, string s, string t) =>
-                             {
-                                 hc.GetTrace().Info(t);
-                             })
-                             .Returns(Task.FromResult(new TaskAgent()));
-
-
-                var ex = await Assert.ThrowsAsync<TaskCanceledException>(() => updater.SelfUpdate(_refreshMessage, _jobDispatcher.Object, true, hc.RunnerShutdownToken));
-                Assert.Contains($"failed after {Constants.RunnerDownloadRetryMaxAttempts} download attempts", ex.Message);
-            }
-        }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Runner")]
-        public async void TestSelfUpdateAsync_ValidateHash()
-        {
-            using (var hc = new TestHostContext(this))
-            {
-                //Arrange
-                var updater = new Runner.Listener.SelfUpdater();
-                hc.SetSingleton<ITerminal>(_term.Object);
-                hc.SetSingleton<IRunnerServer>(_runnerServer.Object);
-                hc.SetSingleton<IConfigurationStore>(_configStore.Object);
-                hc.SetSingleton<IHttpClientHandlerFactory>(new HttpClientHandlerFactory());
-
-                _runnerServer.Setup(x => x.GetPackageAsync("agent", BuildConstants.RunnerPackage.PackageName, "2.299.0", true, It.IsAny<CancellationToken>()))
-                         .Returns(Task.FromResult(new PackageMetadata() { Platform = BuildConstants.RunnerPackage.PackageName, Version = new PackageVersion("2.299.0"), DownloadUrl = _packageUrl, HashValue = "bad_hash" }));
-
-                var p = new ProcessInvokerWrapper();
-                p.Initialize(hc);
-                hc.EnqueueInstance<IProcessInvoker>(p);
-                updater.Initialize(hc);
-
-                _runnerServer.Setup(x => x.UpdateAgentUpdateStateAsync(1, 1, It.IsAny<string>(), It.IsAny<string>()))
-                             .Callback((int p, int a, string s, string t) =>
-                             {
-                                 hc.GetTrace().Info(t);
-                             })
-                             .Returns(Task.FromResult(new TaskAgent()));
-
-
-                var ex = await Assert.ThrowsAsync<Exception>(() => updater.SelfUpdate(_refreshMessage, _jobDispatcher.Object, true, hc.RunnerShutdownToken));
-                Assert.Contains("did not match expected Runner Hash", ex.Message);
-            }
-        }
-    }
-}

src/Test/L0/ProcessInvokerL0.cs

@@ -197,7 +197,7 @@ namespace GitHub.Runner.Common.Tests
 #if OS_WINDOWS
                 execTask = processInvoker.ExecuteAsync("", "cmd.exe", $"/c \"choice /T {SecondsToRun} /D y\"", null, tokenSource.Token);
 #else
-                execTask = processInvoker.ExecuteAsync("", "bash", $"-c \"sleep {SecondsToRun}\"", null, tokenSource.Token);
+                execTask = processInvoker.ExecuteAsync("", "bash", $"-c \"sleep {SecondsToRun}s\"", null, tokenSource.Token);
 #endif
                 await Task.Delay(500);
                 tokenSource.Cancel();

src/runnerversion

@@ -1 +1 @@
-2.286.0
+2.285.1