Implement most of WinRT API

Author: florelis

src/windows/WslcSDK/Defaults.h

@@ -13,6 +13,7 @@ Module Name:
 --*/
 
 #pragma once
+#include <cstdint>
 
 constexpr uint32_t s_DefaultCPUCount = 2;
 constexpr uint32_t s_DefaultMemoryMB = 2000;

src/windows/WslcSDK/winrt/CMakeLists.txt

@@ -2,16 +2,46 @@ add_idl_winrt(wslcsdkwinrtidl "wslcsdk.idl")
 set_target_properties(wslcsdkwinrtidl PROPERTIES FOLDER windows)
 
 set(SOURCES
+    Container.cpp
+    ContainerNamedVolume.cpp
+    ContainerPortMapping.cpp
+    ContainerSettings.cpp
+    ContainerVolume.cpp
+    ImageInfo.cpp
+    ImageProgress.cpp
+    InstallProgress.cpp
+    Process.cpp
+    ProcessSettings.cpp
+    PullImageOptions.cpp
+    PushImageOptions.cpp
+    ServiceVersion.cpp
     Session.cpp
     SessionSettings.cpp
+    TagImageOptions.cpp
     VhdRequirements.cpp
+    WslcService.cpp
 )
 
 set(HEADERS
+    Container.h
+    ContainerNamedVolume.h
+    ContainerPortMapping.h
+    ContainerSettings.h
+    ContainerVolume.h
     Helpers.h
+    ImageInfo.h
+    ImageProgress.h
+    InstallProgress.h
+    Process.h
+    ProcessSettings.h
+    PullImageOptions.h
+    PushImageOptions.h
+    ServiceVersion.h
     Session.h
     SessionSettings.h
+    TagImageOptions.h
     VhdRequirements.h
+    WslcService.h
 )
 
 add_library(wslcsdkwinrt STATIC ${SOURCES} ${HEADERS})

src/windows/WslcSDK/winrt/Container.cpp

@@ -0,0 +1,104 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    Container.cpp
+
+Abstract:
+
+    This file contains the implementation of the WinRT wrapper for the WSLC SDK Container class.
+
+--*/
+
+#include "precomp.h"
+#include "Container.h"
+#include "Microsoft.WSL.Containers.Container.g.cpp"
+#include "Process.h"
+
+namespace winrt::Microsoft::WSL::Containers::implementation {
+Container::Container(WslcContainer container)
+    : m_container(container)
+{
+}
+
+winrt::Microsoft::WSL::Containers::Container Container::Create(
+    winrt::Microsoft::WSL::Containers::Session const& session, winrt::Microsoft::WSL::Containers::ContainerSettings const& containerSettings)
+{
+    wil::unique_cotaskmem_string errorMessage;
+    WslcContainer containerHandle;
+    auto hr = WslcCreateContainer(GetHandle(session), GetStructPointer(containerSettings), &containerHandle, errorMessage.put());
+    THROW_MSG_IF_FAILED(hr, errorMessage);
+    return *winrt::make_self<implementation::Container>(containerHandle);
+}
+
+void Container::Start(winrt::Microsoft::WSL::Containers::ContainerStartFlags const& flags)
+{
+    wil::unique_cotaskmem_string errorMessage;
+    auto hr = WslcStartContainer(ToHandle(), static_cast<WslcContainerStartFlags>(flags), errorMessage.put());
+    THROW_MSG_IF_FAILED(hr, errorMessage);
+}
+
+void Container::Stop(winrt::Microsoft::WSL::Containers::Signal const& signal, uint32_t timeoutSeconds)
+{
+    wil::unique_cotaskmem_string errorMessage;
+    auto hr = WslcStopContainer(ToHandle(), static_cast<WslcSignal>(signal), timeoutSeconds, errorMessage.put());
+    THROW_MSG_IF_FAILED(hr, errorMessage);
+}
+
+void Container::Delete(winrt::Microsoft::WSL::Containers::DeleteContainerFlags const& flags)
+{
+    wil::unique_cotaskmem_string errorMessage;
+    auto hr = WslcDeleteContainer(ToHandle(), static_cast<WslcDeleteContainerFlags>(flags), errorMessage.put());
+    THROW_MSG_IF_FAILED(hr, errorMessage);
+}
+
+winrt::Microsoft::WSL::Containers::Process Container::CreateProcess(winrt::Microsoft::WSL::Containers::ProcessSettings const& newProcessSettings)
+{
+    wil::unique_cotaskmem_string errorMessage;
+    WslcProcess process;
+    auto hr = WslcCreateContainerProcess(ToHandle(), GetStructPointer(newProcessSettings), &process, errorMessage.put());
+    THROW_MSG_IF_FAILED(hr, errorMessage);
+    return *winrt::make_self<implementation::Process>(process);
+}
+
+hstring Container::Inspect()
+{
+    wil::unique_cotaskmem_ansistring inspectData;
+    winrt::check_hresult(WslcInspectContainer(ToHandle(), inspectData.put()));
+    return winrt::to_hstring(inspectData.get());
+}
+
+hstring Container::Id()
+{
+    CHAR id[WSLC_CONTAINER_ID_BUFFER_SIZE];
+    winrt::check_hresult(WslcGetContainerID(ToHandle(), id));
+    return winrt::to_hstring(id);
+}
+
+winrt::Microsoft::WSL::Containers::Process Container::InitProcess()
+{
+    WslcProcess initProcess;
+    winrt::check_hresult(WslcGetContainerInitProcess(ToHandle(), &initProcess));
+    return *winrt::make_self<implementation::Process>(initProcess);
+}
+
+winrt::Microsoft::WSL::Containers::ContainerState Container::State()
+{
+    WslcContainerState state;
+    winrt::check_hresult(WslcGetContainerState(ToHandle(), &state));
+    return static_cast<winrt::Microsoft::WSL::Containers::ContainerState>(state);
+}
+
+WslcContainer Container::ToHandle()
+{
+    return m_container.get();
+}
+
+WslcContainer* Container::ToHandlePointer()
+{
+    return m_container.addressof();
+}
+
+} // namespace winrt::Microsoft::WSL::Containers::implementation

src/windows/WslcSDK/winrt/Container.h

@@ -0,0 +1,50 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    Container.h
+
+Abstract:
+
+    This file contains the definition of the WinRT wrapper for the WSLC SDK Container class.
+
+--*/
+
+#pragma once
+#include "Microsoft.WSL.Containers.Container.g.h"
+#include "Helpers.h"
+
+namespace winrt::Microsoft::WSL::Containers::implementation {
+struct Container : ContainerT<Container>
+{
+    Container() = default;
+    Container(WslcContainer container);
+
+    static winrt::Microsoft::WSL::Containers::Container Create(
+        winrt::Microsoft::WSL::Containers::Session const& session, winrt::Microsoft::WSL::Containers::ContainerSettings const& containerSettings);
+    void Start(winrt::Microsoft::WSL::Containers::ContainerStartFlags const& flags);
+    void Stop(winrt::Microsoft::WSL::Containers::Signal const& signal, uint32_t timeoutSeconds);
+    void Delete(winrt::Microsoft::WSL::Containers::DeleteContainerFlags const& flags);
+    winrt::Microsoft::WSL::Containers::Process CreateProcess(winrt::Microsoft::WSL::Containers::ProcessSettings const& newProcessSettings);
+    hstring Inspect();
+    hstring Id();
+    winrt::Microsoft::WSL::Containers::Process InitProcess();
+    winrt::Microsoft::WSL::Containers::ContainerState State();
+
+    WslcContainer* ToHandlePointer();
+    WslcContainer ToHandle();
+
+private:
+    wil::unique_any<WslcContainer, decltype(&WslcReleaseContainer), &WslcReleaseContainer> m_container;
+};
+
+} // namespace winrt::Microsoft::WSL::Containers::implementation
+namespace winrt::Microsoft::WSL::Containers::factory_implementation {
+struct Container : ContainerT<Container, implementation::Container>
+{
+};
+} // namespace winrt::Microsoft::WSL::Containers::factory_implementation
+
+DEFINE_TYPE_HELPERS(Container);

src/windows/WslcSDK/winrt/ContainerNamedVolume.cpp

@@ -0,0 +1,98 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    ContainerNamedVolume.cpp
+
+Abstract:
+
+    This file contains the implementation of the WinRT wrapper for the WSLC SDK ContainerNamedVolume class.
+
+--*/
+
+#include "precomp.h"
+#include "ContainerNamedVolume.h"
+#include "Microsoft.WSL.Containers.ContainerNamedVolume.g.cpp"
+
+namespace winrt::Microsoft::WSL::Containers::implementation {
+
+ContainerNamedVolume::ContainerNamedVolume(hstring const& name, hstring const& containerPath, bool readOnly) :
+    m_name(winrt::to_string(name)), m_containerPath(winrt::to_string(containerPath)), m_readOnly(readOnly)
+{
+    if (name.empty() || containerPath.empty())
+    {
+        throw hresult_invalid_argument();
+    }
+}
+
+hstring ContainerNamedVolume::Name()
+{
+    return winrt::to_hstring(m_name);
+}
+
+void ContainerNamedVolume::Name(hstring const& value)
+{
+    if (m_containerNamedVolume)
+    {
+        throw hresult_illegal_state_change();
+    }
+
+    if (value.empty())
+    {
+        throw hresult_invalid_argument();
+    }
+
+    m_name = winrt::to_string(value);
+}
+
+hstring ContainerNamedVolume::ContainerPath()
+{
+    return winrt::to_hstring(m_containerPath);
+}
+
+void ContainerNamedVolume::ContainerPath(hstring const& value)
+{
+    if (m_containerNamedVolume)
+    {
+        throw hresult_illegal_state_change();
+    }
+
+    if (value.empty())
+    {
+        throw hresult_invalid_argument();
+    }
+
+    m_containerPath = winrt::to_string(value);
+}
+
+bool ContainerNamedVolume::ReadOnly()
+{
+    return m_readOnly;
+}
+
+void ContainerNamedVolume::ReadOnly(bool value)
+{
+    if (m_containerNamedVolume)
+    {
+        throw hresult_illegal_state_change();
+    }
+
+    m_readOnly = value;
+}
+
+WslcContainerNamedVolume ContainerNamedVolume::ToStruct()
+{
+    if (!m_containerNamedVolume)
+    {
+        m_containerNamedVolume = std::make_unique<WslcContainerNamedVolume>();
+        m_containerNamedVolume->name = m_name.c_str();
+        m_containerNamedVolume->containerPath = m_containerPath.c_str();
+        m_containerNamedVolume->readOnly = m_readOnly;
+    }
+
+    return *m_containerNamedVolume;
+}
+
+} // namespace winrt::Microsoft::WSL::Containers::implementation

src/windows/WslcSDK/winrt/ContainerNamedVolume.h

@@ -0,0 +1,49 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    ContainerNamedVolume.h
+
+Abstract:
+
+    This file contains the definition of the WinRT wrapper for the WSLC SDK ContainerNamedVolume class.
+
+--*/
+
+#pragma once
+#include "Microsoft.WSL.Containers.ContainerNamedVolume.g.h"
+#include "Helpers.h"
+
+namespace winrt::Microsoft::WSL::Containers::implementation {
+struct ContainerNamedVolume : ContainerNamedVolumeT<ContainerNamedVolume>
+{
+    ContainerNamedVolume() = default;
+
+    ContainerNamedVolume(hstring const& name, hstring const& containerPath, bool readOnly);
+    hstring Name();
+    void Name(hstring const& value);
+    hstring ContainerPath();
+    void ContainerPath(hstring const& value);
+    bool ReadOnly();
+    void ReadOnly(bool value);
+
+    WslcContainerNamedVolume ToStruct();
+
+private:
+    std::string m_name;
+    std::string m_containerPath;
+    bool m_readOnly{};
+
+    std::unique_ptr<WslcContainerNamedVolume> m_containerNamedVolume;
+};
+} // namespace winrt::Microsoft::WSL::Containers::implementation
+
+namespace winrt::Microsoft::WSL::Containers::factory_implementation {
+struct ContainerNamedVolume : ContainerNamedVolumeT<ContainerNamedVolume, implementation::ContainerNamedVolume>
+{
+};
+} // namespace winrt::Microsoft::WSL::Containers::factory_implementation
+
+DEFINE_TYPE_HELPERS(ContainerNamedVolume);