io.evitadb.api.configuration.ServerOptions Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of evita_api Show documentation
Show all versions of evita_api Show documentation
Module contains external API of the evitaDB.
/*
*
* _ _ ____ ____
* _____ _(_) |_ __ _| _ \| __ )
* / _ \ \ / / | __/ _` | | | | _ \
* | __/\ V /| | || (_| | |_| | |_) |
* \___| \_/ |_|\__\__,_|____/|____/
*
* Copyright (c) 2023-2024
*
* Licensed under the Business Source License, Version 1.1 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://github.com/FgForrest/evitaDB/blob/master/LICENSE
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.evitadb.api.configuration;
import io.evitadb.api.EvitaSessionContract;
import io.evitadb.api.requestResponse.data.EntityContract;
import lombok.ToString;
import javax.annotation.Nonnull;
/**
* Record contains base server wide settings for the evitaDB.
*
* @param requestThreadPool Defines limits for core thread pool that is used for serving all
* incoming requests. Threads from this pool handles all queries and
* updates up until the transaction is committed / rolled-back.
* @param transactionThreadPool Defines limits for transaction thread pool that is used for processing
* transactions when they're committed. I.e. conflict resolution,
* incorporation into trunk and replacing the used shared indexes.
* @param serviceThreadPool Defines limits for service thread pool that is used for service tasks
* such as maintenance, creating backups, restoring backups, etc.
* @param queryTimeoutInMilliseconds sets the timeout in milliseconds after which threads that are executing
* read-only session requests should timeout and cancel its execution
* @param transactionTimeoutInMilliseconds sets the timeout in milliseconds after which threads that are executing
* read-write session requests should timeout and cancel its execution
* @param closeSessionsAfterSecondsOfInactivity sets the timeout in seconds after which the session is closed
* automatically if there is no activity observed on it
* @param readOnly starts the database in full read-only mode that forbids to execute write
* operations on {@link EntityContract} level and open read-write
* {@link EvitaSessionContract}
* @param quiet when true all outputs to system console output are suppressed
* @author Jan Novotný ([email protected]), FG Forrest a.s. (c) 2022
*/
public record ServerOptions(
@Nonnull ThreadPoolOptions requestThreadPool,
@Nonnull ThreadPoolOptions transactionThreadPool,
@Nonnull ThreadPoolOptions serviceThreadPool,
long queryTimeoutInMilliseconds,
long transactionTimeoutInMilliseconds,
int closeSessionsAfterSecondsOfInactivity,
boolean readOnly,
boolean quiet
) {
public static final long DEFAULT_QUERY_TIMEOUT_IN_MILLISECONDS = 5000L;
public static final long DEFAULT_TRANSACTION_TIMEOUT_IN_MILLISECONDS = 300 * 1000L;
public static final int DEFAULT_CLOSE_SESSIONS_AFTER_SECONDS_OF_INACTIVITY = 60 * 20;
public static final boolean DEFAULT_READ_ONLY = false;
public static final boolean DEFAULT_QUIET = false;
/**
* Builder for the server options. Recommended to use to avoid binary compatibility problems in the future.
*/
public static ServerOptions.Builder builder() {
return new Builder();
}
/**
* Builder for the server options. Recommended to use to avoid binary compatibility problems in the future.
*/
public static ServerOptions.Builder builder(@Nonnull ServerOptions serverOptions) {
return new Builder(serverOptions);
}
public ServerOptions() {
this(
ThreadPoolOptions.requestThreadPoolBuilder().build(),
ThreadPoolOptions.transactionThreadPoolBuilder().build(),
ThreadPoolOptions.serviceThreadPoolBuilder().build(),
DEFAULT_QUERY_TIMEOUT_IN_MILLISECONDS,
DEFAULT_TRANSACTION_TIMEOUT_IN_MILLISECONDS,
DEFAULT_CLOSE_SESSIONS_AFTER_SECONDS_OF_INACTIVITY,
DEFAULT_READ_ONLY,
DEFAULT_QUIET
);
}
/**
* Standard builder pattern implementation.
*/
@ToString
public static class Builder {
private ThreadPoolOptions requestThreadPool = ThreadPoolOptions.requestThreadPoolBuilder().build();
private ThreadPoolOptions transactionThreadPool = ThreadPoolOptions.transactionThreadPoolBuilder().build();
private ThreadPoolOptions serviceThreadPool = ThreadPoolOptions.serviceThreadPoolBuilder().build();
private long queryTimeoutInMilliseconds = DEFAULT_QUERY_TIMEOUT_IN_MILLISECONDS;
private long transactionTimeoutInMilliseconds = DEFAULT_TRANSACTION_TIMEOUT_IN_MILLISECONDS;
private int closeSessionsAfterSecondsOfInactivity = DEFAULT_CLOSE_SESSIONS_AFTER_SECONDS_OF_INACTIVITY;
private boolean readOnly = DEFAULT_READ_ONLY;
private boolean quiet = DEFAULT_QUIET;
Builder() {
}
Builder(@Nonnull ServerOptions serverOptions) {
this.requestThreadPool = serverOptions.requestThreadPool();
this.transactionThreadPool = serverOptions.transactionThreadPool();
this.serviceThreadPool = serverOptions.serviceThreadPool();
this.queryTimeoutInMilliseconds = serverOptions.queryTimeoutInMilliseconds();
this.transactionTimeoutInMilliseconds = serverOptions.transactionTimeoutInMilliseconds();
this.closeSessionsAfterSecondsOfInactivity = serverOptions.closeSessionsAfterSecondsOfInactivity();
this.readOnly = serverOptions.readOnly();
this.quiet = serverOptions.quiet();
}
@Nonnull
public ServerOptions.Builder requestThreadPool(@Nonnull ThreadPoolOptions requestThreadPool) {
this.requestThreadPool = requestThreadPool;
return this;
}
@Nonnull
public ServerOptions.Builder transactionThreadPool(@Nonnull ThreadPoolOptions transactionThreadPool) {
this.transactionThreadPool = transactionThreadPool;
return this;
}
@Nonnull
public ServerOptions.Builder serviceThreadPool(@Nonnull ThreadPoolOptions serviceThreadPool) {
this.serviceThreadPool = serviceThreadPool;
return this;
}
@Nonnull
public ServerOptions.Builder queryTimeoutInMilliseconds(long queryTimeoutInMilliseconds) {
this.queryTimeoutInMilliseconds = queryTimeoutInMilliseconds;
return this;
}
@Nonnull
public ServerOptions.Builder transactionTimeoutInMilliseconds(long transactionTimeoutInMilliseconds) {
this.transactionTimeoutInMilliseconds = transactionTimeoutInMilliseconds;
return this;
}
@Nonnull
public ServerOptions.Builder closeSessionsAfterSecondsOfInactivity(int closeSessionsAfterSecondsOfInactivity) {
this.closeSessionsAfterSecondsOfInactivity = closeSessionsAfterSecondsOfInactivity;
return this;
}
@Nonnull
public ServerOptions.Builder readOnly(boolean readOnly) {
this.readOnly = readOnly;
return this;
}
@Nonnull
public ServerOptions.Builder quiet(boolean quiet) {
this.quiet = quiet;
return this;
}
@Nonnull
public ServerOptions build() {
return new ServerOptions(
requestThreadPool,
transactionThreadPool,
serviceThreadPool,
queryTimeoutInMilliseconds,
transactionTimeoutInMilliseconds,
closeSessionsAfterSecondsOfInactivity,
readOnly,
quiet
);
}
}
}