Configuration Options

/**
 * Get network options for configuration.
 * Options must be set before network starts.
 * 
 * Returns:
 * NetworkOptions - Network configuration interface
 */
NetworkOptions FDB.options();

// Enable trace logging to directory
void NetworkOptions.setTraceEnable(String traceDirectory);

// Set maximum size of single trace file in bytes
void NetworkOptions.setTraceRollSize(long bytes);

// Set maximum total size of all trace files in bytes
void NetworkOptions.setTraceMaxLogsSize(long bytes);

// Set log group attribute for all trace events
void NetworkOptions.setTraceLogGroup(String logGroup);

// Set trace file format (xml or json)
void NetworkOptions.setTraceFormat(String format);

// Set clock source for traces (now or realtime)
void NetworkOptions.setTraceClockSource(String source);

// Set identifier included in trace file names
void NetworkOptions.setTraceFileIdentifier(String identifier);

// Use same base trace file name for all client threads
void NetworkOptions.setTraceShareAmongClientThreads();

// Initialize trace files on network setup
void NetworkOptions.setTraceInitializeOnSetup();

// Set suffix for partially written log files
void NetworkOptions.setTracePartialFileSuffix(String suffix);

FDB fdb = FDB.selectAPIVersion(740);

// Enable tracing
fdb.options().setTraceEnable("/var/log/fdb-traces");
fdb.options().setTraceFormat("json");
fdb.options().setTraceRollSize(10_000_000);  // 10MB per file
fdb.options().setTraceMaxLogsSize(100_000_000);  // 100MB total
fdb.options().setTraceLogGroup("myapp");

// Now start network
Database db = fdb.open();

// Set certificate chain from bytes
void NetworkOptions.setTLSCertBytes(byte[] certBytes);

// Set certificate chain from file
void NetworkOptions.setTLSCertPath(String certPath);

// Set private key from bytes
void NetworkOptions.setTLSKeyBytes(byte[] keyBytes);

// Set private key from file
void NetworkOptions.setTLSKeyPath(String keyPath);

// Set CA bundle from bytes
void NetworkOptions.setTLSCaBytes(byte[] caBytes);

// Set CA bundle from file
void NetworkOptions.setTLSCaPath(String caPath);

// Set password for encrypted private key
void NetworkOptions.setTLSPassword(String password);

// Set peer certificate verification criteria
void NetworkOptions.setTLSVerifyPeers(byte[] verificationPattern);

// Prevent non-TLS connections
void NetworkOptions.setTLSDisablePlaintextConnection();

// Configure TLS
fdb.options().setTLSCertPath("/etc/fdb/client.pem");
fdb.options().setTLSKeyPath("/etc/fdb/client-key.pem");
fdb.options().setTLSCaPath("/etc/fdb/ca-bundle.crt");
fdb.options().setTLSVerifyPeers("S.CN=FDB".getBytes());
fdb.options().setTLSDisablePlaintextConnection();

// Disable multi-version client API
void NetworkOptions.setDisableMultiVersionClientApi();

// Add external client library
void NetworkOptions.setExternalClientLibrary(String path);

// Add directory containing client libraries
void NetworkOptions.setExternalClientDirectory(String path);

// Disable local client
void NetworkOptions.setDisableLocalClient();

// Spawn multiple threads per client version
void NetworkOptions.setClientThreadsPerVersion(long threads);

// Enable callbacks on external threads
void NetworkOptions.setCallbacksOnExternalThreads();

// Retain copies of external client libraries
void NetworkOptions.setRetainClientLibraryCopies();

// Ignore failures loading external clients
void NetworkOptions.setIgnoreExternalClientFailures();

// Disable client bypass for GRV caching
void NetworkOptions.setDisableClientBypass();

// Set internal tuning knob
void NetworkOptions.setKnob(String knobName);

// Disable client statistics logging
void NetworkOptions.setDisableClientStatisticsLogging();

// Enable run loop profiling
void NetworkOptions.setEnableRunLoopProfiling();

// Set client temporary directory
void NetworkOptions.setClientTmpDir(String path);

// Set distributed tracer type
void NetworkOptions.setDistributedClientTracer(String tracerType);

/**
 * Get database options for configuration.
 * 
 * Returns:
 * DatabaseOptions - Database configuration interface
 */
DatabaseOptions Database.options();

// Set size of location cache (default: 100000)
void DatabaseOptions.setLocationCacheSize(long size);

// Set maximum outstanding watches (default: 10000, max: 1000000)
void DatabaseOptions.setMaxWatches(long maxWatches);

// Set machine ID for location-aware load balancing
void DatabaseOptions.setMachineId(String hexId);

// Set datacenter ID for location-aware load balancing
void DatabaseOptions.setDatacenterId(String datacenterId);

// Set default transaction timeout in milliseconds
void DatabaseOptions.setTransactionTimeout(long timeoutMs);

// Set default transaction retry limit
void DatabaseOptions.setTransactionRetryLimit(long retries);

// Set default transaction max retry delay in milliseconds
void DatabaseOptions.setTransactionMaxRetryDelay(long delayMs);

// Set default transaction size limit in bytes
void DatabaseOptions.setTransactionSizeLimit(long bytes);

// Enable causal read risky for all transactions
void DatabaseOptions.setTransactionCausalReadRisky();

// Set default transaction logging max field length
void DatabaseOptions.setTransactionLoggingMaxFieldLength(long length);

// Enable automatic idempotency for all transactions
void DatabaseOptions.setTransactionAutomaticIdempotency();

// Enable bypass unreadable for all transactions
void DatabaseOptions.setTransactionBypassUnreadable();

// Disable used during commit protection for all transactions
void DatabaseOptions.setTransactionUsedDuringCommitProtectionDisable();

// Enable conflicting key reporting for all transactions
void DatabaseOptions.setTransactionReportConflictingKeys();

// Enable snapshot RYW (default)
void DatabaseOptions.setSnapshotRywEnable();

// Disable snapshot RYW
void DatabaseOptions.setSnapshotRywDisable();

Database db = fdb.open();

// Configure database
db.options().setLocationCacheSize(200000);
db.options().setMaxWatches(20000);
db.options().setTransactionTimeout(10000);  // 10 second default
db.options().setTransactionRetryLimit(100);
db.options().setMachineId("machine-001");

/**
 * Get transaction options for configuration.
 * 
 * Returns:
 * TransactionOptions - Transaction configuration interface
 */
TransactionOptions Transaction.options();

// Allow duplicate commits on fault (risky)
void TransactionOptions.setCausalWriteRisky();

// Read version may not be latest on fault+clock issue
void TransactionOptions.setCausalReadRisky();

// Disable causal read consistency
void TransactionOptions.setCausalReadDisable();

// Next write won't generate write conflict range
void TransactionOptions.setNextWriteNoWriteConflictRange();

// Report which keys are conflicting
void TransactionOptions.setReportConflictingKeys();

// Disable read-your-writes
void TransactionOptions.setReadYourWritesDisable();

// Enable server-side read cache (default)
void TransactionOptions.setReadServerSideCacheEnable();

// Disable server-side read cache
void TransactionOptions.setReadServerSideCacheDisable();

// Set normal read priority (default)
void TransactionOptions.setReadPriorityNormal();

// Set low read priority
void TransactionOptions.setReadPriorityLow();

// Set high read priority
void TransactionOptions.setReadPriorityHigh();

// System immediate priority (highest)
void TransactionOptions.setPrioritySystemImmediate();

// Batch priority (lowest, throttled)
void TransactionOptions.setPriorityBatch();

// Add throttling tag
void TransactionOptions.setTag(String tag);

// Add auto-throttle tag
void TransactionOptions.setAutoThrottleTag(String tag);

// Allow access to system keys (0xFF prefix)
void TransactionOptions.setAccessSystemKeys();

// Allow read-only access to system keys
void TransactionOptions.setReadSystemKeys();

// Allow raw key-space access in tenant mode
void TransactionOptions.setRawAccess();

// Lock-aware transaction
void TransactionOptions.setLockAware();

// Read lock-aware transaction
void TransactionOptions.setReadLockAware();

// Set transaction timeout in milliseconds
void TransactionOptions.setTimeout(long timeoutMs);

// Set retry limit (-1 for unlimited)
void TransactionOptions.setRetryLimit(long limit);

// Set maximum retry delay in milliseconds
void TransactionOptions.setMaxRetryDelay(long delayMs);

// Set transaction size limit in bytes
void TransactionOptions.setSizeLimit(long bytes);

// Set transaction identifier for tracing
void TransactionOptions.setDebugTransactionIdentifier(String identifier);

// Enable transaction logging
void TransactionOptions.setLogTransaction();

// Set max field length for logged keys/values
void TransactionOptions.setTransactionLoggingMaxFieldLength(long length);

// Enable debug retry logging
void TransactionOptions.setDebugRetryLogging(String transactionName);

// Enable server request tracing
void TransactionOptions.setServerRequestTracing();

// Include port numbers in addresses (deprecated - enabled by default since API 630)
@Deprecated void TransactionOptions.setIncludePortInAddress();

// Enable snapshot read-your-writes (default)
void TransactionOptions.setSnapshotRywEnable();

// Disable snapshot read-your-writes
void TransactionOptions.setSnapshotRywDisable();

// Bypass unreadable versionstamp sections
void TransactionOptions.setBypassUnreadable();

// Use cached GRV from database context
void TransactionOptions.setUseGrvCache();

// Disable used-during-commit protection
void TransactionOptions.setUsedDuringCommitProtectionDisable();

// Enable special key space relaxed mode
void TransactionOptions.setSpecialKeySpaceRelaxed();

// Enable writes to special key space
void TransactionOptions.setSpecialKeySpaceEnableWrites();

// Set idempotency ID
void TransactionOptions.setIdempotencyId(String id);

// Enable automatic idempotency
void TransactionOptions.setAutomaticIdempotency();

// Set authorization token
void TransactionOptions.setAuthorizationToken(String token);

// Enable expensive clear cost estimation
void TransactionOptions.setExpensiveClearCostEstimationEnable();

// Bypass storage quota enforcement
void TransactionOptions.setBypassStorageQuota();

// Set span parent for tracing
void TransactionOptions.setSpanParent(byte[] spanContext);

// Configure transaction for low-priority batch work
db.run(tr -> {
    tr.options().setPriorityBatch();
    tr.options().setTimeout(60000);  // 60 seconds
    tr.options().setTag("batch_import");
    
    // Perform batch operations
    return null;
});

// High-priority transaction with system key access
db.run(tr -> {
    tr.options().setPrioritySystemImmediate();
    tr.options().setAccessSystemKeys();
    
    // System operations
    return null;
});

// Debugging transaction
db.run(tr -> {
    tr.options().setDebugTransactionIdentifier("my-transaction-123");
    tr.options().setLogTransaction();
    tr.options().setServerRequestTracing();
    
    // Operations to debug
    return null;
});

// Performance-optimized read
db.read(tr -> {
    tr.options().setReadPriorityHigh();
    tr.options().setReadServerSideCacheDisable();
    
    // One-time read operations
    return null;
});

class NetworkOptions {
    // All methods documented above
    void setOption(int code, byte[] value);
}

class DatabaseOptions {
    // All methods documented above
    void setOption(int code, byte[] value);
}

class TransactionOptions {
    // All methods documented above
    void setOption(int code, byte[] value);
}