CLI: Initialize cidfile option

src/windows/wslc/arguments/ArgumentDefinitions.h

@@ -36,7 +36,7 @@ Module Name:
 _(All,            "all",                 L"a",              Kind::Flag,        Localization::WSLCCLI_AllArgDescription()) \
 _(Attach,         "attach",              L"a",              Kind::Flag,        Localization::WSLCCLI_AttachArgDescription()) \
 _(BuildArg,       "build-arg",           NO_ALIAS,          Kind::Value,       Localization::WSLCCLI_BuildArgDescription()) \
-/*_(CIDFile,        "cidfile",             NO_ALIAS,          Kind::Value,       Localization::WSLCCLI_CIDFileArgDescription())*/ \
+_(CIDFile,        "cidfile",             NO_ALIAS,          Kind::Value,       Localization::WSLCCLI_CIDFileArgDescription()) \
 _(Command,        "command",             NO_ALIAS,          Kind::Positional,  Localization::WSLCCLI_CommandArgDescription()) \
 _(ContainerId,    "container-id",        NO_ALIAS,          Kind::Positional,  Localization::WSLCCLI_ContainerIdArgDescription()) \
 _(Force,          "force",               L"f",              Kind::Flag,        Localization::WSLCCLI_ForceArgDescription()) \

src/windows/wslc/arguments/ArgumentValidation.cpp

@@ -58,6 +58,12 @@ void Argument::Validate(const ArgMap& execArgs) const
         break;
     }
 
+    case ArgType::CIDFile:
+    {
+        validation::ValidateCidFile(execArgs.Get<ArgType::CIDFile>());
+        break;
+    }
+
     default:
         break;
     }
@@ -97,6 +103,17 @@ void ValidateVolumeMount(const std::vector<std::wstring>& values)
     }
 }
 
+void ValidateCidFile(const std::wstring& value)
+{
+    std::error_code ec;
+    if (std::filesystem::exists(std::filesystem::path{value}, ec))
+    {
+        THROW_HR_WITH_USER_ERROR(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), std::format(L"CID file '{}' already exists", value));
+    }
+
+    THROW_HR_IF(E_INVALIDARG, ec.value() != 0);
+}
+
 // Convert string to WSLCSignal enum - accepts either signal name (e.g., "SIGKILL") or number (e.g., "9")
 WSLCSignal GetWSLCSignalFromString(const std::wstring& input, const std::wstring& argName)
 {

src/windows/wslc/arguments/ArgumentValidation.h

@@ -62,4 +62,6 @@ FormatType GetFormatTypeFromString(const std::wstring& input, const std::wstring
 
 void ValidateVolumeMount(const std::vector<std::wstring>& values);
 
+void ValidateCidFile(const std::wstring& values);
+
 } // namespace wsl::windows::wslc::validation

src/windows/wslc/commands/ContainerCreateCommand.cpp

@@ -31,7 +31,7 @@ std::vector<Argument> ContainerCreateCommand::GetArguments() const
         Argument::Create(ArgType::ImageId, true),
         Argument::Create(ArgType::Command),
         Argument::Create(ArgType::ForwardArgs),
-        // Argument::Create(ArgType::CIDFile),
+        Argument::Create(ArgType::CIDFile),
         // Argument::Create(ArgType::DNS),
         // Argument::Create(ArgType::DNSDomain),
         // Argument::Create(ArgType::DNSOption),

src/windows/wslc/commands/ContainerRunCommand.cpp

@@ -31,7 +31,7 @@ std::vector<Argument> ContainerRunCommand::GetArguments() const
         Argument::Create(ArgType::ImageId, true),
         Argument::Create(ArgType::Command),
         Argument::Create(ArgType::ForwardArgs),
-        // Argument::Create(ArgType::CIDFile),
+        Argument::Create(ArgType::CIDFile),
         Argument::Create(ArgType::Detach),
         // Argument::Create(ArgType::DNS),
         // Argument::Create(ArgType::DNSDomain),

src/windows/wslc/services/ContainerModel.h

@@ -42,6 +42,7 @@ struct ContainerOptions
     std::vector<std::string> Entrypoint;
     std::optional<std::string> User{};
     std::vector<std::string> Tmpfs;
+    std::optional<std::wstring> CidFile{};
 };
 
 struct CreateContainerResult

src/windows/wslc/services/ContainerService.cpp

@@ -20,6 +20,8 @@ Module Name:
 #include <wslutil.h>
 #include <WSLCProcessLauncher.h>
 #include <CommandLine.h>
+#include <filesystem>
+#include <fstream>
 #include <unordered_map>
 #include <wslc.h>
 
@@ -37,6 +39,26 @@ static void SetContainerArguments(WSLCProcessOptions& options, std::vector<const
     options.CommandLine = {.Values = argsStorage.data(), .Count = static_cast<ULONG>(argsStorage.size())};
 }
 
+static void WriteContainerIdToFile(const std::optional<std::wstring>& cidFilePath, const std::string& containerId)
+{
+    if (!cidFilePath.has_value())
+    {
+        return;
+    }
+
+    std::ofstream file(std::filesystem::path{*cidFilePath}, std::ios::out | std::ios::binary | std::ios::trunc);
+    if (!file.is_open() || !file.good())
+    {
+        THROW_HR_WITH_USER_ERROR(E_INVALIDARG, std::format(L"CID file '{}' cannot be opened for writing", *cidFilePath));
+    }
+
+    file << containerId;
+    if (!file.good())
+    {
+        THROW_HR_WITH_USER_ERROR(E_FAIL, std::format(L"Failed to write container ID to CID file '{}'", *cidFilePath));
+    }
+}
+
 static wsl::windows::common::RunningWSLCContainer CreateInternal(Session& session, const std::string& image, const ContainerOptions& options)
 {
     auto processFlags = WSLCProcessFlagsNone;
@@ -294,6 +316,10 @@ int ContainerService::Run(Session& session, const std::string& image, ContainerO
     runningContainer.SetDeleteOnClose(false);
     auto& container = runningContainer.Get();
 
+    WSLCContainerId containerId{};
+    THROW_IF_FAILED(container.GetId(containerId));
+    WriteContainerIdToFile(runOptions.CidFile, containerId);
+
     // Start the created container
     WSLCContainerStartFlags startFlags{};
     WI_SetFlagIf(startFlags, WSLCContainerStartFlagsAttach, !runOptions.Detach);
@@ -306,8 +332,6 @@ int ContainerService::Run(Session& session, const std::string& image, ContainerO
         return consoleService.AttachToCurrentConsole(runningContainer.GetInitProcess());
     }
 
-    WSLCContainerId containerId{};
-    THROW_IF_FAILED(container.GetId(containerId));
     PrintMessage(L"%hs", stdout, containerId);
     return 0;
 }
@@ -319,6 +343,7 @@ CreateContainerResult ContainerService::Create(Session& session, const std::stri
     auto& container = runningContainer.Get();
     WSLCContainerId id{};
     THROW_IF_FAILED(container.GetId(id));
+    WriteContainerIdToFile(runOptions.CidFile, id);
     return {.Id = id};
 }
 

src/windows/wslc/tasks/ContainerTasks.cpp

@@ -197,6 +197,11 @@ void SetContainerOptionsFromArgs(CLIExecutionContext& context)
 {
     ContainerOptions options;
 
+    if (context.Args.Contains(ArgType::CIDFile))
+    {
+        options.CidFile = context.Args.Get<ArgType::CIDFile>();
+    }
+
     if (context.Args.Contains(ArgType::Name))
     {
         options.Name = WideToMultiByte(context.Args.Get<ArgType::Name>());

test/windows/wslc/CommandLineTestCases.h

@@ -57,6 +57,7 @@ COMMAND_LINE_TEST_CASE(L"container list --format badformat", L"list", false)
 COMMAND_LINE_TEST_CASE(L"run ubuntu", L"run", true)
 COMMAND_LINE_TEST_CASE(L"container run ubuntu bash -c 'echo Hello World'", L"run", true)
 COMMAND_LINE_TEST_CASE(L"container run ubuntu", L"run", true)
+COMMAND_LINE_TEST_CASE(L"container run --cidfile C:\\temp\\cidfile ubuntu", L"run", true)
 COMMAND_LINE_TEST_CASE(L"container run -it --name foo ubuntu", L"run", true)
 COMMAND_LINE_TEST_CASE(L"container run --rm -it --name foo ubuntu", L"run", true)
 COMMAND_LINE_TEST_CASE(L"stop", L"stop", true)
@@ -70,6 +71,7 @@ COMMAND_LINE_TEST_CASE(L"container start --attach cont", L"start", true)
 COMMAND_LINE_TEST_CASE(L"container start -a cont", L"start", true)
 COMMAND_LINE_TEST_CASE(L"create ubuntu:latest", L"create", true)
 COMMAND_LINE_TEST_CASE(L"container create --name foo ubuntu", L"create", true)
+COMMAND_LINE_TEST_CASE(L"container create --cidfile C:\\temp\\cidfile --name foo ubuntu", L"create", true)
 COMMAND_LINE_TEST_CASE(L"exec cont1 echo Hello", L"exec", true)
 COMMAND_LINE_TEST_CASE(L"exec cont1", L"exec", false)                                         // Missing required command argument
 COMMAND_LINE_TEST_CASE(L"container exec -it cont1 sh -c \"echo a && echo b\"", L"exec", true) // docker exec example

test/windows/wslc/e2e/WSLCE2EContainerCreateTests.cpp

@@ -120,6 +120,41 @@ class WSLCE2EContainerCreateTests
         VerifyContainerIsListed(containerId, L"created");
     }
 
+    TEST_METHOD(WSLCE2E_Container_Create_CIDFile_Valid)
+    {
+        WSL2_TEST_ONLY();
+
+        // Prepare a CID file path that does not exist
+        const auto cidFilePath = wsl::windows::common::filesystem::GetTempFilename();
+        VERIFY_IS_TRUE(DeleteFileW(cidFilePath.c_str()));
+        auto deleteCidFile = wil::scope_exit([&]() { VERIFY_IS_TRUE(DeleteFileW(cidFilePath.c_str())); });
+
+        auto result = RunWslc(std::format(
+            L"container create --cidfile \"{}\" --name {} {}", EscapePath(cidFilePath.wstring()), WslcContainerName, DebianImage.NameAndTag()));
+        result.Verify({.Stderr = L"", .ExitCode = S_OK});
+
+        const auto containerId = result.GetStdoutOneLine();
+        VERIFY_IS_TRUE(std::filesystem::exists(cidFilePath));
+        VERIFY_ARE_EQUAL(containerId, ReadFileContent(cidFilePath.wstring()));
+    }
+
+    TEST_METHOD(WSLCE2E_Container_Create_CIDFile_AlreadyExists)
+    {
+        WSL2_TEST_ONLY();
+
+        const auto cidFilePath = wsl::windows::common::filesystem::GetTempFilename();
+        auto deleteCidFile = wil::scope_exit([&]() { VERIFY_IS_TRUE(DeleteFileW(cidFilePath.c_str())); });
+
+        auto result = RunWslc(std::format(
+            L"container create --cidfile \"{}\" --name {} {}", EscapePath(cidFilePath.wstring()), WslcContainerName, DebianImage.NameAndTag()));
+        result.Dump();
+        result.Verify(
+            {.Stderr = std::format(L"CID file '{}' already exists\r\nError code: ERROR_ALREADY_EXISTS\r\n", EscapePath(cidFilePath.wstring())),
+             .ExitCode = 1});
+
+        VerifyContainerIsNotListed(WslcContainerName);
+    }
+
     TEST_METHOD(WSLCE2E_Container_Create_DuplicateContainerName)
     {
         WSL2_TEST_ONLY();
@@ -1232,6 +1267,7 @@ class WSLCE2EContainerCreateTests
     {
         std::wstringstream options;
         options << L"The following options are available:\r\n" //
+                << L"  --cidfile         Write the container ID to the file\r\n"
                 << L"  --entrypoint      Specifies the container init process executable\r\n"
                 << L"  -e,--env          Key=Value pairs for environment variables\r\n"
                 << L"  --env-file        File containing key=value pairs of env variables\r\n"

test/windows/wslc/e2e/WSLCE2EContainerRunTests.cpp

@@ -62,6 +62,43 @@ class WSLCE2EContainerRunTests
         VerifyContainerIsListed(WslcContainerName, L"exited");
     }
 
+    TEST_METHOD(WSLCE2E_Container_Run_CIDFile_Valid)
+    {
+        WSL2_TEST_ONLY();
+
+        // Prepare a CID file path that does not exist
+        const auto cidFilePath = wsl::windows::common::filesystem::GetTempFilename();
+        VERIFY_IS_TRUE(DeleteFileW(cidFilePath.c_str()));
+        auto deleteCidFile = wil::scope_exit([&]() { VERIFY_IS_TRUE(DeleteFileW(cidFilePath.c_str())); });
+
+        auto result = RunWslc(std::format(
+            L"container run -d --cidfile \"{}\" --name {} {} sleep infinity",
+            EscapePath(cidFilePath.wstring()),
+            WslcContainerName,
+            DebianImage.NameAndTag()));
+        result.Verify({.Stderr = L"", .ExitCode = 0});
+
+        const auto containerId = result.GetStdoutOneLine();
+        VERIFY_IS_TRUE(std::filesystem::exists(cidFilePath));
+        VERIFY_ARE_EQUAL(containerId, ReadFileContent(cidFilePath.wstring()));
+    }
+
+    TEST_METHOD(WSLCE2E_Container_Run_CIDFile_AlreadyExists)
+    {
+        WSL2_TEST_ONLY();
+
+        const auto cidFilePath = wsl::windows::common::filesystem::GetTempFilename();
+        auto deleteCidFile = wil::scope_exit([&]() { VERIFY_IS_TRUE(DeleteFileW(cidFilePath.c_str())); });
+
+        auto result = RunWslc(std::format(
+            L"container run --cidfile \"{}\" --name {} {}", EscapePath(cidFilePath.wstring()), WslcContainerName, DebianImage.NameAndTag()));
+        result.Verify(
+            {.Stderr = std::format(L"CID file '{}' already exists\r\nError code: ERROR_ALREADY_EXISTS\r\n", EscapePath(cidFilePath.wstring())),
+             .ExitCode = 1});
+
+        VerifyContainerIsNotListed(WslcContainerName);
+    }
+
     TEST_METHOD(WSLCE2E_Container_Run_Entrypoint)
     {
         WSL2_TEST_ONLY();
@@ -247,6 +284,7 @@ class WSLCE2EContainerRunTests
     {
         std::wstringstream options;
         options << L"The following options are available:\r\n"
+                << L"  --cidfile         Write the container ID to the file\r\n"
                 << L"  -d,--detach       Run container in detached mode\r\n"
                 << L"  --entrypoint      Specifies the container init process executable\r\n"
                 << L"  -e,--env          Key=Value pairs for environment variables\r\n"