Partial SDK implementation

CMakeLists.txt

@@ -275,8 +275,9 @@ endif()
 
 # Determine the Visual Studio installation directory which contains LLVM tools
 # N.B. The version is set to VS2022 to ensure local runs match pipeline behavior
+# Require that Clang be installed in the product to potentially de-deduplicate
 execute_process(
-    COMMAND "${VSWHERE_SOURCE_DIR}/vswhere.exe" -version "[17.0,18.0)" -products * -property installationPath
+    COMMAND "${VSWHERE_SOURCE_DIR}/vswhere.exe" -version "[17.0,18.0)" -products * -requires Microsoft.VisualStudio.Component.VC.Llvm.Clang -property installationPath
     OUTPUT_VARIABLE VS_INSTALL_DIR
     OUTPUT_STRIP_TRAILING_WHITESPACE
     COMMAND_ERROR_IS_FATAL ANY
@@ -293,7 +294,7 @@ else()
 endif()
 
 if (NOT EXISTS ${LLVM_INSTALL_DIR})
-    message(FATAL_ERROR "C++ Clang Compiler for Windows is not installed. Please install it from the Visual Studio Installer.")
+    message(FATAL_ERROR "C++ Clang Compiler for Windows is not installed at ${LLVM_INSTALL_DIR}. Please install it from the Visual Studio Installer.")
 endif()
 
 # Generate the clang-format script which contains a path to clang-format.exe

src/windows/WslcSDK/CMakeLists.txt

@@ -1,5 +1,12 @@
-set(SOURCES wslcsdk.cpp)
+set(SOURCES
+    ProgressCallback.cpp
+    TerminationCallback.cpp
+    wslcsdk.cpp
+    WslcsdkPrivate.cpp
+)
 set(HEADERS
+    ProgressCallback.h
+    TerminationCallback.h
     wslcsdk.h
     WslcsdkPrivate.h
 )

src/windows/WslcSDK/ProgressCallback.cpp

@@ -0,0 +1,74 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    ProgressCallback.cpp
+
+Abstract:
+
+    Implementation of a type that implements IProgressCallback.
+
+--*/
+#include "precomp.h"
+#include "ProgressCallback.h"
+
+using namespace std::string_view_literals;
+
+namespace {
+WslcImageProgressStatus ConvertStatus(LPCSTR Status)
+{
+#define WSLC_STRING_TO_STATUS_MAPPING(_status_, _string_) \
+    if (_string_##sv == Status) \
+    { \
+        return _status_; \
+    }
+
+    // TODO: Mapping engine strings to status values seems fragile.
+    //       WSLA is intentionally avoiding this kind of thing for localization of engine strings, which amounts to the same
+    //       thing. If we keep this, a test should be added to explicitly validate that each status is returned properly.
+    WSLC_STRING_TO_STATUS_MAPPING(WSLC_IMAGE_PROGRESS_STATUS_PULLING, "Pulling fs layer");
+    WSLC_STRING_TO_STATUS_MAPPING(WSLC_IMAGE_PROGRESS_STATUS_WAITING, "Waiting");
+    WSLC_STRING_TO_STATUS_MAPPING(WSLC_IMAGE_PROGRESS_STATUS_DOWNLOADING, "Downloading");
+    WSLC_STRING_TO_STATUS_MAPPING(WSLC_IMAGE_PROGRESS_STATUS_VERIFYING, "Verifying Checksum");
+    WSLC_STRING_TO_STATUS_MAPPING(WSLC_IMAGE_PROGRESS_STATUS_EXTRACTING, "Extracting");
+    WSLC_STRING_TO_STATUS_MAPPING(WSLC_IMAGE_PROGRESS_STATUS_COMPLETE, "Pull complete");
+
+    return WSLC_IMAGE_PROGRESS_STATUS_UNKNOWN;
+}
+} // namespace
+
+ProgressCallback::ProgressCallback(WslcContainerImageProgressCallback callback, PVOID context) :
+    m_callback(callback), m_context(context)
+{
+}
+
+HRESULT STDMETHODCALLTYPE ProgressCallback::OnProgress(LPCSTR Status, LPCSTR Id, ULONGLONG Current, ULONGLONG Total)
+{
+    if (m_callback)
+    {
+        WslcImageProgressMessage message{};
+
+        message.id = Id;
+        message.status = ConvertStatus(Status);
+        message.detail.current = Current;
+        message.detail.total = Total;
+
+        m_callback(&message, m_context);
+    }
+
+    return S_OK;
+}
+
+winrt::com_ptr<ProgressCallback> ProgressCallback::CreateIf(const WslcPullImageOptions* options)
+{
+    if (options->progressCallback)
+    {
+        return winrt::make_self<ProgressCallback>(options->progressCallback, options->progressCallbackContext);
+    }
+    else
+    {
+        return nullptr;
+    }
+}

src/windows/WslcSDK/ProgressCallback.h

@@ -0,0 +1,32 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    ProgressCallback.h
+
+Abstract:
+
+    Header for a type that implements IProgressCallback.
+
+--*/
+#pragma once
+#include "wslaservice.h"
+#include "wslcsdkprivate.h"
+#include <winrt/base.h>
+
+struct ProgressCallback : public winrt::implements<ProgressCallback, IProgressCallback>
+{
+    ProgressCallback(WslcContainerImageProgressCallback callback, PVOID context);
+
+    // IProgressCallback
+    HRESULT STDMETHODCALLTYPE OnProgress(LPCSTR Status, LPCSTR Id, ULONGLONG Current, ULONGLONG Total) override;
+
+    // Creates a ProgressCallback if the options provides a callback.
+    static winrt::com_ptr<ProgressCallback> CreateIf(const WslcPullImageOptions* options);
+
+private:
+    WslcContainerImageProgressCallback m_callback;
+    PVOID m_context;
+};

src/windows/WslcSDK/TerminationCallback.cpp

@@ -0,0 +1,58 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    TerminationCallback.cpp
+
+Abstract:
+
+    Implementation of a type that implements ITerminationCallback.
+
+--*/
+#include "precomp.h"
+#include "TerminationCallback.h"
+
+namespace {
+WslcSessionTerminationReason ConvertReason(WSLAVirtualMachineTerminationReason Reason)
+{
+    switch (Reason)
+    {
+    case WSLAVirtualMachineTerminationReasonShutdown:
+        return WSLC_SESSION_TERMINATION_REASON_SHUTDOWN;
+    case WSLAVirtualMachineTerminationReasonCrashed:
+        return WSLC_SESSION_TERMINATION_REASON_CRASHED;
+    default:
+        return WSLC_SESSION_TERMINATION_REASON_UNKNOWN;
+    }
+}
+} // namespace
+
+TerminationCallback::TerminationCallback(WslcSessionTerminationCallback callback, PVOID context) :
+    m_callback(callback), m_context(context)
+{
+}
+
+// TODO: Details from the runtime are dropped; should the SDK callback function be updated to include the reasons string?
+HRESULT STDMETHODCALLTYPE TerminationCallback::OnTermination(WSLAVirtualMachineTerminationReason Reason, LPCWSTR)
+{
+    if (m_callback)
+    {
+        m_callback(ConvertReason(Reason), m_context);
+    }
+
+    return S_OK;
+}
+
+winrt::com_ptr<TerminationCallback> TerminationCallback::CreateIf(const WSLC_SESSION_OPTIONS_INTERNAL* options)
+{
+    if (options->terminationCallback)
+    {
+        return winrt::make_self<TerminationCallback>(options->terminationCallback, options->terminationCallbackContext);
+    }
+    else
+    {
+        return nullptr;
+    }
+}

src/windows/WslcSDK/TerminationCallback.h

@@ -0,0 +1,32 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    TerminationCallback.h
+
+Abstract:
+
+    Header for a type that implements ITerminationCallback.
+
+--*/
+#pragma once
+#include "wslaservice.h"
+#include "wslcsdkprivate.h"
+#include <winrt/base.h>
+
+struct TerminationCallback : public winrt::implements<TerminationCallback, ITerminationCallback>
+{
+    TerminationCallback(WslcSessionTerminationCallback callback, PVOID context);
+
+    // ITerminationCallback
+    HRESULT STDMETHODCALLTYPE OnTermination(WSLAVirtualMachineTerminationReason Reason, LPCWSTR Details) override;
+
+    // Creates a TerminationCallback if the options provides a callback.
+    static winrt::com_ptr<TerminationCallback> CreateIf(const WSLC_SESSION_OPTIONS_INTERNAL* options);
+
+private:
+    WslcSessionTerminationCallback m_callback;
+    PVOID m_context;
+};

src/windows/WslcSDK/WslcsdkPrivate.cpp

@@ -0,0 +1,46 @@
+/*++
+
+Copyright (c) Microsoft. All rights reserved.
+
+Module Name:
+
+    WslcSDKPrivate.cpp
+
+Abstract:
+
+    This file contains the private WSL Container SDK implementations.
+
+--*/
+#include "precomp.h"
+
+#include "wslcsdkprivate.h"
+
+WSLC_SESSION_OPTIONS_INTERNAL* GetInternalType(WslcSessionSettings* settings)
+{
+    return reinterpret_cast<WSLC_SESSION_OPTIONS_INTERNAL*>(settings);
+}
+
+WSLC_CONTAINER_PROCESS_OPTIONS_INTERNAL* GetInternalType(WslcProcessSettings* settings)
+{
+    return reinterpret_cast<WSLC_CONTAINER_PROCESS_OPTIONS_INTERNAL*>(settings);
+}
+
+WSLC_CONTAINER_OPTIONS_INTERNAL* GetInternalType(WslcContainerSettings* settings)
+{
+    return reinterpret_cast<WSLC_CONTAINER_OPTIONS_INTERNAL*>(settings);
+}
+
+WslcSessionImpl* GetInternalType(WslcSession handle)
+{
+    return reinterpret_cast<WslcSessionImpl*>(handle);
+}
+
+WslcContainerImpl* GetInternalType(WslcContainer handle)
+{
+    return reinterpret_cast<WslcContainerImpl*>(handle);
+}
+
+WslcProcessImpl* GetInternalType(WslcProcess handle)
+{
+    return reinterpret_cast<WslcProcessImpl*>(handle);
+}

src/windows/WslcSDK/WslcsdkPrivate.h

@@ -27,7 +27,7 @@ typedef struct WSLC_SESSION_OPTIONS_INTERNAL
     PCWSTR storagePath;
 
     uint32_t cpuCount;
-    uint64_t memoryMb;
+    uint32_t memoryMb;
     uint32_t timeoutMS;
 
     WslcVhdRequirements vhdRequirements;
@@ -42,13 +42,15 @@ static_assert(
     __alignof(WSLC_SESSION_OPTIONS_INTERNAL) == WSLC_SESSION_OPTIONS_ALIGNMENT,
     "WSLC_SESSION_OPTIONS_INTERNAL alignment mismatch");
 
+WSLC_SESSION_OPTIONS_INTERNAL* GetInternalType(WslcSessionSettings* settings);
+
 // PROCESS DEFINITIONS
 typedef struct WSLC_CONTAINER_PROCESS_OPTIONS_INTERNAL
 {
     PCSTR executable; // path to executable inside container
-    PCSTR* commandLine;
+    PCSTR const* commandLine;
     uint32_t commandLineCount;
-    PCSTR* environment;
+    PCSTR const* environment;
     uint32_t environmentCount;
     PCSTR currentDirectory;
 } WSLC_CONTAINER_PROCESS_OPTIONS_INTERNAL;
@@ -60,6 +62,8 @@ static_assert(
     __alignof(WSLC_CONTAINER_PROCESS_OPTIONS_INTERNAL) == WSLC_CONTAINER_PROCESS_OPTIONS_ALIGNMENT,
     "WSLC_CONTAINER_PROCESS_OPTIONS_INTERNAL must be 8-byte aligned");
 
+WSLC_CONTAINER_PROCESS_OPTIONS_INTERNAL* GetInternalType(WslcProcessSettings* settings);
+
 // CONTAINER DEFINITIONS
 typedef struct WSLC_CONTAINER_OPTIONS_INTERNAL
 {
@@ -76,24 +80,50 @@ typedef struct WSLC_CONTAINER_OPTIONS_INTERNAL
     WslcContainerFlags containerFlags;
 
 } WSLC_CONTAINER_OPTIONS_INTERNAL;
+
 static_assert(
     sizeof(WSLC_CONTAINER_OPTIONS_INTERNAL) == WSLC_CONTAINER_OPTIONS_SIZE, "WSLC_CONTAINER_OPTIONS_INTERNAL must be 80 bytes");
 static_assert(
     __alignof(WSLC_CONTAINER_OPTIONS_INTERNAL) == WSLC_CONTAINER_OPTIONS_ALIGNMENT,
     "WSLC_CONTAINER_OPTIONS_INTERNAL must be 8-byte aligned");
 
+WSLC_CONTAINER_OPTIONS_INTERNAL* GetInternalType(WslcContainerSettings* settings);
+
 // Use to allocate the actual objects on the heap to keep it alive.
 struct WslcSessionImpl
 {
-    wil::com_ptr<IWSLASessionManager> sessionManager;
+    wil::com_ptr<IWSLASession> session;
+    wil::com_ptr<ITerminationCallback> terminationCallback;
 };
 
+WslcSessionImpl* GetInternalType(WslcSession handle);
+
 struct WslcContainerImpl
 {
     wil::com_ptr<IWSLAContainer> container;
 };
 
+WslcContainerImpl* GetInternalType(WslcContainer handle);
+
 struct WslcProcessImpl
 {
     wil::com_ptr<IWSLAProcess> process;
 };
+
+WslcProcessImpl* GetInternalType(WslcProcess handle);
+
+// Returns an error on null input then converts to a local named `internalType`.
+#define WSLC_GET_INTERNAL_TYPE_NAMED(_input_, _name_) \
+    RETURN_HR_IF_NULL(E_POINTER, _input_); \
+    auto _name_ = GetInternalType(_input_)
+
+#define WSLC_GET_INTERNAL_TYPE(_input_) WSLC_GET_INTERNAL_TYPE_NAMED(_input_, internalType)
+
+// Returns an error on null input then converts to a unique_ptr local named `internalType`.
+// Use for Release functions to clean up the implementation object on return.
+#define WSLC_GET_INTERNAL_TYPE_FOR_RELEASE(_input_) \
+    RETURN_HR_IF_NULL(E_POINTER, _input_); \
+    std::unique_ptr<std::remove_pointer_t<decltype(GetInternalType(_input_))>> internalType \
+    { \
+        GetInternalType(_input_) \
+    }\