Struct Service 

pub struct Service { /* private fields */ }

A Synapse service instance

Implementations

impl Service

pub fn builder(service_name: impl Into<String>) -> ServiceBuilder

Create a new service builder

pub fn name(&self) -> &str

Get the service name

pub fn instance_id(&self) -> InstanceId

Get the instance ID

pub fn rpc_server(&self) -> &Arc<RpcServer>

Get access to the RPC server

pub async fn register( &self, registration: InterfaceRegistration, handler: Arc<dyn RpcHandler>, ) -> Result<()>

Register a codegen-generated interface

Takes the (InterfaceRegistration, Arc<dyn RpcHandler>) tuple returned by FooServiceRouter::create(impl) and registers it locally + with the gateway.

This is the preferred way to register interfaces — no need to repeat interface names or method names manually.

Example

let impl_ = MyServiceImpl::new();
let (reg, handler) = MyServiceRouter::create(impl_);
service.register(reg, handler).await?;

pub async fn register_interface( &self, interface_name: &str, method_names: &[&str], handler: Arc<dyn RpcHandler>, ) -> Result<()>

Register an interface implementation from string parameters

Prefer [register] when using codegen-generated routers. This method is useful for dynamic/manual interface registration.

pub async fn register_http_routes( &self, routes: Vec<HttpRouteConfig>, ) -> Result<()>

Register HTTP routes with the gateway, proxying to this service’s own endpoint.

Sends an HttpEndpointRegister message to the gateway, which will add the routes to the gateway’s HTTP router. The gateway must have appropriate http_registration_permissions configured to allow this.

Routes are stored and automatically re-registered if the gateway connection is lost and re-established.

pub async fn register_http_route_group( &self, group: HttpRouteGroup, ) -> Result<()>

Register HTTP routes with the gateway, proxying to an arbitrary host:port.

Use this to register routes for services that aren’t Synapse-connected (e.g., a frontend dev server, static file server, or external API). The gateway will proxy matching requests to the specified target.

Each group has its own service_name because the gateway maps service_name → endpoint URL. Different backends need different names.

Routes are stored and automatically re-registered on reconnect.

pub async fn handle_request(&self, request: RpcRequest) -> RpcResponse

Handle an RPC request

pub fn set_health_check<F>(&mut self, check: F)

where F: Fn() -> HealthStatus + Send + Sync + 'static,

Set a custom health check function

pub fn health_response(&self) -> HealthResponse

Create a HealthResponse message

pub fn is_gateway_connected(&self) -> bool

Check if currently connected to gateway

pub fn start_gateway_connection_task( self: Arc<Self>, interval_ms: u64, ) -> JoinHandle<()>

Start background task that pushes health status and handles reconnection

This task:

• Sends health status to gateway periodically
• Detects when gateway connection is lost
• Automatically re-registers all interfaces and HTTP routes when gateway comes back

interval_ms controls the health push frequency. initial_delay_ms controls the initial startup delay (default 500ms if 0).

pub fn start_gateway_connection_task_with_delay( self: Arc<Self>, interval_ms: u64, initial_delay_ms: u64, ) -> JoinHandle<()>

Like start_gateway_connection_task but with a custom initial delay

pub fn start_health_pusher(self: Arc<Self>, interval_ms: u64) -> JoinHandle<()>

Start background health push task (legacy alias for start_gateway_connection_task)

pub fn gateway_client(&self) -> Option<&HttpRpcClient>

Get access to the gateway client (if configured)