@API(value=STABLE) public class FDBDatabase extends Object
Database
, associated with a cluster file location.
All reads and writes to the database are transactional: an open FDBRecordContext
is needed.
An FDBDatabase
is needed to open an FDBRecordContext
.
final FDBDatabase fdb = FDBDatabaseFactory.instance().getDatabase();
try (FDBRecordContext ctx = fdb.openContext()) {
...
}
FDBDatabaseFactory
Modifier and Type | Class and Description |
---|---|
static interface |
FDBDatabase.ExceptionMapper
Function for mapping an underlying exception to a synchronous failure.
|
static class |
FDBDatabase.WeakReadSemantics
1.
|
Modifier and Type | Field and Description |
---|---|
protected static String |
BLOCKING_FOR_FUTURE_MESSAGE
Message that is logged when one joins on a future and expects it to be completed, but it is not yet done.
|
protected static String |
BLOCKING_IN_ASYNC_CONTEXT_MESSAGE
Text of message that is logged or exception that is thrown when a blocking API call
(
asyncToSync() , join(CompletableFuture) , or get(CompletableFuture) ) is
called from within a CompletableFuture completion state. |
protected static String |
BLOCKING_RETURNING_ASYNC_MESSAGE
Message that is logged when it is detected that a blocking call is being made in a method that may be producing
a future (specifically a method that ends in "
Async "). |
static int |
DEFAULT_MAX_REVERSE_CACHE_ENTRIES |
static int |
DEFAULT_RESOLVER_STATE_CACHE_REFRESH_SECONDS |
Constructor and Description |
---|
FDBDatabase(FDBDatabaseFactory factory,
String clusterFile) |
Modifier and Type | Method and Description |
---|---|
<T> T |
asyncToSync(FDBStoreTimer timer,
StoreTimer.Wait event,
CompletableFuture<T> async) |
void |
clearAsyncToSyncTimeout() |
void |
clearCaches() |
void |
clearForwardDirectoryCache() |
void |
clearReverseDirectoryCache() |
void |
close() |
Transaction |
createTransaction(Executor executor,
Map<String,String> mdcContext,
boolean transactionIsTraced) |
Database |
database()
Get the underlying FDB database.
|
<T> T |
get(CompletableFuture<T> future)
Get a future, following the same logic that
asyncToSync() uses to validate that the operation
isn't blocking in an asynchronous context. |
Function<StoreTimer.Wait,org.apache.commons.lang3.tuple.Pair<Long,TimeUnit>> |
getAsyncToSyncTimeout() |
org.apache.commons.lang3.tuple.Pair<Long,TimeUnit> |
getAsyncToSyncTimeout(StoreTimer.Wait event) |
BlockingInAsyncDetection |
getBlockingInAsyncDetection() |
String |
getClusterFile()
Get the path to the cluster file that this database was created with.
|
String |
getDatacenterId() |
com.google.common.cache.Cache<ScopedValue<String>,ResolverResult> |
getDirectoryCache(int atVersion) |
com.google.common.cache.CacheStats |
getDirectoryCacheStats() |
int |
getDirectoryCacheVersion() |
Executor |
getExecutor() |
protected FDBDatabaseFactory |
getFactory()
Get the factory that produced this database.
|
FDBLocalityProvider |
getLocalityProvider()
Get the locality provider that is used to discover the server location of the keys.
|
CompletableFuture<Long> |
getReadVersion(FDBRecordContext context)
Deprecated.
use
FDBRecordContext.getReadVersionAsync() instead |
long |
getResolverStateCacheRefreshTime() |
FDBReverseDirectoryCache |
getReverseDirectoryCache() |
com.google.common.cache.Cache<ScopedValue<Long>,String> |
getReverseDirectoryInMemoryCache() |
CompletableFuture<ResolverStateProto.State> |
getStateForResolver(LocatableResolver resolver,
Supplier<CompletableFuture<ResolverStateProto.State>> loader) |
FDBRecordStoreStateCache |
getStoreStateCache()
Get the store state cache for this database.
|
boolean |
hasAsyncToSyncTimeout() |
protected CompletableFuture<Void> |
injectLatency(FDBLatencySource fdbLatencySource)
Given a specific FDB API call, a future is returned that is delayed by the number of milliseconds
that was computed by the installed latency injector (
FDBDatabaseFactory.setLatencyInjector(Function) ). |
boolean |
isTrackLastSeenVersion() |
boolean |
isTrackLastSeenVersionOnCommit() |
boolean |
isTrackLastSeenVersionOnRead() |
<T> T |
join(CompletableFuture<T> future)
Join a future, following the same logic that
asyncToSync() uses to validate that the operation
isn't blocking in an asynchronous context. |
<T> T |
joinNow(CompletableFuture<T> future)
Join a future but validate that the future is already completed.
|
CompletableFuture<Tuple> |
loadBoundaryKeys(FDBTransactionContext context,
Tuple key) |
protected RuntimeException |
mapAsyncToSyncException(Throwable ex) |
protected Executor |
newContextExecutor() |
FDBDatabaseRunner |
newRunner()
Create an
FDBDatabaseRunner for use against this database. |
FDBDatabaseRunner |
newRunner(FDBStoreTimer timer,
Map<String,String> mdcContext)
Create an
FDBDatabaseRunner for use against this database. |
FDBDatabaseRunner |
newRunner(FDBStoreTimer timer,
Map<String,String> mdcContext,
FDBDatabase.WeakReadSemantics weakReadSemantics)
Create an
FDBDatabaseRunner for use against this database. |
FDBRecordContext |
openContext()
Open a new record context with a new transaction begun on the underlying FDB database.
|
FDBRecordContext |
openContext(Map<String,String> mdcContext,
FDBStoreTimer timer)
Open a new record context with a new transaction begun on the underlying FDB database.
|
FDBRecordContext |
openContext(Map<String,String> mdcContext,
FDBStoreTimer timer,
FDBDatabase.WeakReadSemantics weakReadSemantics)
Open a new record context with a new transaction begun on the underlying FDB database.
|
FDBRecordContext |
openContext(Map<String,String> mdcContext,
FDBStoreTimer timer,
FDBDatabase.WeakReadSemantics weakReadSemantics,
FDBTransactionPriority priority)
Open a new record context with a new transaction begun on the underlying FDB database.
|
FDBRecordContext |
openContext(Map<String,String> mdcContext,
FDBStoreTimer timer,
FDBDatabase.WeakReadSemantics weakReadSemantics,
FDBTransactionPriority priority,
String transactionId)
Open a new record context with a new transaction begun on the underlying FDB database.
|
protected void |
openFDB() |
void |
performNoOp()
Perform a no-op against FDB to check network thread liveness.
|
void |
performNoOp(FDBStoreTimer timer)
Perform a no-op against FDB to check network thread liveness.
|
void |
performNoOp(Map<String,String> mdcContext,
FDBStoreTimer timer)
Perform a no-op against FDB to check network thread liveness.
|
CompletableFuture<Void> |
performNoOpAsync()
Perform a no-op against FDB to check network thread liveness.
|
CompletableFuture<Void> |
performNoOpAsync(FDBStoreTimer timer)
Perform a no-op against FDB to check network thread liveness.
|
CompletableFuture<Void> |
performNoOpAsync(Map<String,String> mdcContext,
FDBStoreTimer timer)
Perform a no-op against FDB to check network thread liveness.
|
<T> T |
run(FDBStoreTimer timer,
Map<String,String> mdcContext,
FDBDatabase.WeakReadSemantics weakReadSemantics,
Function<? super FDBRecordContext,? extends T> retriable)
Runs a transactional function against this
FDBDatabase with retry logic. |
<T> T |
run(FDBStoreTimer timer,
Map<String,String> mdcContext,
Function<? super FDBRecordContext,? extends T> retriable)
Runs a transactional function against this
FDBDatabase with retry logic. |
<T> T |
run(Function<? super FDBRecordContext,? extends T> retriable)
Runs a transactional function against this
FDBDatabase with retry logic. |
<T> CompletableFuture<T> |
runAsync(FDBStoreTimer timer,
Map<String,String> mdcContext,
FDBDatabase.WeakReadSemantics weakReadSemantics,
Function<? super FDBRecordContext,CompletableFuture<? extends T>> retriable)
Runs a transactional function asynchronously against this
FDBDatabase with retry logic. |
<T> CompletableFuture<T> |
runAsync(FDBStoreTimer timer,
Map<String,String> mdcContext,
Function<? super FDBRecordContext,CompletableFuture<? extends T>> retriable)
Runs a transactional function asynchronously against this
FDBDatabase with retry logic. |
<T> CompletableFuture<T> |
runAsync(Function<? super FDBRecordContext,CompletableFuture<? extends T>> retriable)
Runs a transactional function asynchronously against this
FDBDatabase with retry logic. |
void |
setAsyncToSyncExceptionMapper(FDBDatabase.ExceptionMapper asyncToSyncExceptionMapper) |
void |
setAsyncToSyncTimeout(Function<StoreTimer.Wait,org.apache.commons.lang3.tuple.Pair<Long,TimeUnit>> asyncToSyncTimeout) |
void |
setAsyncToSyncTimeout(long asyncToSyncTimeout,
TimeUnit asyncToSyncTimeoutUnit) |
void |
setDatacenterId(String datacenterId) |
void |
setDirectoryCacheSize(int size) |
void |
setResolverStateRefreshTimeMillis(long resolverStateRefreshTimeMillis) |
void |
setStoreStateCache(FDBRecordStoreStateCache storeStateCache)
Set the store state cache for this database.
|
void |
setTrackLastSeenVersion(boolean trackLastSeenVersion) |
void |
setTrackLastSeenVersionOnCommit(boolean trackLastSeenVersion) |
void |
setTrackLastSeenVersionOnRead(boolean trackLastSeenVersion) |
void |
updateLastSeenFDBVersion(long startTime,
long readVersion) |
protected static final String BLOCKING_IN_ASYNC_CONTEXT_MESSAGE
asyncToSync()
, join(CompletableFuture)
, or get(CompletableFuture)
) is
called from within a CompletableFuture
completion state.protected static final String BLOCKING_RETURNING_ASYNC_MESSAGE
Async
").protected static final String BLOCKING_FOR_FUTURE_MESSAGE
public static final int DEFAULT_MAX_REVERSE_CACHE_ENTRIES
public static final int DEFAULT_RESOLVER_STATE_CACHE_REFRESH_SECONDS
public FDBDatabase(@Nonnull FDBDatabaseFactory factory, @Nullable String clusterFile)
protected void openFDB()
public void setDirectoryCacheSize(int size)
public void setDatacenterId(String datacenterId)
public String getDatacenterId()
@Nonnull public FDBLocalityProvider getLocalityProvider()
public void setTrackLastSeenVersionOnRead(boolean trackLastSeenVersion)
public boolean isTrackLastSeenVersionOnRead()
public void setTrackLastSeenVersionOnCommit(boolean trackLastSeenVersion)
public boolean isTrackLastSeenVersionOnCommit()
public void setTrackLastSeenVersion(boolean trackLastSeenVersion)
public boolean isTrackLastSeenVersion()
@Nullable public String getClusterFile()
null
if using the
default cluster file.@Nonnull protected FDBDatabaseFactory getFactory()
@Nonnull public Database database()
@Nonnull public FDBRecordContext openContext()
Database.createTransaction()
@Nonnull public FDBRecordContext openContext(@Nullable Map<String,String> mdcContext, @Nullable FDBStoreTimer timer)
If the logger context includes "uuid" as a key, the value associated with that key will be associated
with the returned transaction as its debug identifier. See
openContext(Map, FDBStoreTimer, WeakReadSemantics, FDBTransactionPriority, String)
for more details.
mdcContext
- logger context to set in running threadstimer
- the timer to use for instrumentationDatabase.createTransaction()
@Nonnull public FDBRecordContext openContext(@Nullable Map<String,String> mdcContext, @Nullable FDBStoreTimer timer, @Nullable FDBDatabase.WeakReadSemantics weakReadSemantics)
If the logger context includes "uuid" as a key, the value associated with that key will be associated
with the returned transaction as its debug identifier. See
openContext(Map, FDBStoreTimer, WeakReadSemantics, FDBTransactionPriority, String)
for more details.
mdcContext
- logger context to set in running threadstimer
- the timer to use for instrumentationweakReadSemantics
- allowable staleness information if caching read versionsDatabase.createTransaction()
@Nonnull public FDBRecordContext openContext(@Nullable Map<String,String> mdcContext, @Nullable FDBStoreTimer timer, @Nullable FDBDatabase.WeakReadSemantics weakReadSemantics, @Nonnull FDBTransactionPriority priority)
If the logger context includes "uuid" as a key, the value associated with that key will be associated
with the returned transaction as its debug identifier. See
openContext(Map, FDBStoreTimer, WeakReadSemantics, FDBTransactionPriority, String)
for more details.
mdcContext
- logger context to set in running threadstimer
- the timer to use for instrumentationweakReadSemantics
- allowable staleness information if caching read versionspriority
- the priority of the transaction being createdDatabase.createTransaction()
@Nonnull public FDBRecordContext openContext(@Nullable Map<String,String> mdcContext, @Nullable FDBStoreTimer timer, @Nullable FDBDatabase.WeakReadSemantics weakReadSemantics, @Nonnull FDBTransactionPriority priority, @Nullable String transactionId)
Note that other variants of this method will inspect the MDC context for the transaction ID by looking
for an entry in the map with the key "uuid". This method will ignore whatever is in the MDC context
and use the ID provided as a parameter instead. The transaction ID should typically consist solely of
printable ASCII characters and should not exceed 100 bytes. The ID may be truncated or dropped if the ID will
not fit in 100 bytes. See FDBRecordContext.getTransactionId()
for more details.
mdcContext
- logger context to set in running threadstimer
- the timer to use for instrumentationweakReadSemantics
- allowable staleness information if caching read versionspriority
- the priority of the transaction being createdtransactionId
- the transaction ID to associate with this transactionDatabase.createTransaction()
@Nonnull public CompletableFuture<Void> performNoOpAsync()
performNoOp(Map, FDBStoreTimer)
for more information. This will use the default MDC for running threads and will not instrument the
operation.performNoOp(Map, FDBStoreTimer)
@Nonnull public CompletableFuture<Void> performNoOpAsync(@Nullable FDBStoreTimer timer)
performNoOp(Map, FDBStoreTimer)
for more information. This will use the default MDC for running threads.timer
- the timer to use for instrumentationperformNoOp(Map, FDBStoreTimer)
@Nonnull public CompletableFuture<Void> performNoOpAsync(@Nullable Map<String,String> mdcContext, @Nullable FDBStoreTimer timer)
If the provided FDBStoreTimer
is not null
, then this will update the FDBStoreTimer.Events.PERFORM_NO_OP
operation with related timing information. This can then be monitored to detect instances of client saturation
where the performance bottleneck lies in scheduling work to run on the FDB event queue.
mdcContext
- logger context to set in running threadstimer
- the timer to use for instrumentationpublic void performNoOp()
performNoOpAsync()
.
Note that the future is expected to complete relatively quickly in most circumstances, but it may take a long
time if the network thread has been saturated, e.g., if there is a lot of work being scheduled to run in FDB.performNoOpAsync()
public void performNoOp(@Nullable FDBStoreTimer timer)
performNoOpAsync(FDBStoreTimer)
.
Note that the future is expected to complete relatively quickly in most circumstances, but it may take a long
time if the network thread has been saturated, e.g., if there is a lot of work being scheduled to run in FDB.timer
- the timer to use for instrumentationperformNoOpAsync(FDBStoreTimer)
public void performNoOp(@Nullable Map<String,String> mdcContext, @Nullable FDBStoreTimer timer)
performNoOpAsync(Map, FDBStoreTimer)
.
Note that the future is expected to complete relatively quickly in most circumstances, but it may take a long
time if the network thread has been saturated, e.g., if there is a lot of work being scheduled to run in FDB.mdcContext
- logger context to set in running threadstimer
- the timer to use for instrumentationperformNoOpAsync(Map, FDBStoreTimer)
public long getResolverStateCacheRefreshTime()
public void setResolverStateRefreshTimeMillis(long resolverStateRefreshTimeMillis)
@Nonnull @API(value=INTERNAL) public CompletableFuture<ResolverStateProto.State> getStateForResolver(@Nonnull LocatableResolver resolver, @Nonnull Supplier<CompletableFuture<ResolverStateProto.State>> loader)
@Deprecated @Nonnull public CompletableFuture<Long> getReadVersion(@Nonnull FDBRecordContext context)
FDBRecordContext.getReadVersionAsync()
insteadcontext
- transaction to use to access the database@API(value=INTERNAL) public void updateLastSeenFDBVersion(long startTime, long readVersion)
@Nonnull @API(value=INTERNAL) public FDBReverseDirectoryCache getReverseDirectoryCache()
public com.google.common.cache.CacheStats getDirectoryCacheStats()
@Nonnull @API(value=INTERNAL) public com.google.common.cache.Cache<ScopedValue<String>,ResolverResult> getDirectoryCache(int atVersion)
@Nonnull @API(value=INTERNAL) public com.google.common.cache.Cache<ScopedValue<Long>,String> getReverseDirectoryInMemoryCache()
@Nonnull public FDBRecordStoreStateCache getStoreStateCache()
FDBRecordStoreStateCache
public void setStoreStateCache(@Nonnull FDBRecordStoreStateCache storeStateCache)
storeStateCache
- the store state cachepublic void close()
public Transaction createTransaction(Executor executor, @Nullable Map<String,String> mdcContext, boolean transactionIsTraced)
@Nonnull public FDBDatabaseRunner newRunner()
FDBDatabaseRunner
for use against this database.@Nonnull public FDBDatabaseRunner newRunner(@Nullable FDBStoreTimer timer, @Nullable Map<String,String> mdcContext)
FDBDatabaseRunner
for use against this database.timer
- the timer to use for instrumentationmdcContext
- logger context to set in running threads@Nonnull public FDBDatabaseRunner newRunner(@Nullable FDBStoreTimer timer, @Nullable Map<String,String> mdcContext, @Nullable FDBDatabase.WeakReadSemantics weakReadSemantics)
FDBDatabaseRunner
for use against this database.timer
- the timer to use for instrumentationmdcContext
- logger context to set in running threadsweakReadSemantics
- allowable staleness information if caching read versionspublic <T> T run(@Nonnull Function<? super FDBRecordContext,? extends T> retriable)
FDBDatabase
with retry logic.
This creates a new runner
and closes it when complete.
To better control the lifetime / sharing of the runner, create it separately.T
- return type of function to runretriable
- the database operation to run transactionallynewRunner()
,
FDBDatabaseRunner.run(java.util.function.Function<? super com.apple.foundationdb.record.provider.foundationdb.FDBRecordContext, ? extends T>)
public <T> T run(@Nullable FDBStoreTimer timer, @Nullable Map<String,String> mdcContext, @Nonnull Function<? super FDBRecordContext,? extends T> retriable)
FDBDatabase
with retry logic.
This creates a new runner
and closes it when complete.
To better control the lifetime / sharing of the runner, create it separately.T
- return type of function to runtimer
- the timer to use for instrumentationmdcContext
- logger context to set in running threadsretriable
- the database operation to run transactionallynewRunner(FDBStoreTimer, Map)
,
FDBDatabaseRunner.run(java.util.function.Function<? super com.apple.foundationdb.record.provider.foundationdb.FDBRecordContext, ? extends T>)
public <T> T run(@Nullable FDBStoreTimer timer, @Nullable Map<String,String> mdcContext, @Nullable FDBDatabase.WeakReadSemantics weakReadSemantics, @Nonnull Function<? super FDBRecordContext,? extends T> retriable)
FDBDatabase
with retry logic.
This will run the function and commit the transaction associated with it until the
function either completes successfully or encounters a non-retriable error. An error
is considered retriable if it is a RecordCoreRetriableTransactionException
,
a retriable FDBException
, or is an exception caused by a retriable error.
The function will not be run more than the number of times specified by
FDBDatabaseFactory.getMaxAttempts()
.
It also important that the function provided is idempotent as the function
may be applied multiple times successfully if the transaction commit returns
a commit_unknown_result
error.
If this FDBDatabase
is configured to cache read versions, one
can specify that this function should use the cached version by supplying
a non-null
FDBDatabase.WeakReadSemantics
object to the
weakReadSemantics
parameter. Each time that the function is
retried, the cached read version is checked again, so each retry
might get different read versions.
This is a blocking call, and this function will not return until the database
has synchronously returned a response as to the success or failure of this
operation. If one wishes to achieve the same functionality in a non-blocking
manner, see runAsync()
.
runner
and closes it when complete.
To better control the lifetime / sharing of the runner, create it separately.T
- return type of function to runtimer
- the timer to use for instrumentationmdcContext
- logger context to set in running threadsweakReadSemantics
- allowable staleness parameters if caching read versionsretriable
- the database operation to run transactionallynewRunner(FDBStoreTimer, Map, WeakReadSemantics)
,
FDBDatabaseRunner.run(java.util.function.Function<? super com.apple.foundationdb.record.provider.foundationdb.FDBRecordContext, ? extends T>)
@Nonnull @API(value=MAINTAINED) public <T> CompletableFuture<T> runAsync(@Nonnull Function<? super FDBRecordContext,CompletableFuture<? extends T>> retriable)
FDBDatabase
with retry logic.
This creates a new runner
and closes it when complete.
To better control the lifetime / sharing of the runner, create it separately.T
- return type of function to runretriable
- the database operation to run transactionallynewRunner()
,
FDBDatabaseRunner.runAsync(java.util.function.Function<? super com.apple.foundationdb.record.provider.foundationdb.FDBRecordContext, java.util.concurrent.CompletableFuture<? extends T>>)
@Nonnull @API(value=MAINTAINED) public <T> CompletableFuture<T> runAsync(@Nullable FDBStoreTimer timer, @Nullable Map<String,String> mdcContext, @Nonnull Function<? super FDBRecordContext,CompletableFuture<? extends T>> retriable)
FDBDatabase
with retry logic.
This creates a new runner
and closes it when complete.
To better control the lifetime / sharing of the runner, create it separately.T
- return type of function to runtimer
- the timer to use for instrumentationmdcContext
- logger context to set in running threadsretriable
- the database operation to run transactionallynewRunner(FDBStoreTimer, Map)
,
FDBDatabaseRunner.runAsync(java.util.function.Function<? super com.apple.foundationdb.record.provider.foundationdb.FDBRecordContext, java.util.concurrent.CompletableFuture<? extends T>>)
@Nonnull @API(value=MAINTAINED) public <T> CompletableFuture<T> runAsync(@Nullable FDBStoreTimer timer, @Nullable Map<String,String> mdcContext, @Nullable FDBDatabase.WeakReadSemantics weakReadSemantics, @Nonnull Function<? super FDBRecordContext,CompletableFuture<? extends T>> retriable)
FDBDatabase
with retry logic.
This will run the function and commit the transaction associated with it until the
function either completes successfully or encounters a non-retriable error. An error
is considered retriable if it is a RecordCoreRetriableTransactionException
,
a retriable FDBException
, or is an exception caused by a retriable error.
The function will not be run more than the number of times specified by
FDBDatabaseFactory.getMaxAttempts()
.
It also important that the function provided is idempotent as the function
may be applied multiple times successfully if the transaction commit returns
a commit_uknown_result
error.
If this FDBDatabase
is configured to cache read versions, one
can specify that this function should use the cached version by supplying
a non-null
FDBDatabase.WeakReadSemantics
object to the
weakReadSemantics
parameter. Each time that the function is
retried, the cached read version is checked again, so each retry
might get different read versions.
This is a non-blocking call, and this function will return immediately with
a future that will not be ready until the database has returned a response as
to the success or failure of this operation. If one wishes to achieve the same
functionality in a blocking manner, see run()
.
runner
and closes it when complete.
To better control the lifetime / sharing of the runner, create it separately.T
- return type of function to runtimer
- the timer to use for instrumentationmdcContext
- logger context to set in running threadsweakReadSemantics
- allowable staleness information if caching read versionsretriable
- the database operation to run transactionallynewRunner(FDBStoreTimer, Map, WeakReadSemantics)
,
FDBDatabaseRunner.runAsync(java.util.function.Function<? super com.apple.foundationdb.record.provider.foundationdb.FDBRecordContext, java.util.concurrent.CompletableFuture<? extends T>>)
public boolean hasAsyncToSyncTimeout()
@Nullable public org.apache.commons.lang3.tuple.Pair<Long,TimeUnit> getAsyncToSyncTimeout(StoreTimer.Wait event)
@Nullable public Function<StoreTimer.Wait,org.apache.commons.lang3.tuple.Pair<Long,TimeUnit>> getAsyncToSyncTimeout()
public void setAsyncToSyncTimeout(@Nullable Function<StoreTimer.Wait,org.apache.commons.lang3.tuple.Pair<Long,TimeUnit>> asyncToSyncTimeout)
public void setAsyncToSyncTimeout(long asyncToSyncTimeout, @Nonnull TimeUnit asyncToSyncTimeoutUnit)
public void clearAsyncToSyncTimeout()
public void setAsyncToSyncExceptionMapper(@Nonnull FDBDatabase.ExceptionMapper asyncToSyncExceptionMapper)
protected RuntimeException mapAsyncToSyncException(@Nonnull Throwable ex)
@Nullable public <T> T asyncToSync(@Nullable FDBStoreTimer timer, StoreTimer.Wait event, @Nonnull CompletableFuture<T> async)
public <T> T join(CompletableFuture<T> future)
asyncToSync()
uses to validate that the operation
isn't blocking in an asynchronous context.T
- the type of the value produced by the futurefuture
- the future to be completedpublic <T> T joinNow(CompletableFuture<T> future)
BlockingInAsyncDetection
behavior is set
to throw an exception on incomplete futures and otherwise just log that future was waited on.T
- the type of the value produced by the futurefuture
- the future that should already be completedpublic <T> T get(CompletableFuture<T> future) throws InterruptedException, ExecutionException
asyncToSync()
uses to validate that the operation
isn't blocking in an asynchronous context.T
- the type of the value produced by the futurefuture
- the future to be completedCancellationException
- if the future was cancelledExecutionException
- if the future completed exceptionallyInterruptedException
- if the current thread was interrupted@API(value=INTERNAL) public BlockingInAsyncDetection getBlockingInAsyncDetection()
protected CompletableFuture<Void> injectLatency(FDBLatencySource fdbLatencySource)
FDBDatabaseFactory.setLatencyInjector(Function)
).fdbLatencySource
- the call for which the latency is to be computedpublic CompletableFuture<Tuple> loadBoundaryKeys(@Nonnull FDBTransactionContext context, Tuple key)