CLI: Initial support for version format option

src/windows/wslc/commands/RootCommand.cpp

@@ -21,8 +21,13 @@ Module Name:
 #include "SettingsCommand.h"
 #include "VersionCommand.h"
 
+#include "wslutil.h"
+#include "VersionService.h"
+
 using namespace wsl::windows::wslc::execution;
 using namespace wsl::shared;
+using namespace wsl::windows::common;
+using namespace wsl::windows::wslc::services;
 
 namespace wsl::windows::wslc {
 std::vector<std::unique_ptr<Command>> RootCommand::GetCommands() const
@@ -79,7 +84,7 @@ void RootCommand::ExecuteInternal(CLIExecutionContext& context) const
 {
     if (context.Args.Contains(ArgType::Version))
     {
-        VersionCommand::PrintVersion();
+        wslutil::PrintMessage(VersionService::GetVersionString());
         return;
     }
 

src/windows/wslc/commands/VersionCommand.cpp

@@ -12,11 +12,20 @@ Module Name:
 
 --*/
 #include "VersionCommand.h"
+#include "VersionTasks.h"
 
 using namespace wsl::shared;
 using namespace wsl::windows::wslc::execution;
+using namespace wsl::windows::wslc::task;
 
 namespace wsl::windows::wslc {
+std::vector<Argument> VersionCommand::GetArguments() const
+{
+    return {
+        Argument::Create(ArgType::Format),
+    };
+}
+
 std::wstring VersionCommand::ShortDescription() const
 {
     return Localization::WSLCCLI_VersionDesc();
@@ -27,14 +36,9 @@ std::wstring VersionCommand::LongDescription() const
     return Localization::WSLCCLI_VersionLongDesc();
 }
 
-void VersionCommand::PrintVersion()
-{
-    wsl::windows::common::wslutil::PrintMessage(std::format(L"{} {}", s_ExecutableName, WSL_PACKAGE_VERSION));
-}
-
 void VersionCommand::ExecuteInternal(CLIExecutionContext& context) const
 {
-    UNREFERENCED_PARAMETER(context);
-    PrintVersion();
+    context << GetVersionInfo //
+            << ListVersionInfo;
 }
 } // namespace wsl::windows::wslc

src/windows/wslc/commands/VersionCommand.h

@@ -21,7 +21,7 @@ struct VersionCommand final : public Command
     VersionCommand(const std::wstring& parent) : Command(CommandName, parent)
     {
     }
-    static void PrintVersion();
+    std::vector<Argument> GetArguments() const override;
     std::wstring ShortDescription() const override;
     std::wstring LongDescription() const override;
 

src/windows/wslc/core/ExecutionContextData.h

@@ -15,6 +15,7 @@ Module Name:
 #include "EnumVariantMap.h"
 #include "ContainerModel.h"
 #include "ImageModel.h"
+#include "VersionModel.h"
 #include "SessionModel.h"
 
 #include <string>
@@ -36,6 +37,7 @@ enum class Data : size_t
     Containers,
     ContainerOptions,
     Images,
+    Version,
 
     Max
 };
@@ -50,6 +52,7 @@ namespace details {
     DEFINE_DATA_MAPPING(Containers, std::vector<wsl::windows::wslc::models::ContainerInformation>);
     DEFINE_DATA_MAPPING(ContainerOptions, wsl::windows::wslc::models::ContainerOptions);
     DEFINE_DATA_MAPPING(Images, std::vector<wsl::windows::wslc::models::ImageInformation>);
+    DEFINE_DATA_MAPPING(Version, wsl::windows::wslc::models::VersionInfo);
 } // namespace details
 
 struct DataMap : wsl::windows::wslc::EnumBasedVariantMap<Data, wsl::windows::wslc::execution::details::DataMapping>

src/windows/wslc/services/VersionModel.h

@@ -0,0 +1,90 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    VersionModel.h
+
+Abstract:
+
+    This file contains the VersionModel definitions
+--*/
+
+#pragma once
+
+namespace wsl::windows::wslc::models {
+
+#define WSLC_VERSION_ROW(key, value) std::format("{:<20}{}\n", key ":", value)
+
+struct ClientVersion
+{
+    std::string Version = WSL_PACKAGE_VERSION;
+    std::string GitCommit = COMMIT_HASH;
+    std::string Built = __DATE__ " " __TIME__;
+    std::string Os = "windows";
+
+#if defined(_AMD64_)
+    std::string Arch = "amd64";
+#elif defined(_ARM64_)
+    std::string Arch = "arm64";
+#else
+    std::string Arch = "unknown";
+#endif
+
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(ClientVersion, Version, GitCommit, Built, Os, Arch);
+
+    std::string ToString() const
+    {
+        std::stringstream ss;
+        ss << "Client:\n";
+        ss << WSLC_VERSION_ROW("  Version", Version);
+        ss << WSLC_VERSION_ROW("  Git commit", GitCommit);
+        ss << WSLC_VERSION_ROW("  Built", Built);
+        ss << WSLC_VERSION_ROW("  OS/Arch", Os + "/" + Arch);
+        return ss.str();
+    }
+};
+
+struct ServerVersion
+{
+    std::string Kernel = KERNEL_VERSION;
+    std::string WSLg = WSLG_VERSION;
+    std::string MSRDC = MSRDC_VERSION;
+    std::string Direct3D = DIRECT3D_VERSION;
+    std::string DXCore = DXCORE_VERSION;
+    std::string Windows = wsl::windows::common::helpers::GetWindowsVersionString();
+
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(ServerVersion, Kernel, WSLg, MSRDC, Direct3D, DXCore, Windows);
+
+    std::string ToString() const
+    {
+        std::stringstream ss;
+        ss << "Server:\n";
+        ss << WSLC_VERSION_ROW("  Linux kernel", Kernel);
+        ss << WSLC_VERSION_ROW("  WSLg", WSLg);
+        ss << WSLC_VERSION_ROW("  MSRDC", MSRDC);
+        ss << WSLC_VERSION_ROW("  Direct3D", Direct3D);
+        ss << WSLC_VERSION_ROW("  DXCore", DXCore);
+        ss << WSLC_VERSION_ROW("  Windows", Windows);
+        return ss.str();
+    }
+};
+
+struct VersionInfo
+{
+    ClientVersion Client{};
+    ServerVersion Server{};
+
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(VersionInfo, Client, Server);
+
+    std::string ToString() const
+    {
+        std::stringstream ss;
+        ss << Client.ToString() << "\n";
+        ss << Server.ToString();
+        return ss.str();
+    }
+};
+#undef WSLC_VERSION_ROW
+} // namespace wsl::windows::wslc::models

src/windows/wslc/services/VersionService.cpp

@@ -0,0 +1,33 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    VersionService.cpp
+
+Abstract:
+
+    This file contains the VersionService implementation
+--*/
+
+#include "precomp.h"
+#include "VersionService.h"
+#include "Command.h"
+
+namespace wsl::windows::wslc::services {
+
+using namespace wsl::shared::string;
+
+std::wstring VersionService::GetVersionString()
+{
+    return std::format(L"{} {}", s_ExecutableName, MultiByteToWide(VersionInfo().Client.Version));
+}
+
+const wsl::windows::wslc::models::VersionInfo& VersionService::VersionInfo()
+{
+    static const wsl::windows::wslc::models::VersionInfo s_versionInfo{};
+    return s_versionInfo;
+}
+
+} // namespace wsl::windows::wslc::services

src/windows/wslc/services/VersionService.h

@@ -0,0 +1,24 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    VersionService.h
+
+Abstract:
+
+    This file contains the VersionService definition
+--*/
+#pragma once
+
+#include "VersionModel.h"
+#include <wslc.h>
+
+namespace wsl::windows::wslc::services {
+struct VersionService
+{
+    static std::wstring GetVersionString();
+    static const wsl::windows::wslc::models::VersionInfo& VersionInfo();
+};
+} // namespace wsl::windows::wslc::services

src/windows/wslc/tasks/VersionTasks.cpp

@@ -0,0 +1,66 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    VersionTasks.cpp
+
+Abstract:
+
+    Implementation of version command related execution logic.
+
+--*/
+#include "precomp.h"
+#include "Argument.h"
+#include "ArgumentValidation.h"
+#include "ContainerModel.h"
+#include "VersionTasks.h"
+#include "VersionService.h"
+#include "CLIExecutionContext.h"
+#include <wil/result_macros.h>
+#include <wslc_schema.h>
+
+using namespace wsl::shared;
+using namespace wsl::shared::string;
+using namespace wsl::windows::wslc::execution;
+using namespace wsl::windows::wslc::models;
+using namespace wsl::windows::wslc::services;
+using namespace wsl::windows::common::wslutil;
+
+namespace wsl::windows::wslc::task {
+
+void GetVersionInfo(CLIExecutionContext& context)
+{
+    context.Data.Add<Data::Version>(VersionService::VersionInfo());
+}
+
+void ListVersionInfo(CLIExecutionContext& context)
+{
+    WI_ASSERT(context.Data.Contains(Data::Version));
+    auto& versionInfo = context.Data.Get<Data::Version>();
+
+    FormatType format = FormatType::Table; // Default is table
+    if (context.Args.Contains(ArgType::Format))
+    {
+        format = validation::GetFormatTypeFromString(context.Args.Get<ArgType::Format>());
+    }
+
+    switch (format)
+    {
+    case FormatType::Json:
+    {
+        auto json = ToJson(versionInfo, c_jsonPrettyPrintIndent);
+        PrintMessage(MultiByteToWide(json));
+        break;
+    }
+    case FormatType::Table:
+    {
+        PrintMessage(MultiByteToWide(versionInfo.ToString()));
+        break;
+    }
+    default:
+        THROW_HR(E_UNEXPECTED);
+    }
+}
+} // namespace wsl::windows::wslc::task

src/windows/wslc/tasks/VersionTasks.h

@@ -0,0 +1,22 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    VersionTasks.h
+
+Abstract:
+
+    Declaration of version command execution tasks.
+--*/
+#pragma once
+#include "CLIExecutionContext.h"
+#include "Task.h"
+
+using wsl::windows::wslc::execution::CLIExecutionContext;
+
+namespace wsl::windows::wslc::task {
+void GetVersionInfo(CLIExecutionContext& context);
+void ListVersionInfo(CLIExecutionContext& context);
+} // namespace wsl::windows::wslc::task

test/windows/wslc/WSLCCLICommandUnitTests.cpp

@@ -142,13 +142,13 @@ class WSLCCLICommandUnitTests
         VERIFY_ARE_EQUAL(0u, cmd.GetCommands().size());
     }
 
-    // Test: Verify VersionCommand has no arguments (only the auto-added --help)
-    TEST_METHOD(VersionCommand_HasNoArguments)
+    // Test: Verify VersionCommand has the expected arguments (--format, plus the auto-added --help)
+    TEST_METHOD(VersionCommand_HasFormatArgument)
     {
         auto cmd = VersionCommand(L"wslc");
-        VERIFY_ARE_EQUAL(0u, cmd.GetArguments().size());
-        // Test out that auto added help command is the only one
-        VERIFY_ARE_EQUAL(1u, cmd.GetAllArguments().size());
+        VERIFY_ARE_EQUAL(1u, cmd.GetArguments().size());
+        // Test out that --format and auto-added --help are the only arguments
+        VERIFY_ARE_EQUAL(2u, cmd.GetAllArguments().size());
     }
 
     // Test: Verify RootCommand contains VersionCommand as a subcommand

test/windows/wslc/WSLCCLIExecutionUnitTests.cpp

@@ -97,6 +97,12 @@ class WSLCCLIExecutionUnitTests
                 dataMap.Add<Data::Images>(std::move(images));
                 handled = true;
             }
+            else if (dataType == Data::Version)
+            {
+                wsl::windows::wslc::models::VersionInfo versionInfo;
+                dataMap.Add<Data::Version>(std::move(versionInfo));
+                handled = true;
+            }
 
             if (!handled)
             {

test/windows/wslc/e2e/WSLCE2EGlobalTests.cpp

@@ -66,11 +66,6 @@ class WSLCE2EGlobalTests
         RunWslcAndVerify(L"INVALID_CMD", {.Stdout = GetHelpMessage(), .Stderr = L"Unrecognized command: 'INVALID_CMD'\r\n", .ExitCode = 1});
     }
 
-    WSLC_TEST_METHOD(WSLCE2E_VersionCommand)
-    {
-        RunWslcAndVerify(L"version", {.Stdout = GetVersionMessage(), .Stderr = L"", .ExitCode = 0});
-    }
-
     WSLC_TEST_METHOD(WSLCE2E_VersionFlag)
     {
         RunWslcAndVerify(L"--version", {.Stdout = GetVersionMessage(), .Stderr = L"", .ExitCode = 0});