@samitouri / QOSAMI-WSL-1
Code Commits Issues Pulls Sessions CI/CD
master
master
md 148 lines 4.63 KB
Rendered Raw
1 # End-to-End Example
2
3 The example below shows one full lifecycle:
4
5 1. Initialize session settings
6 2. Create a session
7 3. Pull an image
8 4. Configure a container
9 5. Create and start the container
10 6. Inspect it
11 7. Create a second process
12 8. Stop and delete the container
13 9. Release handles and terminate the session
14
15 ```c
16
17 #include <winsock2.h>
18 #include <windows.h>
19 #include <stdio.h>
20 #include <objbase.h>
21 #include <filesystem>
22 #include "wslcsdk.h"
23
24 #pragma comment(lib, "ole32.lib")
25 #pragma comment(lib, "wslcsdk.lib")
26
27 int main()
28 {
29 // Initialize COM
30 CoInitializeEx(nullptr, COINIT_MULTITHREADED);
31
32 HRESULT hr;
33 PWSTR error = nullptr;
34
35 // 0. Check prerequisites
36 WslcComponentFlags missing = WSLC_COMPONENT_FLAG_NONE;
37 hr = WslcGetMissingComponents(&missing);
38 if (FAILED(hr) || missing != WSLC_COMPONENT_FLAG_NONE) {
39 printf("WSL components are missing. Run: wsl --install\n");
40 CoUninitialize();
41 return 1;
42 }
43
44 WslcVersion ver = {};
45 WslcGetVersion(&ver);
46 printf("WSL version: %u.%u.%u\n", ver.major, ver.minor, ver.revision);
47
48 // 1. Initialize and create a session
49 std::filesystem::path storagePath = std::filesystem::current_path();
50
51 WslcSessionSettings sessionSettings;
52 hr = WslcInitSessionSettings(L"MyApp", storagePath.c_str(), &sessionSettings);
53 if (FAILED(hr)) return 1;
54
55 // Optionally customize resources
56 WslcSetSessionSettingsCpuCount(&sessionSettings, 4);
57 WslcSetSessionSettingsMemory(&sessionSettings, 4096);
58
59 WslcSession session = nullptr;
60 hr = WslcCreateSession(&sessionSettings, &session, &error);
61 if (FAILED(hr)) {
62 wprintf(L"Session creation failed: %s\n", error ? error : L"unknown");
63 CoTaskMemFree(error);
64 CoUninitialize();
65 return 1;
66 }
67
68 // 2. Pull an image
69 WslcPullImageOptions pullOpts = {};
70 pullOpts.uri = "docker.io/library/alpine:latest";
71 hr = WslcPullSessionImage(session, &pullOpts, &error);
72 if (FAILED(hr)) {
73 wprintf(L"Pull failed: %s\n", error ? error : L"unknown");
74 CoTaskMemFree(error);
75 WslcTerminateSession(session);
76 WslcReleaseSession(session);
77 CoUninitialize();
78 return 1;
79 }
80
81 // 3. Configure an init process
82 WslcProcessSettings initProcSettings;
83 WslcInitProcessSettings(&initProcSettings);
84
85 PCSTR argv[] = { "/bin/echo", "Hello from WSL Container!" };
86 WslcSetProcessSettingsCmdLine(&initProcSettings, argv, 2);
87
88 // 4. Configure and create a container
89 WslcContainerSettings containerSettings;
90 WslcInitContainerSettings("alpine:latest", &containerSettings);
91 WslcSetContainerSettingsName(&containerSettings, "hello-container");
92 WslcSetContainerSettingsInitProcess(&containerSettings, &initProcSettings);
93
94 WslcContainer container = nullptr;
95 hr = WslcCreateContainer(session, &containerSettings, &container, &error);
96 if (FAILED(hr)) {
97 wprintf(L"Container creation failed: %s\n", error ? error : L"unknown");
98 CoTaskMemFree(error);
99 WslcTerminateSession(session);
100 WslcReleaseSession(session);
101 CoUninitialize();
102 return 1;
103 }
104
105 // 5. Start the container
106 hr = WslcStartContainer(container, WSLC_CONTAINER_START_FLAG_NONE, &error);
107 if (FAILED(hr)) {
108 wprintf(L"Start failed: %s\n", error ? error : L"unknown");
109 CoTaskMemFree(error);
110 WslcDeleteContainer(container, WSLC_DELETE_CONTAINER_FLAG_FORCE, nullptr);
111 WslcReleaseContainer(container);
112 WslcTerminateSession(session);
113 WslcReleaseSession(session);
114 CoUninitialize();
115 return 1;
116 }
117
118 // 6. Wait for the init process to exit
119 WslcProcess initProc = nullptr;
120 hr = WslcGetContainerInitProcess(container, &initProc);
121 if (SUCCEEDED(hr)) {
122 HANDLE exitEvent = nullptr;
123 if (SUCCEEDED(WslcGetProcessExitEvent(initProc, &exitEvent))) {
124 WaitForSingleObject(exitEvent, 30000); // 30-second timeout
125 }
126
127 INT32 exitCode = 0;
128 if (SUCCEEDED(WslcGetProcessExitCode(initProc, &exitCode))) {
129 printf("Process exited with code: %d\n", exitCode);
130 }
131 WslcReleaseProcess(initProc);
132 }
133
134 // 7. Clean up
135 WslcContainerState containerState = WSLC_CONTAINER_STATE_INVALID;
136 if (SUCCEEDED(WslcGetContainerState(container, &containerState)) &&
137 containerState == WSLC_CONTAINER_STATE_RUNNING) {
138 WslcStopContainer(container, WSLC_SIGNAL_SIGTERM, 10, nullptr);
139 }
140 WslcDeleteContainer(container, WSLC_DELETE_CONTAINER_FLAG_NONE, nullptr);
141 WslcReleaseContainer(container);
142 WslcTerminateSession(session);
143 WslcReleaseSession(session);
144
145 CoUninitialize();
146 return 0;
147 }
148 ```