.

* add ref and type to job completion in run service

* lint

.devcontainer/devcontainer.json

@@ -4,7 +4,7 @@
   "features": {
     "ghcr.io/devcontainers/features/docker-in-docker:1": {},
     "ghcr.io/devcontainers/features/dotnet": {
-      "version": "6.0.421"
+      "version": "6.0.425"
     },
     "ghcr.io/devcontainers/features/node:1": {
       "version": "16"

.github/workflows/build.yml

@@ -75,7 +75,7 @@ jobs:
     # Upload runner package tar.gz/zip as artifact
     - name: Publish Artifact
       if: github.event_name != 'pull_request'
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
         name: runner-package-${{ matrix.runtime }}
         path: |

.github/workflows/release.yml

@@ -117,12 +117,11 @@ jobs:
       working-directory: _package
 
     # Upload runner package tar.gz/zip as artifact.
-    # Since each package name is unique, so we don't need to put ${{matrix}} info into artifact name
     - name: Publish Artifact
       if: github.event_name != 'pull_request'
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v4
       with:
-        name: runner-packages
+        name: runner-packages-${{ matrix.runtime }}
         path: |
           _package
 
@@ -134,10 +133,40 @@ jobs:
     - uses: actions/checkout@v3
 
     # Download runner package tar.gz/zip produced by 'build' job
-    - name: Download Artifact
+    - name: Download Artifact (win-x64)
-      uses: actions/download-artifact@v1
+      uses: actions/download-artifact@v4
       with:
-        name: runner-packages
+        name: runner-packages-win-x64
+        path: ./
+    - name: Download Artifact (win-arm64)
+      uses: actions/download-artifact@v4
+      with:
+        name: runner-packages-win-arm64
+        path: ./
+    - name: Download Artifact (osx-x64)
+      uses: actions/download-artifact@v4
+      with:
+        name: runner-packages-osx-x64
+        path: ./
+    - name: Download Artifact (osx-arm64)
+      uses: actions/download-artifact@v4
+      with:
+        name: runner-packages-osx-arm64
+        path: ./
+    - name: Download Artifact (linux-x64)
+      uses: actions/download-artifact@v4
+      with:
+        name: runner-packages-linux-x64
+        path: ./
+    - name: Download Artifact (linux-arm)
+      uses: actions/download-artifact@v4
+      with:
+        name: runner-packages-linux-arm
+        path: ./
+    - name: Download Artifact (linux-arm64)
+      uses: actions/download-artifact@v4
+      with:
+        name: runner-packages-linux-arm64
         path: ./
 
     # Create ReleaseNote file

releaseNote.md

@@ -1,10 +1,17 @@
 ## What's Changed
 
-- .NET 8 OS compatibility test https://github.com/actions/runner/pull/3422
+- Adding Snapshot additional mapping tokens https://github.com/actions/runner/pull/3468
-- Ignore ssl cert on websocket client https://github.com/actions/runner/pull/3423
+- Create launch httpclient using the right handler and setting https://github.com/actions/runner/pull/3476
-- Revert "Bump runner to dotnet 8" https://github.com/actions/runner/pull/3412
+- Fix missing default user-agent for jitconfig runner https://github.com/actions/runner/pull/3473
+- Cleanup back-compat code for interpreting Run Service status codes https://github.com/actions/runner/pull/3456
+- Add runner or worker to the useragent https://github.com/actions/runner/pull/3457
+- Handle Error Body in Responses from Broker https://github.com/actions/runner/pull/3454
+- Fix issues for composite actions (Run Service flow) https://github.com/actions/runner/pull/3446
+- Trace GitHub RequestId to log https://github.com/actions/runner/pull/3442
+- Add `jq`, `git`, `unzip` and `curl` to default packages installed https://github.com/actions/runner/pull/3056
+- Add pid to user-agent and session owner https://github.com/actions/runner/pull/3432
 
-**Full Changelog**: https://github.com/actions/runner/compare/v2.318.0...v2.319.0
+**Full Changelog**: https://github.com/actions/runner/compare/v2.319.1...v2.320.0
 
 _Note: Actions Runner follows a progressive release policy, so the latest release might not be available to your enterprise, organization, or repository yet.
 To confirm which version of the Actions Runner you should expect, please view the download instructions for your enterprise, organization, or repository.

src/Misc/layoutroot/mock_update_messages.json

@@ -0,0 +1 @@
+{ "2.319.0": {"targetVersion":"2.320.0"}}

src/Runner.Common/HostContext.cs

@@ -36,6 +36,7 @@ namespace GitHub.Runner.Common
         event EventHandler Unloading;
         void ShutdownRunner(ShutdownReason reason);
         void WritePerfCounter(string counter);
+        void LoadDefaultUserAgents();
     }
 
     public enum StartupType
@@ -67,6 +68,7 @@ namespace GitHub.Runner.Common
         private StartupType _startupType;
         private string _perfFile;
         private RunnerWebProxy _webProxy = new();
+        private string _hostType = string.Empty;
 
         public event EventHandler Unloading;
         public CancellationToken RunnerShutdownToken => _runnerShutdownTokenSource.Token;
@@ -78,6 +80,7 @@ namespace GitHub.Runner.Common
         {
             // Validate args.
             ArgUtil.NotNullOrEmpty(hostType, nameof(hostType));
+            _hostType = hostType;
 
             _loadContext = AssemblyLoadContext.GetLoadContext(typeof(HostContext).GetTypeInfo().Assembly);
             _loadContext.Unloading += LoadContext_Unloading;
@@ -196,6 +199,16 @@ namespace GitHub.Runner.Common
                 }
             }
 
+            if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_TLS_NO_VERIFY")))
+            {
+                _trace.Warning($"Runner is running under insecure mode: HTTPS server certificate validation has been turned off by GITHUB_ACTIONS_RUNNER_TLS_NO_VERIFY environment variable.");
+            }
+
+            LoadDefaultUserAgents();
+        }
+
+        public void LoadDefaultUserAgents()
+        {
             if (string.IsNullOrEmpty(WebProxy.HttpProxyAddress) && string.IsNullOrEmpty(WebProxy.HttpsProxyAddress))
             {
                 _trace.Info($"No proxy settings were found based on environmental variables (http_proxy/https_proxy/HTTP_PROXY/HTTPS_PROXY)");
@@ -205,11 +218,6 @@ namespace GitHub.Runner.Common
                 _userAgents.Add(new ProductInfoHeaderValue("HttpProxyConfigured", bool.TrueString));
             }
 
-            if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_TLS_NO_VERIFY")))
-            {
-                _trace.Warning($"Runner is running under insecure mode: HTTPS server certificate validation has been turned off by GITHUB_ACTIONS_RUNNER_TLS_NO_VERIFY environment variable.");
-            }
-
             var credFile = GetConfigFile(WellKnownConfigFile.Credentials);
             if (File.Exists(credFile))
             {
@@ -248,7 +256,7 @@ namespace GitHub.Runner.Common
             var currentProcess = Process.GetCurrentProcess();
             _userAgents.Add(new ProductInfoHeaderValue("Pid", currentProcess.Id.ToString()));
             _userAgents.Add(new ProductInfoHeaderValue("CreationTime", Uri.EscapeDataString(DateTime.UtcNow.ToString("O"))));
-            _userAgents.Add(new ProductInfoHeaderValue($"({hostType})"));
+            _userAgents.Add(new ProductInfoHeaderValue($"({_hostType})"));
         }
 
         public string GetDirectory(WellKnownDirectory directory)

src/Runner.Common/LaunchServer.cs

@@ -1,11 +1,12 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.WebApi;
+using GitHub.Runner.Sdk;
+using GitHub.Services.Common;
 using GitHub.Services.Launch.Client;
-using GitHub.Services.WebApi;
 
 namespace GitHub.Runner.Common
 {
@@ -23,8 +24,21 @@ namespace GitHub.Runner.Common
 
         public void InitializeLaunchClient(Uri uri, string token)
         {
-            var httpMessageHandler = HostContext.CreateHttpClientHandler();
+            // Using default 100 timeout
-            this._launchClient = new LaunchHttpClient(uri, httpMessageHandler, token, disposeHandler: true);
+            RawClientHttpRequestSettings settings = VssUtil.GetHttpRequestSettings(null);
+
+            // Create retry handler
+            IEnumerable<DelegatingHandler> delegatingHandlers = new List<DelegatingHandler>();
+            if (settings.MaxRetryRequest > 0)
+            {
+                delegatingHandlers = new DelegatingHandler[] { new VssHttpRetryMessageHandler(settings.MaxRetryRequest) };
+            }
+
+            // Setup RawHttpMessageHandler without credentials
+            var httpMessageHandler = new RawHttpMessageHandler(new NoOpCredentials(null), settings);
+            var pipeline = HttpClientFactory.CreatePipeline(httpMessageHandler, delegatingHandlers);
+
+            this._launchClient = new LaunchHttpClient(uri, pipeline, token, disposeHandler: true);
         }
 
         public Task<ActionDownloadInfoCollection> ResolveActionsDownloadInfoAsync(Guid planId, Guid jobId, ActionReferenceList actionReferenceList,

src/Runner.Listener/MessageListener.cs

@@ -248,15 +248,16 @@ namespace GitHub.Runner.Listener
                 _getMessagesTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token);
                 try
                 {
-                    message = await _runnerServer.GetAgentMessageAsync(_settings.PoolId,
+                    await Task.Delay(5000);
-                                                                _session.SessionId,
+                    // message = await _runnerServer.GetAgentMessageAsync(_settings.PoolId,
-                                                                _lastMessageId,
+                    //                                             _session.SessionId,
-                                                                runnerStatus,
+                    //                                             _lastMessageId,
-                                                                BuildConstants.RunnerPackage.Version,
+                    //                                             runnerStatus,
-                                                                VarUtil.OS,
+                    //                                             BuildConstants.RunnerPackage.Version,
-                                                                VarUtil.OSArchitecture,
+                    //                                             VarUtil.OS,
-                                                                _settings.DisableUpdate,
+                    //                                             VarUtil.OSArchitecture,
-                                                                _getMessagesTokenSource.Token);
+                    //                                             _settings.DisableUpdate,
+                    //                                             _getMessagesTokenSource.Token);
 
                     // Decrypt the message body if the session is using encryption
                     message = DecryptMessage(message);
@@ -264,8 +265,6 @@ namespace GitHub.Runner.Listener
 
                     if (message != null && message.MessageType == BrokerMigrationMessage.MessageType)
                     {
-                        Trace.Info("BrokerMigration message received. Polling Broker for messages...");
-
                         var migrationMessage = JsonUtility.FromString<BrokerMigrationMessage>(message.Body);
 
                         await _brokerServer.UpdateConnectionIfNeeded(migrationMessage.BrokerBaseUrl, _creds);

src/Runner.Listener/Runner.cs

@@ -237,6 +237,10 @@ namespace GitHub.Runner.Listener
                             File.SetAttributes(configFile, File.GetAttributes(configFile) | FileAttributes.Hidden);
                             Trace.Info($"Saved {configContent.Length} bytes to '{configFile}'.");
                         }
+
+                        // make sure we have the right user agent data added from the jitconfig
+                        HostContext.LoadDefaultUserAgents();
+                        VssUtil.InitializeVssClientSettings(HostContext.UserAgents, HostContext.WebProxy);
                     }
                     catch (Exception ex)
                     {
@@ -475,14 +479,14 @@ namespace GitHub.Runner.Listener
                                 }
                             }
 
-                            message = await getNextMessage; //get next message
+                            // message = await getNextMessage; //get next message
-                            HostContext.WritePerfCounter($"MessageReceived_{message.MessageType}");
+                            // HostContext.WritePerfCounter($"MessageReceived_{message.MessageType}");
-                            if (string.Equals(message.MessageType, AgentRefreshMessage.MessageType, StringComparison.OrdinalIgnoreCase))
+                            // if (string.Equals(message.MessageType, AgentRefreshMessage.MessageType, StringComparison.OrdinalIgnoreCase))
                             {
                                 if (autoUpdateInProgress == false)
                                 {
                                     autoUpdateInProgress = true;
-                                    AgentRefreshMessage runnerUpdateMessage = JsonUtility.FromString<AgentRefreshMessage>(message.Body);
+                                    AgentRefreshMessage runnerUpdateMessage = null;
 
 #if DEBUG
                                     // Can mock the update for testing
@@ -498,9 +502,9 @@ namespace GitHub.Runner.Listener
                                             if (mockUpdateMessages.ContainsKey(BuildConstants.RunnerPackage.Version))
                                             {
                                                 var mockTargetVersion = mockUpdateMessages[BuildConstants.RunnerPackage.Version].TargetVersion;
-                                                _term.WriteLine($"Mocking update, using version {mockTargetVersion} instead of {runnerUpdateMessage.TargetVersion}");
+                                                _term.WriteLine($"Mocking update, using version {mockTargetVersion}");
-                                                Trace.Info($"Mocking update, using version {mockTargetVersion} instead of {runnerUpdateMessage.TargetVersion}");
+                                                Trace.Info($"Mocking update, using version {mockTargetVersion}");
-                                                runnerUpdateMessage = new AgentRefreshMessage(runnerUpdateMessage.AgentId, mockTargetVersion, runnerUpdateMessage.Timeout);
+                                                runnerUpdateMessage = new AgentRefreshMessage(settings.AgentId, mockTargetVersion, TimeSpan.FromSeconds(100));
                                             }
                                         }
                                     }
@@ -514,125 +518,125 @@ namespace GitHub.Runner.Listener
                                     Trace.Info("Refresh message received, skip autoupdate since a previous autoupdate is already running.");
                                 }
                             }
-                            else if (string.Equals(message.MessageType, RunnerRefreshMessage.MessageType, StringComparison.OrdinalIgnoreCase))
+                            // else if (string.Equals(message.MessageType, RunnerRefreshMessage.MessageType, StringComparison.OrdinalIgnoreCase))
-                            {
+                            // {
-                                if (autoUpdateInProgress == false)
+                            //     if (autoUpdateInProgress == false)
-                                {
+                            //     {
-                                    autoUpdateInProgress = true;
+                            //         autoUpdateInProgress = true;
-                                    RunnerRefreshMessage brokerRunnerUpdateMessage = JsonUtility.FromString<RunnerRefreshMessage>(message.Body);
+                            //         RunnerRefreshMessage brokerRunnerUpdateMessage = JsonUtility.FromString<RunnerRefreshMessage>(message.Body);
 
-                                    var selfUpdater = HostContext.GetService<ISelfUpdaterV2>();
+                            //         var selfUpdater = HostContext.GetService<ISelfUpdaterV2>();
-                                    selfUpdateTask = selfUpdater.SelfUpdate(brokerRunnerUpdateMessage, jobDispatcher, false, HostContext.RunnerShutdownToken);
+                            //         selfUpdateTask = selfUpdater.SelfUpdate(brokerRunnerUpdateMessage, jobDispatcher, false, HostContext.RunnerShutdownToken);
-                                    Trace.Info("Refresh message received, kick-off selfupdate background process.");
+                            //         Trace.Info("Refresh message received, kick-off selfupdate background process.");
-                                }
+                            //     }
-                                else
+                            //     else
-                                {
+                            //     {
-                                    Trace.Info("Refresh message received, skip autoupdate since a previous autoupdate is already running.");
+                            //         Trace.Info("Refresh message received, skip autoupdate since a previous autoupdate is already running.");
-                                }
+                            //     }
-                            }
+                            // }
-                            else if (string.Equals(message.MessageType, JobRequestMessageTypes.PipelineAgentJobRequest, StringComparison.OrdinalIgnoreCase))
+                            // else if (string.Equals(message.MessageType, JobRequestMessageTypes.PipelineAgentJobRequest, StringComparison.OrdinalIgnoreCase))
-                            {
+                            // {
-                                if (autoUpdateInProgress || runOnceJobReceived)
+                            //     if (autoUpdateInProgress || runOnceJobReceived)
-                                {
+                            //     {
-                                    skipMessageDeletion = true;
+                            //         skipMessageDeletion = true;
-                                    Trace.Info($"Skip message deletion for job request message '{message.MessageId}'.");
+                            //         Trace.Info($"Skip message deletion for job request message '{message.MessageId}'.");
-                                }
+                            //     }
-                                else
+                            //     else
-                                {
+                            //     {
-                                    Trace.Info($"Received job message of length {message.Body.Length} from service, with hash '{IOUtil.GetSha256Hash(message.Body)}'");
+                            //         Trace.Info($"Received job message of length {message.Body.Length} from service, with hash '{IOUtil.GetSha256Hash(message.Body)}'");
-                                    var jobMessage = StringUtil.ConvertFromJson<Pipelines.AgentJobRequestMessage>(message.Body);
+                            //         var jobMessage = StringUtil.ConvertFromJson<Pipelines.AgentJobRequestMessage>(message.Body);
-                                    jobDispatcher.Run(jobMessage, runOnce);
+                            //         jobDispatcher.Run(jobMessage, runOnce);
-                                    if (runOnce)
+                            //         if (runOnce)
-                                    {
+                            //         {
-                                        Trace.Info("One time used runner received job message.");
+                            //             Trace.Info("One time used runner received job message.");
-                                        runOnceJobReceived = true;
+                            //             runOnceJobReceived = true;
-                                    }
+                            //         }
-                                }
+                            //     }
-                            }
+                            // }
-                            // Broker flow
+                            // // Broker flow
-                            else if (MessageUtil.IsRunServiceJob(message.MessageType))
+                            // else if (MessageUtil.IsRunServiceJob(message.MessageType))
-                            {
+                            // {
-                                if (autoUpdateInProgress || runOnceJobReceived)
+                            //     if (autoUpdateInProgress || runOnceJobReceived)
-                                {
+                            //     {
-                                    skipMessageDeletion = true;
+                            //         skipMessageDeletion = true;
-                                    Trace.Info($"Skip message deletion for job request message '{message.MessageId}'.");
+                            //         Trace.Info($"Skip message deletion for job request message '{message.MessageId}'.");
-                                }
+                            //     }
-                                else
+                            //     else
-                                {
+                            //     {
-                                    var messageRef = StringUtil.ConvertFromJson<RunnerJobRequestRef>(message.Body);
+                            //         var messageRef = StringUtil.ConvertFromJson<RunnerJobRequestRef>(message.Body);
-                                    Pipelines.AgentJobRequestMessage jobRequestMessage = null;
+                            //         Pipelines.AgentJobRequestMessage jobRequestMessage = null;
 
-                                    // Create connection
+                            //         // Create connection
-                                    var credMgr = HostContext.GetService<ICredentialManager>();
+                            //         var credMgr = HostContext.GetService<ICredentialManager>();
-                                    var creds = credMgr.LoadCredentials();
+                            //         var creds = credMgr.LoadCredentials();
 
-                                    if (string.IsNullOrEmpty(messageRef.RunServiceUrl))
+                            //         if (string.IsNullOrEmpty(messageRef.RunServiceUrl))
-                                    {
+                            //         {
-                                        var actionsRunServer = HostContext.CreateService<IActionsRunServer>();
+                            //             var actionsRunServer = HostContext.CreateService<IActionsRunServer>();
-                                        await actionsRunServer.ConnectAsync(new Uri(settings.ServerUrl), creds);
+                            //             await actionsRunServer.ConnectAsync(new Uri(settings.ServerUrl), creds);
-                                        jobRequestMessage = await actionsRunServer.GetJobMessageAsync(messageRef.RunnerRequestId, messageQueueLoopTokenSource.Token);
+                            //             jobRequestMessage = await actionsRunServer.GetJobMessageAsync(messageRef.RunnerRequestId, messageQueueLoopTokenSource.Token);
-                                    }
+                            //         }
-                                    else
+                            //         else
-                                    {
+                            //         {
-                                        var runServer = HostContext.CreateService<IRunServer>();
+                            //             var runServer = HostContext.CreateService<IRunServer>();
-                                        await runServer.ConnectAsync(new Uri(messageRef.RunServiceUrl), creds);
+                            //             await runServer.ConnectAsync(new Uri(messageRef.RunServiceUrl), creds);
-                                        try
+                            //             try
-                                        {
+                            //             {
-                                            jobRequestMessage = await runServer.GetJobMessageAsync(messageRef.RunnerRequestId, messageQueueLoopTokenSource.Token);
+                            //                 jobRequestMessage = await runServer.GetJobMessageAsync(messageRef.RunnerRequestId, messageQueueLoopTokenSource.Token);
-                                            _acquireJobThrottler.Reset();
+                            //                 _acquireJobThrottler.Reset();
-                                        }
+                            //             }
-                                        catch (Exception ex) when (
+                            //             catch (Exception ex) when (
-                                            ex is TaskOrchestrationJobNotFoundException ||          // HTTP status 404
+                            //                 ex is TaskOrchestrationJobNotFoundException ||          // HTTP status 404
-                                            ex is TaskOrchestrationJobAlreadyAcquiredException ||   // HTTP status 409
+                            //                 ex is TaskOrchestrationJobAlreadyAcquiredException ||   // HTTP status 409
-                                            ex is TaskOrchestrationJobUnprocessableException)       // HTTP status 422
+                            //                 ex is TaskOrchestrationJobUnprocessableException)       // HTTP status 422
-                                        {
+                            //             {
-                                            Trace.Info($"Skipping message Job. {ex.Message}");
+                            //                 Trace.Info($"Skipping message Job. {ex.Message}");
-                                            await _acquireJobThrottler.IncrementAndWaitAsync(messageQueueLoopTokenSource.Token);
+                            //                 await _acquireJobThrottler.IncrementAndWaitAsync(messageQueueLoopTokenSource.Token);
-                                            continue;
+                            //                 continue;
-                                        }
+                            //             }
-                                        catch (Exception ex)
+                            //             catch (Exception ex)
-                                        {
+                            //             {
-                                            Trace.Error($"Caught exception from acquiring job message: {ex}");
+                            //                 Trace.Error($"Caught exception from acquiring job message: {ex}");
-                                            continue;
+                            //                 continue;
-                                        }
+                            //             }
-                                    }
+                            //         }
 
-                                    jobDispatcher.Run(jobRequestMessage, runOnce);
+                            //         jobDispatcher.Run(jobRequestMessage, runOnce);
-                                    if (runOnce)
+                            //         if (runOnce)
-                                    {
+                            //         {
-                                        Trace.Info("One time used runner received job message.");
+                            //             Trace.Info("One time used runner received job message.");
-                                        runOnceJobReceived = true;
+                            //             runOnceJobReceived = true;
-                                    }
+                            //         }
-                                }
+                            //     }
-                            }
+                            // }
-                            else if (string.Equals(message.MessageType, JobCancelMessage.MessageType, StringComparison.OrdinalIgnoreCase))
+                            // else if (string.Equals(message.MessageType, JobCancelMessage.MessageType, StringComparison.OrdinalIgnoreCase))
-                            {
+                            // {
-                                var cancelJobMessage = JsonUtility.FromString<JobCancelMessage>(message.Body);
+                            //     var cancelJobMessage = JsonUtility.FromString<JobCancelMessage>(message.Body);
-                                bool jobCancelled = jobDispatcher.Cancel(cancelJobMessage);
+                            //     bool jobCancelled = jobDispatcher.Cancel(cancelJobMessage);
-                                skipMessageDeletion = (autoUpdateInProgress || runOnceJobReceived) && !jobCancelled;
+                            //     skipMessageDeletion = (autoUpdateInProgress || runOnceJobReceived) && !jobCancelled;
 
-                                if (skipMessageDeletion)
+                            //     if (skipMessageDeletion)
-                                {
+                            //     {
-                                    Trace.Info($"Skip message deletion for cancellation message '{message.MessageId}'.");
+                            //         Trace.Info($"Skip message deletion for cancellation message '{message.MessageId}'.");
-                                }
+                            //     }
-                            }
+                            // }
-                            else if (string.Equals(message.MessageType, Pipelines.HostedRunnerShutdownMessage.MessageType, StringComparison.OrdinalIgnoreCase))
+                            // else if (string.Equals(message.MessageType, Pipelines.HostedRunnerShutdownMessage.MessageType, StringComparison.OrdinalIgnoreCase))
-                            {
+                            // {
-                                var HostedRunnerShutdownMessage = JsonUtility.FromString<Pipelines.HostedRunnerShutdownMessage>(message.Body);
+                            //     var HostedRunnerShutdownMessage = JsonUtility.FromString<Pipelines.HostedRunnerShutdownMessage>(message.Body);
-                                skipMessageDeletion = true;
+                            //     skipMessageDeletion = true;
-                                skipSessionDeletion = true;
+                            //     skipSessionDeletion = true;
-                                Trace.Info($"Service requests the hosted runner to shutdown. Reason: '{HostedRunnerShutdownMessage.Reason}'.");
+                            //     Trace.Info($"Service requests the hosted runner to shutdown. Reason: '{HostedRunnerShutdownMessage.Reason}'.");
-                                return Constants.Runner.ReturnCode.Success;
+                            //     return Constants.Runner.ReturnCode.Success;
-                            }
+                            // }
-                            else if (string.Equals(message.MessageType, TaskAgentMessageTypes.ForceTokenRefresh))
+                            // else if (string.Equals(message.MessageType, TaskAgentMessageTypes.ForceTokenRefresh))
-                            {
+                            // {
-                                Trace.Info("Received ForceTokenRefreshMessage");
+                            //     Trace.Info("Received ForceTokenRefreshMessage");
-                                await _listener.RefreshListenerTokenAsync(messageQueueLoopTokenSource.Token);
+                            //     await _listener.RefreshListenerTokenAsync(messageQueueLoopTokenSource.Token);
-                            }
+                            // }
-                            else
+                            // else
-                            {
+                            // {
-                                Trace.Error($"Received message {message.MessageId} with unsupported message type {message.MessageType}.");
+                            //     Trace.Error($"Received message {message.MessageId} with unsupported message type {message.MessageType}.");
-                            }
+                            // }
                         }
                         finally
                         {

src/Runner.Listener/SelfUpdater.cs

@@ -132,6 +132,18 @@ namespace GitHub.Runner.Listener
 
         private async Task<bool> UpdateNeeded(string targetVersion, CancellationToken token)
         {
+            if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_IS_MOCK_UPDATE")))
+            {
+                _targetPackage = new PackageMetadata()
+                {
+                    Type = "agent",
+                    Platform = BuildConstants.RunnerPackage.PackageName,
+                    Version = new PackageVersion(targetVersion),
+                };
+            }
+            else
+            {
+
                 // when talk to old version server, always prefer latest package.
                 // old server won't send target version as part of update message.
                 if (string.IsNullOrEmpty(targetVersion))
@@ -154,6 +166,7 @@ namespace GitHub.Runner.Listener
                         return false;
                     }
                 }
+            }
 
             Trace.Info($"Version '{_targetPackage.Version}' of '{_targetPackage.Type}' package available in server.");
             PackageVersion serverVersion = new(_targetPackage.Version);

src/Runner.Worker/ExecutionContext.cs

@@ -508,6 +508,8 @@ namespace GitHub.Runner.Worker
                     Status = _record.State,
                     Number = _record.Order,
                     Name = _record.Name,
+                    Ref = StepTelemetry?.Ref,
+                    Type = StepTelemetry?.Type,
                     StartedAt = _record.StartTime,
                     CompletedAt = _record.FinishTime,
                     Annotations = new List<Annotation>()

src/Runner.Worker/JobExtension.cs

@@ -403,7 +403,7 @@ namespace GitHub.Runner.Worker
                         var snapshotOperationProvider = HostContext.GetService<ISnapshotOperationProvider>();
                         jobContext.RegisterPostJobStep(new JobExtensionRunner(
                             runAsync: (executionContext, _) => snapshotOperationProvider.CreateSnapshotRequestAsync(executionContext, snapshotRequest),
-                            condition: $"{PipelineTemplateConstants.Success}()",
+                            condition: snapshotRequest.Condition,
                             displayName: $"Create custom image",
                             data: null));
                     }

src/Sdk/DTPipelines/Pipelines/ObjectTemplating/PipelineTemplateConstants.cs

@@ -30,6 +30,7 @@ namespace GitHub.DistributedTask.Pipelines.ObjectTemplating
         public const String If = "if";
         public const String Image = "image";
         public const String ImageName = "image-name";
+        public const String CustomImageVersion = "version";
         public const String Include = "include";
         public const String Inputs = "inputs";
         public const String Job = "job";

src/Sdk/DTPipelines/Pipelines/ObjectTemplating/PipelineTemplateConverter.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Globalization;
 using System.Linq;
 using GitHub.DistributedTask.Expressions2;
 using GitHub.DistributedTask.Expressions2.Sdk;
@@ -349,6 +350,10 @@ namespace GitHub.DistributedTask.Pipelines.ObjectTemplating
         internal static Snapshot ConvertToJobSnapshotRequest(TemplateContext context, TemplateToken token)
         {
             string imageName = null;
+            string version = "1.*";
+            string versionString = string.Empty;
+            var condition = $"{PipelineTemplateConstants.Success}()";
+
             if (token is StringToken snapshotStringLiteral)
             {
                 imageName = snapshotStringLiteral.Value;
@@ -359,11 +364,19 @@ namespace GitHub.DistributedTask.Pipelines.ObjectTemplating
                 foreach (var snapshotPropertyPair in snapshotMapping)
                 {
                     var propertyName = snapshotPropertyPair.Key.AssertString($"{PipelineTemplateConstants.Snapshot} key");
+                    var propertyValue = snapshotPropertyPair.Value;
                     switch (propertyName.Value)
                     {
                         case PipelineTemplateConstants.ImageName:
                             imageName = snapshotPropertyPair.Value.AssertString($"{PipelineTemplateConstants.Snapshot} {propertyName}").Value;
                             break;
+                        case PipelineTemplateConstants.If:
+                            condition = ConvertToIfCondition(context, propertyValue, false);
+                            break;
+                        case PipelineTemplateConstants.CustomImageVersion:
+                            versionString = propertyValue.AssertString($"job {PipelineTemplateConstants.Snapshot} {PipelineTemplateConstants.CustomImageVersion}").Value;
+                            version = IsSnapshotImageVersionValid(versionString) ? versionString : null;
+                            break;
                         default:
                             propertyName.AssertUnexpectedValue($"{PipelineTemplateConstants.Snapshot} key");
                             break;
@@ -376,7 +389,26 @@ namespace GitHub.DistributedTask.Pipelines.ObjectTemplating
                 return null;
             }
 
-            return new Snapshot(imageName);
+            return new Snapshot(imageName)
+            {
+                Condition = condition,
+                Version = version
+            };
+        }
+
+        private static bool IsSnapshotImageVersionValid(string versionString)
+        {
+            var versionSegments = versionString.Split(".");
+
+            if (versionSegments.Length != 2 ||
+                !versionSegments[1].Equals("*") ||
+                !Int32.TryParse(versionSegments[0], NumberStyles.None, CultureInfo.InvariantCulture, result: out int parsedMajor) ||
+                parsedMajor < 0)
+            {
+                return false;
+            }
+
+            return true;
         }
 
         private static ActionStep ConvertToStep(

src/Sdk/DTPipelines/Pipelines/Snapshot.cs

@@ -1,17 +1,27 @@
 using System;
 using System.Runtime.Serialization;
+using GitHub.DistributedTask.ObjectTemplating.Tokens;
+using GitHub.DistributedTask.Pipelines.ObjectTemplating;
 
 namespace GitHub.DistributedTask.Pipelines
 {
     [DataContract]
     public class Snapshot
     {
-        public Snapshot(string imageName)
+        public Snapshot(string imageName, string condition = null, string version = null)
         {
             ImageName = imageName;
+            Condition = condition ?? $"{PipelineTemplateConstants.Success}()";
+            Version = version ?? "1.*";
         }
 
         [DataMember(EmitDefaultValue = false)]
         public String ImageName { get; set; }
+
+        [DataMember(EmitDefaultValue = false)]
+        public String Condition { get; set; }
+
+        [DataMember(EmitDefaultValue = false)]
+        public String Version { get; set; }
     }
 }

src/Sdk/DTPipelines/workflow-v1.0.json

@@ -169,11 +169,28 @@
           "image-name": {
             "type": "non-empty-string",
             "required": true
+          },
+          "if": "snapshot-if",
+          "version": {
+            "type": "non-empty-string",
+            "required": false
           }
         }
       }
     },
 
+    "snapshot-if": {
+      "context": [
+        "github",
+        "inputs",
+        "vars",
+        "needs",
+        "strategy",
+        "matrix"
+      ],
+      "string": {}
+    },
+
     "runs-on": {
       "context": [
         "github",

src/Sdk/RSWebApi/Contracts/StepResult.cs

@@ -19,6 +19,12 @@ namespace GitHub.Actions.RunService.WebApi
         [DataMember(Name = "name", EmitDefaultValue = false)]
         public string Name { get; set; }
 
+        [DataMember(Name = "ref", EmitDefaultValue = false)]
+        public string Ref { get; set; }
+
+        [DataMember(Name = "type", EmitDefaultValue = false)]
+        public string Type { get; set; }
+
         [DataMember(Name = "status")]
         public TimelineRecordState? Status { get; set; }
 

src/Test/L0/TestHostContext.cs

@@ -370,6 +370,11 @@ namespace GitHub.Runner.Common.Tests
                 Unloading(this, null);
             }
         }
+
+        public void LoadDefaultUserAgents()
+        {
+            return;
+        }
     }
 
     public class DelayEventArgs : EventArgs

src/Test/L0/Worker/JobExtensionL0.cs

@@ -506,7 +506,27 @@ namespace GitHub.Runner.Common.Tests.Worker
             return EnsureSnapshotPostJobStepForToken(mappingToken, snapshot);
         }
 
-        private async Task EnsureSnapshotPostJobStepForToken(TemplateToken snapshotToken, Pipelines.Snapshot expectedSnapshot)
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public Task EnsureSnapshotPostJobStepForMappingToken_WithIf_Is_False()
+        {
+            var snapshot = new Pipelines.Snapshot("TestImageNameFromMappingToken", condition: $"{PipelineTemplateConstants.Success}() && 1==0", version: "2.*");
+            var imageNameValueStringToken = new StringToken(null, null, null, snapshot.ImageName);
+            var condition = new StringToken(null, null, null, snapshot.Condition);
+            var version = new StringToken(null, null, null, snapshot.Version);
+
+            var mappingToken = new MappingToken(null, null, null)
+            {
+                { new StringToken(null,null,null, PipelineTemplateConstants.ImageName), imageNameValueStringToken },
+                { new StringToken(null,null,null, PipelineTemplateConstants.If), condition },
+                { new StringToken(null,null,null, PipelineTemplateConstants.CustomImageVersion), version }
+            };
+
+            return EnsureSnapshotPostJobStepForToken(mappingToken, snapshot, skipSnapshotStep: true);
+        }
+
+        private async Task EnsureSnapshotPostJobStepForToken(TemplateToken snapshotToken, Pipelines.Snapshot expectedSnapshot, bool skipSnapshotStep = false)
         {
             using (TestHostContext hc = CreateTestContext())
             {
@@ -524,14 +544,28 @@ namespace GitHub.Runner.Common.Tests.Worker
 
                 Assert.Equal(1, postJobSteps.Count);
                 var snapshotStep = postJobSteps.First();
+                _jobEc.JobSteps.Enqueue(snapshotStep);
+
+                var _stepsRunner = new StepsRunner();
+                _stepsRunner.Initialize(hc);
+                await _stepsRunner.RunAsync(_jobEc);
+
                 Assert.Equal("Create custom image", snapshotStep.DisplayName);
-                Assert.Equal($"{PipelineTemplateConstants.Success}()", snapshotStep.Condition);
+                Assert.Equal(expectedSnapshot.Condition ?? $"{PipelineTemplateConstants.Success}()", snapshotStep.Condition);
 
                 // Run the mock snapshot step, so we can verify it was executed with the expected snapshot object.
-                await snapshotStep.RunAsync();
+                // await snapshotStep.RunAsync();
-
+                if (skipSnapshotStep)
+                {
+                    Assert.Null(_requestedSnapshot);
+                }
+                else
+                {
                     Assert.NotNull(_requestedSnapshot);
                     Assert.Equal(expectedSnapshot.ImageName, _requestedSnapshot.ImageName);
+                    Assert.Equal(expectedSnapshot.Condition ?? $"{PipelineTemplateConstants.Success}()", _requestedSnapshot.Condition);
+                    Assert.Equal(expectedSnapshot.Version ?? "1.*", _requestedSnapshot.Version);
+                }
             }
         }
     }

src/dev.sh

@@ -17,7 +17,7 @@ LAYOUT_DIR="$SCRIPT_DIR/../_layout"
 DOWNLOAD_DIR="$SCRIPT_DIR/../_downloads/netcore2x"
 PACKAGE_DIR="$SCRIPT_DIR/../_package"
 DOTNETSDK_ROOT="$SCRIPT_DIR/../_dotnetsdk"
-DOTNETSDK_VERSION="6.0.421"
+DOTNETSDK_VERSION="6.0.425"
 DOTNETSDK_INSTALLDIR="$DOTNETSDK_ROOT/$DOTNETSDK_VERSION"
 DOTNET8SDK_VERSION="8.0.303"
 DOTNET8SDK_INSTALLDIR="$DOTNETSDK_ROOT/$DOTNET8SDK_VERSION"

src/global.json

@@ -1,5 +1,5 @@
 {
   "sdk": {
-    "version": "6.0.421"
+    "version": "6.0.425"
   }
 }

src/runnerversion

@@ -1 +1 @@
-2.319.1
+2.319.0