package async

You can search for identifiers within the package.

in-package search v0.2.0

Monadic concurrency library

Install

Dune Dependency

github.com Readme Changelog MIT License Edit opam file Versions (6)

Authors

J

Jane Street Group, LLC

Maintainers

J

Jane Street developers

Sources

async-v0.13.0.tar.gz

sha256=fef9ebe342ea59d7804f6292b7891ad664a8ba8d4174a1b202db91363a9c71ab

md5=fbfc7059179bc9ddd5dc1411e7d2e815

doc/async.persistent_connection/Persistent_connection/Versioned_rpc/index.html

Module `Persistent_connection.Versioned_rpc`

include Persistent_connection_kernel.S
  with type conn = Async.Versioned_rpc.Connection_with_menu.t
  with type address = Core.Host_and_port.t

type t

type address = Core.Host_and_port.t

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.

type conn = Async.Versioned_rpc.Connection_with_menu.t

A connection, perhaps embellished with additional information upon connection.

module Event : sig ... end

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.

val current_connection : t -> conn option

The current connection, if any.

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.

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.Log.t ->
  ?on_event:(Event.t -> unit Async.Deferred.t) ->
  ?retry_delay:(unit -> Core.Time.Span.t) ->
  ?random_state:Core.Random.State.t ->
  ?time_source:Async.Time_source.t ->
  connect:(address -> conn Core.Or_error.t Async.Deferred.t) ->
  (unit -> address Core.Or_error.t Async.Deferred.t) ->
  t