FDBDatabaseFactory (fdb-record-layer-core 2.8.97.0 API)

java.lang.Object
- com.apple.foundationdb.record.provider.foundationdb.FDBDatabaseFactory

```
@API(value=STABLE)
public class FDBDatabaseFactory
extends Object
```
A singleton maintaining a list of FDBDatabase instances, indexed by their cluster file location.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DEFAULT_DIRECTORY_CACHE_SIZE` The default number of entries that is to be cached, per database, from `LocatableResolver` retrieval requests.
`protected static Function<FDBLatencySource,Long>`	`DEFAULT_LATENCY_INJECTOR`

Constructor Summary

Constructors
Constructor and Description

FDBDatabaseFactory()

Constructors
Constructor and Description
`FDBDatabaseFactory()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`void`	`clearLatencyInjector()` Removes any previously installed latency injector.
`protected Supplier<BlockingInAsyncDetection>`	`getBlockingInAsyncDetectionSupplier()`
`FDBDatabase`	`getDatabase()`
`FDBDatabase`	`getDatabase(String clusterFile)`
`String`	`getDatacenterId()`
`int`	`getDirectoryCacheSize()`
`Executor`	`getExecutor()`
`long`	`getInitialDelayMillis()` Gets the delay ceiling (in milliseconds) that will be applied between attempts to run a transactional database operation.
`Function<FDBLatencySource,Long>`	`getLatencyInjector()` Returns the current latency injector.
`FDBLocalityProvider`	`getLocalityProvider()` Get the locality provider that is used to discover the server location of the keys.
`int`	`getMaxAttempts()` Gets the maximum number of attempts for a database to make when running a retriable transactional operation.
`long`	`getMaxDelayMillis()` Gets the maximum delay (in milliseconds) that will be applied between attempts to run a transactional database operation.
`Executor`	`getNetworkExecutor()`
`long`	`getReverseDirectoryMaxMillisPerTransaction()`
`int`	`getReverseDirectoryRowsPerTransaction()`
`long`	`getStateRefreshTimeMillis()`
`FDBRecordStoreStateCacheFactory`	`getStoreStateCacheFactory()` Get the store state cache factory.
`boolean`	`getTrackLastSeenVersion()`
`Supplier<Boolean>`	`getTransactionIsTracedSupplier()`
`protected FDB`	`initFDB()`
`static FDBDatabaseFactory`	`instance()`
`boolean`	`isUnclosedWarning()`
`protected Executor`	`newContextExecutor()`
`void`	`setBlockingInAsyncDetection(BlockingInAsyncDetection behavior)` Controls if calls to `FDBDatabase#asyncToSync(FDBStoreTimer, FDBStoreTimer.Wait, CompletableFuture)` or `FDBRecordContext#asyncToSync(FDBStoreTimer.Wait, CompletableFuture)` will attempt to detect when they are being called from within an asynchronous context and how they should react to this fact when they are.
`void`	`setBlockingInAsyncDetection(Supplier<BlockingInAsyncDetection> supplier)` Provides a supplier that controls if calls to `FDBDatabase#asyncToSync(FDBStoreTimer, FDBStoreTimer.Wait, CompletableFuture)` or `FDBRecordContext#asyncToSync(FDBStoreTimer.Wait, CompletableFuture)` will attempt to detect when they are being called from within an asynchronous context and how they should react to this fact when they are.
`void`	`setContextExecutor(Function<Executor,Executor> contextExecutor)` Provides a function that will be invoked when a `FDBRecordContext` is created, taking as input the `Executor` that is configured for the database, returning the `Executor` that will be used to execute all asynchronous completions produced from the `FDBRecordContext`.
`void`	`setDatacenterId(String datacenterId)`
`void`	`setDirectoryCacheSize(int directoryCacheSize)` Sets the number of directory layer entries that will be cached for each database that is produced by the factory.
`void`	`setExecutor(Executor executor)` Sets the executor that will be used for all asynchronous tasks that are produced from operations initiated from databases produced from this factory.
`void`	`setInitialDelayMillis(long initialDelayMillis)` Sets the delay ceiling (in milliseconds) that will be applied between attempts to run a transactional database operation.
`void`	`setLatencyInjector(Function<FDBLatencySource,Long> latencyInjector)` Provides a function that computes a latency that should be injected into a specific FDB operation.
`void`	`setLocalityProvider(FDBLocalityProvider localityProvider)` Set the locality provider that is used to discover the server location of the keys.
`void`	`setMaxAttempts(int maxAttempts)` Sets the maximum number of attempts for a database to make when running a retriable transactional operation.
`void`	`setMaxDelayMillis(long maxDelayMillis)` Sets the maximum delay (in milliseconds) that will be applied between attempts to run a transactional database operation.
`void`	`setNetworkExecutor(Executor networkExecutor)`
`void`	`setReverseDirectoryMaxMillisPerTransaction(long millisPerTransaction)` When a reverse directory lookup is performed from a `FDBReverseDirectoryCache` and an entry is not found in the cache and, thus, the directory layer must be scanned to find it, this property determines how many milliseconds may be spent scanning the cache within the context of a single transaction, before the transaction is closed and re-opened in order to avoid a `past_version`.
`void`	`setReverseDirectoryRowsPerTransaction(int rowsPerTransaction)` When a reverse directory lookup is performed from a `FDBReverseDirectoryCache` and an entry is not found in the cache and, thus, the directory layer must be scanned to find it, this property determines how many rows will be scanned within the context of a single transaction, before the transaction is closed and re-opened in order to avoid a `past_version`.
`void`	`setStateRefreshTimeMillis(long stateRefreshTimeMillis)` Set the refresh time for the cached `LocatableResolver` state.
`void`	`setStoreStateCacheFactory(FDBRecordStoreStateCacheFactory storeStateCacheFactory)` Set the store state cache factory.
`void`	`setTrace(String traceDirectory, String traceLogGroup)` Configure the client trace directory and log group.
`void`	`setTraceFormat(FDBTraceFormat traceFormat)` Set the output format for the client trace logs.
`void`	`setTrackLastSeenVersion(boolean trackLastSeenVersion)`
`void`	`setTransactionIsTracedSupplier(Supplier<Boolean> transactionIsTracedSupplier)` Use transactionIsTracedSupplier to control whether a newly created transaction should be traced or not.
`void`	`setUnclosedWarning(boolean unclosedWarning)`
`void`	`shutdown()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_LATENCY_INJECTOR
```
protected static final Function<FDBLatencySource,Long> DEFAULT_LATENCY_INJECTOR
```
  - DEFAULT_DIRECTORY_CACHE_SIZE
```
public static final int DEFAULT_DIRECTORY_CACHE_SIZE
```
    The default number of entries that is to be cached, per database, from LocatableResolver retrieval requests.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - FDBDatabaseFactory
```
public FDBDatabaseFactory()
```
- Method Detail
  - instance
```
@Nonnull
public static FDBDatabaseFactory instance()
```
  - initFDB
```
protected FDB initFDB()
```
  - getNetworkExecutor
```
@Nonnull
public Executor getNetworkExecutor()
```
  - setNetworkExecutor
```
public void setNetworkExecutor(@Nonnull
                               Executor networkExecutor)
```
  - getExecutor
```
@Nonnull
public Executor getExecutor()
```
  - setExecutor
```
public void setExecutor(@Nonnull
                        Executor executor)
```
    Sets the executor that will be used for all asynchronous tasks that are produced from operations initiated from databases produced from this factory.
    
    Parameters:
    
    executor - the executor to be used for asynchronous task completion
  - setContextExecutor
```
public void setContextExecutor(@Nonnull
                               Function<Executor,Executor> contextExecutor)
```
    Provides a function that will be invoked when a FDBRecordContext is created, taking as input the Executor that is configured for the database, returning the Executor that will be used to execute all asynchronous completions produced from the FDBRecordContext. An example use case for this function is to ensure that ThreadLocal variables that are present in the thread that creates the FDBRecordContext will be made present in the executor threads that are executing tasks.
    
    Parameters:
    
    contextExecutor - function to produce an executor to be used for all tasks executed on behalf of a specific record context
  - newContextExecutor
```
@Nonnull
protected Executor newContextExecutor()
```
  - shutdown
```
public void shutdown()
```
  - clear
```
public void clear()
```
  - isUnclosedWarning
```
public boolean isUnclosedWarning()
```
  - setUnclosedWarning
```
public void setUnclosedWarning(boolean unclosedWarning)
```
  - setTrace
```
public void setTrace(@Nullable
                     String traceDirectory,
                     @Nullable
                     String traceLogGroup)
```
    Configure the client trace directory and log group. If set, this will configure the native client to emit trace logs with important metrics and instrumentation. As this information is useful for monitoring FoundationDB client behavior, it is generally recommended that the user set this option in production environments.
    The logs will be placed in the directory on the local filesystem specified by the traceDirectory parameter. If the traceLogGroup is set to a non-null value, each log message will have a LogGroup field associated with it that is set to the parameter's value. This can be used to associate log messages from related processes together.
    
    This method should be called prior to the first time this factory is used to produce an FDBDatabase. The factory will configure the client in a manner consistent with the passed parameters the first time a database is needed, and subsequent calls to this method will have no effect.
    
    Parameters:
    
    traceDirectory - the directory in which to write trace log files or null to disable writing logs
    
    traceLogGroup - the value to set the log group field to in each message of null to set no group
  - setTraceFormat
```
public void setTraceFormat(@Nonnull
                           FDBTraceFormat traceFormat)
```
    Set the output format for the client trace logs. This only will have any effect if setTrace(String, String) is also called. If that method is called (i.e., if trace logs are enabled), then this will be used to configure what the output format of trace log files should be. See FDBTraceFormat for more details on what options are available.
    This method should be called prior to the first time this factory is used to produce an FDBDatabase. The factory will configure the client in a manner consistent with the passed parameters the first time a database is needed, and subsequent calls to this method will have no effect.
    
    Parameters:
    
    traceFormat - the output format for client trace logs
    
    See Also:
    
    setTrace(String, String), FDBTraceFormat
  - getDirectoryCacheSize
```
public int getDirectoryCacheSize()
```
  - getTrackLastSeenVersion
```
public boolean getTrackLastSeenVersion()
```
  - getDatacenterId
```
public String getDatacenterId()
```
  - setDirectoryCacheSize
```
public void setDirectoryCacheSize(int directoryCacheSize)
```
    Sets the number of directory layer entries that will be cached for each database that is produced by the factory. Changing this value after databases have been created will result in each database having its existing entries discarded and the cache size adjusted to the provided value.
    Each FDBDatabase maintains a cache of entries that have been retrieved by any instance of a LocatableResolver using that database. Thus, this cache is shared across all resolvers (it should be noted entries in this cache are segregated by resolver and treated as distinct, ensuring that the value for a directory entry from one resolver will not be returned to another resolver even if they share the same key).
    
    Parameters:
    
    directoryCacheSize - the new directory cache size
  - setTrackLastSeenVersion
```
public void setTrackLastSeenVersion(boolean trackLastSeenVersion)
```
  - setDatacenterId
```
public void setDatacenterId(String datacenterId)
```
  - getMaxAttempts
```
public int getMaxAttempts()
```
    Gets the maximum number of attempts for a database to make when running a retriable transactional operation. This is used by FDBDatabase.run() and FDBDatabase.runAsync() to limit the number of attempts that an operation is retried. The default value is 10.
    
    Returns:
    
    the maximum number of times to run a transactional database operation
  - setMaxAttempts
```
public void setMaxAttempts(int maxAttempts)
```
    Sets the maximum number of attempts for a database to make when running a retriable transactional operation. This is used by FDBDatabase.run() and FDBDatabase.runAsync() to limit the number of attempts that an operation is retried. The default value is 10.
    
    Parameters:
    
    maxAttempts - the maximum number of times to run a transactional database operation
    
    Throws:
    
    IllegalArgumentException - if a non-positive number is given
  - getMaxDelayMillis
```
public long getMaxDelayMillis()
```
    Gets the maximum delay (in milliseconds) that will be applied between attempts to run a transactional database operation. This is used within FDBDatabase.run() and FDBDatabase.runAsync() to limit the time spent between successive attempts at completing a database operation. The default value is 1000 so that there will not be more than 1 second between attempts.
    
    Returns:
    
    the maximum delay between attempts when retrying operations
  - setMaxDelayMillis
```
public void setMaxDelayMillis(long maxDelayMillis)
```
    Sets the maximum delay (in milliseconds) that will be applied between attempts to run a transactional database operation. This is used within FDBDatabase.run() and FDBDatabase.runAsync() to limit the time spent between successive attempts at completing a database operation. The default is 1000 so that there will not be more than 1 second between attempts.
    
    Parameters:
    
    maxDelayMillis - the maximum delay between attempts when retrying operations
    
    Throws:
    
    IllegalArgumentException - if the value is negative or less than the minimum delay
  - getInitialDelayMillis
```
public long getInitialDelayMillis()
```
    Gets the delay ceiling (in milliseconds) that will be applied between attempts to run a transactional database operation. This is used within FDBDatabase.run() and FDBDatabase.runAsync() to determine how long to wait between the first and second attempts at running a database operation. The exponential backoff algorithm will choose an amount of time to wait between zero and the initial delay, and will use that value each successive iteration to determine how long that wait should be. The default value is 10 milliseconds.
    
    Returns:
    
    the delay ceiling between the first and second attempts at running a database operation
  - setInitialDelayMillis
```
public void setInitialDelayMillis(long initialDelayMillis)
```
    Sets the delay ceiling (in milliseconds) that will be applied between attempts to run a transactional database operation. This is used within FDBDatabase.run() and FDBDatabase.runAsync() to determine how long to wait between the first and second attempts at running a database operation. The exponential backoff algorithm will choose an amount of time to wait between zero and the initial delay, and will use that value each successive iteration to determine how long that wait should be. The default value is 10 milliseconds.
    
    Parameters:
    
    initialDelayMillis - the delay ceiling between the first and second attempts at running a database operation
    
    Throws:
    
    IllegalArgumentException - if the value is negative or greater than the maximum delay
  - setReverseDirectoryRowsPerTransaction
```
public void setReverseDirectoryRowsPerTransaction(int rowsPerTransaction)
```
    When a reverse directory lookup is performed from a FDBReverseDirectoryCache and an entry is not found in the cache and, thus, the directory layer must be scanned to find it, this property determines how many rows will be scanned within the context of a single transaction, before the transaction is closed and re-opened in order to avoid a past_version.
    
    Parameters:
    
    rowsPerTransaction - the number of rows to scan within the context of a single transaction
  - getReverseDirectoryRowsPerTransaction
```
public int getReverseDirectoryRowsPerTransaction()
```
  - setReverseDirectoryMaxMillisPerTransaction
```
public void setReverseDirectoryMaxMillisPerTransaction(long millisPerTransaction)
```
    When a reverse directory lookup is performed from a FDBReverseDirectoryCache and an entry is not found in the cache and, thus, the directory layer must be scanned to find it, this property determines how many milliseconds may be spent scanning the cache within the context of a single transaction, before the transaction is closed and re-opened in order to avoid a past_version.
    
    Parameters:
    
    millisPerTransaction - the number of miliseconds to spend scanning
  - getReverseDirectoryMaxMillisPerTransaction
```
public long getReverseDirectoryMaxMillisPerTransaction()
```
  - setTransactionIsTracedSupplier
```
public void setTransactionIsTracedSupplier(Supplier<Boolean> transactionIsTracedSupplier)
```
    Use transactionIsTracedSupplier to control whether a newly created transaction should be traced or not. Traced transactions are used to identify and profile unclosed transactions. In order to trace the source of a leaked transaction, it is necessary to capture a stack trace at the point the transaction is created which is a rather expensive operation, so this should either be disabled in a production environment or the supplier to return true for only a very small subset of transactions.
    
    Parameters:
    
    transactionIsTracedSupplier - a supplier which should return true for creating TracedTransactions or false for creating normal Transactions
  - getTransactionIsTracedSupplier
```
public Supplier<Boolean> getTransactionIsTracedSupplier()
```
  - setBlockingInAsyncDetection
```
public void setBlockingInAsyncDetection(@Nonnull
                                        BlockingInAsyncDetection behavior)
```
    Controls if calls to FDBDatabase#asyncToSync(FDBStoreTimer, FDBStoreTimer.Wait, CompletableFuture) or FDBRecordContext#asyncToSync(FDBStoreTimer.Wait, CompletableFuture) will attempt to detect when they are being called from within an asynchronous context and how they should react to this fact when they are. Note that the process of performing this detection is quite expensive, so running with detection enabled in not recommended for environments other than testing.
    
    Parameters:
    
    behavior - the blocking desired blocking detection behavior (see BlockingInAsyncDetection)
  - setBlockingInAsyncDetection
```
public void setBlockingInAsyncDetection(@Nonnull
                                        Supplier<BlockingInAsyncDetection> supplier)
```
    Provides a supplier that controls if calls to FDBDatabase#asyncToSync(FDBStoreTimer, FDBStoreTimer.Wait, CompletableFuture) or FDBRecordContext#asyncToSync(FDBStoreTimer.Wait, CompletableFuture) will attempt to detect when they are being called from within an asynchronous context and how they should react to this fact when they are. Because such detection is quite expensive, it is suggested that it is either BlockingInAsyncDetection.DISABLED for anything other than testing environments or that the supplier randomly chooses a small sample rate in which detection should be enabled.
    
    Parameters:
    
    supplier - a supplier that produces the blocking desired blocking detection behavior (see BlockingInAsyncDetection)
  - getBlockingInAsyncDetectionSupplier
```
@Nonnull
protected Supplier<BlockingInAsyncDetection> getBlockingInAsyncDetectionSupplier()
```
  - setLatencyInjector
```
public void setLatencyInjector(@Nonnull
                               Function<FDBLatencySource,Long> latencyInjector)
```
    Provides a function that computes a latency that should be injected into a specific FDB operation. The provided function takes a FDBLatencySource as input and returns the number of milliseconds delay that should be injected before the operation completes. Returning a value of zero or less indicates that no delay should be injected.
    Latency injection can be useful for simulating environments in which FDB is under stress or in a configuration in which latency is inherent in its operation.
    
    Parameters:
    
    latencyInjector - a function computing the latency to be injected into an operation
  - getLatencyInjector
```
public Function<FDBLatencySource,Long> getLatencyInjector()
```
    Returns the current latency injector.
    
    Returns:
    
    the current latency injector
  - clearLatencyInjector
```
public void clearLatencyInjector()
```
    Removes any previously installed latency injector.
  - getStateRefreshTimeMillis
```
public long getStateRefreshTimeMillis()
```
  - setStateRefreshTimeMillis
```
public void setStateRefreshTimeMillis(long stateRefreshTimeMillis)
```
    Set the refresh time for the cached LocatableResolver state. Defaults to seconds.
    
    Parameters:
    
    stateRefreshTimeMillis - time to set, in milliseconds
  - getStoreStateCacheFactory
```
@API(value=EXPERIMENTAL)
 @Nonnull
public FDBRecordStoreStateCacheFactory getStoreStateCacheFactory()
```
    Get the store state cache factory. Each FDBDatabase produced by this FDBDatabaseFactory will be initialized with an FDBRecordStoreStateCache from this cache factory. By default, the factory is a PassThroughRecordStoreStateCacheFactory which means that the record store state information is never cached.
    
    Returns:
    
    the factory of FDBRecordStoreStateCaches used when initializing FDBDatabases
  - setStoreStateCacheFactory
```
@API(value=EXPERIMENTAL)
public void setStoreStateCacheFactory(@Nonnull
                                                               FDBRecordStoreStateCacheFactory storeStateCacheFactory)
```
    Set the store state cache factory. Each FDBDatabase produced by this FDBDatabaseFactory will be initialized with an FDBRecordStoreStateCache from the cache factory provided.
    
    Parameters:
    
    storeStateCacheFactory - a factory of FDBRecordStoreStateCaches to use when initializing FDBDatabases
    
    See Also:
    
    FDBRecordStoreStateCache
  - getDatabase
```
@Nonnull
public FDBDatabase getDatabase(@Nullable
                                        String clusterFile)
```
  - getDatabase
```
@Nonnull
public FDBDatabase getDatabase()
```
  - getLocalityProvider
```
@Nonnull
public FDBLocalityProvider getLocalityProvider()
```
    Get the locality provider that is used to discover the server location of the keys.
    
    Returns:
    
    the installed locality provider
  - setLocalityProvider
```
public void setLocalityProvider(@Nonnull
                                FDBLocalityProvider localityProvider)
```
    Set the locality provider that is used to discover the server location of the keys.
    
    Parameters:
    
    localityProvider - the locality provider
    
    See Also:
    
    FDBLocalityUtil

Class FDBDatabaseFactory

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_LATENCY_INJECTOR

DEFAULT_DIRECTORY_CACHE_SIZE

Constructor Detail

FDBDatabaseFactory

Method Detail

instance

initFDB

getNetworkExecutor

setNetworkExecutor

getExecutor

setExecutor

setContextExecutor

newContextExecutor

shutdown

clear

isUnclosedWarning

setUnclosedWarning

setTrace

setTraceFormat

getDirectoryCacheSize

getTrackLastSeenVersion

getDatacenterId

setDirectoryCacheSize

setTrackLastSeenVersion

setDatacenterId

getMaxAttempts

setMaxAttempts

getMaxDelayMillis

setMaxDelayMillis

getInitialDelayMillis

setInitialDelayMillis

setReverseDirectoryRowsPerTransaction

getReverseDirectoryRowsPerTransaction

setReverseDirectoryMaxMillisPerTransaction

getReverseDirectoryMaxMillisPerTransaction

setTransactionIsTracedSupplier

getTransactionIsTracedSupplier

setBlockingInAsyncDetection

setBlockingInAsyncDetection

getBlockingInAsyncDetectionSupplier

setLatencyInjector

getLatencyInjector

clearLatencyInjector

getStateRefreshTimeMillis

setStateRefreshTimeMillis

getStoreStateCacheFactory

setStoreStateCacheFactory

getDatabase

getDatabase

getLocalityProvider

setLocalityProvider