Struct Server 

pub struct Server<'a, F> { /* private fields */ }

A function server with options beyond the command-line Args. Create it with Server::new, chain the options, then call Server::serve; with no options it serves exactly like serve. New options arrive as new methods, so code that builds a server keeps compiling.

function_sdk_rust::Server::new(function, args)
    .ready(async { Ok::<(), std::io::Error>(()) })
    .serve()
    .await

Implementations

impl<'a, F: FunctionRunnerService> Server<'a, F>

pub fn new(function: F, args: &'a Args) -> Self

Creates a server for function, configured by the command-line args.

pub fn ready<R, E>(self, ready: R) -> Self

where R: Future<Output = Result<(), E>> + Send + 'static, E: Into<Box<dyn Error + Send + Sync>>,

Holds the function back until ready completes, for a function that must finish loading before it can run. The server listens at once, but reports NOT_SERVING on the gRPC health service and answers RunFunction with UNAVAILABLE. Ok flips the function to SERVING; an error or a panic stops the server, and Server::serve returns it as Error::NotReady.

pub fn metrics_registry(self, registry: Registry) -> Self

Serves registry at /metrics, like function-sdk-go’s WithMetricsRegistry: register the function’s own series in it first, and the SDK adds its grpc_server_* series at the root. With --metrics-address empty nothing is served.

Build the registry and its metrics with a prometheus-client version that is semver-compatible with the SDK’s own dependency on it (while prometheus-client is 0.x, the same minor version). Cargo then resolves both to one copy of the crate; a registry from an incompatible version is a different type and does not compile here.

pub async fn serve(self) -> Result<(), Error>

Serves RunFunctionRequests until SIGTERM or SIGINT, then shuts down gracefully. See serve for what is served.