Add curl_multi_init

Signed-off-by: Petr Shumilov <p.shumilov@vkteam.ru>

Author: PetrShumilov

builtin-functions/kphp-light/stdlib/curl-functions.txt

@@ -268,10 +268,11 @@ function curl_errno ($curl_handle ::: int) ::: int;
 /** @kphp-extern-func-info interruptible */
 function curl_getinfo ($curl_handle ::: int, $option ::: int = 0) ::: mixed;
 
+/** @kphp-extern-func-info interruptible */
+function curl_multi_init () ::: int;
+
 // ===== UNSUPPORTED =====
 
-/** @kphp-extern-func-info stub generation-required */
-function curl_multi_init () ::: int;
 /** @kphp-extern-func-info stub generation-required */
 function curl_multi_add_handle ($multi_handle ::: int, $curl_handle ::: int) ::: int|false;
 /** @kphp-extern-func-info stub generation-required */

runtime-light/stdlib/curl/curl-multi-functions.h

@@ -9,7 +9,20 @@
 #include <optional>
 
 #include "runtime-common/core/runtime-core.h"
+#include "runtime-light/stdlib/curl/defs.h"
+#include "runtime-light/stdlib/curl/details/diagnostics.h"
 #include "runtime-light/stdlib/diagnostics/logs.h"
+#include "runtime-light/stdlib/fork/fork-functions.h"
+#include "runtime-light/stdlib/web-transfer-lib/composite-transfer.h"
+
+inline auto f$curl_multi_init() noexcept -> kphp::coro::task<kphp::web::curl::multi_type> {
+  auto open_res{co_await kphp::forks::id_managed(kphp::web::composite_transfer_open(kphp::web::transfer_backend::CURL))};
+  if (!open_res.has_value()) [[unlikely]] {
+    kphp::web::curl::print_error("Could not initialize a new curl multi handle", std::move(open_res.error()));
+    co_return 0;
+  }
+  co_return (*open_res).descriptor;
+}
 
 inline Optional<array<int64_t>> f$curl_multi_info_read([[maybe_unused]] int64_t /*unused*/,
                                                        [[maybe_unused]] Optional<std::optional<std::reference_wrapper<int64_t>>> /*unused*/ = {}) {

runtime-light/stdlib/curl/defs.h

@@ -16,6 +16,7 @@ enum class PHPCURL : uint64_t {
 };
 
 using easy_type = simple_transfer::descriptor_type;
+using multi_type = composite_transfer::descriptor_type;
 
 constexpr auto CURL_ERROR_SIZE = 256;
 

runtime-light/stdlib/web-transfer-lib/composite-transfer.h

@@ -0,0 +1,68 @@
+// Compiler for PHP (aka KPHP)
+// Copyright (c) 2025 LLC «V Kontakte»
+// Distributed under the GPL v3 License, see LICENSE.notice.txt
+
+#pragma once
+
+#include <cstddef>
+#include <expected>
+#include <span>
+#include <utility>
+
+#include "runtime-light/coroutine/task.h"
+#include "runtime-light/stdlib/diagnostics/logs.h"
+#include "runtime-light/stdlib/web-transfer-lib/defs.h"
+#include "runtime-light/stdlib/web-transfer-lib/details/web-error.h"
+#include "runtime-light/stdlib/web-transfer-lib/web-state.h"
+#include "runtime-light/tl/tl-core.h"
+#include "runtime-light/tl/tl-functions.h"
+#include "runtime-light/tl/tl-types.h"
+
+namespace kphp::web {
+
+inline auto composite_transfer_open(transfer_backend backend) noexcept -> kphp::coro::task<std::expected<composite_transfer, error>> {
+  auto session{WebInstanceState::get().session_get_or_init()};
+  if (!session.has_value()) [[unlikely]] {
+    kphp::log::error("failed to start or get session with Web component");
+  }
+
+  if ((*session).get() == nullptr) [[unlikely]] {
+    kphp::log::error("session with Web components has been closed");
+  }
+
+  tl::CompositeWebTransferOpen web_transfer_open{.web_backend = {static_cast<tl::CompositeWebTransferOpen::web_backend_type::underlying_type>(backend)}};
+  tl::storer tls{web_transfer_open.footprint()};
+  web_transfer_open.store(tls);
+
+  kphp::stl::vector<std::byte, kphp::memory::script_allocator> resp_buf{};
+  const auto response_buffer_provider{[&resp_buf](size_t size) noexcept -> std::span<std::byte> {
+    resp_buf.resize(size);
+    return {resp_buf.data(), size};
+  }};
+
+  auto resp{co_await (*session).get()->client.query(tls.view(), std::move(response_buffer_provider))};
+  if (!resp.has_value()) [[unlikely]] {
+    kphp::log::error("failed to send request for Composite descriptor creation");
+  }
+
+  tl::Either<tl::CompositeWebTransferOpenResultOk, tl::WebError> transfer_open_resp{};
+  tl::fetcher tlf{*resp};
+  if (!transfer_open_resp.fetch(tlf)) [[unlikely]] {
+    kphp::log::error("failed to parse response for Composite descriptor creation");
+  }
+
+  const auto result{transfer_open_resp.value};
+  if (std::holds_alternative<tl::WebError>(result)) {
+    co_return std::unexpected{details::process_error(std::get<tl::WebError>(result))};
+  }
+
+  const auto descriptor{std::get<0>(result).descriptor.value};
+
+  auto& composite2config{WebInstanceState::get().composite_transfer2config};
+  kphp::log::assertion(composite2config.contains(descriptor) == false); // NOLINT
+  composite2config.emplace(descriptor, composite_transfer_config{});
+
+  co_return std::expected<composite_transfer, error>{descriptor};
+}
+
+} // namespace kphp::web

runtime-light/stdlib/web-transfer-lib/defs.h

@@ -99,6 +99,10 @@ struct simple_transfer_config {
   properties_type properties{};
 };
 
+struct composite_transfer_config {
+  properties_type properties{};
+};
+
 struct response {
   string headers;
   string body;

runtime-light/stdlib/web-transfer-lib/web-state.h

@@ -26,7 +26,7 @@ struct WebInstanceState final : private vk::not_copyable {
   bool session_is_finished{false};
   kphp::stl::unordered_map<kphp::web::simple_transfer::descriptor_type, kphp::web::simple_transfer_config, kphp::memory::script_allocator>
       simple_transfer2config{};
-  kphp::stl::unordered_map<kphp::web::composite_transfer::descriptor_type, kphp::web::simple_transfer_config, kphp::memory::script_allocator>
+  kphp::stl::unordered_map<kphp::web::composite_transfer::descriptor_type, kphp::web::composite_transfer_config, kphp::memory::script_allocator>
       composite_transfer2config{};
 
   inline auto session_get_or_init() noexcept -> std::expected<shared_session_type, int32_t>;

runtime-light/tl/tl-functions.h

@@ -396,6 +396,28 @@ struct CacheFetch final {
 
 // ===== WEB TRANSFER LIB =====
 
+class WebTransferGetProperties final {
+  static constexpr uint32_t WEB_TRANSFER_GET_PROPERTIES_MAGIC = 0x72B7'16DD;
+
+public:
+  tl::u8 is_simple;
+  tl::u64 descriptor;
+  tl::Maybe<tl::u64> property_id;
+
+  void store(tl::storer& tls) const noexcept {
+    tl::magic{.value = WEB_TRANSFER_GET_PROPERTIES_MAGIC}.store(tls);
+    is_simple.store(tls);
+    descriptor.store(tls);
+    property_id.store(tls);
+  }
+
+  constexpr size_t footprint() const noexcept {
+    return tl::magic{.value = WEB_TRANSFER_GET_PROPERTIES_MAGIC}.footprint() + is_simple.footprint() + descriptor.footprint() + property_id.footprint();
+  }
+};
+
+// ===== Simple =====
+
 class SimpleWebTransferOpen final {
   static constexpr uint32_t SIMPLE_WEB_TRANSFER_OPEN_MAGIC = 0x24F8'98AA;
 
@@ -463,23 +485,22 @@ class SimpleWebTransferReset final {
   }
 };
 
-class WebTransferGetProperties final {
-  static constexpr uint32_t WEB_TRANSFER_GET_PROPERTIES_MAGIC = 0x72B7'16DD;
+// ===== Composite =====
+
+class CompositeWebTransferOpen final {
+  static constexpr uint32_t COMPOSITE_WEB_TRANSFER_OPEN_MAGIC = 0x428F'89FF;
 
 public:
-  tl::u8 is_simple;
-  tl::u64 descriptor;
-  tl::Maybe<tl::u64> property_id;
+  using web_backend_type = tl::u8;
+  web_backend_type web_backend;
 
   void store(tl::storer& tls) const noexcept {
-    tl::magic{.value = WEB_TRANSFER_GET_PROPERTIES_MAGIC}.store(tls);
-    is_simple.store(tls);
-    descriptor.store(tls);
-    property_id.store(tls);
+    tl::magic{.value = COMPOSITE_WEB_TRANSFER_OPEN_MAGIC}.store(tls);
+    web_backend.store(tls);
   }
 
   constexpr size_t footprint() const noexcept {
-    return tl::magic{.value = WEB_TRANSFER_GET_PROPERTIES_MAGIC}.footprint() + is_simple.footprint() + descriptor.footprint() + property_id.footprint();
+    return tl::magic{.value = COMPOSITE_WEB_TRANSFER_OPEN_MAGIC}.footprint() + web_backend.footprint();
   }
 };
 

runtime-light/tl/tl-types.h

@@ -1236,6 +1236,25 @@ struct simpleWebTransferConfig final {
   }
 };
 
+class WebTransferGetPropertiesResultOk final {
+  static constexpr uint32_t WEB_TRANSFER_GET_PROPERTIES_RESULT_OK_MAGIC = 0x48A7'16CC;
+
+public:
+  tl::vector<tl::webProperty> properties;
+
+  bool fetch(tl::fetcher& tlf) noexcept {
+    tl::magic magic{};
+    bool ok{magic.fetch(tlf) && magic.expect(WEB_TRANSFER_GET_PROPERTIES_RESULT_OK_MAGIC) && properties.fetch(tlf)};
+    return ok;
+  }
+
+  constexpr size_t footprint() const noexcept {
+    return tl::magic{.value = WEB_TRANSFER_GET_PROPERTIES_RESULT_OK_MAGIC}.footprint();
+  }
+};
+
+// ===== Simple =====
+
 class SimpleWebTransferOpenResultOk final {
   static constexpr uint32_t SIMPLE_WEB_TRANSFER_OPEN_RESULT_OK_MAGIC = 0x24A8'98FF;
 
@@ -1298,20 +1317,22 @@ class SimpleWebTransferResetResultOk final {
   }
 };
 
-class WebTransferGetPropertiesResultOk final {
-  static constexpr uint32_t WEB_TRANSFER_GET_PROPERTIES_RESULT_OK_MAGIC = 0x48A7'16CC;
+// ===== Composite =====
+
+class CompositeWebTransferOpenResultOk final {
+  static constexpr uint32_t COMPOSITE_WEB_TRANSFER_OPEN_RESULT_OK_MAGIC = 0x428A'89DD;
 
 public:
-  tl::vector<tl::webProperty> properties;
+  tl::u64 descriptor;
 
   bool fetch(tl::fetcher& tlf) noexcept {
     tl::magic magic{};
-    bool ok{magic.fetch(tlf) && magic.expect(WEB_TRANSFER_GET_PROPERTIES_RESULT_OK_MAGIC) && properties.fetch(tlf)};
+    bool ok{magic.fetch(tlf) && magic.expect(COMPOSITE_WEB_TRANSFER_OPEN_RESULT_OK_MAGIC) && descriptor.fetch(tlf)};
     return ok;
   }
 
   constexpr size_t footprint() const noexcept {
-    return tl::magic{.value = WEB_TRANSFER_GET_PROPERTIES_RESULT_OK_MAGIC}.footprint();
+    return tl::magic{.value = COMPOSITE_WEB_TRANSFER_OPEN_RESULT_OK_MAGIC}.footprint() + descriptor.footprint();
   }
 };