Merge pull request #69 from unum-cloud/main-dev

Windows support

Author: ashvardanian

.clang-format

@@ -2,6 +2,7 @@ Language: Cpp
 BasedOnStyle:  LLVM
 IndentWidth: 4
 TabWidth: 4
+StatementMacros: ['PyObject_HEAD']
 NamespaceIndentation: None
 ColumnLimit: 120
 ReflowComments: true

.github/workflows/release.yml

@@ -7,6 +7,7 @@ on:
 env:
   BUILD_TYPE: Release
   GH_TOKEN: ${{ secrets.SEMANTIC_RELEASE_TOKEN }}
+  PYTHONUTF8: 1
 
 # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
 permissions:
@@ -33,24 +34,30 @@ jobs:
     needs: versioning
     strategy:
       matrix:
-        os: [ubuntu-20.04, macOS-11]
+        os: [ubuntu-20.04, macOS-11, windows-2022]
 
     steps:
       - uses: actions/checkout@v3
         with:
           ref: 'main'      
       - uses: actions/setup-python@v3
-      - uses: crazy-max/ghaction-setup-docker@v1.0.0
+      
+      - name: Setup Docker
+        if: matrix.os != 'windows-2022'
+        uses: crazy-max/ghaction-setup-docker@v1.0.0
         with:
           version: 23.0.1
-      - uses: docker/setup-qemu-action@v2.1.0
+
+      - name: Setup QEMU
+        if: matrix.os != 'windows-2022'
+        uses: docker/setup-qemu-action@v2.1.0
 
       - name: Install CIBuildWheel
         run: python -m pip install cibuildwheel
 
       - name: Build wheels
         run: python -m cibuildwheel
-        
+
       - uses: actions/upload-artifact@v3
         with:
           path: ./wheelhouse/*.whl
@@ -82,11 +89,12 @@ jobs:
 
   deploy_docs:
     name: Deploy Docs
-    environment: 
+    environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-22.04
-    needs: publish_python
+    if: ${{ always() }}
+    needs: publish_wheels
     steps:
       - name: Checkout
         uses: actions/checkout@v3

CITATION.cff

@@ -0,0 +1,11 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+- family-names: "Vardanian"
+  given-names: "Ashot"
+  orcid: "https://orcid.org/0000-0002-4882-1815"
+title: "UCall by Unum Cloud"
+version: 0.5.0
+doi: 10.5281/zenodo.7951497
+date-released: 2023-01-03
+url: "https://github.com/unum-cloud/ucall"

CMakeLists.txt

@@ -19,15 +19,22 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/build/lib" CACHE PATH "P
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/build/lib" CACHE PATH "Path to shared libs")
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/build/bin")
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /DEBUG")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /O2 /DEBUG")
+else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+endif()
+
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fmax-errors=1")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 endif()
 
 # Check if we are running on Linux

examples/login/ucall_server.cpp

@@ -4,7 +4,6 @@
 #include <charconv> // `std::to_chars`
 #include <cstdio>   // `std::fprintf`
 #include <thread>
-#include <unistd.h> // `STDOUT_FILENO`
 #include <vector>
 
 #include <cxxopts.hpp>
@@ -41,13 +40,13 @@ int main(int argc, char** argv) {
 
     ucall_server_t server{};
     ucall_config_t config{};
-    config.interface = result["nic"].as<std::string>().c_str();
+    config.hostname = result["nic"].as<std::string>().c_str();
     config.port = result["port"].as<int>();
     config.max_threads = result["threads"].as<int>();
     config.max_concurrent_connections = 1024;
     config.queue_depth = 4096 * config.max_threads;
     config.max_lifetime_exchanges = UINT32_MAX;
-    config.logs_file_descriptor = result["silent"].as<bool>() ? -1 : STDOUT_FILENO;
+    config.logs_file_descriptor = result["silent"].as<bool>() ? -1 : fileno(stdin);
     config.logs_format = "human";
     // config.use_ssl = true;
     // config.ssl_private_key_path = "./examples/login/certs/main.key";
@@ -57,11 +56,11 @@ int main(int argc, char** argv) {
 
     ucall_init(&config, &server);
     if (!server) {
-        std::printf("Failed to start server: %s:%i\n", config.interface, config.port);
+        std::printf("Failed to start server: %s:%i\n", config.hostname, config.port);
         return -1;
     }
 
-    std::printf("Initialized server: %s:%i\n", config.interface, config.port);
+    std::printf("Initialized server: %s:%i\n", config.hostname, config.port);
     std::printf("- %zu threads\n", static_cast<std::size_t>(config.max_threads));
     std::printf("- %zu max concurrent connections\n", static_cast<std::size_t>(config.max_concurrent_connections));
     if (result["silent"].as<bool>())

include/ucall/ucall.h

@@ -49,7 +49,7 @@ typedef void (*ucall_callback_t)(ucall_call_t, ucall_callback_tag_t);
  * @brief Configuration parameters for `ucall_init()`.
  */
 typedef struct ucall_config_t {
-    char const* interface;
+    char const* hostname;
     uint16_t port;
     uint16_t queue_depth;
     uint16_t max_callbacks;

pyproject.toml

@@ -30,3 +30,11 @@ repair-wheel-command = "auditwheel repair --lib-sdir . -w {dest_dir} {wheel}"
 [tool.cibuildwheel.macos]
 archs = ["x86_64", "universal2", "arm64"]
 repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
+
+[tool.cibuildwheel.windows]
+before-build = [
+    "rd /s /q {project}\\CMakeCache.txt {project}\\build {project}\\build_debug {project}\\CMakeFiles.txt {project}\\_deps || echo Done",
+    "md build\\ucall"
+]
+archs = ["x86", "AMD64"]
+skip = ["*win32*", "pp*"]

setup.py

@@ -58,6 +58,9 @@ def build_extension(self, ext):
         # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level
         # across all generators.
         build_args = []
+        if sys.platform.startswith('win32'):
+            build_args += ['--config', 'Release']
+
         if 'CMAKE_BUILD_PARALLEL_LEVEL' not in os.environ:
             # self.parallel is a Python 3 only way to set parallel jobs by hand
             # using -j in the build_ext call, not supported by pip or PyPA-build.
@@ -114,7 +117,7 @@ def run(self):
     ],
 
     packages=['ucall'],
-    package_dir={'': 'src/'},
+    package_dir={'': 'src'},
     ext_modules=[
         CMakeExtension('ucall.uring'),
         CMakeExtension('ucall.posix'),

src/engine_posix.cpp

@@ -2,16 +2,38 @@
  * @brief JSON-RPC implementation for TCP/IP stack with POSIX calls.
  * @author Ashot Vardanian
  */
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#define UCALL_IS_WINDOWS
+
+#include <Ws2tcpip.h>
+#include <io.h>
+#include <winsock2.h>
+
+#define SHUT_WR SD_SEND
+#define SHUT_RD SD_RECEIVE
+#define SHUT_RDWR SD_BOTH
+// SO_REUSEPORT is not supported on Windows.
+#define SO_REUSEPORT 0
+
+#pragma comment(lib, "Ws2_32.lib")
+#define UNICODE
+
+#else
 #include <arpa/inet.h>  // `inet_addr`
-#include <errno.h>      // `strerror`
-#include <fcntl.h>      // `fcntl`
 #include <netinet/in.h> // `sockaddr_in`
-#include <stdlib.h>     // `std::aligned_malloc`
+
 #include <sys/ioctl.h>
 #include <sys/socket.h> // `recv`, `setsockopt`
-#include <sys/types.h>
+
 #include <sys/uio.h>
 #include <unistd.h>
+#endif
+
+#include <errno.h>  // `strerror`
+#include <fcntl.h>  // `fcntl`
+#include <stdlib.h> // `std::aligned_malloc`
+#include <sys/types.h>
 
 #include <charconv> // `std::to_chars`
 #include <chrono>   // `std::chrono`
@@ -244,13 +266,13 @@ void forward_packet(engine_t& engine) noexcept {
 
 int ssl_send(void* ctx, const unsigned char* buf, size_t len) {
     mbedtls_net_context* conn = reinterpret_cast<mbedtls_net_context*>(ctx);
-    ssize_t ret = send(conn->fd, buf, len, 0);
+    ssize_t ret = send(conn->fd, reinterpret_cast<char const*>(buf), len, 0);
     return ret;
 }
 
 int ssl_recv(void* ctx, unsigned char* buf, size_t len) {
     mbedtls_net_context* conn = reinterpret_cast<mbedtls_net_context*>(ctx);
-    ssize_t ret = recv(conn->fd, buf, len, 0);
+    ssize_t ret = recv(conn->fd, reinterpret_cast<char*>(buf), len, 0);
     return ret;
 }
 
@@ -329,11 +351,14 @@ void ucall_take_call(ucall_server_t server, uint16_t) {
     if (auto error_ptr = std::get_if<default_error_t>(&json_or_error); error_ptr)
         return ucall_call_reply_error(&engine, error_ptr->code, error_ptr->note.data(), error_ptr->note.size());
     parsed_request_t request = std::get<parsed_request_t>(json_or_error);
-    auto res = std::from_chars(request.content_length.begin(), request.content_length.end(), bytes_expected);
-    bytes_expected += (request.body.begin() - buffer_ptr);
+    auto res = std::from_chars(request.content_length.data(),
+                               request.content_length.data() + request.content_length.size(), bytes_expected);
+    bytes_expected += (request.body.data() - buffer_ptr);
 
     if (res.ec == std::errc::invalid_argument || bytes_expected <= 0)
+#if !defined(UCALL_IS_WINDOWS)
         if (ioctl(engine.connection, FIONREAD, &bytes_expected) == -1 || bytes_expected == 0)
+#endif
             bytes_expected = bytes_received; // TODO what?
 
     // Either process it in the statically allocated memory,
@@ -352,7 +377,11 @@ void ucall_take_call(ucall_server_t server, uint16_t) {
         if (parser.allocate(bytes_expected, bytes_expected / 2) != sj::SUCCESS)
             return ucall_call_reply_error_out_of_memory(&engine);
 
+#if defined(UCALL_IS_WINDOWS)
+        buffer_ptr = (char*)_aligned_malloc(round_up_to<align_k>(bytes_expected + sj::SIMDJSON_PADDING), align_k);
+#else
         buffer_ptr = (char*)std::aligned_alloc(align_k, round_up_to<align_k>(bytes_expected + sj::SIMDJSON_PADDING));
+#endif
         if (!buffer_ptr)
             return ucall_call_reply_error_out_of_memory(&engine);
 
@@ -364,7 +393,11 @@ void ucall_take_call(ucall_server_t server, uint16_t) {
         engine.stats.bytes_received += bytes_received;
         engine.stats.packets_received++;
         forward_packet(engine);
+#if defined(UCALL_IS_WINDOWS)
+        _aligned_free(buffer_ptr);
+#else
         std::free(buffer_ptr);
+#endif
         buffer_ptr = nullptr;
     }
 
@@ -396,8 +429,8 @@ void ucall_init(ucall_config_t* config_inout, ucall_server_t* server_out) {
         config.queue_depth = 128u;
     if (!config.max_callbacks)
         config.max_callbacks = 128u;
-    if (!config.interface)
-        config.interface = "0.0.0.0";
+    if (!config.hostname)
+        config.hostname = "0.0.0.0";
     if (config.use_ssl &&
         !(config.ssl_private_key_path || config.ssl_certificates_paths || config.ssl_certificates_count))
         return;
@@ -420,7 +453,7 @@ void ucall_init(ucall_config_t* config_inout, ucall_server_t* server_out) {
     // By default, let's open TCP port for IPv4.
     struct sockaddr_in address;
     address.sin_family = AF_INET;
-    address.sin_addr.s_addr = inet_addr(config.interface);
+    address.sin_addr.s_addr = inet_addr(config.hostname);
     address.sin_port = htons(config.port);
 
     // Try allocating all the necessary memory.
@@ -435,8 +468,8 @@ void ucall_init(ucall_config_t* config_inout, ucall_server_t* server_out) {
     if (socket_descriptor < 0)
         goto cleanup;
     // Optionally configure the socket, but don't always expect it to succeed.
-    if (setsockopt(socket_descriptor, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &socket_options,
-                   sizeof(socket_options)) == -1)
+    if (setsockopt(socket_descriptor, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT,
+                   reinterpret_cast<char const*>(&socket_options), sizeof(socket_options)) == -1)
         errno;
     if (bind(socket_descriptor, (struct sockaddr*)&address, sizeof(address)) < 0)
         goto cleanup;

src/engine_uring.cpp

@@ -307,8 +307,8 @@ void ucall_init(ucall_config_t* config_inout, ucall_server_t* server_out) {
         config.max_lifetime_micro_seconds = 100'000u;
     if (!config.max_lifetime_exchanges)
         config.max_lifetime_exchanges = 100u;
-    if (!config.interface)
-        config.interface = "0.0.0.0";
+    if (!config.hostname)
+        config.hostname = "0.0.0.0";
 
     // Allocate
     int socket_options{1};
@@ -334,7 +334,7 @@ void ucall_init(ucall_config_t* config_inout, ucall_server_t* server_out) {
     // By default, let's open TCP port for IPv4.
     struct sockaddr_in address {};
     address.sin_family = AF_INET;
-    address.sin_addr.s_addr = inet_addr(config.interface);
+    address.sin_addr.s_addr = inet_addr(config.hostname);
     address.sin_port = htons(config.port);
 
     // Initialize `io_uring` first, it is the most likely to fail.