reactor-effect-native 0.0.0-reserved.0 → 0.2.0

package/rust/build.rs

@@ -0,0 +1,159 @@
+use std::env;
+use std::fs;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+
+fn source_files(root: &Path, directory: &Path, files: &mut Vec<String>) {
+    for entry in fs::read_dir(directory).expect("native source directory must exist") {
+        let path = entry.expect("read native source entry").path();
+        if path.is_dir() {
+            source_files(root, &path, files);
+        } else if path.is_file() {
+            files.push(
+                path.strip_prefix(root)
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .replace('\\', "/"),
+            );
+        }
+    }
+}
+
+fn quote(value: &str) -> String {
+    let mut out = String::from("\"");
+    for ch in value.chars() {
+        match ch {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            ch if ch.is_control() => out.push_str(&format!("\\u{:04x}", ch as u32)),
+            ch => out.push(ch),
+        }
+    }
+    out.push('"');
+    out
+}
+
+fn version(program: &str) -> String {
+    let output = Command::new(program)
+        .arg("--version")
+        .output()
+        .unwrap_or_else(|_| panic!("could not inspect native build tool {program}"));
+    assert!(
+        output.status.success(),
+        "native build tool {program} failed"
+    );
+    String::from_utf8(output.stdout)
+        .expect("build tool version must be UTF-8")
+        .lines()
+        .next()
+        .unwrap_or("")
+        .to_owned()
+}
+
+fn build_identity() {
+    let root = PathBuf::from(env::var_os("CARGO_MANIFEST_DIR").unwrap());
+    let mut files = [
+        "Cargo.toml",
+        "Cargo.lock",
+        "build.rs",
+        ".cargo/config.toml",
+        "include/reactor_effect_native.h",
+    ]
+    .map(str::to_owned)
+    .to_vec();
+    source_files(&root, &root.join("src"), &mut files);
+    files.sort();
+    let mut input = Vec::new();
+    for file in files {
+        println!("cargo:rerun-if-changed={file}");
+        input.extend_from_slice(file.as_bytes());
+        input.push(0);
+        input.extend_from_slice(&fs::read(root.join(file)).expect("read native build input"));
+        input.push(0);
+    }
+    let mut command = if cfg!(target_os = "macos") {
+        let mut command = Command::new("shasum");
+        command.args(["-a", "256"]);
+        command
+    } else {
+        Command::new("sha256sum")
+    };
+    let mut child = command
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .spawn()
+        .expect("a SHA-256 tool is required to identify native build inputs");
+    child
+        .stdin
+        .take()
+        .unwrap()
+        .write_all(&input)
+        .expect("hash native build inputs");
+    let output = child.wait_with_output().expect("join native source hash");
+    assert!(output.status.success(), "native source hash failed");
+    let text = String::from_utf8(output.stdout).unwrap();
+    let digest = text.split_whitespace().next().unwrap();
+    assert!(digest.len() == 64 && digest.chars().all(|ch| ch.is_ascii_hexdigit()));
+
+    let cc = env::var("CC").unwrap_or_else(|_| "clang".into());
+    let cxx = env::var("CXX").unwrap_or_else(|_| "clang++".into());
+    let mut fields = vec![
+        "\"schemaVersion\":1".to_owned(),
+        "\"abiVersion\":2".to_owned(),
+        format!("\"sourceSha256\":{}", quote(digest)),
+        format!("\"target\":{}", quote(&env::var("TARGET").unwrap())),
+        format!("\"profile\":{}", quote(&env::var("PROFILE").unwrap())),
+        format!("\"rustc\":{}", quote(&version(&env::var("RUSTC").unwrap()))),
+        format!("\"cc\":{}", quote(&version(&cc))),
+        format!("\"cxx\":{}", quote(&version(&cxx))),
+    ];
+    for key in [
+        "CC",
+        "CXX",
+        "CARGO_ENCODED_RUSTFLAGS",
+        "CFLAGS",
+        "CXXFLAGS",
+        "MACOSX_DEPLOYMENT_TARGET",
+    ] {
+        println!("cargo:rerun-if-env-changed={key}");
+        if let Ok(value) = env::var(key) {
+            fields.push(format!("{}:{}", quote(key), quote(&value)));
+        }
+    }
+    println!(
+        "cargo:rustc-env=REACTOR_EFFECT_BUILD_IDENTITY={{{}}}",
+        fields.join(",")
+    );
+}
+
+fn main() {
+    build_identity();
+    if env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("macos") {
+        return;
+    }
+
+    // The pinned Reactor libwebrtc archive contains ScreenCaptureKit objects
+    // produced by Clang. They reference compiler-rt's deployment-version helper,
+    // which rustc's macOS link line does not add on its own.
+    let cc = env::var("CC").unwrap_or_else(|_| "clang".to_owned());
+    let output = Command::new(cc)
+        .arg("-print-resource-dir")
+        .output()
+        .expect("clang is required to link the Reactor libwebrtc archive on macOS");
+    assert!(output.status.success(), "clang -print-resource-dir failed");
+    let resource = String::from_utf8(output.stdout).expect("clang resource path is not UTF-8");
+    let directory = PathBuf::from(resource.trim()).join("lib/darwin");
+    let runtime = directory.join("libclang_rt.osx.a");
+    assert!(
+        runtime.is_file(),
+        "missing macOS compiler-rt archive at {}",
+        runtime.display()
+    );
+    println!("cargo:rustc-link-search=native={}", directory.display());
+    println!("cargo:rustc-link-lib=static=clang_rt.osx");
+}

package/rust/include/reactor_effect_native.h

@@ -0,0 +1,118 @@
+#ifndef REACTOR_EFFECT_NATIVE_H
+#define REACTOR_EFFECT_NATIVE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ReactorEffectPeer ReactorEffectPeer;
+
+enum ReactorEffectStatus {
+  REACTOR_EFFECT_OK = 0,
+  REACTOR_EFFECT_AGAIN = 1,
+  REACTOR_EFFECT_BUFFER_TOO_SMALL = 2,
+  REACTOR_EFFECT_CLOSED = 3,
+  REACTOR_EFFECT_INVALID = -1,
+  REACTOR_EFFECT_NATIVE = -2,
+  REACTOR_EFFECT_OVERFLOW = -3
+};
+
+enum ReactorEffectCall {
+  REACTOR_EFFECT_PREPARE = 1,
+  REACTOR_EFFECT_ANSWER = 2,
+  REACTOR_EFFECT_DIRECTION = 3,
+  REACTOR_EFFECT_MAX_BITRATE = 4,
+  REACTOR_EFFECT_STATS = 5,
+  REACTOR_EFFECT_MEDIA_SNAPSHOT = 6
+};
+
+enum ReactorEffectChannel {
+  REACTOR_EFFECT_CONTROL = 0,
+  REACTOR_EFFECT_DATA = 1
+};
+
+uint32_t reactor_effect_abi_version(void);
+/* Static source/build identity of this loaded image; never free the pointer. */
+const char *reactor_effect_build_identity(void);
+
+ReactorEffectPeer *reactor_effect_peer_create(void);
+
+/*
+ * request is UTF-8. The response is UTF-8 JSON on both success and failure.
+ * Calls are serialized by the native peer owner and may block on libwebrtc.
+ */
+int reactor_effect_peer_call(
+    ReactorEffectPeer *peer,
+    uint32_t operation,
+    const uint8_t *request,
+    size_t request_len,
+    uint8_t *response,
+    size_t response_cap,
+    size_t *response_len);
+
+int reactor_effect_peer_send(
+    ReactorEffectPeer *peer,
+    uint32_t channel,
+    const uint8_t *data,
+    size_t data_len,
+    uint8_t *error,
+    size_t error_cap,
+    size_t *error_len);
+
+/*
+ * Poll packets are [u32 little-endian header length][UTF-8 JSON header][payload].
+ * A zero-capacity call returns BUFFER_TOO_SMALL with the required packet size and
+ * retains that exact packet until copy or close. Retained packets count toward
+ * item and byte bounds and cannot be evicted by producer pressure. Each queue
+ * permits one reader across probe/copy; the host must serialize that pair.
+ * timeout_ms == 0 is a nonblocking poll.
+ */
+int reactor_effect_peer_poll_event(
+    ReactorEffectPeer *peer,
+    uint32_t timeout_ms,
+    uint8_t *out,
+    size_t out_cap,
+    size_t *out_len);
+
+int reactor_effect_peer_poll_video(
+    ReactorEffectPeer *peer,
+    uint32_t timeout_ms,
+    uint8_t *out,
+    size_t out_cap,
+    size_t *out_len);
+
+int reactor_effect_peer_poll_audio(
+    ReactorEffectPeer *peer,
+    uint32_t timeout_ms,
+    uint8_t *out,
+    size_t out_cap,
+    size_t *out_len);
+
+/* Immediate admission fence. No callback/event can be admitted after return. */
+void reactor_effect_peer_close(ReactorEffectPeer *peer);
+
+/*
+ * Drops channels/tracks/PeerConnection on the owner thread, waits for all native
+ * callback guards to leave, then joins that owner. Safe to call more than once.
+ */
+int reactor_effect_peer_shutdown(
+    ReactorEffectPeer *peer,
+    uint8_t *error,
+    size_t error_cap,
+    size_t *error_len);
+
+/*
+ * Performs shutdown if needed, then frees the opaque handle. The host must
+ * first join EVERY foreign call using this handle, including work still queued
+ * in its FFI executor. Native owner shutdown alone does not establish that.
+ */
+void reactor_effect_peer_destroy(ReactorEffectPeer *peer);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif