google/tarpc
Tarpc
tarpc is a remote procedure call framework for Rust that generates server traits and client stubs for network communication. It provides an asynchronous service interface that allows remote functions to be called as if they were local asynchronous tasks.
The framework utilizes a serialized transport layer to move request and response data via TCP sockets, Unix domain sockets, or in-process channels. It includes a request lifecycle interceptor for injecting custom logic to handle authorization, throttling, and load balancing, as well as a distributed request telemetry system that attaches deadlines and trace identifiers to calls for performance analysis.
The system covers distributed system communication and inter-process communication, with built-in capabilities for network service resource management and remote service instrumentation.
Features
- Remote Procedure Calls - Provides a framework for executing functions on remote servers as if they were local asynchronous calls.
- Interface Definition Code Generation - Generates client stubs and server skeletons from service specifications to reduce manual implementation.
- Server Boilerplate Generators - Automates the creation of server-side boilerplate code from RPC service definitions.
- Distributed System Communication - Enables multiple processes to exchange data and execute logic across different machines via network or local sockets.
- Remote Procedure Call Frameworks - Provides a high-performance framework for invoking remote methods as if they were local asynchronous functions.
- RPC Frameworks - Offers a complete framework for executing remote procedures across network nodes using optimized transport protocols.
- RPC Service Implementations - Enables the implementation of business logic for RPC services by fulfilling generated shared interfaces.
- Transport Layers - Implements a transport layer that moves serialized request and response data via TCP, Unix sockets, or channels.
- Asynchronous Request Handlers - Implements non-blocking concurrent request processing using asynchronous futures to maintain high throughput.
- Inter-Process Communication - Implements mechanisms for data exchange and synchronization between separate execution processes on a single machine.
- Service Trait Generators - Uses Rust procedural macros to automatically generate server traits and client stubs from service definitions.
- Service Trait Definitions - Generates service traits that allow remote functions to be called as local asynchronous tasks.
- Request Cancellations - Allows servers to terminate active processing when a client drops the connection to free up resources.
- Network Service Resource Management - Protects server resources by enforcing request deadlines, limiting connection volumes, and propagating client cancellations.
- Protocol-Agnostic Transport Layers - Abstracts the network layer by treating communication mediums as generic streams for serialized data.
- RPC Routing Layers - Routes RPC calls between clients and servers using in-process channels or network protocols.
- RPC Transport Implementations - Implements request-response patterns across TCP, Unix domain sockets, and in-process channels.
- TCP and Unix Socket Listeners - Supports moving serialized request and response data using both TCP ports and local Unix domain sockets.
- TCP Transport Connections - Establishes reliable connections to transport serialized RPC data using TCP or compatible protocols.
- Contextual Metadata Propagation - Automatically attaches and propagates request-scoped metadata and trace identifiers across distributed execution flows.
- Connection Limiters - Provides mechanisms to cap the number of concurrent network connections to protect server resources.
- In-Memory Communication Channels - Provides thread-safe memory channels for exchanging data between tasks within a single process using the RPC interface.
- Request Interception Middleware - Implements a request lifecycle interceptor chain to handle cross-cutting concerns like telemetry and authorization.
- RPC Interceptors - Provides interceptors that wrap remote procedure calls to inject logic for authorization, throttling, and load balancing.
- Request Deadlines - Implements time-based limits that automatically terminate remote requests exceeding a specified duration.
- Distributed Request Tracking - Tracks the full lifecycle of requests across services by attaching deadlines and trace identifiers.
- Distributed Tracing Instrumentation - Provides instrumentation to track the execution flow of distributed requests across operations.
- Distributed Request Tracing - Attaches deadlines and trace identifiers to remote calls to capture processing data across backend operations.
- Request Interception Middlewares - Provides middleware pipelines to intercept and process requests for authorization, throttling, and load balancing.
- Language Toolkits - RPC framework for Rust.
