include Tezos_requester.Requester.FULL_REQUESTER
with type key = Tezos_crypto.Protocol_hash.t
with type param = unit
with type request_param = unit request_param
with type store = State.t
with type value = Tezos_base.Protocol.t
with type notified_value = Tezos_base.Protocol.tinclude Tezos_requester.Requester.REQUESTER
with type key = Tezos_crypto.Protocol_hash.t
with type param = unit
with type value = Tezos_base.Protocol.ttype key = Tezos_crypto.Protocol_hash.tThe index key
type value = Tezos_base.Protocol.tThe indexed data
know t k returns true iff the key is present in the memory table or the disk.
val read :
t ->
key ->
(value, Tezos_error_monad.TzCore.error list) Stdlib.result Lwt.tReturn value if it is found in-memory, or else on disk. Otherwise fail with error Missing_data.
val fetch :
t ->
?peer:Tezos_base.P2p_peer.Id.t ->
?timeout:Tezos_base.Time.System.Span.t ->
key ->
param ->
(value, Tezos_error_monad.TzCore.error list) Stdlib.result Lwt.tfetch t ?peer ?timeout k param returns the value when it is known. It can fail with Timeout k if timeout is provided and the value isn't know before the timeout expires. It can fail with Cancel if the request is canceled.
The key is first looked up in memory, then on disk. If not present and not already requested, it schedules a request, and blocks until the requester is notified with notify. param is used to validate the notified value once it is received. (see also PRECHECK and notify).
Requests are re-sent via a 1.5 exponential back-off, with initial delay set to Request.initial_delay. If the function is called multiple time with the same key but with distinct peers, the internal scheduler randomly chooses the requested peer (at each retry).
type store = State.tThe "disk" storage
type request_param = unit request_paramConfiguration parameter to the Request service
type notified_value = Tezos_base.Protocol.ttype of values notified to the requester
val watch : t -> (key * value) Lwt_stream.t * Lwt_watcher.stopperMonitor all the fetched data. A given data will appear only once.
inject t k v returns false if k is already present in the memory table or in the disk, or has already been requested. Otherwise it updates the memory table and return true
val notify :
t ->
Tezos_base.P2p_peer.Id.t ->
key ->
notified_value ->
unit Lwt.tnotify t peer k nv notifies the requester that a value has been received for key k, from peer peer. nv is a *notified value*. The notified value is validated using Precheck.precheck, and the param provided at fetching time (see PRECHECK). If valid, the memory table is updated and all promises waiting on this key are resolved.
If the key is not pending the notification is ignored.
val memory_table_length : t -> intmemory_table_length t returns the number of keys either known or pending in the memory table of t
val pending_requests : t -> intReturns the number of requests currently pending
val create :
?random_table:bool ->
?global_input:(key * value) Lwt_watcher.input ->
request_param ->
store ->
tcreate ?random_table ?global_input r s creates a requester. r is the configuration parameter passed to Request functions.
The value for random_table determines whether the underlying hashtable randomises its hash (see Stdlib.Hashtbl.create and specifically the documentation of the random parameter). The default depends on environment variables and Stdlib.Hashtbl.randomize has been called.