Refine localized error handling

beena352 · beena352 · commit c60e0034f4e4 · 2026-01-09T16:27:53.000-08:00
diff --git a/src/windows/common/ExecutionContext.h b/src/windows/common/ExecutionContext.h
@@ -66,6 +66,7 @@ enum Context : ULONGLONG
     UpdatePackage = 0x10000000000,
     QueryLatestGitHubRelease = 0x20000000000,
     VerifyChecksum = 0x40000000000,
+    WslaDiag = 0x80000000000,
 };
 
 DEFINE_ENUM_FLAG_OPERATORS(Context)
diff --git a/src/windows/common/wslutil.cpp b/src/windows/common/wslutil.cpp
@@ -191,7 +191,8 @@ static const std::map<Context, LPCWSTR> g_contextStrings{
     X(HNS),
     X(ReadDistroConfig),
     X(MoveDistro),
-    X(VerifyChecksum)};
+    X(VerifyChecksum),
+    X(WslaDiag)};
 
 #undef X
 
diff --git a/src/windows/wsladiag/wsladiag.cpp b/src/windows/wsladiag/wsladiag.cpp
@@ -8,7 +8,7 @@ Module Name:
 
 Abstract:
 
-    Entry point for the wsladiag tool, performs WSL runtime initialization and parses list/shell/help.
+    Entry point for the wsladiag tool. Provides diagnostic commands for WSLA sessions.
 
 --*/
 
@@ -24,32 +24,25 @@ Module Name:
 
 using namespace wsl::shared;
 namespace wslutil = wsl::windows::common::wslutil;
+using wsl::windows::common::Context;
+using wsl::windows::common::ExecutionContext;
 using wsl::windows::common::WSLAProcessLauncher;
 
-// Adding a helper to factor error handling between all the arguments.
+// Report an operation failure with localized context and HRESULT details.
 static int ReportError(const std::wstring& context, HRESULT hr)
 {
-    const std::wstring hrMessage = wslutil::GetErrorString(hr);
-
-    if (!hrMessage.empty())
-    {
-        wslutil::PrintMessage(std::format(L"{}: 0x{:08x} - {}", context, static_cast<uint32_t>(hr), hrMessage), stderr);
-    }
-    else
-    {
-        wslutil::PrintMessage(std::format(L"{}: 0x{:08x}", context, static_cast<uint32_t>(hr)), stderr);
-    }
-
+    auto errorString = wsl::windows::common::wslutil::ErrorCodeToString(hr);
+    wslutil::PrintMessage(context, stderr);
     return 1;
 }
 
-// Handler for `wsladiag shell <SessionName> [--verbose]` command - launches TTY-backed interactive shell.
+// Handler for `wsladiag shell <SessionName>` command.
 static int RunShellCommand(std::wstring_view commandLine)
 {
     std::wstring sessionName;
     bool verbose = false;
 
-    ArgumentParser parser(std::wstring{commandLine}, L"wsladiag", 2, false); // Skip "wsladiag.exe shell" to parse shell-specific args
+    ArgumentParser parser(std::wstring{commandLine}, L"wsladiag", 2, false);
     parser.AddPositionalArgument(sessionName, 0);
     parser.AddArgument(verbose, L"--verbose", L'v');
 
@@ -61,15 +54,6 @@ static int RunShellCommand(std::wstring_view commandLine)
             E_INVALIDARG, wsl::shared::Localization::MessageMissingArgument(L"<SessionName>", L"wsladiag shell"));
     }
 
-    const auto log = [&](std::wstring_view msg) {
-        if (verbose)
-        {
-            wslutil::PrintMessage(std::wstring(msg), stdout);
-        }
-    };
-
-    log(std::format(L"[diag] shell='{}'", sessionName));
-
     wil::com_ptr<IWSLAUserSession> userSession;
     THROW_IF_FAILED(CoCreateInstance(__uuidof(WSLAUserSession), nullptr, CLSCTX_LOCAL_SERVER, IID_PPV_ARGS(&userSession)));
     wsl::windows::common::security::ConfigureForCOMImpersonation(userSession.get());
@@ -87,8 +71,6 @@ static int RunShellCommand(std::wstring_view commandLine)
         return ReportError(Localization::MessageWslaOpenSessionFailed(sessionName.c_str()), hr);
     }
 
-    log(L"[diag] OpenSessionByName succeeded");
-
     // Console size for TTY.
     CONSOLE_SCREEN_BUFFER_INFO info{};
     THROW_LAST_ERROR_IF(!GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info));
@@ -105,12 +87,9 @@ static int RunShellCommand(std::wstring_view commandLine)
     launcher.AddFd(WSLA_PROCESS_FD{.Fd = 1, .Type = WSLAFdTypeTerminalOutput, .Path = nullptr});
     launcher.AddFd(WSLA_PROCESS_FD{.Fd = 2, .Type = WSLAFdTypeTerminalControl, .Path = nullptr});
 
-    log(std::format(L"[diag] tty rows={} cols={}", rows, cols));
     launcher.SetTtySize(rows, cols);
 
-    log(L"[diag] launching shell process...");
     auto process = launcher.Launch(*session);
-    log(L"[diag] shell launched (TTY)");
 
     auto ttyIn = process.GetStdHandle(0);
     auto ttyOut = process.GetStdHandle(1);
@@ -129,13 +108,12 @@ static int RunShellCommand(std::wstring_view commandLine)
     // Save/restore console state.
     DWORD originalInMode{};
     DWORD originalOutMode{};
+    const UINT originalOutCP = GetConsoleOutputCP();
+    const UINT originalInCP = GetConsoleCP();
 
     THROW_LAST_ERROR_IF(!GetConsoleMode(consoleIn, &originalInMode));
     THROW_LAST_ERROR_IF(!GetConsoleMode(consoleOut, &originalOutMode));
 
-    const UINT originalOutCP = GetConsoleOutputCP();
-    const UINT originalInCP = GetConsoleCP();
-
     auto restoreConsole = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, [&] {
         LOG_IF_WIN32_BOOL_FALSE(SetConsoleMode(consoleIn, originalInMode));
         LOG_IF_WIN32_BOOL_FALSE(SetConsoleMode(consoleOut, originalOutMode));
@@ -158,19 +136,13 @@ static int RunShellCommand(std::wstring_view commandLine)
 
     auto exitEvent = wil::unique_event(wil::EventOptions::ManualReset);
 
-    auto ttyControl = process.GetStdHandle(2); // TerminalControl
-    wsl::shared::SocketChannel controlChannel{wil::unique_socket{(SOCKET)ttyControl.release()}, "TerminalControl", exitEvent.get()};
-
     auto updateTerminalSize = [&]() {
         CONSOLE_SCREEN_BUFFER_INFOEX infoEx{};
         infoEx.cbSize = sizeof(infoEx);
         THROW_IF_WIN32_BOOL_FALSE(GetConsoleScreenBufferInfoEx(consoleOut, &infoEx));
 
-        WSLA_TERMINAL_CHANGED message{};
-        message.Columns = infoEx.srWindow.Right - infoEx.srWindow.Left + 1;
-        message.Rows = infoEx.srWindow.Bottom - infoEx.srWindow.Top + 1;
-
-        controlChannel.SendMessage(message);
+        LOG_IF_FAILED(process.Get().ResizeTty(
+            infoEx.srWindow.Bottom - infoEx.srWindow.Top + 1, infoEx.srWindow.Right - infoEx.srWindow.Left + 1));
     };
 
     // Start input relay thread to forward console input to TTY
@@ -186,7 +158,7 @@ static int RunShellCommand(std::wstring_view commandLine)
         }
     });
 
-    auto joinInput = wil::scope_exit([&] {
+    auto joinInput = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, [&] {
         exitEvent.SetEvent();
         if (inputThread.joinable())
         {
@@ -199,22 +171,30 @@ static int RunShellCommand(std::wstring_view commandLine)
 
     process.GetExitEvent().wait();
 
-    auto [exitCode, signalled] = process.GetExitState();
+    auto exitCode = process.GetExitCode();
 
     std::wstring shellWide(shell.begin(), shell.end());
-    wslutil::PrintMessage(Localization::MessageWslaShellExited(shellWide.c_str(), exitCode), stdout);
+    wslutil::PrintMessage(wsl::shared::Localization::MessageWslaShellExited(shellWide.c_str(), static_cast<int>(exitCode)), stdout);
 
-    return 0;
+    return static_cast<int>(exitCode);
 }
 
+// Handler for `wsladiag list` command.
 static int RunListCommand(std::wstring_view commandLine)
 {
     bool verbose = false;
 
-    ArgumentParser parser(std::wstring{commandLine}, L"wsladiag", 2, false); // Skip "wsladiag.exe list" to parse list-specific args
+    ArgumentParser parser(std::wstring{commandLine}, L"wsladiag", 2, false);
     parser.AddArgument(verbose, L"--verbose", L'v');
 
-    parser.Parse();
+    try
+    {
+        parser.Parse();
+    }
+    catch (...)
+    {
+        THROW_HR_WITH_USER_ERROR(E_INVALIDARG, wsl::shared::Localization::MessageWsladiagUsage());
+    }
 
     wil::com_ptr<IWSLAUserSession> userSession;
     THROW_IF_FAILED(CoCreateInstance(__uuidof(WSLAUserSession), nullptr, CLSCTX_LOCAL_SERVER, IID_PPV_ARGS(&userSession)));
@@ -235,7 +215,8 @@ static int RunListCommand(std::wstring_view commandLine)
     }
 
     wslutil::PrintMessage(Localization::MessageWslaSessionsFound(sessions.size(), sessions.size() == 1 ? L"" : L"s"), stdout);
-    // Compute column widths from headers + data.
+
+    // Use localized headers
     const auto idHeader = Localization::MessageWslaHeaderId();
     const auto pidHeader = Localization::MessageWslaHeaderCreatorPid();
     const auto nameHeader = Localization::MessageWslaHeaderDisplayName();
@@ -279,7 +260,6 @@ static int RunListCommand(std::wstring_view commandLine)
     for (const auto& s : sessions)
     {
         const wchar_t* displayName = s.DisplayName ? s.DisplayName : L"";
-
         wprintf(
             L"%-*lu  %-*lu  %-*ls\n",
             static_cast<int>(idWidth),
@@ -293,14 +273,15 @@ static int RunListCommand(std::wstring_view commandLine)
     return 0;
 }
 
+// Print localized usage message to stderr.
 static void PrintUsage()
 {
     wslutil::PrintMessage(Localization::MessageWsladiagUsage(), stderr);
 }
 
 int wsladiag_main(std::wstring_view commandLine)
 {
-    // Basic initialization that was previously in this function.
+    // Initialize runtime and COM.
     wslutil::ConfigureCrt();
     wslutil::InitializeWil();
 
@@ -316,107 +297,75 @@ int wsladiag_main(std::wstring_view commandLine)
     THROW_IF_WIN32_ERROR(WSAStartup(MAKEWORD(2, 2), &data));
     auto wsaCleanup = wil::scope_exit_log(WI_DIAGNOSTICS_INFO, []() { WSACleanup(); });
 
-    // Enable contextualized error collection and create an ExecutionContext so
-    // THROW_HR_WITH_USER_ERROR will save a user-visible message.
-    wsl::windows::common::EnableContextualizedErrors(false);
+    // Parse the top-level verb (list, shell, --help).
+    ArgumentParser parser(std::wstring{commandLine}, L"wsladiag", 1, true);
+
+    bool help = false;
+    std::wstring verb;
+
+    parser.AddPositionalArgument(verb, 0);
+    parser.AddArgument(help, L"--help", L'h');
 
-    FILE* warningsFile = nullptr;
-    const char* disableWarnings = getenv("WSL_DISABLE_WARNINGS");
-    if (disableWarnings == nullptr || strcmp(disableWarnings, "1") != 0)
+    parser.Parse();
+
+    if (help || verb.empty())
     {
-        warningsFile = stderr;
+        PrintUsage();
+        return 0;
     }
 
-    std::optional<wsl::windows::common::ExecutionContext> context;
-    context.emplace(wsl::windows::common::Context::Wsl, warningsFile);
-
-    int exitCode = 0;
-    HRESULT result = S_OK;
+    if (verb == L"list")
+    {
+        return RunListCommand(commandLine);
+    }
 
-    try
+    if (verb == L"shell")
     {
-        ArgumentParser parser(std::wstring{commandLine}, L"wsladiag", 1, true);
+        return RunShellCommand(commandLine);
+    }
 
-        bool help = false;
-        std::wstring verb;
+    // Unknown verb - show usage and fail.
+    wslutil::PrintMessage(Localization::MessageWslaUnknownCommand(verb.c_str()), stderr);
+    PrintUsage();
+    return 1;
+}
 
-        parser.AddPositionalArgument(verb, 0);
-        parser.AddArgument(help, L"--help", L'h');
+int wmain(int, wchar_t**)
+{
+    wsl::windows::common::EnableContextualizedErrors(false);
 
-        parser.Parse(); // Let exceptions propagate to this try/catch
+    ExecutionContext context{Context::WslaDiag};
+    int exitCode = 1;
+    HRESULT result = S_OK;
 
-        if (help || verb.empty())
-        {
-            PrintUsage();
-            exitCode = 0;
-        }
-        else if (verb == L"list")
-        {
-            exitCode = RunListCommand(commandLine);
-        }
-        else if (verb == L"shell")
-        {
-            exitCode = RunShellCommand(commandLine);
-        }
-        else
-        {
-            wslutil::PrintMessage(Localization::MessageWslaUnknownCommand(verb.c_str()), stderr);
-            PrintUsage();
-            exitCode = 1;
-        }
+    try
+    {
+        exitCode = wsladiag_main(GetCommandLineW());
     }
     catch (...)
     {
-        // Capture the exception HRESULT and fall through to printing contextualized error.
         result = wil::ResultFromCaughtException();
-        // Default nonzero exit code on failure.
-        exitCode = 1;
     }
 
-    // If there was a failure, attempt to print a contextualized error message collected
-    // by the ExecutionContext. Otherwise fall back to the HRESULT -> string path.
     if (FAILED(result))
     {
         try
         {
-            std::wstring errorString{};
-            if (context.has_value() && context->ReportedError().has_value())
+            if (auto reported = context.ReportedError())
             {
-                auto strings = wsl::windows::common::wslutil::ErrorToString(context->ReportedError().value());
-
-                // For most errors, show both message and code
-                errorString = wsl::shared::Localization::MessageErrorCode(strings.Message, strings.Code);
-
-                // Log telemetry for user-visible errors (matches other tools).
-                WSL_LOG("UserVisibleError", TraceLoggingValue(strings.Code.c_str(), "ErrorCode"));
+                auto strings = wsl::windows::common::wslutil::ErrorToString(*reported);
+                wslutil::PrintMessage(wsl::shared::Localization::MessageErrorCode(strings.Message, strings.Code), stderr);
             }
             else
             {
-                // Fallback: show basic HRESULT string.
-                errorString = wslutil::ErrorCodeToString(result);
+                wslutil::PrintMessage(wslutil::GetErrorString(result), stderr);
             }
-
-            wslutil::PrintMessage(errorString, stderr);
         }
         catch (...)
         {
             LOG_CAUGHT_EXCEPTION();
         }
-
     }
 
     return exitCode;
-}
-
-int wmain(int, wchar_t**)
-{
-    try
-    {
-        return wsladiag_main(GetCommandLineW());
-    }
-    catch (...)
-    {
-        const auto hr = wil::ResultFromCaughtException();
-        return ReportError(L"wsladiag failed", hr);
-    }
 }
