package polling_state_rpc
Install
Dune Dependency
Authors
Maintainers
Sources
sha256=6b930abc3c9863d2391882d78d56694d3c4ed58f0d364e5b17f21d7d1ec10d49
doc/polling_state_rpc/Polling_state_rpc/index.html
Module Polling_state_rpcSource
This is just the diffable signature but with the diffable type also supporting bin_io.
The type representing the RPC itself. Similar to Rpc.Rpc.t and its friends.
val create :
name:string ->
version:int ->
query_equal:('query -> 'query -> bool) ->
bin_query:'query Core.Bin_prot.Type_class.t ->
(module Diffable with type t = 'response) ->
('query, 'response) tval implement :
on_client_and_server_out_of_sync:(Core.Sexp.t -> unit) ->
?for_first_request:
('connection_state -> 'query -> 'response Async_kernel.Deferred.t) ->
('query, 'response) t ->
('connection_state -> 'query -> 'response Async_kernel.Deferred.t) ->
('connection_state * Async_rpc_kernel.Rpc.Connection.t)
Async_rpc_kernel.Rpc.Implementation.tHandling the first request and handling the remaining requests is different because the first request you likely want to compute immediately, but for subsequent requests, it's more likely that you'll want to block until your data store changes and updates are made available.
val implement_with_client_state :
on_client_and_server_out_of_sync:(Core.Sexp.t -> unit) ->
create_client_state:('connection_state -> 'client_state) ->
?on_client_forgotten:('client_state -> unit) ->
?for_first_request:
('connection_state ->
'client_state ->
'query ->
'response Async_kernel.Deferred.t) ->
('query, 'response) t ->
('connection_state ->
'client_state ->
'query ->
'response Async_kernel.Deferred.t) ->
('connection_state * Async_rpc_kernel.Rpc.Connection.t)
Async_rpc_kernel.Rpc.Implementation.tSimilar to implement, but with support for per-client state. This allows you to support multiple clients, each with different server-side state, that share a single Rpc.Connection.t.
Note that, similar to the connection state, the client state cannot be shared between multiple connections - if a client reconnects after disconnecting, it will be given a new client state.
on_client_forgotten is called when the client calls Client.forget_on_server, or when the underlying connection is closed.
val implement_via_bus :
on_client_and_server_out_of_sync:(Core.Sexp.t -> unit) ->
create_client_state:('connection_state -> 'client_state) ->
?on_client_forgotten:('client_state -> unit) ->
('query, 'response) t ->
('connection_state ->
'client_state ->
'query ->
('response -> unit, [> Core.read ]) Bus.t) ->
('connection_state * Async_rpc_kernel.Rpc.Connection.t)
Async_rpc_kernel.Rpc.Implementation.tLike implement, except the callback is invoked only once per query, and must return a bus instead of a single result. Each time a client polls, it will receive the newest response that it has not yet seen. If it has seen the newest response, then the RPC implementation will block until there is a newer response.
This function immediately subscribes to the returned bus and cancels any previous subscriptions each time it invokes the callback. It is recommended that the bus use Allow_and_send_last_value, so that each new query doesn't miss the first response for each query (or even raise, if on_subscription_after_first_write is set to Raise).