Informs the request tracker of the effect of a request that is to be committed. The effect is described by a CommitSet, namely which contracts should be deactivated and which ones activated.

This method may be called only after an addResult call for the same request.

Shorthand for addCommitSet(rc, CommitSet.empty)

Adds the confirmation request to the request tracker. It schedules the activeness check for the activenessTime and the timeout of the request for the decisionTime, whereby a result exactly at the decisionTime is considered to be in time. If a scala.Right$ is returned, it also signals the arrival of the message with sequencerCounter and timestamp requestTimestamp, like the RequestTracker!.tick operation.

The activeness check request is expressed as an activeness set comprising all the contracts that must be active and those that may be created or transferred-in. This operation returns a pair of futures indicating the outcome of the activeness check and the timeout state of the request, described below.

If a request with requestCounter and sequencerCounter is added, the request tracker expects that eventually every request prior to requestCounter will be added, and that every sequencer counter prior to sequencerCounter will be signaled.

If the request has been added before with the same parameters, but it is not yet finalized nor has it timed out, the method ignores the second call and returns the same futures as in the first call.

Informs the request tracker that a result message has arrived for the given request. This marks the request as not having timed out. The actual effect of the result must be supplied via a subsequent call to RequestTracker!.addCommitSet. The request tracker may not progress beyond the commitTime until the commit set is provided.

This method may be called only after a RequestTracker!.addRequest call for the same request.

Returns a future that completes after the request has progressed to the given timestamp. If the request tracker has already progressed to the timestamp, scala.None is returned.

Blocks until all earlier tasks have completed and then prevents further tasks from being run.

closeAsync asynchronously releases resources held by a future

Returns a possibly outdated state of the contract.

Check whether we're closing. Susceptible to race conditions; unless you're using using this as a flag to the retry lib or you really know what you're doing, prefer performUnlessClosing and friends.

track running futures on shutdown

set to true to get detailed information about all futures that did not complete during shutdown. if set to false, we don't do anything.

Performs the task given by f unless a shutdown has been initiated. The shutdown will only begin after f completes, but other tasks may execute concurrently with f, if started using this function, or one of the other variants (performUnlessClosingF and performUnlessClosingEitherT). The tasks are assumed to take less than closingTimeout to complete.

Performs the EitherT[Future] given by etf unless a shutdown has been initiated, in which case the provided error is returned instead. Both etf and the error are lazy; etf is only evaluated if there is no shutdown, the error only if we're shutting down. The shutdown will only begin after etf completes, but other tasks may execute concurrently with etf, if started using this function, or one of the other variants (performUnlessClosing and performUnlessClosingF). The tasks are assumed to take less than closingTimeout to complete.

Performs the Future given by f unless a shutdown has been initiated. The future is lazy and not evaluated during shutdown. The shutdown will only begin after f completes, but other tasks may execute concurrently with f, if started using this function, or one of the other variants (performUnlessClosing and performUnlessClosingEitherT). The tasks are assumed to take less than closingTimeout to complete.

Returns whether the request is in flight, i.e., in the requests map.

Register a task that will run onClose after all "performUnlessShutdown" tasks have finished

Tells the request tracker that a message with the given sequencer counter and timestamp has been received.

If RequestTracker!.addRequest or RequestTracker!.addResult shall be called for the same message, RequestTracker!.tick may only be called after those methods as they may schedule tasks at the timestamp or later and task scheduling for a timestamp must be done before the time is observed.

A given sequencer counter may be signalled several times provided that all calls signal the same timestamp. Only the first such call is taken into account. Since RequestTracker!.addRequest and RequestTracker!.addResult implicitly signal the sequencer counter and timestamp to the request tracker (unless specified otherwise), it is safe to call this method after calling these methods.

The timestamps must increase with the sequencer counters.