Initial public release of Warp.

Repo-Sync-Origin: warpdotdev/warp-internal@12af1d983b
2026-04-28 08:43:33 -05:00
commit 0dbd3d567a
4982 changed files with 1431549 additions and 0 deletions
@@ -0,0 +1,60 @@
+//! This crate provides an ipmlementation of a basic IPC request/response protocol.
+//!
+//! Users may instantiate a server that implements any number of [`Service`]s as well as
+//! corresponding typed "clients" ([`ServiceCaller`]s) which provide a typed interface to call the
+//! services across process boundaries.
+//!
+//! This is intended to initially be used to support communication between the Warp app and
+//! third-party plugins running in a separate "plugin host" process, but is designed generically to
+//! be extended to other use cases (such as the terminal server).  Where possible,
+//! transport-specific details are abstracted out to eventually support the same protocol on top of
+//! the WebWorkers `MessagePort` API in the browser for Warp on Web.
+//!
+//! On native platforms, this is implemented on top of the `interprocess` crate, which uses
+//! Unix Domain Sockets on Unix platforms and named pipes on Windows as the underlying transport.
+//!
+//! WASM (wasm32-unknown-unknown) is currently unsupported.
+//!
+//!
+//! Basic usage is like so:
+//!
+//! ```ignore
+//! // In the server's process...
+//! let background_executor = ctx.background_executor();
+//!
+//! // `MyServiceImpl` implements `ServiceImpl<Service = MyService>`.
+//! let my_service_impl = MyServiceImpl::new();
+//! let (server, connection_address) = ServerBuilder::default()
+//!     .with_service(my_service_impl)
+//!     .build_and_run(background_executor)
+//!     .expect("Failed to instantiate server");
+//!
+//! // In the client process, passing the same connection address returned from the server
+//! // instantiation (possibly as an environment variable set in the client process).
+//! let client = Arc::new(
+//!     Client::connect(connection_address, background_executor)
+//!         .await
+//!         .expect("Failed to connect client"),
+//! );
+//! let my_service_stub = service_caller::<MyService>(client);
+//! let response = my_service_stub.call(MyServiceRequest { .. }).await;
+//! ```
+mod client;
+mod protocol;
+mod server;
+mod service;
+
+// Platform-specific implementations of the underlying transport for both server and client.  For
+// native platforms, this uses the `interprocess` crate. On wasm, we plan to use the WebWorkers
+// MessagePort API, but this is not yet implemented.
+#[cfg_attr(not(target_family = "wasm"), path = "native.rs")]
+#[cfg_attr(target_family = "wasm", path = "wasm.rs")]
+mod platform;
+
+pub use client::{Client, ClientError};
+pub use protocol::ConnectionAddress;
+pub use server::{Server, ServerBuilder};
+pub use service::{service_caller, Service, ServiceCaller, ServiceImpl};
+
+#[cfg(test)]
+pub mod testing;