include S with type conn = Rpc.Connection.t and type address = Core.Host_and_port.t
include Async_extra__.Import.Async_kernel_persistent_connection.S
type address
The address of a service to which one can connect. E.g. Host_and_port.t
is a
reasonable choice when making a TCP connection.
module Event : sig ... end
val create : server_name:string ‑> ?on_event:(Event.t ‑> unit Async_kernel.Deferred.t) ‑> ?retry_delay:(unit ‑> Core_kernel.Time_ns.Span.t) ‑> connect:(address ‑> conn Core_kernel.Or_error.t Async_kernel.Deferred.t) ‑> (unit ‑> address Core_kernel.Or_error.t Async_kernel.Deferred.t) ‑> t
create ~server_name ~on_event ~retry_delay get_address
returns a persistent
connection to a server whose host and port are obtained via get_address
every
time we try to connect. For example, get_address
might look up a server's host
and port in catalog at a particular path to which multiple redundant copies of a
service are publishing their location. If one copy dies, we get the address of the
another one when looking up the address afterwards.
All connection events (see the type above) are passed to the on_event
callback, if
given. When this callback becomes determined, we move on to the next step in our
connection attempt (e.g. we won't actually attempt to connect until
on_event Attempting_to_connect
is finished). Note that on_event Disconnected
will only be called once on_event (Connected conn)
finishes even if the connection
goes down during that callback.
`Failed_to_connect error
and `Obtained_address addr
events are only reported if
they are distinct from the most recent event of the same type that has taken place
since the most recent `Attempting_to_connect
event.
Connection is retried after Time.Span.randomize ~percent:(Percent.of_mult 0.3)
(retry_delay ())
. The default for retry_delay
is const (sec 10.)
. Note that
what this retry delay actually throttles is the delay between two connection
attempts, so when a long-lived connection dies, connection is usually immediately
retried, and if that failed, wait for another retry delay and retry.
val connected : t ‑> conn Async_kernel.Deferred.t
connected
returns the first available connection from the time it is called. When
currently connected, the returned deferred is already determined. If closed
has
been called, then the returned deferred is never determined.
close t
closes the current connection and stops it from trying to reconnect.
After the deferred it returns becomes determined, the last connection has been
closed and no others will be attempted.
Note: no close
calls are ever generated internally in response to the connection
being closed by the other side.
include Async_kernel__.Persistent_connection_intf.Closable with type t := t
val close : t ‑> unit Async_kernel.Deferred.t
close t
closes the connection. The returned deferred becomes determined once any
resources needed to maintain the connection have been released.
val is_closed : t ‑> bool
is_closed t
returns true if close
has ever been called (even if the returned
deferred has not yet been fulfilled).
Note that some modules implementing Closable
may call close internally upon
noticing that the connection was closed by the other side. The interface of such a
module ought to say that this is the case.
val close_finished : t ‑> unit Async_kernel.Deferred.t
close_finished t
becomes determined at the same time as the result of the first
call to close
. close_finished
differs from close
in that it does not have the
side effect of initiating a close.
val create : server_name:string ‑> ?log:Async_extra__.Import.Log.t ‑> ?on_event:(Event.t ‑> unit Async_extra__.Import.Deferred.t) ‑> ?retry_delay:(unit ‑> Core.Time.Span.t) ‑> connect:(address ‑> conn Core.Or_error.t Async_extra__.Import.Deferred.t) ‑> (unit ‑> address Core.Or_error.t Async_extra__.Import.Deferred.t) ‑> t
val create' : server_name:string ‑> ?log:Async_extra__.Import.Log.t ‑> ?on_event:(Event.t ‑> unit Async_extra__.Import.Deferred.t) ‑> ?retry_delay:(unit ‑> Core.Time.Span.t) ‑> ?bind_to_address:Async_extra__.Import.Unix.Inet_addr.t ‑> ?implementations:_ Rpc.Connection.Client_implementations.t ‑> ?max_message_size:int ‑> ?make_transport:Rpc.Connection.transport_maker ‑> ?handshake_timeout:Core.Time.Span.t ‑> ?heartbeat_config:Rpc.Connection.Heartbeat_config.t ‑> (unit ‑> Core.Host_and_port.t Core.Or_error.t Async_extra__.Import.Deferred.t) ‑> t
create'
is like the create
, but slightly more convenient for constructing
unembellished rpc connections.