Release version 288.1

.github/workflows/release.yml

@@ -101,11 +101,11 @@ jobs:
       working-directory: src
 
     # Run tests
-    #- name: L0
+    - name: L0
-    #  run: |
+      run: |
-    #    ${{ matrix.devScript }} test
+        ${{ matrix.devScript }} test
-    #  working-directory: src
+      working-directory: src
-    #  if: matrix.runtime != 'linux-arm64' && matrix.runtime != 'linux-arm'
+      if: matrix.runtime != 'linux-arm64' && matrix.runtime != 'linux-arm'
 
     # Create runner package tar.gz/zip
     - name: Package Release
@@ -260,17 +260,6 @@ jobs:
           console.log(releaseNote)
           core.setOutput('version', runnerVersion);
           core.setOutput('note', releaseNote);
-
-    - name: Validate Packages HASH
-      working-directory: _package
-      run: |
-        ls -l
-        echo "${{needs.build.outputs.win-x64-sha}}  actions-runner-win-x64-${{ steps.releaseNote.outputs.version }}.zip" | shasum -a 256 -c
-        echo "${{needs.build.outputs.osx-x64-sha}}  actions-runner-osx-x64-${{ steps.releaseNote.outputs.version }}.tar.gz" | shasum -a 256 -c
-        echo "${{needs.build.outputs.linux-x64-sha}}  actions-runner-linux-x64-${{ steps.releaseNote.outputs.version }}.tar.gz" | shasum -a 256 -c
-        echo "${{needs.build.outputs.linux-arm-sha}}  actions-runner-linux-arm-${{ steps.releaseNote.outputs.version }}.tar.gz" | shasum -a 256 -c
-        echo "${{needs.build.outputs.linux-arm64-sha}}  actions-runner-linux-arm64-${{ steps.releaseNote.outputs.version }}.tar.gz" | shasum -a 256 -c
-
     # Create GitHub release
     - uses: actions/create-release@master
       id: createRelease

releaseNote.md

@@ -1,11 +1,32 @@
 ## Features
 
+- Make run.sh|cmd handle update without quitting so containers using them as entrypoints don't exit on update (#1646, #1633, #1708)
+- Add support for Step Summary (#1642, #1667, #1712) 
+- Pass jobId to the actionsDownloadInfo controller (#1639)
+- updated systemd svc.sh to accept custom service file (#1612) 
+- Add ability to specify runner group when creating service (#1675)
+- Prefer node16 over node12 when running internal scripts (#1621) 
+- Sending telemetry about actions usage. (#1688) 
+- Bump node12 version to latest (#1651)
+- Add internal to node version function and use better env var name (#1715)
+- Force JS Actions Node version to 16 if FF is on unless user opted out (#1716)
+
 ## Bugs
-- Fixed a bug where windows path separators were used in generated folders (#1617)
+- Fix windows console runner update crash (#1670) 
-- Fixed an issue where runner's invoked via `run.sh` or `run.cmd` did not properly restart after update (#1812). This fix applies to all future updates after installing this version
+- Retry policy for methods GetTenantCredential and GetJITRunnerTokenAsync (#1691)
+- Skip DeleteAgentSession when the acess token has been revoked. (#1692)
+- Repaired hashFiles call so if error was thrown, it was returned to process invoker (#1678)
+- Runner throws null ref exception when new line after EOF is missing (#1687)
+- Lets allow up to 150 characters for services on linux/mac (#1710) 
 
 ## Misc
-- Relaxed Actions Summary size limit to 1MiB (#1839)
+
+- Added examples and aligned language within docs/checks/actions.md (#1664)
+- Problem with debugging on macOS M1 (#1625) 
+- Fix typo in hashFiles.ts. (#1672) 
+- Allow mocked updates for E2E testing (#1654)
+- Move JobTelemetry and StepsTelemetry into GlobalContext. (#1680) 
+- Fix inconsistency of outputs (both canceled and cancelled are used (#1624)
 
 ## Windows x64
 We recommend configuring the runner in a root folder of the Windows drive (e.g. "C:\actions-runner"). This will help avoid issues related to service identity folder permissions and long file path restrictions on Windows.

releaseVersion

@@ -1 +1 @@
-2.291.1
+2.288.1

src/Misc/expressionFunc/hashFiles/.eslintrc.json

@@ -1,6 +1,6 @@
 {
-    "plugins": ["@typescript-eslint"],
+    "plugins": ["jest", "@typescript-eslint"],
-    "extends": ["plugin:github/recommended"],
+    "extends": ["plugin:github/es6"],
     "parser": "@typescript-eslint/parser",
     "parserOptions": {
       "ecmaVersion": 9,
@@ -17,16 +17,13 @@
       "@typescript-eslint/no-require-imports": "error",
       "@typescript-eslint/array-type": "error",
       "@typescript-eslint/await-thenable": "error",
-      "@typescript-eslint/naming-convention": [
+      "@typescript-eslint/ban-ts-ignore": "error",
-        "error",
-        {
-          "selector": "default",
-          "format": ["camelCase"]
-        }
-      ],
       "camelcase": "off",
+      "@typescript-eslint/camelcase": "error",
+      "@typescript-eslint/class-name-casing": "error",
       "@typescript-eslint/explicit-function-return-type": ["error", {"allowExpressions": true}],
       "@typescript-eslint/func-call-spacing": ["error", "never"],
+      "@typescript-eslint/generic-type-naming": ["error", "^[A-Z][A-Za-z]*$"],
       "@typescript-eslint/no-array-constructor": "error",
       "@typescript-eslint/no-empty-interface": "error",
       "@typescript-eslint/no-explicit-any": "error",
@@ -36,6 +33,7 @@
       "@typescript-eslint/no-misused-new": "error",
       "@typescript-eslint/no-namespace": "error",
       "@typescript-eslint/no-non-null-assertion": "warn",
+      "@typescript-eslint/no-object-literal-type-assertion": "error",
       "@typescript-eslint/no-unnecessary-qualifier": "error",
       "@typescript-eslint/no-unnecessary-type-assertion": "error",
       "@typescript-eslint/no-useless-constructor": "error",
@@ -43,19 +41,19 @@
       "@typescript-eslint/prefer-for-of": "warn",
       "@typescript-eslint/prefer-function-type": "warn",
       "@typescript-eslint/prefer-includes": "error",
+      "@typescript-eslint/prefer-interface": "error",
       "@typescript-eslint/prefer-string-starts-ends-with": "error",
       "@typescript-eslint/promise-function-async": "error",
       "@typescript-eslint/require-array-sort-compare": "error",
       "@typescript-eslint/restrict-plus-operands": "error",
+      "semi": "off",
       "@typescript-eslint/semi": ["error", "never"],
       "@typescript-eslint/type-annotation-spacing": "error",
-      "@typescript-eslint/unbound-method": "error",
+      "@typescript-eslint/unbound-method": "error"
-      "filenames/match-regex" : "off",
-      "github/no-then" : 1, // warning
-      "semi": "off"
     },
     "env": {
       "node": true,
-      "es6": true
+      "es6": true,
+      "jest/globals": true
     }
   }

src/Misc/expressionFunc/hashFiles/package.json

@@ -25,10 +25,10 @@
   },
   "devDependencies": {
     "@types/node": "^12.7.12",
-    "@typescript-eslint/parser": "^5.15.0",
+    "@typescript-eslint/parser": "^2.8.0",
     "@zeit/ncc": "^0.20.5",
-    "eslint": "^8.11.0",
+    "eslint": "^6.8.0",
-    "eslint-plugin-github": "^4.3.5",
+    "eslint-plugin-github": "^2.0.0",
     "prettier": "^1.19.1",
     "typescript": "^3.6.4"
   }

src/Misc/expressionFunc/hashFiles/src/hashFiles.ts

@@ -1,9 +1,9 @@
+import * as glob from '@actions/glob'
 import * as crypto from 'crypto'
 import * as fs from 'fs'
-import * as glob from '@actions/glob'
-import * as path from 'path'
 import * as stream from 'stream'
 import * as util from 'util'
+import * as path from 'path'
 
 async function run(): Promise<void> {
   // arg0 -> node

src/Misc/layoutbin/RunnerService.js

@@ -3,135 +3,94 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 var childProcess = require("child_process");
-var path = require("path");
+var path = require("path")
 
-var supported = ["linux", "darwin"];
+var supported = ['linux', 'darwin']
 
 if (supported.indexOf(process.platform) == -1) {
-  console.log("Unsupported platform: " + process.platform);
+    console.log('Unsupported platform: ' + process.platform);
-  console.log("Supported platforms are: " + supported.toString());
+    console.log('Supported platforms are: ' + supported.toString());
-  process.exit(1);
+    process.exit(1);
 }
 
 var stopping = false;
 var listener = null;
 
-var exitServiceAfterNFailures = Number(
+var runService = function () {
-  process.env.GITHUB_ACTIONS_SERVICE_EXIT_AFTER_N_FAILURES
+    var listenerExePath = path.join(__dirname, '../bin/Runner.Listener');
-);
+    var interactive = process.argv[2] === "interactive";
 
-if (exitServiceAfterNFailures <= 0) {
+    if (!stopping) {
-  exitServiceAfterNFailures = NaN;
+        try {
+            if (interactive) {
+                console.log('Starting Runner listener interactively');
+                listener = childProcess.spawn(listenerExePath, ['run'], { env: process.env });
+            } else {
+                console.log('Starting Runner listener with startup type: service');
+                listener = childProcess.spawn(listenerExePath, ['run', '--startuptype', 'service'], { env: process.env });
+            }
+
+            console.log(`Started listener process, pid: ${listener.pid}`);
+
+            listener.stdout.on('data', (data) => {
+                process.stdout.write(data.toString('utf8'));
+            });
+
+            listener.stderr.on('data', (data) => {
+                process.stdout.write(data.toString('utf8'));
+            });
+
+            listener.on("error", (err) => {
+                console.log(`Runner listener fail to start with error ${err.message}`);
+            });
+
+            listener.on('close', (code) => {
+                console.log(`Runner listener exited with error code ${code}`);
+
+                if (code === 0) {
+                    console.log('Runner listener exit with 0 return code, stop the service, no retry needed.');
+                    stopping = true;
+                } else if (code === 1) {
+                    console.log('Runner listener exit with terminated error, stop the service, no retry needed.');
+                    stopping = true;
+                } else if (code === 2) {
+                    console.log('Runner listener exit with retryable error, re-launch runner in 5 seconds.');
+                } else if (code === 3) {
+                    console.log('Runner listener exit because of updating, re-launch runner in 5 seconds.');
+                } else {
+                    console.log('Runner listener exit with undefined return code, re-launch runner in 5 seconds.');
+                }
+
+                if (!stopping) {
+                    setTimeout(runService, 5000);
+                }
+            });
+
+        } catch (ex) {
+            console.log(ex);
+        }
+    }
 }
 
-var consecutiveFailureCount = 0;
-
-var gracefulShutdown = function () {
-  console.log("Shutting down runner listener");
-  stopping = true;
-  if (listener) {
-    console.log("Sending SIGINT to runner listener to stop");
-    listener.kill("SIGINT");
-
-    console.log("Sending SIGKILL to runner listener");
-    setTimeout(() => listener.kill("SIGKILL"), 30000).unref();
-  }
-};
-
-var runService = function () {
-  var listenerExePath = path.join(__dirname, "../bin/Runner.Listener");
-  var interactive = process.argv[2] === "interactive";
-
-  if (!stopping) {
-    try {
-      if (interactive) {
-        console.log("Starting Runner listener interactively");
-        listener = childProcess.spawn(listenerExePath, ["run"], {
-          env: process.env,
-        });
-      } else {
-        console.log("Starting Runner listener with startup type: service");
-        listener = childProcess.spawn(
-          listenerExePath,
-          ["run", "--startuptype", "service"],
-          { env: process.env }
-        );
-      }
-
-      console.log(`Started listener process, pid: ${listener.pid}`);
-
-      listener.stdout.on("data", (data) => {
-        if (data.toString("utf8").includes("Listening for Jobs")) {
-          consecutiveFailureCount = 0;
-        }
-        process.stdout.write(data.toString("utf8"));
-      });
-
-      listener.stderr.on("data", (data) => {
-        process.stdout.write(data.toString("utf8"));
-      });
-
-      listener.on("error", (err) => {
-        console.log(`Runner listener fail to start with error ${err.message}`);
-      });
-
-      listener.on("close", (code) => {
-        console.log(`Runner listener exited with error code ${code}`);
-
-        if (code === 0) {
-          console.log(
-            "Runner listener exit with 0 return code, stop the service, no retry needed."
-          );
-          stopping = true;
-        } else if (code === 1) {
-          console.log(
-            "Runner listener exit with terminated error, stop the service, no retry needed."
-          );
-          stopping = true;
-        } else if (code === 2) {
-          console.log(
-            "Runner listener exit with retryable error, re-launch runner in 5 seconds."
-          );
-          consecutiveFailureCount = 0;
-        } else if (code === 3 || code === 4) {
-          console.log(
-            "Runner listener exit because of updating, re-launch runner in 5 seconds."
-          );
-          consecutiveFailureCount = 0;
-        } else {
-          var messagePrefix = "Runner listener exit with undefined return code";
-          consecutiveFailureCount++;
-          if (
-            !isNaN(exitServiceAfterNFailures) &&
-            consecutiveFailureCount >= exitServiceAfterNFailures
-          ) {
-            console.error(
-              `${messagePrefix}, exiting service after ${consecutiveFailureCount} consecutive failures`
-            );
-            gracefulShutdown();
-            return;
-          } else {
-            console.log(`${messagePrefix}, re-launch runner in 5 seconds.`);
-          }
-        }
-
-        if (!stopping) {
-          setTimeout(runService, 5000);
-        }
-      });
-    } catch (ex) {
-      console.log(ex);
-    }
-  }
-};
-
 runService();
-console.log("Started running service");
+console.log('Started running service');
 
-process.on("SIGINT", () => {
+var gracefulShutdown = function (code) {
-  gracefulShutdown();
+    console.log('Shutting down runner listener');
+    stopping = true;
+    if (listener) {
+        console.log('Sending SIGINT to runner listener to stop');
+        listener.kill('SIGINT');
+
+        console.log('Sending SIGKILL to runner listener');
+        setTimeout(() => listener.kill('SIGKILL'), 30000).unref();
+    }
+}
+
+process.on('SIGINT', () => {
+    gracefulShutdown(0);
 });
 
-process.on("SIGTERM", () => {
+process.on('SIGTERM', () => {
-  gracefulShutdown();
+    gracefulShutdown(0);
 });

src/Misc/layoutbin/darwin.svc.sh.template

@@ -63,7 +63,7 @@ function install()
     mkdir -p "${log_path}" || failed "failed to create ${log_path}"
 
     echo Creating ${PLIST_PATH}
-    sed "s/{{User}}/${USER:-$SUDO_USER}/g; s/{{SvcName}}/$SVC_NAME/g; s@{{RunnerRoot}}@${RUNNER_ROOT}@g; s@{{UserHome}}@$HOME@g;" "${TEMPLATE_PATH}" > "${TEMP_PATH}" || failed "failed to create replacement temp file"
+    sed "s/{{User}}/${SUDO_USER:-$USER}/g; s/{{SvcName}}/$SVC_NAME/g; s@{{RunnerRoot}}@${RUNNER_ROOT}@g; s@{{UserHome}}@$HOME@g;" "${TEMPLATE_PATH}" > "${TEMP_PATH}" || failed "failed to create replacement temp file"
     mv "${TEMP_PATH}" "${PLIST_PATH}" || failed "failed to copy plist"
 
     # Since we started with sudo, runsvc.sh will be owned by root. Change this to current login user.

src/Misc/layoutbin/hashFiles/index.js

@@ -1557,12 +1557,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const glob = __importStar(__webpack_require__(281));
 const crypto = __importStar(__webpack_require__(417));
 const fs = __importStar(__webpack_require__(747));
-const glob = __importStar(__webpack_require__(281));
-const path = __importStar(__webpack_require__(622));
 const stream = __importStar(__webpack_require__(413));
 const util = __importStar(__webpack_require__(669));
+const path = __importStar(__webpack_require__(622));
 function run() {
     var e_1, _a;
     return __awaiter(this, void 0, void 0, function* () {

src/Misc/layoutbin/update.sh.template

@@ -30,13 +30,13 @@ date "+[%F %T-%4N] Waiting for $runnerprocessname ($runnerpid) to complete" >> "
 while [ -e /proc/$runnerpid ]
 do
     date "+[%F %T-%4N] Process $runnerpid still running" >> "$logfile" 2>&1
-    "$rootfolder"/safe_sleep.sh 2
+    sleep 2
 done
 date "+[%F %T-%4N] Process $runnerpid finished running" >> "$logfile" 2>&1
 
 # start re-organize folders
 date "+[%F %T-%4N] Sleep 1 more second to make sure process exited" >> "$logfile" 2>&1
-"$rootfolder"/safe_sleep.sh 1
+sleep 1
 
 # the folder structure under runner root will be
 # ./bin -> bin.2.100.0 (junction folder)

src/Misc/layoutroot/run-helper.sh.template

@@ -10,6 +10,22 @@ fi
 # Run
 shopt -s nocasematch
 
+safe_sleep() {
+    if [ ! -x "$(command -v sleep)" ]; then
+        if [ ! -x "$(command -v ping)" ]; then
+            COUNT="0"
+            while [[ $COUNT != 5000 ]]; do
+                echo "SLEEP" > /dev/null
+                COUNT=$[$COUNT+1]
+            done
+        else
+            ping -c 5 127.0.0.1 > /dev/null
+        fi
+    else
+        sleep 5
+    fi
+}
+
 SOURCE="${BASH_SOURCE[0]}"
 while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
     DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
@@ -28,17 +44,17 @@ elif [[ $returnCode == 1 ]]; then
     exit 0
 elif [[ $returnCode == 2 ]]; then
     echo "Runner listener exit with retryable error, re-launch runner in 5 seconds."
-    "$DIR"/safe_sleep.sh 5
+    safe_sleep
     exit 2
 elif [[ $returnCode == 3 ]]; then
     # Sleep 5 seconds to wait for the runner update process finish
     echo "Runner listener exit because of updating, re-launch runner in 5 seconds"
-    "$DIR"/safe_sleep.sh 5
+    safe_sleep
     exit 2
 elif [[ $returnCode == 4 ]]; then
     # Sleep 5 seconds to wait for the ephemeral runner update process finish
     echo "Runner listener exit because of updating, re-launch ephemeral runner in 5 seconds"
-    "$DIR"/safe_sleep.sh 5
+    safe_sleep
     exit 2
 else
     echo "Exiting with unknown error code: ${returnCode}"

src/Misc/layoutroot/safe_sleep.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-
-SECONDS=0
-while [[ $SECONDS != $1 ]]; do
-    :
-done

src/Runner.Common/Constants.cs

@@ -86,7 +86,7 @@ namespace GitHub.Runner.Common
             public static class CommandLine
             {
                 //if you are adding a new arg, please make sure you update the
-                //validOptions dictionary as well present in the CommandSettings.cs
+                //validArgs array as well present in the CommandSettings.cs
                 public static class Args
                 {
                     public static readonly string Auth = "auth";
@@ -121,7 +121,7 @@ namespace GitHub.Runner.Common
                 }
 
                 //if you are adding a new flag, please make sure you update the
-                //validOptions dictionary as well present in the CommandSettings.cs
+                //validFlags array as well present in the CommandSettings.cs
                 public static class Flags
                 {
                     public static readonly string Check = "check";
@@ -149,8 +149,6 @@ namespace GitHub.Runner.Common
             public static class Features
             {
                 public static readonly string DiskSpaceWarning = "runner.diskspace.warning";
-                public static readonly string Node12Warning = "DistributedTask.AddWarningToNode12Action";
-                public static readonly string UseContainerPathForTemplate = "DistributedTask.UseContainerPathForTemplate";
             }
 
             public static readonly string InternalTelemetryIssueDataKey = "_internal_telemetry";
@@ -160,7 +158,6 @@ namespace GitHub.Runner.Common
             public static readonly string UnsupportedCommandMessageDisabled = "The `{0}` command is disabled. Please upgrade to using Environment Files or opt into unsecure command execution by setting the `ACTIONS_ALLOW_UNSECURE_COMMANDS` environment variable to `true`. For more information see: https://github.blog/changelog/2020-10-01-github-actions-deprecating-set-env-and-add-path-commands/";
             public static readonly string UnsupportedStopCommandTokenDisabled = "You cannot use a endToken that is an empty string, the string 'pause-logging', or another workflow command. For more information see: https://docs.github.com/actions/learn-github-actions/workflow-commands-for-github-actions#example-stopping-and-starting-workflow-commands or opt into insecure command execution by setting the `ACTIONS_ALLOW_UNSECURE_STOPCOMMAND_TOKENS` environment variable to `true`.";
             public static readonly string UnsupportedSummarySize = "$GITHUB_STEP_SUMMARY upload aborted, supports content up to a size of {0}k, got {1}k. For more information see: https://docs.github.com/actions/using-workflows/workflow-commands-for-github-actions#adding-a-markdown-summary";
-            public static readonly string Node12DetectedAfterEndOfLife = "Node.js 12 actions are deprecated. Please update the following actions to use Node.js 16: {0}";
         }
 
         public static class RunnerEvent
@@ -192,12 +189,6 @@ namespace GitHub.Runner.Common
             public static readonly string Success = "success";
         }
 
-        public static class Hooks
-        {
-            public static readonly string JobStartedStepName = "Set up runner";
-            public static readonly string JobCompletedStepName = "Complete runner";
-        }
-
         public static class Path
         {
             public static readonly string ActionsDirectory = "_actions";

src/Runner.Common/JobServer.cs

@@ -2,31 +2,24 @@ using GitHub.DistributedTask.WebApi;
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 using System.Net.Http;
-using System.Net.Http.Headers;
-using System.Net.WebSockets;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using GitHub.Runner.Sdk;
 using GitHub.Services.Common;
 using GitHub.Services.WebApi;
-using GitHub.Services.WebApi.Utilities.Internal;
-using Newtonsoft.Json;
 
 namespace GitHub.Runner.Common
 {
     [ServiceLocator(Default = typeof(JobServer))]
-    public interface IJobServer : IRunnerService, IAsyncDisposable
+    public interface IJobServer : IRunnerService
     {
         Task ConnectAsync(VssConnection jobConnection);
 
-        void InitializeWebsocketClient(ServiceEndpoint serviceEndpoint);
-
         // logging and console
         Task<TaskLog> AppendLogContentAsync(Guid scopeIdentifier, string hubName, Guid planId, int logId, Stream uploadStream, CancellationToken cancellationToken);
-        Task AppendTimelineRecordFeedAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, Guid stepId, IList<string> lines, long? startLine, CancellationToken cancellationToken);
+        Task AppendTimelineRecordFeedAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, Guid stepId, IList<string> lines, CancellationToken cancellationToken);
+        Task AppendTimelineRecordFeedAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, Guid stepId, IList<string> lines, long startLine, CancellationToken cancellationToken);
         Task<TaskAttachment> CreateAttachmentAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, String type, String name, Stream uploadStream, CancellationToken cancellationToken);
         Task<TaskLog> CreateLogAsync(Guid scopeIdentifier, string hubName, Guid planId, TaskLog log, CancellationToken cancellationToken);
         Task<Timeline> CreateTimelineAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, CancellationToken cancellationToken);
@@ -41,20 +34,6 @@ namespace GitHub.Runner.Common
         private bool _hasConnection;
         private VssConnection _connection;
         private TaskHttpClient _taskClient;
-        private ClientWebSocket _websocketClient;
-
-        private ServiceEndpoint _serviceEndpoint;
-
-        private int totalBatchedLinesAttemptedByWebsocket = 0;
-        private int failedAttemptsToPostBatchedLinesByWebsocket = 0;
-
-
-        private static readonly TimeSpan _minDelayForWebsocketReconnect = TimeSpan.FromMilliseconds(100);
-        private static readonly TimeSpan _maxDelayForWebsocketReconnect = TimeSpan.FromMilliseconds(500);
-        private static readonly int _minWebsocketFailurePercentageAllowed = 50;
-        private static readonly int _minWebsocketBatchedLinesCountToConsider = 5;
-
-        private Task _websocketConnectTask;
 
         public async Task ConnectAsync(VssConnection jobConnection)
         {
@@ -138,21 +117,6 @@ namespace GitHub.Runner.Common
             }
         }
 
-        public void InitializeWebsocketClient(ServiceEndpoint serviceEndpoint)
-        {
-             this._serviceEndpoint = serviceEndpoint;
-             InitializeWebsocketClient(TimeSpan.Zero);
-        }
-
-        public ValueTask DisposeAsync()
-        {
-            CloseWebSocket(WebSocketCloseStatus.NormalClosure, CancellationToken.None);
-
-            GC.SuppressFinalize(this);
-
-            return ValueTask.CompletedTask;
-        }
-
         private void CheckConnection()
         {
             if (!_hasConnection)
@@ -161,53 +125,6 @@ namespace GitHub.Runner.Common
             }
         }
 
-        private void InitializeWebsocketClient(TimeSpan delay)
-        {
-             if (_serviceEndpoint.Authorization != null &&
-                 _serviceEndpoint.Authorization.Parameters.TryGetValue(EndpointAuthorizationParameters.AccessToken, out var accessToken) &&
-                 !string.IsNullOrEmpty(accessToken))
-            {
-                if (_serviceEndpoint.Data.TryGetValue("FeedStreamUrl", out var feedStreamUrl) && !string.IsNullOrEmpty(feedStreamUrl))
-                {
-                    // let's ensure we use the right scheme
-                    feedStreamUrl = feedStreamUrl.Replace("https://", "wss://").Replace("http://", "ws://");
-                    Trace.Info($"Creating websocket client ..." + feedStreamUrl);
-                    this._websocketClient = new ClientWebSocket();
-                    this._websocketClient.Options.SetRequestHeader("Authorization", $"Bearer {accessToken}");
-                    var userAgentValues = new List<ProductInfoHeaderValue>();
-                    userAgentValues.AddRange(UserAgentUtility.GetDefaultRestUserAgent());
-                    userAgentValues.AddRange(HostContext.UserAgents);
-                    this._websocketClient.Options.SetRequestHeader("User-Agent", string.Join(" ", userAgentValues.Select(x=>x.ToString())));
-
-                    this._websocketConnectTask = ConnectWebSocketClient(feedStreamUrl, delay);
-                }
-                else
-                {
-                    Trace.Info($"No FeedStreamUrl found, so we will use Rest API calls for sending feed data");
-                }
-            }
-            else
-            {
-                Trace.Info($"No access token from the service endpoint");
-            }
-        }
-
-        private async Task ConnectWebSocketClient(string feedStreamUrl, TimeSpan delay)
-        {
-            try
-            {
-                Trace.Info($"Attempting to start websocket client with delay {delay}.");
-                await Task.Delay(delay);
-                await this._websocketClient.ConnectAsync(new Uri(feedStreamUrl), default(CancellationToken));
-                Trace.Info($"Successfully started websocket client.");
-            }
-            catch(Exception ex)
-            {
-                Trace.Info("Exception caught during websocket client connect, fallback of HTTP would be used now instead of websocket.");
-                Trace.Error(ex);
-            }
-        }
-
         //-----------------------------------------------------------------
         // Feedback: WebConsole, TimelineRecords and Logs
         //-----------------------------------------------------------------
@@ -218,86 +135,16 @@ namespace GitHub.Runner.Common
             return _taskClient.AppendLogContentAsync(scopeIdentifier, hubName, planId, logId, uploadStream, cancellationToken: cancellationToken);
         }
 
-        public async Task AppendTimelineRecordFeedAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, Guid stepId, IList<string> lines, long? startLine, CancellationToken cancellationToken)
+        public Task AppendTimelineRecordFeedAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, Guid stepId, IList<string> lines, CancellationToken cancellationToken)
         {
             CheckConnection();
-            var pushedLinesViaWebsocket = false;
+            return _taskClient.AppendTimelineRecordFeedAsync(scopeIdentifier, hubName, planId, timelineId, timelineRecordId, stepId, lines, cancellationToken: cancellationToken);
-            if (_websocketConnectTask != null)
-            {
-                await _websocketConnectTask;
-            }
-
-            // "_websocketClient != null" implies either: We have a successful connection OR we have to attempt sending again and then reconnect
-            // ...in other words, if websocket client is null, we will skip sending to websocket and just use rest api calls to send data
-            if (_websocketClient != null)
-            {
-                var linesWrapper =  startLine.HasValue? new TimelineRecordFeedLinesWrapper(stepId, lines, startLine.Value):  new TimelineRecordFeedLinesWrapper(stepId, lines);
-                var jsonData = StringUtil.ConvertToJson(linesWrapper);
-                try
-                {
-                    totalBatchedLinesAttemptedByWebsocket++;
-                    var jsonDataBytes = Encoding.UTF8.GetBytes(jsonData);
-                    // break the message into chunks of 1024 bytes
-                    for (var i = 0; i < jsonDataBytes.Length; i += 1 * 1024)
-                    {
-                        var lastChunk = i + (1 * 1024) >= jsonDataBytes.Length;
-                        var chunk = new ArraySegment<byte>(jsonDataBytes, i, Math.Min(1 * 1024, jsonDataBytes.Length - i));
-                        await _websocketClient.SendAsync(chunk, WebSocketMessageType.Text, endOfMessage:lastChunk, cancellationToken);
-                    }
-
-                    pushedLinesViaWebsocket = true;
-                }
-                catch (Exception ex)
-                {
-                    failedAttemptsToPostBatchedLinesByWebsocket++;
-                    Trace.Info($"Caught exception during append web console line to websocket, let's fallback to sending via non-websocket call (total calls: {totalBatchedLinesAttemptedByWebsocket}, failed calls: {failedAttemptsToPostBatchedLinesByWebsocket}, websocket state: {this._websocketClient?.State}).");
-                    Trace.Error(ex);
-                    if (totalBatchedLinesAttemptedByWebsocket > _minWebsocketBatchedLinesCountToConsider)
-                    {
-                        // let's consider failure percentage
-                        if (failedAttemptsToPostBatchedLinesByWebsocket * 100 / totalBatchedLinesAttemptedByWebsocket > _minWebsocketFailurePercentageAllowed)
-                        {
-                            Trace.Info($"Exhausted websocket allowed retries, we will not attempt websocket connection for this job to post lines again.");
-                            CloseWebSocket(WebSocketCloseStatus.InternalServerError, cancellationToken);
-
-                            // By setting it to null, we will ensure that we never try websocket path again for this job
-                            _websocketClient = null;
-                        }
-                    }
-
-                    if (_websocketClient != null)
-                    {
-                        var delay = BackoffTimerHelper.GetRandomBackoff(_minDelayForWebsocketReconnect, _maxDelayForWebsocketReconnect);
-                        Trace.Info($"Websocket is not open, let's attempt to connect back again with random backoff {delay} ms (total calls: {totalBatchedLinesAttemptedByWebsocket}, failed calls: {failedAttemptsToPostBatchedLinesByWebsocket}).");
-                        InitializeWebsocketClient(delay);
-                    }
-                }
-            }
-
-            if (!pushedLinesViaWebsocket)
-            {
-                if (startLine.HasValue)
-                {
-                    await _taskClient.AppendTimelineRecordFeedAsync(scopeIdentifier, hubName, planId, timelineId, timelineRecordId, stepId, lines, startLine.Value, cancellationToken: cancellationToken);
-                }
-                else
-                {
-                    await _taskClient.AppendTimelineRecordFeedAsync(scopeIdentifier, hubName, planId, timelineId, timelineRecordId, stepId, lines, cancellationToken: cancellationToken);
-                }
-            }
         }
 
-        private void CloseWebSocket(WebSocketCloseStatus closeStatus, CancellationToken cancellationToken)
+        public Task AppendTimelineRecordFeedAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, Guid stepId, IList<string> lines, long startLine, CancellationToken cancellationToken)
         {
-            try
+            CheckConnection();
-            {
+            return _taskClient.AppendTimelineRecordFeedAsync(scopeIdentifier, hubName, planId, timelineId, timelineRecordId, stepId, lines, startLine, cancellationToken: cancellationToken);
-                _websocketClient?.CloseOutputAsync(closeStatus, "Closing websocket", cancellationToken);
-            }
-            catch (Exception websocketEx)
-            {
-                // In some cases this might be okay since the websocket might be open yet, so just close and don't trace exceptions
-                Trace.Info($"Failed to close websocket gracefully {websocketEx.GetType().Name}");
-            }
         }
 
         public Task<TaskAttachment> CreateAttachmentAsync(Guid scopeIdentifier, string hubName, Guid planId, Guid timelineId, Guid timelineRecordId, string type, string name, Stream uploadStream, CancellationToken cancellationToken)

src/Runner.Common/JobServerQueue.cs

@@ -71,7 +71,7 @@ namespace GitHub.Runner.Common
 
         // Web console dequeue will start with process queue every 250ms for the first 60*4 times (~60 seconds).
         // Then the dequeue will happen every 500ms.
-        // In this way, customer still can get instance live console output on job start,
+        // In this way, customer still can get instance live console output on job start, 
         // at the same time we can cut the load to server after the build run for more than 60s
         private int _webConsoleLineAggressiveDequeueCount = 0;
         private const int _webConsoleLineAggressiveDequeueLimit = 4 * 60;
@@ -89,10 +89,6 @@ namespace GitHub.Runner.Common
         {
             Trace.Entering();
 
-            var serviceEndPoint = jobRequest.Resources.Endpoints.Single(x => string.Equals(x.Name, WellKnownServiceEndpointNames.SystemVssConnection, StringComparison.OrdinalIgnoreCase));
-
-            _jobServer.InitializeWebsocketClient(serviceEndPoint);
-
             if (_queueInProcess)
             {
                 Trace.Info("No-opt, all queue process tasks are running.");
@@ -160,9 +156,6 @@ namespace GitHub.Runner.Common
             await ProcessTimelinesUpdateQueueAsync(runOnce: true);
             Trace.Info("Timeline update queue drained.");
 
-            Trace.Info($"Disposing job server ...");
-            await _jobServer.DisposeAsync();
-
             Trace.Info("All queue process tasks have been stopped, and all queues are drained.");
         }
 
@@ -299,7 +292,15 @@ namespace GitHub.Runner.Common
                         {
                             try
                             {
-                                await _jobServer.AppendTimelineRecordFeedAsync(_scopeIdentifier, _hubName, _planId, _jobTimelineId, _jobTimelineRecordId, stepRecordId, batch.Select(logLine => logLine.Line).ToList(), batch[0].LineNumber, default(CancellationToken));
+                                // we will not requeue failed batch, since the web console lines are time sensitive.
+                                if (batch[0].LineNumber.HasValue)
+                                {
+                                    await _jobServer.AppendTimelineRecordFeedAsync(_scopeIdentifier, _hubName, _planId, _jobTimelineId, _jobTimelineRecordId, stepRecordId, batch.Select(logLine => logLine.Line).ToList(), batch[0].LineNumber.Value, default(CancellationToken));
+                                }
+                                else
+                                {
+                                    await _jobServer.AppendTimelineRecordFeedAsync(_scopeIdentifier, _hubName, _planId, _jobTimelineId, _jobTimelineRecordId, stepRecordId, batch.Select(logLine => logLine.Line).ToList(), default(CancellationToken));
+                                }
 
                                 if (_firstConsoleOutputs)
                                 {
@@ -488,8 +489,8 @@ namespace GitHub.Runner.Common
 
                 if (runOnce)
                 {
-                    // continue process timeline records update,
+                    // continue process timeline records update, 
-                    // we might have more records need update,
+                    // we might have more records need update, 
                     // since we just create a new sub-timeline
                     if (pendingSubtimelineUpdate)
                     {

src/Runner.Listener/CommandSettings.cs

@@ -17,57 +17,43 @@ namespace GitHub.Runner.Listener
         private readonly IPromptManager _promptManager;
         private readonly Tracing _trace;
 
-        // Valid flags for all commands
+        private readonly string[] validCommands =
-        private readonly string[] genericOptions =
         {
-            Constants.Runner.CommandLine.Flags.Help,
+            Constants.Runner.CommandLine.Commands.Configure,
-            Constants.Runner.CommandLine.Flags.Version,
+            Constants.Runner.CommandLine.Commands.Remove,
-            Constants.Runner.CommandLine.Flags.Commit,
+            Constants.Runner.CommandLine.Commands.Run,
-            Constants.Runner.CommandLine.Flags.Check
+            Constants.Runner.CommandLine.Commands.Warmup,
         };
 
-        // Valid flags and args for specific command - key: command, value: array of valid flags and args
+        private readonly string[] validFlags =
-        private readonly Dictionary<string, string[]> validOptions = new Dictionary<string, string[]>
         {
-            // Valid configure flags and args
+            Constants.Runner.CommandLine.Flags.Check,
-            [Constants.Runner.CommandLine.Commands.Configure] = 
+            Constants.Runner.CommandLine.Flags.Commit,
-                new string[] 
+            Constants.Runner.CommandLine.Flags.DisableUpdate,
-                {
+            Constants.Runner.CommandLine.Flags.Ephemeral,
-                    Constants.Runner.CommandLine.Flags.DisableUpdate,
+            Constants.Runner.CommandLine.Flags.Help,
-                    Constants.Runner.CommandLine.Flags.Ephemeral,
+            Constants.Runner.CommandLine.Flags.Once,
-                    Constants.Runner.CommandLine.Flags.Replace,
+            Constants.Runner.CommandLine.Flags.Replace,
-                    Constants.Runner.CommandLine.Flags.RunAsService,
+            Constants.Runner.CommandLine.Flags.RunAsService,
-                    Constants.Runner.CommandLine.Flags.Unattended,
+            Constants.Runner.CommandLine.Flags.Unattended,
-                    Constants.Runner.CommandLine.Args.Auth,
+            Constants.Runner.CommandLine.Flags.Version
-                    Constants.Runner.CommandLine.Args.Labels,
+        };
-                    Constants.Runner.CommandLine.Args.MonitorSocketAddress,
+
-                    Constants.Runner.CommandLine.Args.Name,
+        private readonly string[] validArgs =
-                    Constants.Runner.CommandLine.Args.PAT,
+        {
-                    Constants.Runner.CommandLine.Args.RunnerGroup,
+            Constants.Runner.CommandLine.Args.Auth,
-                    Constants.Runner.CommandLine.Args.Token,
+            Constants.Runner.CommandLine.Args.Labels,
-                    Constants.Runner.CommandLine.Args.Url,
+            Constants.Runner.CommandLine.Args.MonitorSocketAddress,
-                    Constants.Runner.CommandLine.Args.UserName,
+            Constants.Runner.CommandLine.Args.Name,
-                    Constants.Runner.CommandLine.Args.WindowsLogonAccount,
+            Constants.Runner.CommandLine.Args.PAT,
-                    Constants.Runner.CommandLine.Args.WindowsLogonPassword,
+            Constants.Runner.CommandLine.Args.RunnerGroup,
-                    Constants.Runner.CommandLine.Args.Work
+            Constants.Runner.CommandLine.Args.StartupType,
-                },
+            Constants.Runner.CommandLine.Args.Token,
-            // Valid remove flags and args
+            Constants.Runner.CommandLine.Args.Url,
-            [Constants.Runner.CommandLine.Commands.Remove] =
+            Constants.Runner.CommandLine.Args.UserName,
-                new string[]
+            Constants.Runner.CommandLine.Args.WindowsLogonAccount,
-                {
+            Constants.Runner.CommandLine.Args.WindowsLogonPassword,
-                    Constants.Runner.CommandLine.Args.Token,
+            Constants.Runner.CommandLine.Args.Work
-                    Constants.Runner.CommandLine.Args.PAT
-                },
-            // Valid run flags and args
-            [Constants.Runner.CommandLine.Commands.Run] =
-                new string[]
-                {
-                    Constants.Runner.CommandLine.Flags.Once,
-                    Constants.Runner.CommandLine.Args.StartupType
-                },
-            // valid warmup flags and args
-            [Constants.Runner.CommandLine.Commands.Warmup] =
-                new string[] { }
         };
 
         // Commands.
@@ -140,48 +126,17 @@ namespace GitHub.Runner.Listener
             List<string> unknowns = new List<string>();
 
             // detect unknown commands
-            unknowns.AddRange(_parser.Commands.Where(x => !validOptions.Keys.Contains(x, StringComparer.OrdinalIgnoreCase)));
+            unknowns.AddRange(_parser.Commands.Where(x => !validCommands.Contains(x, StringComparer.OrdinalIgnoreCase)));
 
-            if (unknowns.Count == 0)
+            // detect unknown flags
-            {
+            unknowns.AddRange(_parser.Flags.Where(x => !validFlags.Contains(x, StringComparer.OrdinalIgnoreCase)));
-                // detect unknown flags and args for valid commands
+
-                foreach (var command in _parser.Commands)
+            // detect unknown args
-                {
+            unknowns.AddRange(_parser.Args.Keys.Where(x => !validArgs.Contains(x, StringComparer.OrdinalIgnoreCase)));
-                    if (validOptions.TryGetValue(command, out string[] options))
-                    {
-                        unknowns.AddRange(_parser.Flags.Where(x => !options.Contains(x, StringComparer.OrdinalIgnoreCase) && !genericOptions.Contains(x, StringComparer.OrdinalIgnoreCase)));
-                        unknowns.AddRange(_parser.Args.Keys.Where(x => !options.Contains(x, StringComparer.OrdinalIgnoreCase)));
-                    }
-                }
-            }
 
             return unknowns;
         }
 
-        public string GetCommandName()
-        {
-            string command = string.Empty;
-
-            if (Configure)
-            {
-                command = Constants.Runner.CommandLine.Commands.Configure;
-            }
-            else if (Remove)
-            {
-                command = Constants.Runner.CommandLine.Commands.Remove;
-            }
-            else if (Run)
-            {
-                command = Constants.Runner.CommandLine.Commands.Run;
-            }
-            else if (Warmup)
-            {
-                command = Constants.Runner.CommandLine.Commands.Warmup;
-            }
-            
-            return command;
-        }
-
         //
         // Interactive flags.
         //

src/Runner.Listener/Configuration/ConfigurationManager.cs

@@ -624,12 +624,9 @@ namespace GitHub.Runner.Listener.Configuration
                     httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("basic", base64EncodingToken);
                     httpClient.DefaultRequestHeaders.UserAgent.AddRange(HostContext.UserAgents);
                     httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/vnd.github.v3+json");
-                    
-                    var responseStatus = System.Net.HttpStatusCode.OK;
                     try
                     {
                         var response = await httpClient.PostAsync(githubApiUrl, new StringContent(string.Empty));
-                        responseStatus = response.StatusCode;
 
                         if (response.IsSuccessStatusCode)
                         {
@@ -637,6 +634,11 @@ namespace GitHub.Runner.Listener.Configuration
                             var jsonResponse = await response.Content.ReadAsStringAsync();
                             return StringUtil.ConvertFromJson<GitHubRunnerRegisterToken>(jsonResponse);
                         }
+                        else if(response.StatusCode == System.Net.HttpStatusCode.NotFound)
+                        {
+                            // It doesn't make sense to retry in this case, so just stop
+                            break;
+                        }
                         else
                         {
                             _term.WriteError($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}'");
@@ -645,15 +647,15 @@ namespace GitHub.Runner.Listener.Configuration
                             response.EnsureSuccessStatusCode();
                         }
                     }
-                    catch(Exception ex) when (retryCount < 2 && responseStatus != System.Net.HttpStatusCode.NotFound)
+                    catch(Exception ex) when (retryCount < 2)
                     {
                         retryCount++;
                         Trace.Error($"Failed to get JIT runner token -- Atempt: {retryCount}");
                         Trace.Error(ex);
+                        Trace.Info("Retrying in 5 seconds");
                     }
                 }
                 var backOff = BackoffTimerHelper.GetRandomBackoff(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5));
-                Trace.Info($"Retrying in {backOff.Seconds} seconds");
                 await Task.Delay(backOff);
             }
             return null;
@@ -687,11 +689,9 @@ namespace GitHub.Runner.Listener.Configuration
                         {"runner_event", runnerEvent}
                     };
 
-                    var responseStatus = System.Net.HttpStatusCode.OK;
                     try
                     {
                         var response = await httpClient.PostAsync(githubApiUrl, new StringContent(StringUtil.ConvertToJson(bodyObject), null, "application/json"));
-                        responseStatus = response.StatusCode;
 
                         if(response.IsSuccessStatusCode)
                         {
@@ -699,23 +699,29 @@ namespace GitHub.Runner.Listener.Configuration
                             var jsonResponse = await response.Content.ReadAsStringAsync();
                             return StringUtil.ConvertFromJson<GitHubAuthResult>(jsonResponse);
                         }
+                        else if(response.StatusCode == System.Net.HttpStatusCode.NotFound)
+                        {
+                            // It doesn't make sense to retry in this case, so just stop
+                            break;
+                        }
                         else
                         {
                             _term.WriteError($"Http response code: {response.StatusCode} from 'POST {githubApiUrl}'");
                             var errorResponse = await response.Content.ReadAsStringAsync();
                             _term.WriteError(errorResponse);
+                            // Something else bad happened, let's go to our retry logic
                             response.EnsureSuccessStatusCode();
                         }
                     }
-                    catch(Exception ex) when (retryCount < 2 && responseStatus != System.Net.HttpStatusCode.NotFound)
+                    catch(Exception ex) when (retryCount < 2)
                     {
                         retryCount++;
                         Trace.Error($"Failed to get tenant credentials -- Atempt: {retryCount}");
                         Trace.Error(ex);
+                        Trace.Info("Retrying in 5 seconds");
                     }
                 }
                 var backOff = BackoffTimerHelper.GetRandomBackoff(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5));
-                Trace.Info($"Retrying in {backOff.Seconds} seconds");
                 await Task.Delay(backOff);
             }
             return null;

src/Runner.Listener/Program.cs

@@ -95,15 +95,7 @@ namespace GitHub.Runner.Listener
                 var unknownCommandlines = command.Validate();
                 if (unknownCommandlines.Count > 0)
                 {
-                    string commandName = command.GetCommandName();
+                    terminal.WriteError($"Unrecognized command-line input arguments: '{string.Join(", ", unknownCommandlines)}'. For usage refer to: .\\config.cmd --help or ./config.sh --help");
-                    if (string.IsNullOrEmpty(commandName))
-                    {
-                        terminal.WriteError($"This command does not recognize the command-line input arguments: '{string.Join(", ", unknownCommandlines)}'. For usage refer to: .\\config.cmd --help or ./config.sh --help");
-                    }
-                    else
-                    {
-                        terminal.WriteError($"Unrecognized command-line input arguments for command {commandName}: '{string.Join(", ", unknownCommandlines)}'. For usage refer to: .\\config.cmd --help or ./config.sh --help");
-                    }
                 }
 
                 // Defer to the Runner class to execute the command.

src/Runner.Worker/ActionRunner.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.IO;
+using System.Text;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.ObjectTemplating;
 using GitHub.DistributedTask.ObjectTemplating.Tokens;
@@ -140,7 +141,21 @@ namespace GitHub.Runner.Worker
 
             IStepHost stepHost = HostContext.CreateService<IDefaultStepHost>();
 
-            ExecutionContext.WriteWebhookPayload();
+            // Makes directory for event_path data
+            var tempDirectory = HostContext.GetDirectory(WellKnownDirectory.Temp);
+            var workflowDirectory = Path.Combine(tempDirectory, "_github_workflow");
+            Directory.CreateDirectory(workflowDirectory);
+
+            var gitHubEvent = ExecutionContext.GetGitHubContext("event");
+
+            // adds the GitHub event path/file if the event exists
+            if (gitHubEvent != null)
+            {
+                var workflowFile = Path.Combine(workflowDirectory, "event.json");
+                Trace.Info($"Write event payload to {workflowFile}");
+                File.WriteAllText(workflowFile, gitHubEvent, new UTF8Encoding(false));
+                ExecutionContext.SetGitHubContext("event_path", workflowFile);
+            }
 
             // Set GITHUB_ACTION_REPOSITORY if this Action is from a repository
             if (Action.Reference is Pipelines.RepositoryPathReference repoPathReferenceAction &&
@@ -171,16 +186,8 @@ namespace GitHub.Runner.Worker
 
             // Load the inputs.
             ExecutionContext.Debug("Loading inputs");
-            Dictionary<string, string> inputs;
+            var templateEvaluator = ExecutionContext.ToPipelineTemplateEvaluator();
-            if (ExecutionContext.Global.Variables.GetBoolean(Constants.Runner.Features.UseContainerPathForTemplate) ?? false)
+            var inputs = templateEvaluator.EvaluateStepInputs(Action.Inputs, ExecutionContext.ExpressionValues, ExecutionContext.ExpressionFunctions);
-            {
-                inputs = EvaluateStepInputs(stepHost);
-            }
-            else
-            {
-                var templateEvaluator = ExecutionContext.ToPipelineTemplateEvaluator();
-                inputs = templateEvaluator.EvaluateStepInputs(Action.Inputs, ExecutionContext.ExpressionValues, ExecutionContext.ExpressionFunctions);
-            }
 
             var userInputs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             foreach (KeyValuePair<string, string> input in inputs)
@@ -307,15 +314,6 @@ namespace GitHub.Runner.Worker
             return didFullyEvaluate;
         }
 
-        private Dictionary<String, String> EvaluateStepInputs(IStepHost stepHost)
-        {
-            DictionaryContextData expressionValues = ExecutionContext.GetExpressionValues(stepHost);
-            var templateEvaluator = ExecutionContext.ToPipelineTemplateEvaluator();
-            var inputs = templateEvaluator.EvaluateStepInputs(Action.Inputs, expressionValues, ExecutionContext.ExpressionFunctions);
-
-            return inputs;
-        }
-
         private string GenerateDisplayName(ActionStep action, DictionaryContextData contextData, IExecutionContext context, out bool didFullyEvaluate)
         {
             ArgUtil.NotNull(context, nameof(context));

src/Runner.Worker/ExecutionContext.cs

@@ -1,13 +1,17 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Web;
 using GitHub.DistributedTask.Expressions2;
-using GitHub.DistributedTask.ObjectTemplating.Tokens;
+using GitHub.DistributedTask.Pipelines;
 using GitHub.DistributedTask.Pipelines.ContextData;
 using GitHub.DistributedTask.Pipelines.ObjectTemplating;
 using GitHub.DistributedTask.WebApi;
@@ -15,7 +19,7 @@ using GitHub.Runner.Common;
 using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
 using GitHub.Runner.Worker.Container;
-using GitHub.Runner.Worker.Handlers;
+using GitHub.Services.WebApi;
 using Newtonsoft.Json;
 using ObjectTemplating = GitHub.DistributedTask.ObjectTemplating;
 using Pipelines = GitHub.DistributedTask.Pipelines;
@@ -105,11 +109,6 @@ namespace GitHub.Runner.Worker
         void ForceTaskComplete();
         void RegisterPostJobStep(IStep step);
         void PublishStepTelemetry();
-
-        void ApplyContinueOnError(TemplateToken continueOnError);
-        void UpdateGlobalStepsContext();
-
-        void WriteWebhookPayload();
     }
 
     public sealed class ExecutionContext : RunnerService, IExecutionContext
@@ -439,19 +438,14 @@ namespace GitHub.Runner.Worker
 
             _logger.End();
 
-            UpdateGlobalStepsContext();
-
-            return Result.Value;
-        }
-
-        public void UpdateGlobalStepsContext()
-        {
             // Skip if generated context name. Generated context names start with "__". After 3.2 the server will never send an empty context name.
             if (!string.IsNullOrEmpty(ContextName) && !ContextName.StartsWith("__", StringComparison.Ordinal))
             {
                 Global.StepsContext.SetOutcome(ScopeName, ContextName, (Outcome ?? Result ?? TaskResult.Succeeded).ToActionResult());
                 Global.StepsContext.SetConclusion(ScopeName, ContextName, (Result ?? TaskResult.Succeeded).ToActionResult());
             }
+
+            return Result.Value;
         }
 
         public void SetRunnerContext(string name, string value)
@@ -556,15 +550,10 @@ namespace GitHub.Runner.Worker
                 issue.Message = issue.Message[.._maxIssueMessageLength];
             }
 
-            // Tracking the line number (logFileLineNumber) and step number (stepNumber) for each issue that gets created
-            // Actions UI from the run summary page use both values to easily link to an exact locations in logs where annotations originate from
-            if (_record.Order != null)
-            {
-                issue.Data["stepNumber"] = _record.Order.ToString();
-            }
-
             if (issue.Type == IssueType.Error)
             {
+                // tracking line number for each issue in log file
+                // log UI use this to navigate from issue to log
                 if (!string.IsNullOrEmpty(logMessage))
                 {
                     long logLineNumber = Write(WellKnownTags.Error, logMessage);
@@ -580,6 +569,8 @@ namespace GitHub.Runner.Worker
             }
             else if (issue.Type == IssueType.Warning)
             {
+                // tracking line number for each issue in log file
+                // log UI use this to navigate from issue to log
                 if (!string.IsNullOrEmpty(logMessage))
                 {
                     long logLineNumber = Write(WellKnownTags.Warning, logMessage);
@@ -595,6 +586,9 @@ namespace GitHub.Runner.Worker
             }
             else if (issue.Type == IssueType.Notice)
             {
+
+                // tracking line number for each issue in log file
+                // log UI use this to navigate from issue to log
                 if (!string.IsNullOrEmpty(logMessage))
                 {
                     long logLineNumber = Write(WellKnownTags.Notice, logMessage);
@@ -997,24 +991,6 @@ namespace GitHub.Runner.Worker
             }
         }
 
-        public void WriteWebhookPayload()
-        {
-            // Makes directory for event_path data
-            var tempDirectory = HostContext.GetDirectory(WellKnownDirectory.Temp);
-            var workflowDirectory = Path.Combine(tempDirectory, "_github_workflow");
-            Directory.CreateDirectory(workflowDirectory);
-            var gitHubEvent = GetGitHubContext("event");
-
-            // adds the GitHub event path/file if the event exists
-            if (gitHubEvent != null)
-            {
-                var workflowFile = Path.Combine(workflowDirectory, "event.json");
-                Trace.Info($"Write event payload to {workflowFile}");
-                File.WriteAllText(workflowFile, gitHubEvent, new UTF8Encoding(false));
-                SetGitHubContext("event_path", workflowFile);
-            }
-        }
-
         private void InitializeTimelineRecord(Guid timelineId, Guid timelineRecordId, Guid? parentTimelineRecordId, string recordType, string displayName, string refName, int? order)
         {
             _mainTimelineId = timelineId;
@@ -1069,36 +1045,6 @@ namespace GitHub.Runner.Worker
             var newGuid = Guid.NewGuid();
             return CreateChild(newGuid, displayName, newGuid.ToString("N"), null, null, ActionRunStage.Post, intraActionState, _childTimelineRecordOrder - Root.PostJobSteps.Count, siblingScopeName: siblingScopeName);
         }
-
-        public void ApplyContinueOnError(TemplateToken continueOnErrorToken)
-        {
-            if (Result != TaskResult.Failed)
-            {
-                return;
-            }
-            var continueOnError = false;
-            try
-            {
-                var templateEvaluator = this.ToPipelineTemplateEvaluator();
-                continueOnError = templateEvaluator.EvaluateStepContinueOnError(continueOnErrorToken, ExpressionValues, ExpressionFunctions);
-            }
-            catch (Exception ex)
-            {
-                Trace.Info("The step failed and an error occurred when attempting to determine whether to continue on error.");
-                Trace.Error(ex);
-                this.Error("The step failed and an error occurred when attempting to determine whether to continue on error.");
-                this.Error(ex);
-            }
-
-            if (continueOnError)
-            {
-                Outcome = Result;
-                Result = TaskResult.Succeeded;
-                Trace.Info($"Updated step result (continue on error)");
-            }
-
-            UpdateGlobalStepsContext();
-        }
     }
 
     // The Error/Warning/etc methods are created as extension methods to simplify unit testing.
@@ -1120,6 +1066,7 @@ namespace GitHub.Runner.Worker
             context.Error(ex.Message);
             context.Debug(ex.ToString());
         }
+
         // Do not add a format string overload. See comment on ExecutionContext.Write().
         public static void Error(this IExecutionContext context, string message)
         {
@@ -1193,66 +1140,6 @@ namespace GitHub.Runner.Worker
         {
             return new TemplateTraceWriter(context);
         }
-
-        public static DictionaryContextData GetExpressionValues(this IExecutionContext context, IStepHost stepHost)
-        {
-            if (stepHost is ContainerStepHost)
-            {
-
-                var expressionValues = context.ExpressionValues.Clone() as DictionaryContextData;
-                context.UpdatePathsInExpressionValues("github", expressionValues, stepHost);
-                context.UpdatePathsInExpressionValues("runner", expressionValues, stepHost);
-                return expressionValues;
-            }
-            else
-            {
-                return context.ExpressionValues.Clone() as DictionaryContextData;
-            }
-        }
-
-        private static void UpdatePathsInExpressionValues(this IExecutionContext context, string contextName, DictionaryContextData expressionValues, IStepHost stepHost)
-        {
-            var dict = expressionValues[contextName].AssertDictionary($"expected context {contextName} to be a dictionary");
-            context.ResolvePathsInExpressionValuesDictionary(dict, stepHost);
-            expressionValues[contextName] = dict;
-        }
-
-        private static void ResolvePathsInExpressionValuesDictionary(this IExecutionContext context, DictionaryContextData dict, IStepHost stepHost)
-        {
-            foreach (var key in dict.Keys.ToList())
-            {
-                if (dict[key] is StringContextData)
-                {
-                    var value = dict[key].ToString();
-                    if (!string.IsNullOrEmpty(value))
-                    {
-                        dict[key] = new StringContextData(stepHost.ResolvePathForStepHost(value));
-                    }
-                }
-                else if (dict[key] is DictionaryContextData)
-                {
-                    var innerDict = dict[key].AssertDictionary("expected dictionary");
-                    context.ResolvePathsInExpressionValuesDictionary(innerDict, stepHost);
-                    var updatedDict = new DictionaryContextData();
-                    foreach (var k in innerDict.Keys.ToList())
-                    {
-                        updatedDict[k] = innerDict[k];
-                    }
-                    dict[key] = updatedDict;
-                }
-                else if (dict[key] is CaseSensitiveDictionaryContextData)
-                {
-                    var innerDict = dict[key].AssertDictionary("expected dictionary");
-                    context.ResolvePathsInExpressionValuesDictionary(innerDict, stepHost);
-                    var updatedDict = new CaseSensitiveDictionaryContextData();
-                    foreach (var k in innerDict.Keys.ToList())
-                    {
-                        updatedDict[k] = innerDict[k];
-                    }
-                    dict[key] = updatedDict;
-                }
-            }
-        }
     }
 
     internal sealed class TemplateTraceWriter : ObjectTemplating.ITraceWriter

src/Runner.Worker/FileCommandManager.cs

@@ -15,7 +15,7 @@ namespace GitHub.Runner.Worker
     {
         void InitializeFiles(IExecutionContext context, ContainerInfo container);
         void ProcessFiles(IExecutionContext context, ContainerInfo container);
-
+    
     }
 
     public sealed class FileCommandManager : RunnerService, IFileCommandManager
@@ -57,7 +57,7 @@ namespace GitHub.Runner.Worker
                 TryDeleteFile(newPath);
                 File.Create(newPath).Dispose();
 
-                var pathToSet = container != null ? container.TranslateToContainerPath(newPath) : newPath;
+                var pathToSet = container != null ? container.TranslateToContainerPath(newPath) : newPath; 
                 context.SetGitHubContext(fileCommand.ContextName, pathToSet);
             }
         }
@@ -66,7 +66,7 @@ namespace GitHub.Runner.Worker
         {
             foreach (var fileCommand in _commandExtensions)
             {
-                try
+                try 
                 {
                     fileCommand.ProcessCommand(context, Path.Combine(_fileCommandDirectory, fileCommand.FilePrefix + _fileSuffix),container);
                 }
@@ -266,7 +266,7 @@ namespace GitHub.Runner.Worker
 
     public sealed class CreateStepSummaryCommand : RunnerService, IFileCommandExtension
     {
-        public const int AttachmentSizeLimit = 1024 * 1024;
+        private const int _attachmentSizeLimit = 128 * 1024;
 
         public string ContextName => "step_summary";
         public string FilePrefix => "step_summary_";
@@ -296,9 +296,9 @@ namespace GitHub.Runner.Worker
                     return;
                 }
 
-                if (fileSize > AttachmentSizeLimit)
+                if (fileSize > _attachmentSizeLimit)
                 {
-                    context.Error(String.Format(Constants.Runner.UnsupportedSummarySize, AttachmentSizeLimit / 1024, fileSize / 1024));
+                    context.Error(String.Format(Constants.Runner.UnsupportedSummarySize, _attachmentSizeLimit / 1024, fileSize / 1024));
                     Trace.Info($"Step Summary file ({filePath}) is too large ({fileSize} bytes); skipping attachment upload");
 
                     return;

src/Runner.Worker/GitHubContext.cs

@@ -8,10 +8,10 @@ namespace GitHub.Runner.Worker
     {
         private readonly HashSet<string> _contextEnvAllowlist = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
         {
+            "action",
             "action_path",
             "action_ref",
             "action_repository",
-            "action",
             "actor",
             "api_url",
             "base_ref",
@@ -22,12 +22,12 @@ namespace GitHub.Runner.Worker
             "head_ref",
             "job",
             "path",
+            "ref",
             "ref_name",
             "ref_protected",
             "ref_type",
-            "ref",
-            "repository_owner",
             "repository",
+            "repository_owner",
             "retention_days",
             "run_attempt",
             "run_id",
@@ -35,7 +35,6 @@ namespace GitHub.Runner.Worker
             "server_url",
             "sha",
             "step_summary",
-            "triggering_actor",
             "workflow",
             "workspace",
         };

src/Runner.Worker/Handlers/CompositeActionHandler.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using GitHub.DistributedTask.Expressions2;
@@ -11,6 +13,7 @@ using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common;
 using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
+using GitHub.Runner.Worker;
 using GitHub.Runner.Worker.Expressions;
 using Pipelines = GitHub.DistributedTask.Pipelines;
 
@@ -83,7 +86,7 @@ namespace GitHub.Runner.Worker.Handlers
 
                 ExecutionContext.StepTelemetry.HasPreStep = Data.HasPre;
                 ExecutionContext.StepTelemetry.HasPostStep = Data.HasPost;
-
+                
                 ExecutionContext.StepTelemetry.HasRunsStep = hasRunsStep;
                 ExecutionContext.StepTelemetry.HasUsesStep = hasUsesStep;
                 ExecutionContext.StepTelemetry.StepCount = steps.Count;
@@ -404,7 +407,7 @@ namespace GitHub.Runner.Worker.Handlers
                 }
 
                 // Update context
-                step.ExecutionContext.UpdateGlobalStepsContext();
+                SetStepsContext(step);
             }
         }
 
@@ -449,8 +452,6 @@ namespace GitHub.Runner.Worker.Handlers
                 SetStepConclusion(step, Common.Util.TaskResultUtil.MergeTaskResults(step.ExecutionContext.Result, step.ExecutionContext.CommandResult.Value));
             }
 
-            step.ExecutionContext.ApplyContinueOnError(step.ContinueOnError);
-
             Trace.Info($"Step result: {step.ExecutionContext.Result}");
             step.ExecutionContext.Debug($"Finished: {step.DisplayName}");
             step.ExecutionContext.PublishStepTelemetry();
@@ -459,7 +460,16 @@ namespace GitHub.Runner.Worker.Handlers
         private void SetStepConclusion(IStep step, TaskResult result)
         {
             step.ExecutionContext.Result = result;
-            step.ExecutionContext.UpdateGlobalStepsContext();
+            SetStepsContext(step);
+        }
+        private void SetStepsContext(IStep step)
+        {
+            if (!string.IsNullOrEmpty(step.ExecutionContext.ContextName) && !step.ExecutionContext.ContextName.StartsWith("__", StringComparison.Ordinal))
+            {
+                // TODO: when we support continue on error, we may need to do logic here to change conclusion based on the continue on error result
+                step.ExecutionContext.Global.StepsContext.SetOutcome(step.ExecutionContext.ScopeName, step.ExecutionContext.ContextName, (step.ExecutionContext.Result ?? TaskResult.Succeeded).ToActionResult());
+                step.ExecutionContext.Global.StepsContext.SetConclusion(step.ExecutionContext.ScopeName, step.ExecutionContext.ContextName, (step.ExecutionContext.Result ?? TaskResult.Succeeded).ToActionResult());
+            }
         }
     }
 }

src/Runner.Worker/Handlers/Handler.cs

@@ -36,7 +36,6 @@ namespace GitHub.Runner.Worker.Handlers
         protected IActionCommandManager ActionCommandManager { get; private set; }
 
         public Pipelines.ActionStepDefinitionReference Action { get; set; }
-        public bool IsActionStep => Action != null; 
         public Dictionary<string, string> Environment { get; set; }
         public Variables RuntimeVariables { get; set; }
         public IExecutionContext ExecutionContext { get; set; }
@@ -50,18 +49,13 @@ namespace GitHub.Runner.Worker.Handlers
             // Print out action details
             PrintActionDetails(stage);
 
-            // Get telemetry for the action
+            // Get telemetry for the action.
-            PopulateActionTelemetry(stage);
+            PopulateActionTelemetry();
         }
 
-        protected void PopulateActionTelemetry(ActionRunStage stage)
+        protected void PopulateActionTelemetry()
         {
-            if (!IsActionStep)
+            if (Action.Type == Pipelines.ActionSourceType.ContainerRegistry)
-            {
-                ExecutionContext.StepTelemetry.Type = "runner";
-                ExecutionContext.StepTelemetry.Action = $"{stage} Job Hook";
-            }
-            else if (Action.Type == Pipelines.ActionSourceType.ContainerRegistry)
             {
                 ExecutionContext.StepTelemetry.Type = "docker";
                 var registryAction = Action as Pipelines.ContainerRegistryReference;

src/Runner.Worker/Handlers/NodeScriptActionHandler.cs

@@ -3,8 +3,6 @@ using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-using GitHub.DistributedTask.Pipelines;
-using GitHub.DistributedTask.Pipelines.ContextData;
 using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common;
 using GitHub.Runner.Sdk;
@@ -114,17 +112,6 @@ namespace GitHub.Runner.Worker.Handlers
             // Remove environment variable that may cause conflicts with the node within the runner.
             Environment.Remove("NODE_ICU_DATA"); // https://github.com/actions/runner/issues/795
 
-            if (Data.NodeVersion == "node12" && (ExecutionContext.Global.Variables.GetBoolean(Constants.Runner.Features.Node12Warning) ?? false))
-            {
-                if (!ExecutionContext.JobContext.ContainsKey("Node12ActionsWarnings"))
-                {                     
-                    ExecutionContext.JobContext["Node12ActionsWarnings"] = new ArrayContextData();
-                }
-                var repoAction = Action as RepositoryPathReference;
-                var actionDisplayName = new StringContextData(repoAction.Name ?? repoAction.Path); // local actions don't have a 'Name'                
-                ExecutionContext.JobContext["Node12ActionsWarnings"].AssertArray("Node12ActionsWarnings").Add(actionDisplayName);
-            }
-
             using (var stdoutManager = new OutputManager(ExecutionContext, ActionCommandManager))
             using (var stderrManager = new OutputManager(ExecutionContext, ActionCommandManager))
             {

src/Runner.Worker/Handlers/OutputManager.cs

@@ -151,11 +151,6 @@ namespace GitHub.Runner.Worker.Handlers
                 }
             }
 
-            if (line.Contains("fatal: unsafe repository", StringComparison.OrdinalIgnoreCase))
-            {
-                _executionContext.StepTelemetry.ErrorMessages.Add(line);
-            }
-
             // Regular output
             _executionContext.Output(line);
         }

src/Runner.Worker/Handlers/ScriptHandler.cs

@@ -24,22 +24,16 @@ namespace GitHub.Runner.Worker.Handlers
 
         protected override void PrintActionDetails(ActionRunStage stage)
         {
-            // if we're executing a Job Extension, we won't have an 'Action'
+
-            if (!IsActionStep)
+            if (stage == ActionRunStage.Post)
             {
-                if (Inputs.TryGetValue("path", out var path))
+                throw new NotSupportedException("Script action should not have 'Post' job action.");
-                {
-                    ExecutionContext.Output($"##[group]Run '{path}'");
-                }
-                else
-                {
-                    throw new InvalidOperationException("Inputs 'path' must be set for job extensions");
-                }
             }
-            else if (Action.Type == Pipelines.ActionSourceType.Script)
+
+            Inputs.TryGetValue("script", out string contents);
+            contents = contents ?? string.Empty;
+            if (Action.Type == Pipelines.ActionSourceType.Script)
             {
-                Inputs.TryGetValue("script", out string contents);
-                contents = contents ?? string.Empty;
                 var firstLine = contents.TrimStart(' ', '\t', '\r', '\n');
                 var firstNewLine = firstLine.IndexOfAny(new[] { '\r', '\n' });
                 if (firstNewLine >= 0)
@@ -48,16 +42,17 @@ namespace GitHub.Runner.Worker.Handlers
                 }
 
                 ExecutionContext.Output($"##[group]Run {firstLine}");
-                var multiLines = contents.Replace("\r\n", "\n").TrimEnd('\n').Split('\n');
-                foreach (var line in multiLines)
-                {
-                    // Bright Cyan color
-                    ExecutionContext.Output($"\x1b[36;1m{line}\x1b[0m");
-                }
             }
             else
             {
-                throw new InvalidOperationException($"Invalid action type {Action?.Type} for {nameof(ScriptHandler)}");
+                throw new InvalidOperationException($"Invalid action type {Action.Type} for {nameof(ScriptHandler)}");
+            }
+
+            var multiLines = contents.Replace("\r\n", "\n").TrimEnd('\n').Split('\n');
+            foreach (var line in multiLines)
+            {
+                // Bright Cyan color
+                ExecutionContext.Output($"\x1b[36;1m{line}\x1b[0m");
             }
 
             string argFormat;
@@ -137,6 +132,11 @@ namespace GitHub.Runner.Worker.Handlers
 
         public async Task RunAsync(ActionRunStage stage)
         {
+            if (stage == ActionRunStage.Post)
+            {
+                throw new NotSupportedException("Script action should not have 'Post' job action.");
+            }
+
             // Validate args
             Trace.Entering();
             ArgUtil.NotNull(ExecutionContext, nameof(ExecutionContext));
@@ -153,8 +153,7 @@ namespace GitHub.Runner.Worker.Handlers
             string workingDirectory = null;
             if (!Inputs.TryGetValue("workingDirectory", out workingDirectory))
             {
-                // Don't use job level working directories for hooks
+                if (string.IsNullOrEmpty(ExecutionContext.ScopeName) && ExecutionContext.Global.JobDefaults.TryGetValue("run", out var runDefaults))
-                if (IsActionStep && string.IsNullOrEmpty(ExecutionContext.ScopeName) && ExecutionContext.Global.JobDefaults.TryGetValue("run", out var runDefaults))
                 {
                     if (runDefaults.TryGetValue("working-directory", out workingDirectory))
                     {
@@ -213,8 +212,7 @@ namespace GitHub.Runner.Worker.Handlers
                 }
             }
 
-            // Don't override runner telemetry here
+            if (!string.IsNullOrEmpty(shellCommand))
-            if (!string.IsNullOrEmpty(shellCommand) && IsActionStep)
             {
                 ExecutionContext.StepTelemetry.Action = shellCommand;
             }
@@ -224,24 +222,10 @@ namespace GitHub.Runner.Worker.Handlers
             {
                 throw new ArgumentException("Invalid shell option. Shell must be a valid built-in (bash, sh, cmd, powershell, pwsh) or a format string containing '{0}'");
             }
-            string scriptFilePath, resolvedScriptPath;
+
-            if (IsActionStep)
+            // We do not not the full path until we know what shell is being used, so that we can determine the file extension
-            {
+            var scriptFilePath = Path.Combine(tempDirectory, $"{Guid.NewGuid()}{ScriptHandlerHelpers.GetScriptFileExtension(shellCommand)}");
-                // We do not not the full path until we know what shell is being used, so that we can determine the file extension
+            var resolvedScriptPath = $"{StepHost.ResolvePathForStepHost(scriptFilePath).Replace("\"", "\\\"")}";
-                scriptFilePath = Path.Combine(tempDirectory, $"{Guid.NewGuid()}{ScriptHandlerHelpers.GetScriptFileExtension(shellCommand)}");
-                resolvedScriptPath = $"{StepHost.ResolvePathForStepHost(scriptFilePath).Replace("\"", "\\\"")}";
-            }
-            else
-            {
-                // JobExtensionRunners run a script file, we load that from the inputs here
-                if (!Inputs.ContainsKey("path"))
-                {
-                    throw new ArgumentException("Expected 'path' input to be set");
-                }
-                scriptFilePath = Inputs["path"];
-                ArgUtil.NotNullOrEmpty(scriptFilePath, "path");
-                resolvedScriptPath = Inputs["path"].Replace("\"", "\\\"");
-            }
 
             // Format arg string with script path
             var arguments = string.Format(argFormat, resolvedScriptPath);
@@ -257,12 +241,9 @@ namespace GitHub.Runner.Worker.Handlers
 #else
             // Don't add a BOM. It causes the script to fail on some operating systems (e.g. on Ubuntu 14).
             var encoding = new UTF8Encoding(false);
-#endif            
+#endif
-            if (IsActionStep)
+            // Script is written to local path (ie host) but executed relative to the StepHost, which may be a container
-            {
+            File.WriteAllText(scriptFilePath, contents, encoding);
-                // Script is written to local path (ie host) but executed relative to the StepHost, which may be a container
-                File.WriteAllText(scriptFilePath, contents, encoding);
-            }
 
             // Prepend PATH
             AddPrependPathToEnvironment();

src/Runner.Worker/Handlers/ScriptHandlerHelpers.cs

@@ -1,8 +1,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
-using GitHub.Runner.Sdk;
 
 namespace GitHub.Runner.Worker.Handlers
 {
@@ -81,22 +79,5 @@ namespace GitHub.Runner.Worker.Handlers
                 throw new ArgumentException($"Failed to parse COMMAND [..ARGS] from {shellOption}");
             }
         }
-
-        internal static string GetDefaultShellForScript(string path, Common.Tracing trace, string prependPath)
-        {
-            var format = "{0} {1}";
-            switch (Path.GetExtension(path))
-            {
-                case ".sh":
-                    // use 'sh' args but prefer bash
-                    var pathToShell = WhichUtil.Which("bash", false, trace, prependPath) ?? WhichUtil.Which("sh", true, trace, prependPath);
-                    return string.Format(format, pathToShell, _defaultArguments["sh"]);
-                case ".ps1":
-                    var pathToPowershell = WhichUtil.Which("pwsh", false, trace, prependPath) ?? WhichUtil.Which("powershell", true, trace, prependPath);
-                    return string.Format(format, pathToPowershell, _defaultArguments["powershell"]);
-                default:
-                    throw new ArgumentException($"{path} is not a valid path to a script. Make sure it ends in '.sh' or '.ps1'.");
-            }
-        }
     }
 }

src/Runner.Worker/Handlers/StepHost.cs

@@ -1,13 +1,18 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Text;
 using System.Threading;
+using System.Threading.Channels;
 using System.Threading.Tasks;
+using GitHub.DistributedTask.WebApi;
+using GitHub.Runner.Common.Util;
 using GitHub.Runner.Worker.Container;
+using GitHub.Services.WebApi;
+using Newtonsoft.Json;
 using GitHub.Runner.Common;
 using GitHub.Runner.Sdk;
 using System.Linq;
-using GitHub.DistributedTask.Pipelines.ContextData;
 
 namespace GitHub.Runner.Worker.Handlers
 {

src/Runner.Worker/JobExtension.cs

@@ -15,7 +15,6 @@ using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common;
 using GitHub.Runner.Common.Util;
 using GitHub.Runner.Sdk;
-using GitHub.Runner.Worker;
 using Pipelines = GitHub.DistributedTask.Pipelines;
 
 namespace GitHub.Runner.Worker
@@ -249,19 +248,6 @@ namespace GitHub.Runner.Worker
                     Trace.Info("Downloading actions");
                     var actionManager = HostContext.GetService<IActionManager>();
                     var prepareResult = await actionManager.PrepareActionsAsync(context, message.Steps);
-
-                    // add hook to preJobSteps
-                    var startedHookPath = Environment.GetEnvironmentVariable("ACTIONS_RUNNER_HOOK_JOB_STARTED");
-                    if (!string.IsNullOrEmpty(startedHookPath))
-                    {
-                        var hookProvider = HostContext.GetService<IJobHookProvider>();
-                        var jobHookData = new JobHookData(ActionRunStage.Pre, startedHookPath);
-                        preJobSteps.Add(new JobExtensionRunner(runAsync: hookProvider.RunHook,
-                                                                          condition: $"{PipelineTemplateConstants.Always}()",
-                                                                          displayName: Constants.Hooks.JobStartedStepName,
-                                                                          data: (object)jobHookData));
-                    }
-
                     preJobSteps.AddRange(prepareResult.ContainerSetupSteps);
 
                     // Add start-container steps, record and stop-container steps
@@ -351,18 +337,6 @@ namespace GitHub.Runner.Worker
                         }
                     }
 
-                    // Register Job Completed hook if the variable is set
-                    var completedHookPath = Environment.GetEnvironmentVariable("ACTIONS_RUNNER_HOOK_JOB_COMPLETED");
-                    if (!string.IsNullOrEmpty(completedHookPath))
-                    {
-                        var hookProvider = HostContext.GetService<IJobHookProvider>();
-                        var jobHookData = new JobHookData(ActionRunStage.Post, completedHookPath);
-                        jobContext.RegisterPostJobStep(new JobExtensionRunner(runAsync: hookProvider.RunHook,
-                                                                          condition: $"{PipelineTemplateConstants.Always}()",
-                                                                          displayName: Constants.Hooks.JobCompletedStepName,
-                                                                          data: (object)jobHookData));
-                    }
-
                     List<IStep> steps = new List<IStep>();
                     steps.AddRange(preJobSteps);
                     steps.AddRange(jobSteps);
@@ -432,7 +406,7 @@ namespace GitHub.Runner.Worker
             // create a new timeline record node for 'Finalize job'
             IExecutionContext context = jobContext.CreateChild(Guid.NewGuid(), "Complete job", $"{nameof(JobExtension)}_Final", null, null, ActionRunStage.Post);
             context.StepTelemetry.Type = "runner";
-            context.StepTelemetry.Action = "complete_job";
+            context.StepTelemetry.Action = "complete_joh";
             using (var register = jobContext.CancellationToken.Register(() => { context.CancelToken(); }))
             {
                 try

src/Runner.Worker/JobHookProvider.cs

@@ -1,95 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using System.Linq;
-using GitHub.Runner.Common;
-using GitHub.Runner.Common.Util;
-using GitHub.Runner.Sdk;
-using GitHub.Runner.Worker.Handlers;
-
-namespace GitHub.Runner.Worker
-{
-    [ServiceLocator(Default = typeof(JobHookProvider))]
-    public interface IJobHookProvider : IRunnerService
-    {
-        Task RunHook(IExecutionContext executionContext, object data);
-    }
-
-    public class JobHookData
-    {
-        public string Path {get; private set;}
-        public ActionRunStage Stage {get; private set;}
-
-        public JobHookData(ActionRunStage stage, string path)
-        {
-            Path = path;
-            Stage = stage;
-        }
-    }
-
-    public class JobHookProvider : RunnerService, IJobHookProvider
-    {
-        public override void Initialize(IHostContext hostContext)
-        {
-            base.Initialize(hostContext);
-        }
-
-        public async Task RunHook(IExecutionContext executionContext, object data)
-        {
-            // Get Inputs
-            var hookData = data as JobHookData;
-            ArgUtil.NotNull(hookData, nameof(JobHookData));
-
-            var displayName = hookData.Stage == ActionRunStage.Pre ? "job started hook" : "job completed hook";
-            // Log to users so that they know how this step was injected
-            executionContext.Output($"A {displayName} has been configured by the self-hosted runner administrator");
-
-            // Validate script file.
-            if (!File.Exists(hookData.Path))
-            {
-                throw new FileNotFoundException("File doesn't exist");
-            }
-
-            executionContext.WriteWebhookPayload();
-
-            // Create the handler data.
-            var scriptDirectory = Path.GetDirectoryName(hookData.Path);
-            var stepHost = HostContext.CreateService<IDefaultStepHost>();
-            var prependPath = string.Join(Path.PathSeparator.ToString(), executionContext.Global.PrependPath.Reverse<string>());
-            Dictionary<string, string> inputs = new()
-            {
-                ["path"] = hookData.Path,
-                ["shell"] = ScriptHandlerHelpers.GetDefaultShellForScript(hookData.Path, Trace, prependPath)
-            };
-
-            // Create the handler
-            var handlerFactory = HostContext.GetService<IHandlerFactory>();
-            var handler = handlerFactory.Create(
-                            executionContext,
-                            action: null,
-                            stepHost,
-                            new ScriptActionExecutionData(),
-                            inputs,
-                            environment: new Dictionary<string, string>(VarUtil.EnvironmentVariableKeyComparer),
-                            executionContext.Global.Variables,
-                            actionDirectory: scriptDirectory,
-                            localActionContainerSetupSteps: null);
-            handler.PrepareExecution(hookData.Stage);
-
-            // Setup file commands
-            var fileCommandManager = HostContext.CreateService<IFileCommandManager>();
-            fileCommandManager.InitializeFiles(executionContext, null);
-
-            // Run the step and process the file commands
-            try
-            {
-                await handler.RunAsync(hookData.Stage);
-            }
-            finally
-            {
-                fileCommandManager.ProcessFiles(executionContext, executionContext.Global.Container);
-            }
-        }
-    }
-}

src/Runner.Worker/JobRunner.cs

@@ -6,7 +6,6 @@ using System.Net.Http;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
-using GitHub.DistributedTask.Pipelines.ContextData;
 using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Common;
 using GitHub.Runner.Common.Util;
@@ -258,12 +257,6 @@ namespace GitHub.Runner.Worker
                 }
             }
 
-            if (jobContext.JobContext.ContainsKey("Node12ActionsWarnings"))
-            {
-                var actions = string.Join(", ", jobContext.JobContext["Node12ActionsWarnings"].AssertArray("Node12ActionsWarnings").Select(action => action.ToString()));
-                jobContext.Warning(string.Format(Constants.Runner.Node12DetectedAfterEndOfLife, actions));
-            }
-
             try
             {
                 await ShutdownQueue(throwOnFailure: true);

src/Runner.Worker/StepsRunner.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
@@ -134,10 +133,8 @@ namespace GitHub.Runner.Worker
                             // Test the condition again. The job was cancelled after the condition was originally evaluated.
                             jobCancelRegister = jobContext.CancellationToken.Register(() =>
                             {
-                                // Mark job as Cancelled or Failed depending on HostContext shutdown token's cancellation
+                                // Mark job as cancelled
-                                jobContext.Result = HostContext.RunnerShutdownToken.IsCancellationRequested
+                                jobContext.Result = TaskResult.Canceled;
-                                                    ? TaskResult.Failed
-                                                    : TaskResult.Canceled;
                                 jobContext.JobContext.Status = jobContext.Result?.ToActionResult();
 
                                 step.ExecutionContext.Debug($"Re-evaluate condition on job cancellation for step: '{step.DisplayName}'.");
@@ -175,10 +172,8 @@ namespace GitHub.Runner.Worker
                         {
                             if (jobContext.Result != TaskResult.Canceled)
                             {
-                                // Mark job as Cancelled or Failed depending on HostContext shutdown token's cancellation
+                                // Mark job as cancelled
-                                jobContext.Result = HostContext.RunnerShutdownToken.IsCancellationRequested
+                                jobContext.Result = TaskResult.Canceled;
-                                    ? TaskResult.Failed
-                                    : TaskResult.Canceled;
                                 jobContext.JobContext.Status = jobContext.Result?.ToActionResult();
                             }
                         }
@@ -324,8 +319,29 @@ namespace GitHub.Runner.Worker
                 step.ExecutionContext.Result = TaskResultUtil.MergeTaskResults(step.ExecutionContext.Result, step.ExecutionContext.CommandResult.Value);
             }
 
-            step.ExecutionContext.ApplyContinueOnError(step.ContinueOnError);
+            // Fixup the step result if ContinueOnError
+            if (step.ExecutionContext.Result == TaskResult.Failed)
+            {
+                var continueOnError = false;
+                try
+                {
+                    continueOnError = templateEvaluator.EvaluateStepContinueOnError(step.ContinueOnError, step.ExecutionContext.ExpressionValues, step.ExecutionContext.ExpressionFunctions);
+                }
+                catch (Exception ex)
+                {
+                    Trace.Info("The step failed and an error occurred when attempting to determine whether to continue on error.");
+                    Trace.Error(ex);
+                    step.ExecutionContext.Error("The step failed and an error occurred when attempting to determine whether to continue on error.");
+                    step.ExecutionContext.Error(ex);
+                }
 
+                if (continueOnError)
+                {
+                    step.ExecutionContext.Outcome = step.ExecutionContext.Result;
+                    step.ExecutionContext.Result = TaskResult.Succeeded;
+                    Trace.Info($"Updated step result (continue on error)");
+                }
+            }
             Trace.Info($"Step result: {step.ExecutionContext.Result}");
 
             // Complete the step context

src/Runner.Worker/action_yaml.json

@@ -129,10 +129,9 @@
                         "required": true
                     },
                     "env": "step-env",
-                    "continue-on-error": "boolean-steps-context",
                     "working-directory": "string-steps-context",
                     "shell": {
-                        "type": "string-steps-context",
+                        "type": "non-empty-string",
                         "required": true
                     }
                 }
@@ -148,7 +147,6 @@
                         "type": "non-empty-string",
                         "required": true
                     },
-                    "continue-on-error": "boolean-steps-context",
                     "with": "step-with",
                     "env": "step-env"
                 }
@@ -203,20 +201,6 @@
             ],
             "string": {}
         },
-        "boolean-steps-context": {
-            "context": [
-                "github",
-                "inputs",
-                "strategy",
-                "matrix",
-                "steps",
-                "job",
-                "runner",
-                "env",
-                "hashFiles(1,255)"
-            ],
-            "boolean": {}
-        },
         "step-env": {
             "context": [
                 "github",

src/Sdk/Common/Common/ClientStorage/VssFileStorage.cs

@@ -23,6 +23,7 @@ namespace GitHub.Services.Common.ClientStorage
         private readonly string m_filePath;
         private readonly VssFileStorageReader m_reader;
         private readonly IVssClientStorageWriter m_writer;
+
         private const char c_defaultPathSeparator = '\\';
         private const bool c_defaultIgnoreCaseInPaths = false;
 
@@ -191,7 +192,7 @@ namespace GitHub.Services.Common.ClientStorage
                 // Windows Impersonation is being used.
 
                 // Check to see if we can find the user's local application data directory.
-                string subDir = Path.Combine("GitHub", "ActionsService");
+                string subDir = "GitHub\\ActionsService";
                 string path = Environment.GetEnvironmentVariable("localappdata");
                 SafeGetFolderPath(Environment.SpecialFolder.LocalApplicationData);
                 if (string.IsNullOrEmpty(path))

src/Test/L0/Listener/CommandSettingsL0.cs

@@ -708,85 +708,33 @@ namespace GitHub.Runner.Common.Tests
             }
         }
 
-        [Theory]
+        [Fact]
-        [InlineData("configure", "once")]
-        [InlineData("remove", "disableupdate")]
-        [InlineData("remove", "ephemeral")]
-        [InlineData("remove", "once")]
-        [InlineData("remove", "replace")]
-        [InlineData("remove", "runasservice")]
-        [InlineData("remove", "unattended")]
-        [InlineData("run", "disableupdate")]
-        [InlineData("run", "ephemeral")]
-        [InlineData("run", "replace")]
-        [InlineData("run", "runasservice")]
-        [InlineData("run", "unattended")]
-        [InlineData("warmup", "disableupdate")]      
-        [InlineData("warmup", "ephemeral")]     
-        [InlineData("warmup", "once")]   
-        [InlineData("warmup", "replace")]      
-        [InlineData("warmup", "runasservice")]   
-        [InlineData("warmup", "unattended")]
         [Trait("Level", "L0")]
         [Trait("Category", nameof(CommandSettings))]
-        public void ValidateInvalidFlagCommandCombination(string validCommand, string flag)
+        public void ValidateFlags()
         {
             using (TestHostContext hc = CreateTestContext())
             {
                 // Arrange.
-                var command = new CommandSettings(hc, args: new string[] { validCommand, $"--{flag}" });
+                var command = new CommandSettings(hc, args: new string[] { "--badflag" });
 
                 // Assert.
-                Assert.Contains(flag, command.Validate());
+                Assert.Contains("badflag", command.Validate());
             }
         }
 
-        [Theory]
+        [Fact]
-        [InlineData("remove", "auth", "bar arg value")]
-        [InlineData("remove", "labels", "bar arg value")]
-        [InlineData("remove", "monitorsocketaddress", "bar arg value")]
-        [InlineData("remove", "name", "bar arg value")]
-        [InlineData("remove", "runnergroup", "bar arg value")]
-        [InlineData("remove", "url", "bar arg value")]
-        [InlineData("remove", "username", "bar arg value")]
-        [InlineData("remove", "windowslogonaccount", "bar arg value")]
-        [InlineData("remove", "windowslogonpassword", "bar arg value")]
-        [InlineData("remove", "work", "bar arg value")]
-        [InlineData("run", "auth", "bad arg value")]
-        [InlineData("run", "labels", "bad arg value")]
-        [InlineData("run", "monitorsocketaddress", "bad arg value")]
-        [InlineData("run", "name", "bad arg value")]
-        [InlineData("run", "pat", "bad arg value")]
-        [InlineData("run", "runnergroup", "bad arg value")]
-        [InlineData("run", "token", "bad arg value")]
-        [InlineData("run", "url", "bad arg value")]
-        [InlineData("run", "username", "bad arg value")]
-        [InlineData("run", "windowslogonaccount", "bad arg value")]
-        [InlineData("run", "windowslogonpassword", "bad arg value")]
-        [InlineData("run", "work", "bad arg value")]
-        [InlineData("warmup", "auth", "bad arg value")]
-        [InlineData("warmup", "labels", "bad arg value")]
-        [InlineData("warmup", "monitorsocketaddress", "bad arg value")]
-        [InlineData("warmup", "name", "bad arg value")]
-        [InlineData("warmup", "pat", "bad arg value")]
-        [InlineData("warmup", "runnergroup", "bad arg value")]
-        [InlineData("warmup", "token", "bad arg value")]
-        [InlineData("warmup", "url", "bad arg value")]
-        [InlineData("warmup", "username", "bad arg value")]
-        [InlineData("warmup", "windowslogonaccount", "bad arg value")]
-        [InlineData("warmup", "windowslogonpassword", "bad arg value")]
-        [InlineData("warmup", "work", "bad arg value")]
         [Trait("Level", "L0")]
         [Trait("Category", nameof(CommandSettings))]
-        public void ValidateInvalidArgCommandCombination(string validCommand, string arg, string argValue)
+        public void ValidateArgs()
         {
             using (TestHostContext hc = CreateTestContext())
             {
                 // Arrange.
-                var command = new CommandSettings(hc, args: new string[] { validCommand, $"--{arg}", argValue });
+                var command = new CommandSettings(hc, args: new string[] { "--badargname", "bad arg value" });
 
                 // Assert.
-                Assert.Contains(arg, command.Validate());
+                Assert.Contains("badargname", command.Validate());
             }
         }
 
@@ -810,73 +758,6 @@ namespace GitHub.Runner.Common.Tests
             }
         }
 
-        [Theory]
-        [InlineData("configure", "help")]
-        [InlineData("configure", "version")]
-        [InlineData("configure", "commit")]
-        [InlineData("configure", "check")]
-        [InlineData("configure", "disableupdate")]
-        [InlineData("configure", "ephemeral")]
-        [InlineData("configure", "replace")]
-        [InlineData("configure", "runasservice")]
-        [InlineData("configure", "unattended")]
-        [InlineData("remove", "help")]
-        [InlineData("remove", "version")]
-        [InlineData("remove", "commit")]
-        [InlineData("remove", "check")]
-        [InlineData("run", "help")]
-        [InlineData("run", "version")]
-        [InlineData("run", "commit")]
-        [InlineData("run", "check")]
-        [InlineData("run", "once")]
-        [InlineData("warmup", "help")]
-        [InlineData("warmup", "version")]
-        [InlineData("warmup", "commit")]
-        [InlineData("warmup", "check")]
-        [Trait("Level", "L0")]
-        [Trait("Category", nameof(CommandSettings))]
-        public void ValidateGoodFlagCommandCombination(string validCommand, string flag)
-        {
-            using (TestHostContext hc = CreateTestContext())
-            {
-                // Arrange.
-                var command = new CommandSettings(hc, args: new string[] { validCommand, $"--{flag}" });
-
-                // Assert.
-                Assert.True(command.Validate().Count == 0);
-            }
-        }
-
-        [Theory]
-        [InlineData("configure", "auth", "good arg value")]
-        [InlineData("configure", "labels", "good arg value")]
-        [InlineData("configure", "monitorsocketaddress", "good arg value")]
-        [InlineData("configure", "name", "good arg value")]
-        [InlineData("configure", "pat", "good arg value")]
-        [InlineData("configure", "runnergroup", "good arg value")]
-        [InlineData("configure", "token", "good arg value")]
-        [InlineData("configure", "url", "good arg value")]
-        [InlineData("configure", "username", "good arg value")]
-        [InlineData("configure", "windowslogonaccount", "good arg value")]
-        [InlineData("configure", "windowslogonpassword", "good arg value")]
-        [InlineData("configure", "work", "good arg value")]
-        [InlineData("remove", "token", "good arg value")]
-        [InlineData("remove", "pat", "good arg value")]
-        [InlineData("run", "startuptype", "good arg value")]
-        [Trait("Level", "L0")]
-        [Trait("Category", nameof(CommandSettings))]
-        public void ValidateGoodArgCommandCombination(string validCommand, string arg, string argValue)
-        {
-            using (TestHostContext hc = CreateTestContext())
-            {
-                // Arrange.
-                var command = new CommandSettings(hc, args: new string[] { validCommand, $"--{arg}", argValue });
-
-                // Assert.
-                Assert.True(command.Validate().Count == 0);
-            }
-        }
-
         private TestHostContext CreateTestContext([CallerMemberName] string testName = "")
         {
             TestHostContext hc = new TestHostContext(this, testName);

src/Test/L0/Worker/ActionRunnerL0.cs

@@ -118,7 +118,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             await _actionRunner.RunAsync();
 
             //Assert
-            _ec.Verify(x => x.WriteWebhookPayload(), Times.Once);
+            _ec.Verify(x => x.SetGitHubContext("event_path", Path.Combine(_hc.GetDirectory(WellKnownDirectory.Temp), "_github_workflow", "event.json")), Times.Once);
         }
 
         [Fact]

src/Test/L0/Worker/CreateStepSummaryCommandL0.cs

@@ -33,7 +33,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             using (var hostContext = Setup(featureFlagState: "false"))
             {
                 var stepSummaryFile = Path.Combine(_rootDirectory, "feature-off");
-
+                
                 _createStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
                 _jobExecutionContext.Complete();
 
@@ -117,7 +117,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             using (var hostContext = Setup())
             {
                 var stepSummaryFile = Path.Combine(_rootDirectory, "empty-file");
-                File.WriteAllBytes(stepSummaryFile, new byte[CreateStepSummaryCommand.AttachmentSizeLimit + 1]);
+                File.WriteAllBytes(stepSummaryFile, new byte[128 * 1024 + 1]);
 
                 _createStepCommand.ProcessCommand(_executionContext.Object, stepSummaryFile, null);
                 _jobExecutionContext.Complete();

src/Test/L0/Worker/ExecutionContextL0.cs

@@ -6,11 +6,8 @@ using System.Threading;
 using GitHub.DistributedTask.Pipelines.ContextData;
 using GitHub.DistributedTask.WebApi;
 using GitHub.Runner.Worker;
-using GitHub.Runner.Worker.Container;
-using GitHub.Runner.Worker.Handlers;
 using Moq;
 using Xunit;
-using GitHub.DistributedTask.ObjectTemplating.Tokens;
 using Pipelines = GitHub.DistributedTask.Pipelines;
 
 namespace GitHub.Runner.Common.Tests.Worker
@@ -93,63 +90,6 @@ namespace GitHub.Runner.Common.Tests.Worker
             }
         }
 
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public void ApplyContinueOnError_CheckResultAndOutcome()
-        {
-            using (TestHostContext hc = CreateTestContext())
-            {
-
-                // Arrange: Create a job request message.
-                TaskOrchestrationPlanReference plan = new TaskOrchestrationPlanReference();
-                TimelineReference timeline = new TimelineReference();
-                Guid jobId = Guid.NewGuid();
-                string jobName = "some job name";
-                var jobRequest = new Pipelines.AgentJobRequestMessage(plan, timeline, jobId, jobName, jobName, null, null, null, new Dictionary<string, VariableValue>(), new List<MaskHint>(), new Pipelines.JobResources(), new Pipelines.ContextData.DictionaryContextData(), new Pipelines.WorkspaceOptions(), new List<Pipelines.ActionStep>(), null, null, null, null);
-                jobRequest.Resources.Repositories.Add(new Pipelines.RepositoryResource()
-                {
-                    Alias = Pipelines.PipelineConstants.SelfAlias,
-                    Id = "github",
-                    Version = "sha1"
-                });
-                jobRequest.ContextData["github"] = new Pipelines.ContextData.DictionaryContextData();
-                jobRequest.Variables["ACTIONS_STEP_DEBUG"] = "true";
-
-                // Arrange: Setup the paging logger.
-                var pagingLogger = new Mock<IPagingLogger>();
-                var jobServerQueue = new Mock<IJobServerQueue>();
-                jobServerQueue.Setup(x => x.QueueTimelineRecordUpdate(It.IsAny<Guid>(), It.IsAny<TimelineRecord>()));
-                jobServerQueue.Setup(x => x.QueueWebConsoleLine(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<long>())).Callback((Guid id, string msg, long? lineNumber) => { hc.GetTrace().Info(msg); });
-
-                hc.EnqueueInstance(pagingLogger.Object);
-                hc.SetSingleton(jobServerQueue.Object);
-
-                var ec = new Runner.Worker.ExecutionContext();
-                ec.Initialize(hc);
-
-                // Act.
-                ec.InitializeJob(jobRequest, CancellationToken.None);
-
-                foreach (var tc in new List<(TemplateToken token, TaskResult result, TaskResult? expectedResult, TaskResult? expectedOutcome)> {
-                (token: new BooleanToken(null, null, null, true), result: TaskResult.Failed, expectedResult: TaskResult.Succeeded, expectedOutcome: TaskResult.Failed),
-                (token: new BooleanToken(null, null, null, true), result: TaskResult.Succeeded, expectedResult: TaskResult.Succeeded, expectedOutcome: null),
-                (token: new BooleanToken(null, null, null, true), result: TaskResult.Canceled, expectedResult: TaskResult.Canceled, expectedOutcome: null),
-                (token: new BooleanToken(null, null, null, false), result: TaskResult.Failed, expectedResult: TaskResult.Failed, expectedOutcome: null),
-                (token: new BooleanToken(null, null, null, false), result: TaskResult.Succeeded, expectedResult: TaskResult.Succeeded, expectedOutcome: null),
-                (token: new BooleanToken(null, null, null, false), result: TaskResult.Canceled, expectedResult: TaskResult.Canceled, expectedOutcome: null),
-            })
-                {
-                    ec.Result = tc.result;
-                    ec.Outcome = null;
-                    ec.ApplyContinueOnError(tc.token);
-                    Assert.Equal(ec.Result, tc.expectedResult);
-                    Assert.Equal(ec.Outcome, tc.expectedOutcome);
-                }
-            }
-        }
-
-
         [Fact]
         [Trait("Level", "L0")]
         [Trait("Category", "Worker")]
@@ -204,55 +144,6 @@ namespace GitHub.Runner.Common.Tests.Worker
             }
         }
 
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public void AddIssue_AddStepAndLineNumberInformation()
-        {
-            using (TestHostContext hc = CreateTestContext())
-            {
-
-                TaskOrchestrationPlanReference plan = new TaskOrchestrationPlanReference();
-                TimelineReference timeline = new TimelineReference();
-                Guid jobId = Guid.NewGuid();
-                string jobName = "some job name";
-                var jobRequest = new Pipelines.AgentJobRequestMessage(plan, timeline, jobId, jobName, jobName, null, null, null, new Dictionary<string, VariableValue>(), new List<MaskHint>(), new Pipelines.JobResources(), new Pipelines.ContextData.DictionaryContextData(), new Pipelines.WorkspaceOptions(), new List<Pipelines.ActionStep>(), null, null, null, null);
-                jobRequest.Resources.Repositories.Add(new Pipelines.RepositoryResource()
-                {
-                    Alias = Pipelines.PipelineConstants.SelfAlias,
-                    Id = "github",
-                    Version = "sha1"
-                });
-                jobRequest.ContextData["github"] = new Pipelines.ContextData.DictionaryContextData();
-
-                // Arrange: Setup the paging logger.
-                var pagingLogger = new Mock<IPagingLogger>();
-                var pagingLogger2 = new Mock<IPagingLogger>();
-                var jobServerQueue = new Mock<IJobServerQueue>();
-                jobServerQueue.Setup(x => x.QueueTimelineRecordUpdate(It.IsAny<Guid>(), It.IsAny<TimelineRecord>()));
-
-                hc.EnqueueInstance(pagingLogger.Object);
-                hc.EnqueueInstance(pagingLogger2.Object);
-                hc.SetSingleton(jobServerQueue.Object);
-
-                var ec = new Runner.Worker.ExecutionContext();
-                ec.Initialize(hc);
-                ec.InitializeJob(jobRequest, CancellationToken.None);
-                ec.Start();
-
-                var embeddedStep = ec.CreateChild(Guid.NewGuid(), "action_1_pre", "action_1_pre", null, null, ActionRunStage.Main, isEmbedded: true);
-                embeddedStep.Start();
-
-                embeddedStep.AddIssue(new Issue() { Type = IssueType.Error, Message = "error annotation that should have step and line number information" });
-                embeddedStep.AddIssue(new Issue() { Type = IssueType.Warning, Message = "warning annotation that should have step and line number information" });
-                embeddedStep.AddIssue(new Issue() { Type = IssueType.Notice, Message = "notice annotation that should have step and line number information" });
-
-                jobServerQueue.Verify(x => x.QueueTimelineRecordUpdate(It.IsAny<Guid>(), It.Is<TimelineRecord>(t => t.Issues.Where(i => i.Data.ContainsKey("stepNumber") && i.Data.ContainsKey("logFileLineNumber") && i.Type == IssueType.Error).Count() == 1)), Times.AtLeastOnce);
-                jobServerQueue.Verify(x => x.QueueTimelineRecordUpdate(It.IsAny<Guid>(), It.Is<TimelineRecord>(t => t.Issues.Where(i => i.Data.ContainsKey("stepNumber") && i.Data.ContainsKey("logFileLineNumber") && i.Type == IssueType.Warning).Count() == 1)), Times.AtLeastOnce);
-                jobServerQueue.Verify(x => x.QueueTimelineRecordUpdate(It.IsAny<Guid>(), It.Is<TimelineRecord>(t => t.Issues.Where(i => i.Data.ContainsKey("stepNumber") && i.Data.ContainsKey("logFileLineNumber") && i.Type == IssueType.Notice).Count() == 1)), Times.AtLeastOnce);
-            }
-        }
-
         [Fact]
         [Trait("Level", "L0")]
         [Trait("Category", "Worker")]
@@ -726,149 +617,5 @@ namespace GitHub.Runner.Common.Tests.Worker
 
             return hc;
         }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public void GetExpressionValues_ContainerStepHost()
-        {
-            using (TestHostContext hc = CreateTestContext())
-            {
-                const string source = "/home/username/Projects/work/runner/_layout";
-                var containerInfo = new ContainerInfo();
-                containerInfo.ContainerId = "test";
-
-                containerInfo.AddPathTranslateMapping($"{source}/_work", "/__w");
-                containerInfo.AddPathTranslateMapping($"{source}/_temp", "/__t");
-                containerInfo.AddPathTranslateMapping($"{source}/externals", "/__e");
-
-                containerInfo.AddPathTranslateMapping($"{source}/_work/_temp/_github_home", "/github/home");
-                containerInfo.AddPathTranslateMapping($"{source}/_work/_temp/_github_workflow", "/github/workflow");
-
-                foreach (var v in new List<string>() {
-                    $"{source}/_work",
-                    $"{source}/externals",
-                    $"{source}/_work/_temp",
-                    $"{source}/_work/_actions",
-                    $"{source}/_work/_tool",
-                })
-                {
-                    containerInfo.MountVolumes.Add(new MountVolume(v, containerInfo.TranslateToContainerPath(v)));
-                };
-
-                var stepHost = new ContainerStepHost();
-                stepHost.Container = containerInfo;
-
-                var ec = new Runner.Worker.ExecutionContext();
-                ec.Initialize(hc);
-
-                var inputGithubContext = new GitHubContext();
-                var inputeRunnerContext = new RunnerContext();
-
-                // string context data
-                inputGithubContext["action_path"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_actions/owner/composite/main");
-                inputGithubContext["action"] = new StringContextData("__owner_composite");
-                inputGithubContext["api_url"] = new StringContextData("https://api.github.com/custom/path");
-                inputGithubContext["env"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_temp/_runner_file_commands/set_env_265698aa-7f38-40f5-9316-5c01a3153672");
-                inputGithubContext["path"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_temp/_runner_file_commands/add_path_265698aa-7f38-40f5-9316-5c01a3153672");
-                inputGithubContext["event_path"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_temp/_github_workflow/event.json");
-                inputGithubContext["repository"] = new StringContextData("owner/repo-name");
-                inputGithubContext["run_id"] = new StringContextData("2033211332");
-                inputGithubContext["workflow"] = new StringContextData("Name of Workflow");
-                inputGithubContext["workspace"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/step-order/step-order");
-                inputeRunnerContext["temp"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_temp");
-                inputeRunnerContext["tool_cache"] = new StringContextData("/home/username/Projects/work/runner/_layout/_work/_tool");
-
-                // dictionary context data
-                var githubEvent = new DictionaryContextData();
-                githubEvent["inputs"] = null;
-                githubEvent["ref"] = new StringContextData("refs/heads/main");
-                githubEvent["repository"] = new DictionaryContextData();
-                githubEvent["sender"] = new DictionaryContextData();
-                githubEvent["workflow"] = new StringContextData(".github/workflows/composite_step_host_translate.yaml");
-
-                inputGithubContext["event"] = githubEvent;
-
-                ec.ExpressionValues["github"] = inputGithubContext;
-                ec.ExpressionValues["runner"] = inputeRunnerContext;
-
-                var ecExpect = new Runner.Worker.ExecutionContext();
-                ecExpect.Initialize(hc);
-
-                var expectedGithubEvent = new DictionaryContextData();
-                expectedGithubEvent["inputs"] = null;
-                expectedGithubEvent["ref"] = new StringContextData("refs/heads/main");
-                expectedGithubEvent["repository"] = new DictionaryContextData();
-                expectedGithubEvent["sender"] = new DictionaryContextData();
-                expectedGithubEvent["workflow"] = new StringContextData(".github/workflows/composite_step_host_translate.yaml");
-                var expectedGithubContext = new GitHubContext();
-                var expectedRunnerContext = new RunnerContext();
-                expectedGithubContext["action_path"] = new StringContextData("/__w/_actions/owner/composite/main");
-                expectedGithubContext["action"] = new StringContextData("__owner_composite");
-                expectedGithubContext["api_url"] = new StringContextData("https://api.github.com/custom/path");
-                expectedGithubContext["env"] = new StringContextData("/__w/_temp/_runner_file_commands/set_env_265698aa-7f38-40f5-9316-5c01a3153672");
-                expectedGithubContext["path"] = new StringContextData("/__w/_temp/_runner_file_commands/add_path_265698aa-7f38-40f5-9316-5c01a3153672");
-                expectedGithubContext["event_path"] = new StringContextData("/github/workflow/event.json");
-                expectedGithubContext["repository"] = new StringContextData("owner/repo-name");
-                expectedGithubContext["run_id"] = new StringContextData("2033211332");
-                expectedGithubContext["workflow"] = new StringContextData("Name of Workflow");
-                expectedGithubContext["workspace"] = new StringContextData("/__w/step-order/step-order");
-                expectedGithubContext["event"] = expectedGithubEvent;
-                expectedRunnerContext["temp"] = new StringContextData("/__w/_temp");
-                expectedRunnerContext["tool_cache"] = new StringContextData("/__w/_tool");
-
-                ecExpect.ExpressionValues["github"] = expectedGithubContext;
-                ecExpect.ExpressionValues["runner"] = expectedRunnerContext;
-
-                var translatedExpressionValues = ec.GetExpressionValues(stepHost);
-
-                foreach (var contextName in new string[] { "github", "runner" })
-                {
-                    var dict = translatedExpressionValues[contextName].AssertDictionary($"expected context github to be a dictionary");
-                    var expectedExpressionValues = ecExpect.ExpressionValues[contextName].AssertDictionary("expect dict");
-                    foreach (var key in dict.Keys.ToList())
-                    {
-                        if (dict[key] is StringContextData)
-                        {
-                            var expect = dict[key].AssertString("expect string");
-                            var outcome = expectedExpressionValues[key].AssertString("expect string");
-                            Assert.Equal(expect.Value, outcome.Value);
-                        }
-                        else if (dict[key] is DictionaryContextData || dict[key] is CaseSensitiveDictionaryContextData)
-                        {
-                            var expectDict = dict[key].AssertDictionary("expect dict");
-                            var actualDict = expectedExpressionValues[key].AssertDictionary("expect dict");
-                            Assert.True(ExpressionValuesAssertEqual(expectDict, actualDict));
-                        }
-                    }
-                }
-            }
-        }
-
-        private bool ExpressionValuesAssertEqual(DictionaryContextData expect, DictionaryContextData actual)
-        {
-            foreach (var key in expect.Keys.ToList())
-            {
-                if (expect[key] is StringContextData)
-                {
-                    var expectValue = expect[key].AssertString("expect string");
-                    var actualValue = actual[key].AssertString("expect string");
-                    if (expectValue.Equals(actualValue))
-                    {
-                        return false;
-                    }
-                }
-                else if (expect[key] is DictionaryContextData || expect[key] is CaseSensitiveDictionaryContextData)
-                {
-                    var expectDict = expect[key].AssertDictionary("expect dict");
-                    var actualDict = actual[key].AssertDictionary("expect dict");
-                    if (!ExpressionValuesAssertEqual(expectDict, actualDict))
-                    {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        }
     }
-}
+}

src/Test/L0/Worker/JobExtensionL0.cs

@@ -25,7 +25,6 @@ namespace GitHub.Runner.Common.Tests.Worker
         private Mock<IPagingLogger> _logger;
         private Mock<IContainerOperationProvider> _containerProvider;
         private Mock<IDiagnosticLogManager> _diagnosticLogManager;
-        private Mock<IJobHookProvider> _jobHookProvider;
 
         private CancellationTokenSource _tokenSource;
         private TestHostContext CreateTestContext([CallerMemberName] String testName = "")
@@ -41,7 +40,6 @@ namespace GitHub.Runner.Common.Tests.Worker
             _directoryManager = new Mock<IPipelineDirectoryManager>();
             _directoryManager.Setup(x => x.PrepareDirectory(It.IsAny<IExecutionContext>(), It.IsAny<Pipelines.WorkspaceOptions>()))
                              .Returns(new TrackingConfig() { PipelineDirectory = "runner", WorkspaceDirectory = "runner/runner" });
-            _jobHookProvider = new Mock<IJobHookProvider>();
 
             IActionRunner step1 = new ActionRunner();
             IActionRunner step2 = new ActionRunner();
@@ -113,9 +111,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             hc.SetSingleton(_containerProvider.Object);
             hc.SetSingleton(_directoryManager.Object);
             hc.SetSingleton(_diagnosticLogManager.Object);
-            hc.SetSingleton(_jobHookProvider.Object);
             hc.EnqueueInstance<IPagingLogger>(_logger.Object); // JobExecutionContext
-            hc.EnqueueInstance<IPagingLogger>(_logger.Object); // job start hook
             hc.EnqueueInstance<IPagingLogger>(_logger.Object); // Initial Job
             hc.EnqueueInstance<IPagingLogger>(_logger.Object); // step1
             hc.EnqueueInstance<IPagingLogger>(_logger.Object); // step2
@@ -124,7 +120,6 @@ namespace GitHub.Runner.Common.Tests.Worker
             hc.EnqueueInstance<IPagingLogger>(_logger.Object); // step5
             hc.EnqueueInstance<IPagingLogger>(_logger.Object); // prepare1
             hc.EnqueueInstance<IPagingLogger>(_logger.Object); // prepare2
-            hc.EnqueueInstance<IPagingLogger>(_logger.Object); // job complete hook
 
             hc.EnqueueInstance<IActionRunner>(step1);
             hc.EnqueueInstance<IActionRunner>(step2);
@@ -353,62 +348,5 @@ namespace GitHub.Runner.Common.Tests.Worker
                 Assert.Equal(TaskResult.Succeeded, _jobEc.Result);
             }
         }
-
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public async Task EnsurePreAndPostHookStepsIfEnvExists()
-        {
-            Environment.SetEnvironmentVariable("ACTIONS_RUNNER_HOOK_JOB_STARTED", "/foo/bar");
-            Environment.SetEnvironmentVariable("ACTIONS_RUNNER_HOOK_JOB_COMPLETED", "/bar/foo");
-            using (TestHostContext hc = CreateTestContext())
-            {                
-                var jobExtension = new JobExtension();
-                jobExtension.Initialize(hc);
-
-                _actionManager.Setup(x => x.PrepareActionsAsync(It.IsAny<IExecutionContext>(), It.IsAny<IEnumerable<Pipelines.JobStep>>(), It.IsAny<Guid>()))
-                              .Returns(Task.FromResult(new PrepareResult(new List<JobExtensionRunner>(), new Dictionary<Guid, IActionRunner>())));
-
-                List<IStep> result = await jobExtension.InitializeJob(_jobEc, _message);
-
-                var trace = hc.GetTrace();
-
-                var hookStart = result.First() as JobExtensionRunner;
-
-                jobExtension.FinalizeJob(_jobEc, _message, DateTime.UtcNow);
-
-                Assert.Equal(Constants.Hooks.JobStartedStepName, hookStart.DisplayName);
-                Assert.Equal(Constants.Hooks.JobCompletedStepName, (_jobEc.PostJobSteps.Last() as JobExtensionRunner).DisplayName);                
-            }
-
-            Environment.SetEnvironmentVariable("ACTIONS_RUNNER_HOOK_JOB_STARTED", null);
-            Environment.SetEnvironmentVariable("ACTIONS_RUNNER_HOOK_JOB_COMPLETED", null);
-        }
-
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public void EnsureNoPreAndPostHookSteps()
-        {
-            using (TestHostContext hc = CreateTestContext())
-            {
-                var jobExtension = new JobExtension();
-                jobExtension.Initialize(hc);
-
-                _message.ActionsEnvironment = null;
-
-                _jobEc = new Runner.Worker.ExecutionContext {Result = TaskResult.Succeeded};
-                _jobEc.Initialize(hc);
-                _jobEc.InitializeJob(_message, _tokenSource.Token);
-
-                var x = _jobEc.JobSteps;
-
-                jobExtension.FinalizeJob(_jobEc, _message, DateTime.UtcNow);
-
-                Assert.Equal(TaskResult.Succeeded, _jobEc.Result);
-                Assert.Equal(0, _jobEc.PostJobSteps.Count);
-            }
-        }
     }
 }

src/Test/L0/Worker/OutputManagerL0.cs

@@ -3,9 +3,9 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Runtime.CompilerServices;
 using GitHub.Runner.Sdk;
 using GitHub.Runner.Worker;
 using GitHub.Runner.Worker.Container;
@@ -937,19 +937,6 @@ namespace GitHub.Runner.Common.Tests.Worker
             }
         }
 
-        [Fact]
-        [Trait("Level", "L0")]
-        [Trait("Category", "Worker")]
-        public void CaptureTelemetryForGitUnsafeRepository()
-        {
-            using (Setup())
-            using (_outputManager)
-            {
-                Process("fatal: unsafe repository ('/github/workspace' is owned by someone else)");
-                Assert.Contains("fatal: unsafe repository ('/github/workspace' is owned by someone else)", _executionContext.Object.StepTelemetry.ErrorMessages);
-            }
-        }
-
         private TestHostContext Setup(
             [CallerMemberName] string name = "",
             IssueMatchersConfig matchers = null,
@@ -975,8 +962,6 @@ namespace GitHub.Runner.Common.Tests.Worker
                     Variables = _variables,
                     WriteDebug = true,
                 });
-            _executionContext.Setup(x => x.StepTelemetry)
-                .Returns(new DTWebApi.ActionsStepTelemetry());
             _executionContext.Setup(x => x.GetMatchers())
                 .Returns(matchers?.Matchers ?? new List<IssueMatcherConfig>());
             _executionContext.Setup(x => x.Add(It.IsAny<OnMatcherChanged>()))

src/Test/L0/Worker/StepHostL0.cs

@@ -7,9 +7,6 @@ using Xunit;
 using GitHub.Runner.Worker;
 using GitHub.Runner.Worker.Handlers;
 using GitHub.Runner.Worker.Container;
-using GitHub.DistributedTask.Pipelines.ContextData;
-using System.Linq;
-using GitHub.DistributedTask.Pipelines;
 
 namespace GitHub.Runner.Common.Tests.Worker
 {

src/Test/L0/Worker/StepsRunnerL0.cs

@@ -622,40 +622,6 @@ namespace GitHub.Runner.Common.Tests.Worker
                     _stepContext.SetOutcome("", stepContext.Object.ContextName, (stepContext.Object.Outcome ?? stepContext.Object.Result ?? TaskResult.Succeeded).ToActionResult());
                     _stepContext.SetConclusion("", stepContext.Object.ContextName, (stepContext.Object.Result ?? TaskResult.Succeeded).ToActionResult());
                 });
-
-            stepContext.Setup(x => x.UpdateGlobalStepsContext()).Callback(() =>
-            {
-                if (!string.IsNullOrEmpty(stepContext.Object.ContextName) && !stepContext.Object.ContextName.StartsWith("__", StringComparison.Ordinal))
-                {
-                    stepContext.Object.Global.StepsContext.SetOutcome(stepContext.Object.ScopeName, stepContext.Object.ContextName, (stepContext.Object.Outcome ?? stepContext.Object.Result ?? TaskResult.Succeeded).ToActionResult());
-                    stepContext.Object.Global.StepsContext.SetConclusion(stepContext.Object.ScopeName, stepContext.Object.ContextName, (stepContext.Object.Result ?? TaskResult.Succeeded).ToActionResult());
-                }
-            });
-            stepContext.Setup(x => x.ApplyContinueOnError(It.IsAny<TemplateToken>())).Callback((TemplateToken token) =>
-            {
-                if (stepContext.Object.Result != TaskResult.Failed)
-                {
-                    return;
-                }
-                var continueOnError = false;
-                try
-                {
-                    var templateEvaluator = stepContext.Object.ToPipelineTemplateEvaluator();
-                    continueOnError = templateEvaluator.EvaluateStepContinueOnError(token, stepContext.Object.ExpressionValues, stepContext.Object.ExpressionFunctions);
-                }
-                catch (Exception ex)
-                {
-                    stepContext.Object.Error("The step failed and an error occurred when attempting to determine whether to continue on error.");
-                    stepContext.Object.Error(ex);
-                }
-
-                if (continueOnError)
-                {
-                    stepContext.Object.Outcome = stepContext.Object.Result;
-                    stepContext.Object.Result = TaskResult.Succeeded;
-                }
-                stepContext.Object.UpdateGlobalStepsContext();
-            });
             var trace = hc.GetTrace();
             stepContext.Setup(x => x.Write(It.IsAny<string>(), It.IsAny<string>())).Callback((string tag, string message) => { trace.Info($"[{tag}]{message}"); });
             stepContext.Object.Result = result;

src/dev.sh

@@ -128,7 +128,6 @@ function layout ()
         chmod +x "${LAYOUT_DIR}/bin/Runner.Worker"
         chmod +x "${LAYOUT_DIR}/bin/Runner.PluginHost"
         chmod +x "${LAYOUT_DIR}/bin/installdependencies.sh"
-        chmod +x "${LAYOUT_DIR}/safe_sleep.sh"
     fi
 
     heading "Setup externals folder for $RUNTIME_ID runner's layout"

src/runnerversion

@@ -1 +1 @@
-2.291.1
+2.288.1