Add wslc network connect and disconnect commands

localization/strings/en-US/Resources.resw

@@ -3168,6 +3168,18 @@ On first run, creates the file with all settings commented out at their defaults
     <value>Deleted: {}</value>
     <comment>{FixedPlaceholder="{}"}Command line arguments, file names and string inserts should not be translated</comment>
   </data>
+  <data name="WSLCCLI_NetworkConnectDesc" xml:space="preserve">
+    <value>Connect a container to a network.</value>
+  </data>
+  <data name="WSLCCLI_NetworkConnectLongDesc" xml:space="preserve">
+    <value>Connects a container to an existing network.</value>
+  </data>
+  <data name="WSLCCLI_NetworkDisconnectDesc" xml:space="preserve">
+    <value>Disconnect a container from a network.</value>
+  </data>
+  <data name="WSLCCLI_NetworkDisconnectLongDesc" xml:space="preserve">
+    <value>Disconnects a container from an existing network.</value>
+  </data>
   <data name="WSLCCLI_VolumeCommandDesc" xml:space="preserve">
     <value>Manage volumes.</value>
   </data>

src/windows/wslc/commands/NetworkCommand.cpp

@@ -27,6 +27,8 @@ std::vector<std::unique_ptr<Command>> NetworkCommand::GetCommands() const
     commands.push_back(std::make_unique<NetworkInspectCommand>(FullName()));
     commands.push_back(std::make_unique<NetworkListCommand>(FullName()));
     commands.push_back(std::make_unique<NetworkPruneCommand>(FullName()));
+    commands.push_back(std::make_unique<NetworkConnectCommand>(FullName()));
+    commands.push_back(std::make_unique<NetworkDisconnectCommand>(FullName()));
     return commands;
 }
 

src/windows/wslc/commands/NetworkCommand.h

@@ -104,6 +104,36 @@ struct NetworkPruneCommand final : public Command
     std::wstring ShortDescription() const override;
     std::wstring LongDescription() const override;
 
+protected:
+    void ExecuteInternal(CLIExecutionContext& context) const override;
+};
+
+// Connect Command
+struct NetworkConnectCommand final : public Command
+{
+    constexpr static std::wstring_view CommandName = L"connect";
+    NetworkConnectCommand(const std::wstring& parent) : Command(CommandName, parent)
+    {
+    }
+    std::vector<Argument> GetArguments() const override;
+    std::wstring ShortDescription() const override;
+    std::wstring LongDescription() const override;
+
+protected:
+    void ExecuteInternal(CLIExecutionContext& context) const override;
+};
+
+// Disconnect Command
+struct NetworkDisconnectCommand final : public Command
+{
+    constexpr static std::wstring_view CommandName = L"disconnect";
+    NetworkDisconnectCommand(const std::wstring& parent) : Command(CommandName, parent)
+    {
+    }
+    std::vector<Argument> GetArguments() const override;
+    std::wstring ShortDescription() const override;
+    std::wstring LongDescription() const override;
+
 protected:
     void ExecuteInternal(CLIExecutionContext& context) const override;
 };

src/windows/wslc/commands/NetworkConnectCommand.cpp

@@ -0,0 +1,50 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    NetworkConnectCommand.cpp
+
+Abstract:
+
+    Implementation of command execution logic.
+
+--*/
+
+#include "NetworkCommand.h"
+#include "CLIExecutionContext.h"
+#include "SessionTasks.h"
+#include "NetworkTasks.h"
+#include "Task.h"
+
+using namespace wsl::windows::wslc::execution;
+using namespace wsl::windows::wslc::task;
+using namespace wsl::shared;
+
+namespace wsl::windows::wslc {
+// Network Connect Command
+std::vector<Argument> NetworkConnectCommand::GetArguments() const
+{
+    return {
+        Argument::Create(ArgType::NetworkName, true),
+        Argument::Create(ArgType::ContainerId, true),
+    };
+}
+
+std::wstring NetworkConnectCommand::ShortDescription() const
+{
+    return Localization::WSLCCLI_NetworkConnectDesc();
+}
+
+std::wstring NetworkConnectCommand::LongDescription() const
+{
+    return Localization::WSLCCLI_NetworkConnectLongDesc();
+}
+
+void NetworkConnectCommand::ExecuteInternal(CLIExecutionContext& context) const
+{
+    context << ResolveSession //
+            << ConnectNetwork;
+}
+} // namespace wsl::windows::wslc

src/windows/wslc/commands/NetworkDisconnectCommand.cpp

@@ -0,0 +1,50 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    NetworkDisconnectCommand.cpp
+
+Abstract:
+
+    Implementation of command execution logic.
+
+--*/
+
+#include "NetworkCommand.h"
+#include "CLIExecutionContext.h"
+#include "SessionTasks.h"
+#include "NetworkTasks.h"
+#include "Task.h"
+
+using namespace wsl::windows::wslc::execution;
+using namespace wsl::windows::wslc::task;
+using namespace wsl::shared;
+
+namespace wsl::windows::wslc {
+// Network Disconnect Command
+std::vector<Argument> NetworkDisconnectCommand::GetArguments() const
+{
+    return {
+        Argument::Create(ArgType::NetworkName, true),
+        Argument::Create(ArgType::ContainerId, true),
+    };
+}
+
+std::wstring NetworkDisconnectCommand::ShortDescription() const
+{
+    return Localization::WSLCCLI_NetworkDisconnectDesc();
+}
+
+std::wstring NetworkDisconnectCommand::LongDescription() const
+{
+    return Localization::WSLCCLI_NetworkDisconnectLongDesc();
+}
+
+void NetworkDisconnectCommand::ExecuteInternal(CLIExecutionContext& context) const
+{
+    context << ResolveSession //
+            << DisconnectNetwork;
+}
+} // namespace wsl::windows::wslc

src/windows/wslc/services/NetworkService.cpp

@@ -115,4 +115,21 @@ models::PruneNetworksResult NetworkService::Prune(models::Session& session, cons
 
     return result;
 }
+
+void NetworkService::Connect(models::Session& session, const std::string& networkName, const std::string& containerId)
+{
+    wil::com_ptr<IWSLCContainer> container;
+    THROW_IF_FAILED(session.Get()->OpenContainer(containerId.c_str(), &container));
+
+    WSLCNetworkConnectionOptions options{};
+    options.NetworkName = networkName.c_str();
+    THROW_IF_FAILED(container->ConnectToNetwork(&options));
+}
+
+void NetworkService::Disconnect(models::Session& session, const std::string& networkName, const std::string& containerId)
+{
+    wil::com_ptr<IWSLCContainer> container;
+    THROW_IF_FAILED(session.Get()->OpenContainer(containerId.c_str(), &container));
+    THROW_IF_FAILED(container->DisconnectFromNetwork(networkName.c_str()));
+}
 } // namespace wsl::windows::wslc::services

src/windows/wslc/services/NetworkService.h

@@ -25,5 +25,7 @@ struct NetworkService
     static std::vector<WSLCNetworkInformation> List(models::Session& session);
     static wsl::windows::common::wslc_schema::Network Inspect(models::Session& session, const std::string& name);
     static models::PruneNetworksResult Prune(models::Session& session, const std::vector<std::pair<std::string, std::string>>& filters = {});
+    static void Connect(models::Session& session, const std::string& networkName, const std::string& containerId);
+    static void Disconnect(models::Session& session, const std::string& networkName, const std::string& containerId);
 };
 } // namespace wsl::windows::wslc::services

src/windows/wslc/tasks/NetworkTasks.cpp

@@ -227,4 +227,26 @@ void PruneNetworks(CLIExecutionContext& context)
         PrintMessage(Localization::WSLCCLI_NetworkPruneDeleted(MultiByteToWide(networkName)));
     }
 }
+
+void ConnectNetwork(CLIExecutionContext& context)
+{
+    WI_ASSERT(context.Data.Contains(Data::Session));
+    WI_ASSERT(context.Args.Contains(ArgType::NetworkName));
+    WI_ASSERT(context.Args.Contains(ArgType::ContainerId));
+
+    const auto networkName = WideToMultiByte(context.Args.Get<ArgType::NetworkName>());
+    const auto containerId = WideToMultiByte(context.Args.Get<ArgType::ContainerId>());
+    NetworkService::Connect(context.Data.Get<Data::Session>(), networkName, containerId);
+}
+
+void DisconnectNetwork(CLIExecutionContext& context)
+{
+    WI_ASSERT(context.Data.Contains(Data::Session));
+    WI_ASSERT(context.Args.Contains(ArgType::NetworkName));
+    WI_ASSERT(context.Args.Contains(ArgType::ContainerId));
+
+    const auto networkName = WideToMultiByte(context.Args.Get<ArgType::NetworkName>());
+    const auto containerId = WideToMultiByte(context.Args.Get<ArgType::ContainerId>());
+    NetworkService::Disconnect(context.Data.Get<Data::Session>(), networkName, containerId);
+}
 } // namespace wsl::windows::wslc::task

src/windows/wslc/tasks/NetworkTasks.h

@@ -22,4 +22,6 @@ void GetNetworks(wsl::windows::wslc::execution::CLIExecutionContext& context);
 void InspectNetworks(wsl::windows::wslc::execution::CLIExecutionContext& context);
 void ListNetworks(wsl::windows::wslc::execution::CLIExecutionContext& context);
 void PruneNetworks(wsl::windows::wslc::execution::CLIExecutionContext& context);
+void ConnectNetwork(wsl::windows::wslc::execution::CLIExecutionContext& context);
+void DisconnectNetwork(wsl::windows::wslc::execution::CLIExecutionContext& context);
 } // namespace wsl::windows::wslc::task