Release 2.320.1 patch runner with #3548 (#3727)

.devcontainer/devcontainer.json

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

.github/workflows/release.yml

@@ -285,54 +285,54 @@ jobs:
         asset_name: actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}.tar.gz
         asset_content_type: application/octet-stream
 
-  publish-image:
+  # publish-image:
-    needs: release
+  #   needs: release
-    runs-on: ubuntu-latest
+  #   runs-on: ubuntu-latest
-    permissions:
+  #   permissions:
-      contents: read
+  #     contents: read
-      packages: write
+  #     packages: write
-    env:
+  #   env:
-      REGISTRY: ghcr.io
+  #     REGISTRY: ghcr.io
-      IMAGE_NAME: ${{ github.repository_owner }}/actions-runner
+  #     IMAGE_NAME: ${{ github.repository_owner }}/actions-runner
-    steps:
+  #   steps:
-      - name: Checkout repository
+  #     - name: Checkout repository
-        uses: actions/checkout@v3
+  #       uses: actions/checkout@v3
 
-      - name: Compute image version
+  #     - name: Compute image version
-        id: image
+  #       id: image
-        uses: actions/github-script@v6
+  #       uses: actions/github-script@v6
-        with:
+  #       with:
-          script: |
+  #         script: |
-            const fs = require('fs');
+  #           const fs = require('fs');
-            const runnerVersion = fs.readFileSync('${{ github.workspace }}/releaseVersion', 'utf8').replace(/\n$/g, '')
+  #           const runnerVersion = fs.readFileSync('${{ github.workspace }}/releaseVersion', 'utf8').replace(/\n$/g, '')
-            console.log(`Using runner version ${runnerVersion}`)
+  #           console.log(`Using runner version ${runnerVersion}`)
-            core.setOutput('version', runnerVersion);
+  #           core.setOutput('version', runnerVersion);
 
-      - name: Setup Docker buildx
+  #     - name: Setup Docker buildx
-        uses: docker/setup-buildx-action@v2
+  #       uses: docker/setup-buildx-action@v2
 
-      - name: Log into registry ${{ env.REGISTRY }}
+  #     - name: Log into registry ${{ env.REGISTRY }}
-        uses: docker/login-action@v2
+  #       uses: docker/login-action@v2
-        with:
+  #       with:
-          registry: ${{ env.REGISTRY }}
+  #         registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
+  #         username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
+  #         password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build and push Docker image
+  #     - name: Build and push Docker image
-        id: build-and-push
+  #       id: build-and-push
-        uses: docker/build-push-action@v3
+  #       uses: docker/build-push-action@v3
-        with:
+  #       with:
-          context: ./images
+  #         context: ./images
-          platforms: |
+  #         platforms: |
-            linux/amd64
+  #           linux/amd64
-            linux/arm64
+  #           linux/arm64
-          tags: |
+  #         tags: |
-            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.image.outputs.version }}
+  #           ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:${{ steps.image.outputs.version }}
-            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
+  #           ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:latest
-          build-args: |
+  #         build-args: |
-            RUNNER_VERSION=${{ steps.image.outputs.version }}
+  #           RUNNER_VERSION=${{ steps.image.outputs.version }}
-          push: true
+  #         push: true
-          labels: |
+  #         labels: |
-            org.opencontainers.image.source=${{github.server_url}}/${{github.repository}}
+  #           org.opencontainers.image.source=${{github.server_url}}/${{github.repository}}
-            org.opencontainers.image.description=https://github.com/actions/runner/releases/tag/v${{ steps.image.outputs.version }}
+  #           org.opencontainers.image.description=https://github.com/actions/runner/releases/tag/v${{ steps.image.outputs.version }}
-            org.opencontainers.image.licenses=MIT
+  #           org.opencontainers.image.licenses=MIT

releaseNote.md

@@ -1,17 +1,8 @@
 ## What's Changed
 
-- Adding Snapshot additional mapping tokens https://github.com/actions/runner/pull/3468
+- Backport: Expose ENV for cache service v2. https://github.com/actions/runner/pull/3548
-- Create launch httpclient using the right handler and setting https://github.com/actions/runner/pull/3476
-- 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.319.1...v2.320.0
+**Full Changelog**: https://github.com/actions/runner/compare/v2.320.0...v2.320.1
 
 _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.

releaseVersion

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

src/Misc/layoutroot/mock_update_messages.json

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

src/Runner.Listener/MessageListener.cs

@@ -248,16 +248,15 @@ namespace GitHub.Runner.Listener
                 _getMessagesTokenSource = CancellationTokenSource.CreateLinkedTokenSource(token);
                 try
                 {
-                    await Task.Delay(5000);
+                    message = await _runnerServer.GetAgentMessageAsync(_settings.PoolId,
-                    // message = await _runnerServer.GetAgentMessageAsync(_settings.PoolId,
+                                                                _session.SessionId,
-                    //                                             _session.SessionId,
+                                                                _lastMessageId,
-                    //                                             _lastMessageId,
+                                                                runnerStatus,
-                    //                                             runnerStatus,
+                                                                BuildConstants.RunnerPackage.Version,
-                    //                                             BuildConstants.RunnerPackage.Version,
+                                                                VarUtil.OS,
-                    //                                             VarUtil.OS,
+                                                                VarUtil.OSArchitecture,
-                    //                                             VarUtil.OSArchitecture,
+                                                                _settings.DisableUpdate,
-                    //                                             _settings.DisableUpdate,
+                                                                _getMessagesTokenSource.Token);
-                    //                                             _getMessagesTokenSource.Token);
 
                     // Decrypt the message body if the session is using encryption
                     message = DecryptMessage(message);
@@ -265,6 +264,8 @@ 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

@@ -479,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 = null;
+                                    AgentRefreshMessage runnerUpdateMessage = JsonUtility.FromString<AgentRefreshMessage>(message.Body);
 
 #if DEBUG
                                     // Can mock the update for testing
@@ -502,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}");
+                                                _term.WriteLine($"Mocking update, using version {mockTargetVersion} instead of {runnerUpdateMessage.TargetVersion}");
-                                                Trace.Info($"Mocking update, using version {mockTargetVersion}");
+                                                Trace.Info($"Mocking update, using version {mockTargetVersion} instead of {runnerUpdateMessage.TargetVersion}");
-                                                runnerUpdateMessage = new AgentRefreshMessage(settings.AgentId, mockTargetVersion, TimeSpan.FromSeconds(100));
+                                                runnerUpdateMessage = new AgentRefreshMessage(runnerUpdateMessage.AgentId, mockTargetVersion, runnerUpdateMessage.Timeout);
                                             }
                                         }
                                     }
@@ -518,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,39 +132,26 @@ namespace GitHub.Runner.Listener
 
         private async Task<bool> UpdateNeeded(string targetVersion, CancellationToken token)
         {
-            if (StringUtil.ConvertToBoolean(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_IS_MOCK_UPDATE")))
+            // 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))
             {
-                _targetPackage = new PackageMetadata()
+                var packages = await _runnerServer.GetPackagesAsync(_packageType, _platform, 1, true, token);
+                if (packages == null || packages.Count == 0)
                 {
-                    Type = "agent",
+                    Trace.Info($"There is no package for {_packageType} and {_platform}.");
-                    Platform = BuildConstants.RunnerPackage.PackageName,
+                    return false;
-                    Version = new PackageVersion(targetVersion),
+                }
-                };
+
+                _targetPackage = packages.FirstOrDefault();
             }
             else
             {
-
+                _targetPackage = await _runnerServer.GetPackageAsync(_packageType, _platform, targetVersion, true, token);
-                // when talk to old version server, always prefer latest package.
+                if (_targetPackage == null)
-                // old server won't send target version as part of update message.
-                if (string.IsNullOrEmpty(targetVersion))
                 {
-                    var packages = await _runnerServer.GetPackagesAsync(_packageType, _platform, 1, true, token);
+                    Trace.Info($"There is no package for {_packageType} and {_platform} with version {targetVersion}.");
-                    if (packages == null || packages.Count == 0)
+                    return false;
-                    {
-                        Trace.Info($"There is no package for {_packageType} and {_platform}.");
-                        return false;
-                    }
-
-                    _targetPackage = packages.FirstOrDefault();
-                }
-                else
-                {
-                    _targetPackage = await _runnerServer.GetPackageAsync(_packageType, _platform, targetVersion, true, token);
-                    if (_targetPackage == null)
-                    {
-                        Trace.Info($"There is no package for {_packageType} and {_platform} with version {targetVersion}.");
-                        return false;
-                    }
                 }
             }
 

src/Runner.Worker/ExecutionContext.cs

@@ -508,8 +508,6 @@ 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/Handlers/NodeScriptActionHandler.cs

@@ -72,6 +72,11 @@ namespace GitHub.Runner.Worker.Handlers
                 Environment["ACTIONS_RESULTS_URL"] = resultsUrl;
             }
 
+            if (ExecutionContext.Global.Variables.GetBoolean("actions_uses_cache_service_v2") ?? false)
+            {
+                Environment["ACTIONS_CACHE_SERVICE_V2"] = bool.TrueString;
+            }
+
             // Resolve the target script.
             string target = null;
             if (stage == ActionRunStage.Main)

src/Sdk/RSWebApi/Contracts/StepResult.cs

@@ -19,12 +19,6 @@ 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/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.425"
+DOTNETSDK_VERSION="6.0.421"
 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.425"
+    "version": "6.0.421"
   }
 }

src/runnerversion

@@ -1 +1 @@
-2.319.0
+2.320.1