mirror of https://github.com/apache/cassandra
1567 lines
84 KiB
Java
1567 lines
84 KiB
Java
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* 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 org.apache.cassandra.config;
|
|
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.Modifier;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.TreeMap;
|
|
import java.util.function.Supplier;
|
|
|
|
import javax.annotation.Nullable;
|
|
|
|
import com.google.common.base.Joiner;
|
|
import com.google.common.collect.ImmutableSet;
|
|
import com.google.common.collect.Sets;
|
|
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
import org.apache.cassandra.audit.AuditLogOptions;
|
|
import org.apache.cassandra.db.ConsistencyLevel;
|
|
import org.apache.cassandra.db.guardrails.CustomGuardrailConfig;
|
|
import org.apache.cassandra.fql.FullQueryLoggerOptions;
|
|
import org.apache.cassandra.index.internal.CassandraIndex;
|
|
import org.apache.cassandra.io.compress.BufferType;
|
|
import org.apache.cassandra.io.sstable.format.big.BigFormat;
|
|
import org.apache.cassandra.repair.autorepair.AutoRepairConfig;
|
|
import org.apache.cassandra.utils.StorageCompatibilityMode;
|
|
|
|
import static org.apache.cassandra.config.CassandraRelevantProperties.AUTOCOMPACTION_ON_STARTUP_ENABLED;
|
|
import static org.apache.cassandra.config.CassandraRelevantProperties.CASSANDRA_AVAILABLE_PROCESSORS;
|
|
import static org.apache.cassandra.config.CassandraRelevantProperties.CURSOR_COMPACTION_ENABLED;
|
|
import static org.apache.cassandra.config.CassandraRelevantProperties.FILE_CACHE_ENABLED;
|
|
import static org.apache.cassandra.config.CassandraRelevantProperties.SKIP_PAXOS_REPAIR_ON_TOPOLOGY_CHANGE;
|
|
import static org.apache.cassandra.config.CassandraRelevantProperties.SKIP_PAXOS_REPAIR_ON_TOPOLOGY_CHANGE_KEYSPACES;
|
|
|
|
/**
|
|
* A class that contains configuration properties for the cassandra node it runs within.
|
|
* <p>
|
|
* Properties declared as volatile can be mutated via JMX.
|
|
*/
|
|
public class Config
|
|
{
|
|
private static final Logger logger = LoggerFactory.getLogger(Config.class);
|
|
|
|
public static Set<String> splitCommaDelimited(String src)
|
|
{
|
|
if (src == null)
|
|
return ImmutableSet.of();
|
|
String[] split = src.split(",\\s*");
|
|
ImmutableSet.Builder<String> builder = ImmutableSet.builder();
|
|
for (String s : split)
|
|
{
|
|
s = s.trim();
|
|
if (!s.isEmpty())
|
|
builder.add(s);
|
|
}
|
|
return builder.build();
|
|
}
|
|
/*
|
|
* Prefix for Java properties for internal Cassandra configuration options
|
|
*/
|
|
public static final String PROPERTY_PREFIX = "cassandra.";
|
|
|
|
public String cluster_name = "Test Cluster";
|
|
public ParameterizedClass authenticator;
|
|
public ParameterizedClass authorizer;
|
|
public ParameterizedClass role_manager;
|
|
public ParameterizedClass crypto_provider;
|
|
public ParameterizedClass network_authorizer;
|
|
public ParameterizedClass cidr_authorizer;
|
|
|
|
@Replaces(oldName = "permissions_validity_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound permissions_validity = new DurationSpec.IntMillisecondsBound("2s");
|
|
public volatile int permissions_cache_max_entries = 1000;
|
|
@Replaces(oldName = "permissions_update_interval_in_ms", converter = Converters.MILLIS_CUSTOM_DURATION, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound permissions_update_interval = null;
|
|
public volatile boolean permissions_cache_active_update = false;
|
|
@Replaces(oldName = "roles_validity_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound roles_validity = new DurationSpec.IntMillisecondsBound("2s");
|
|
public volatile int roles_cache_max_entries = 1000;
|
|
@Replaces(oldName = "roles_update_interval_in_ms", converter = Converters.MILLIS_CUSTOM_DURATION, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound roles_update_interval = null;
|
|
public volatile boolean roles_cache_active_update = false;
|
|
@Replaces(oldName = "credentials_validity_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound credentials_validity = new DurationSpec.IntMillisecondsBound("2s");
|
|
public volatile int credentials_cache_max_entries = 1000;
|
|
@Replaces(oldName = "credentials_update_interval_in_ms", converter = Converters.MILLIS_CUSTOM_DURATION, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound credentials_update_interval = null;
|
|
public volatile boolean credentials_cache_active_update = false;
|
|
|
|
public int max_comment_length = 128;
|
|
public int max_security_label_length = 48;
|
|
|
|
/* Hashing strategy Random or OPHF */
|
|
public String partitioner;
|
|
|
|
public boolean auto_bootstrap = true;
|
|
public volatile boolean hinted_handoff_enabled = true;
|
|
public Set<String> hinted_handoff_disabled_datacenters = Sets.newConcurrentHashSet();
|
|
@Replaces(oldName = "max_hint_window_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound max_hint_window = new DurationSpec.IntMillisecondsBound("3h");
|
|
public String hints_directory;
|
|
public boolean hint_window_persistent_enabled = true;
|
|
|
|
public volatile boolean force_new_prepared_statement_behaviour = false;
|
|
|
|
public ParameterizedClass seed_provider;
|
|
public DiskAccessMode disk_access_mode = DiskAccessMode.mmap_index_only;
|
|
|
|
public DiskFailurePolicy disk_failure_policy = DiskFailurePolicy.ignore;
|
|
public CommitFailurePolicy commit_failure_policy = CommitFailurePolicy.stop;
|
|
|
|
@Deprecated(since = "5.0.1")
|
|
public volatile boolean use_deterministic_table_id = false;
|
|
|
|
/* initial token in the ring */
|
|
public String initial_token;
|
|
public Integer num_tokens;
|
|
/** Triggers automatic allocation of tokens if set, using the replication strategy of the referenced keyspace */
|
|
public String allocate_tokens_for_keyspace = null;
|
|
/** Triggers automatic allocation of tokens if set, based on the provided replica count for a datacenter */
|
|
public Integer allocate_tokens_for_local_replication_factor = null;
|
|
|
|
@Replaces(oldName = "native_transport_idle_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public DurationSpec.LongMillisecondsBound native_transport_idle_timeout = new DurationSpec.LongMillisecondsBound("0ms");
|
|
|
|
@Replaces(oldName = "request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public volatile DurationSpec.LongMillisecondsBound request_timeout = new DurationSpec.LongMillisecondsBound("10000ms");
|
|
|
|
@Replaces(oldName = "read_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public volatile DurationSpec.LongMillisecondsBound read_request_timeout = new DurationSpec.LongMillisecondsBound("5000ms");
|
|
|
|
@Replaces(oldName = "range_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public volatile DurationSpec.LongMillisecondsBound range_request_timeout = new DurationSpec.LongMillisecondsBound("10000ms");
|
|
|
|
@Replaces(oldName = "write_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public volatile DurationSpec.LongMillisecondsBound write_request_timeout = new DurationSpec.LongMillisecondsBound("2000ms");
|
|
|
|
public volatile DurationSpec.LongMillisecondsBound short_rpc_timeout = new DurationSpec.LongMillisecondsBound("1000ms");
|
|
|
|
@Replaces(oldName = "counter_write_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public volatile DurationSpec.LongMillisecondsBound counter_write_request_timeout = new DurationSpec.LongMillisecondsBound("5000ms");
|
|
|
|
@Replaces(oldName = "cas_contention_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public volatile DurationSpec.LongMillisecondsBound cas_contention_timeout = new DurationSpec.LongMillisecondsBound("1800ms");
|
|
|
|
@Replaces(oldName = "truncate_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public volatile DurationSpec.LongMillisecondsBound truncate_request_timeout = new DurationSpec.LongMillisecondsBound("60000ms");
|
|
|
|
@Replaces(oldName = "repair_request_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public volatile DurationSpec.LongMillisecondsBound repair_request_timeout = new DurationSpec.LongMillisecondsBound("120000ms");
|
|
|
|
public Integer streaming_connections_per_host = 1;
|
|
@Replaces(oldName = "streaming_keep_alive_period_in_secs", converter = Converters.SECONDS_DURATION, deprecated = true)
|
|
public DurationSpec.IntSecondsBound streaming_keep_alive_period = new DurationSpec.IntSecondsBound("300s");
|
|
|
|
@Replaces(oldName = "cross_node_timeout", converter = Converters.IDENTITY, deprecated = true)
|
|
public boolean internode_timeout = true;
|
|
|
|
@Replaces(oldName = "slow_query_log_timeout_in_ms", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public volatile DurationSpec.LongMillisecondsBound slow_query_log_timeout = new DurationSpec.LongMillisecondsBound("500ms");
|
|
|
|
public volatile DurationSpec.LongMillisecondsBound stream_transfer_task_timeout = new DurationSpec.LongMillisecondsBound("12h");
|
|
|
|
public volatile DurationSpec.LongMillisecondsBound cms_await_timeout = new DurationSpec.LongMillisecondsBound("120000ms");
|
|
public volatile int cms_default_max_retries = 10;
|
|
@Deprecated(since="6.0")
|
|
public volatile DurationSpec.IntMillisecondsBound cms_default_retry_backoff = null;
|
|
@Deprecated(since="6.0")
|
|
public volatile DurationSpec.IntMillisecondsBound cms_default_max_retry_backoff = null;
|
|
public String cms_retry_delay = "50ms*attempts <= 500ms ... 100ms*attempts <= 1s,retries=10";
|
|
|
|
public volatile int epoch_aware_debounce_inflight_tracker_max_size = 100;
|
|
|
|
/**
|
|
* How often we should snapshot the cluster metadata.
|
|
*/
|
|
public volatile int metadata_snapshot_frequency = 100;
|
|
|
|
|
|
public volatile double phi_convict_threshold = 8.0;
|
|
|
|
public int concurrent_reads = 32;
|
|
public int concurrent_writes = 32;
|
|
public int concurrent_accord_operations = 32;
|
|
public int concurrent_counter_writes = 32;
|
|
public int concurrent_materialized_view_writes = 32;
|
|
public OptionaldPositiveInt available_processors = new OptionaldPositiveInt(CASSANDRA_AVAILABLE_PROCESSORS.getInt(OptionaldPositiveInt.UNDEFINED_VALUE));
|
|
|
|
public int memtable_flush_writers = 0;
|
|
@Replaces(oldName = "memtable_heap_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound memtable_heap_space;
|
|
@Replaces(oldName = "memtable_offheap_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound memtable_offheap_space;
|
|
public Float memtable_cleanup_threshold = null;
|
|
|
|
public static class MemtableOptions
|
|
{
|
|
public LinkedHashMap<String, InheritingClass> configurations; // order must be preserved
|
|
|
|
public MemtableOptions()
|
|
{
|
|
}
|
|
}
|
|
|
|
public MemtableOptions memtable;
|
|
|
|
// Limit the maximum depth of repair session merkle trees
|
|
/** @deprecated See */
|
|
@Deprecated(since = "4.0")
|
|
public volatile Integer repair_session_max_tree_depth = null;
|
|
@Replaces(oldName = "repair_session_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public volatile DataStorageSpec.IntMebibytesBound repair_session_space = null;
|
|
|
|
public volatile int concurrent_merkle_tree_requests = 0;
|
|
|
|
public volatile boolean use_offheap_merkle_trees = true;
|
|
|
|
public int storage_port = 7000;
|
|
public int ssl_storage_port = 7001;
|
|
public String listen_address;
|
|
public String listen_interface;
|
|
public boolean listen_interface_prefer_ipv6 = false;
|
|
public String broadcast_address;
|
|
public boolean listen_on_broadcast_address = false;
|
|
public ParameterizedClass internode_authenticator;
|
|
|
|
public boolean traverse_auth_from_root = false;
|
|
|
|
/*
|
|
* RPC address and interface refer to the address/interface used for the native protocol used to communicate with
|
|
* clients. It's still called RPC in some places even though Thrift RPC is gone. If you see references to native
|
|
* address or native port it's derived from the RPC address configuration.
|
|
*
|
|
* native_transport_port is the port that is paired with RPC address to bind on.
|
|
*/
|
|
public String rpc_address;
|
|
public String rpc_interface;
|
|
public boolean rpc_interface_prefer_ipv6 = false;
|
|
public String broadcast_rpc_address;
|
|
public boolean rpc_keepalive = true;
|
|
|
|
@Replaces(oldName = "internode_max_message_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated=true)
|
|
public DataStorageSpec.IntBytesBound internode_max_message_size;
|
|
|
|
@Replaces(oldName = "internode_socket_send_buffer_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
@Replaces(oldName = "internode_send_buff_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntBytesBound internode_socket_send_buffer_size = new DataStorageSpec.IntBytesBound("0B");
|
|
@Replaces(oldName = "internode_socket_receive_buffer_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
@Replaces(oldName = "internode_recv_buff_size_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntBytesBound internode_socket_receive_buffer_size = new DataStorageSpec.IntBytesBound("0B");
|
|
|
|
// TODO: derive defaults from system memory settings?
|
|
@Replaces(oldName = "internode_application_send_queue_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntBytesBound internode_application_send_queue_capacity = new DataStorageSpec.IntBytesBound("4MiB");
|
|
@Replaces(oldName = "internode_application_send_queue_reserve_endpoint_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntBytesBound internode_application_send_queue_reserve_endpoint_capacity = new DataStorageSpec.IntBytesBound("128MiB");
|
|
@Replaces(oldName = "internode_application_send_queue_reserve_global_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntBytesBound internode_application_send_queue_reserve_global_capacity = new DataStorageSpec.IntBytesBound("512MiB");
|
|
|
|
@Replaces(oldName = "internode_application_receive_queue_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntBytesBound internode_application_receive_queue_capacity = new DataStorageSpec.IntBytesBound("4MiB");
|
|
@Replaces(oldName = "internode_application_receive_queue_reserve_endpoint_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntBytesBound internode_application_receive_queue_reserve_endpoint_capacity = new DataStorageSpec.IntBytesBound("128MiB");
|
|
@Replaces(oldName = "internode_application_receive_queue_reserve_global_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntBytesBound internode_application_receive_queue_reserve_global_capacity = new DataStorageSpec.IntBytesBound("512MiB");
|
|
|
|
// Defensive settings for protecting Cassandra from true network partitions. See (CASSANDRA-14358) for details.
|
|
// The amount of time to wait for internode tcp connections to establish.
|
|
@Replaces(oldName = "internode_tcp_connect_timeout_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound internode_tcp_connect_timeout = new DurationSpec.IntMillisecondsBound("2s");
|
|
// The amount of time unacknowledged data is allowed on a connection before we throw out the connection
|
|
// Note this is only supported on Linux + epoll, and it appears to behave oddly above a setting of 30000
|
|
// (it takes much longer than 30s) as of Linux 4.12. If you want something that high set this to 0
|
|
// (which picks up the OS default) and configure the net.ipv4.tcp_retries2 sysctl to be ~8.
|
|
@Replaces(oldName = "internode_tcp_user_timeout_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound internode_tcp_user_timeout = new DurationSpec.IntMillisecondsBound("30s");
|
|
// Similar to internode_tcp_user_timeout but used specifically for streaming connection.
|
|
// The default is 5 minutes. Increase it or set it to 0 in order to increase the timeout.
|
|
@Replaces(oldName = "internode_streaming_tcp_user_timeout_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound internode_streaming_tcp_user_timeout = new DurationSpec.IntMillisecondsBound("300s"); // 5 minutes
|
|
|
|
public boolean start_native_transport = true;
|
|
public int native_transport_port = 9042;
|
|
public int native_transport_max_threads = 128;
|
|
@Replaces(oldName = "native_transport_max_frame_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound native_transport_max_frame_size = new DataStorageSpec.IntMebibytesBound("16MiB");
|
|
/** do bcrypt hashing in a limited pool to prevent cpu load spikes; note: any value < 1 will be set to 1 on init **/
|
|
public int native_transport_max_auth_threads = 4;
|
|
public volatile DataStorageSpec.LongBytesBound native_transport_max_message_size = null;
|
|
public volatile long native_transport_max_concurrent_connections = -1L;
|
|
public volatile long native_transport_max_concurrent_connections_per_ip = -1L;
|
|
public boolean native_transport_flush_in_batches_legacy = false;
|
|
public volatile boolean native_transport_allow_older_protocols = true;
|
|
// Below 2 parameters were fixed in 4.0 + to get default value when ==-1 (old name and value format) or ==null(new name and value format),
|
|
// not <=0 as it is in previous versions. Throwing config exceptions on < -1
|
|
@Replaces(oldName = "native_transport_max_concurrent_requests_in_bytes_per_ip", converter = Converters.BYTES_CUSTOM_DATASTORAGE, deprecated = true)
|
|
public volatile DataStorageSpec.LongBytesBound native_transport_max_request_data_in_flight_per_ip = null;
|
|
@Replaces(oldName = "native_transport_max_concurrent_requests_in_bytes", converter = Converters.BYTES_CUSTOM_DATASTORAGE, deprecated = true)
|
|
public volatile DataStorageSpec.LongBytesBound native_transport_max_request_data_in_flight = null;
|
|
public volatile boolean native_transport_rate_limiting_enabled = false;
|
|
public volatile int native_transport_max_requests_per_second = 1000000;
|
|
@Replaces(oldName = "native_transport_receive_queue_capacity_in_bytes", converter = Converters.BYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntBytesBound native_transport_receive_queue_capacity = new DataStorageSpec.IntBytesBound("1MiB");
|
|
|
|
/**
|
|
* Max size of values in SSTables, in MebiBytes.
|
|
* Default is the same as the native protocol frame limit: 256MiB.
|
|
* See AbstractType for how it is used.
|
|
*/
|
|
@Replaces(oldName = "max_value_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound max_value_size = new DataStorageSpec.IntMebibytesBound("256MiB");
|
|
|
|
public boolean snapshot_before_compaction = false;
|
|
public boolean auto_snapshot = true;
|
|
|
|
/**
|
|
* When auto_snapshot is true and this property
|
|
* is set, snapshots created by truncation or
|
|
* drop use this TTL.
|
|
*/
|
|
public String auto_snapshot_ttl;
|
|
|
|
public volatile long snapshot_links_per_second = 0;
|
|
|
|
/* if the size of columns or super-columns are more than this, indexing will kick in */
|
|
@Replaces(oldName = "column_index_size_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
|
|
public volatile DataStorageSpec.IntKibibytesBound column_index_size;
|
|
@Replaces(oldName = "column_index_cache_size_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
|
|
public volatile DataStorageSpec.IntKibibytesBound column_index_cache_size = new DataStorageSpec.IntKibibytesBound("2KiB");
|
|
@Replaces(oldName = "batch_size_warn_threshold_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
|
|
public volatile DataStorageSpec.IntKibibytesBound batch_size_warn_threshold = new DataStorageSpec.IntKibibytesBound("5KiB");
|
|
@Replaces(oldName = "batch_size_fail_threshold_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
|
|
public volatile DataStorageSpec.IntKibibytesBound batch_size_fail_threshold = new DataStorageSpec.IntKibibytesBound("50KiB");
|
|
|
|
public Integer unlogged_batch_across_partitions_warn_threshold = 10;
|
|
public volatile Integer concurrent_compactors;
|
|
@Replaces(oldName = "compaction_throughput_mb_per_sec", converter = Converters.MEBIBYTES_PER_SECOND_DATA_RATE, deprecated = true)
|
|
public volatile DataRateSpec.LongBytesPerSecondBound compaction_throughput = new DataRateSpec.LongBytesPerSecondBound("64MiB/s");
|
|
@Replaces(oldName = "min_free_space_per_drive_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound min_free_space_per_drive = new DataStorageSpec.IntMebibytesBound("50MiB");
|
|
|
|
public DataStorageSpec.IntKibibytesBound compressed_read_ahead_buffer_size = new DataStorageSpec.IntKibibytesBound("256KiB");
|
|
|
|
// fraction of free disk space available for compaction after min free space is subtracted
|
|
public volatile Double max_space_usable_for_compactions_in_percentage = .95;
|
|
|
|
public volatile int concurrent_materialized_view_builders = 1;
|
|
public volatile int reject_repair_compaction_threshold = Integer.MAX_VALUE;
|
|
|
|
// The number of executors to use for building secondary indexes
|
|
public volatile int concurrent_index_builders = 2;
|
|
|
|
// at least 20% of disk must be unused to run repair
|
|
// if you want to disable this feature (the recommendation is not to, but if you want to disable it for whatever reason) then set the ratio to 0.0
|
|
@Replaces(oldName = "incremental_repair_disk_headroom_reject_ratio")
|
|
public volatile double repair_disk_headroom_reject_ratio = 0.2;
|
|
|
|
/**
|
|
* @deprecated retry support removed on CASSANDRA-10992
|
|
*/
|
|
/** @deprecated See CASSANDRA-17378 */
|
|
@Deprecated(since = "4.1")
|
|
public int max_streaming_retries = 3;
|
|
|
|
@Replaces(oldName = "stream_throughput_outbound_megabits_per_sec", converter = Converters.MEGABITS_TO_BYTES_PER_SECOND_DATA_RATE, deprecated = true)
|
|
public volatile DataRateSpec.LongBytesPerSecondBound stream_throughput_outbound = new DataRateSpec.LongBytesPerSecondBound("24MiB/s");
|
|
@Replaces(oldName = "inter_dc_stream_throughput_outbound_megabits_per_sec", converter = Converters.MEGABITS_TO_BYTES_PER_SECOND_DATA_RATE, deprecated = true)
|
|
public volatile DataRateSpec.LongBytesPerSecondBound inter_dc_stream_throughput_outbound = new DataRateSpec.LongBytesPerSecondBound("24MiB/s");
|
|
|
|
public volatile DataRateSpec.LongBytesPerSecondBound entire_sstable_stream_throughput_outbound = new DataRateSpec.LongBytesPerSecondBound("24MiB/s");
|
|
public volatile DataRateSpec.LongBytesPerSecondBound entire_sstable_inter_dc_stream_throughput_outbound = new DataRateSpec.LongBytesPerSecondBound("24MiB/s");
|
|
|
|
public String[] data_file_directories = new String[0];
|
|
|
|
public static class SSTableConfig
|
|
{
|
|
public String selected_format = BigFormat.NAME;
|
|
public Map<String, Map<String, String>> format = new HashMap<>();
|
|
}
|
|
|
|
public final SSTableConfig sstable = new SSTableConfig();
|
|
|
|
/**
|
|
* The directory to use for storing the system keyspaces data.
|
|
* If unspecified the data will be stored in the first of the data_file_directories.
|
|
*/
|
|
public String local_system_data_file_directory;
|
|
|
|
public String saved_caches_directory;
|
|
|
|
// Commit Log
|
|
public String commitlog_directory;
|
|
@Replaces(oldName = "commitlog_total_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound commitlog_total_space;
|
|
public CommitLogSync commitlog_sync;
|
|
|
|
@Replaces(oldName = "commitlog_sync_group_window_in_ms", converter = Converters.MILLIS_DURATION_DOUBLE, deprecated = true)
|
|
public DurationSpec.IntMillisecondsBound commitlog_sync_group_window = new DurationSpec.IntMillisecondsBound("0ms");
|
|
@Replaces(oldName = "commitlog_sync_period_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public DurationSpec.IntMillisecondsBound commitlog_sync_period = new DurationSpec.IntMillisecondsBound("0ms");
|
|
@Replaces(oldName = "commitlog_segment_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound commitlog_segment_size = new DataStorageSpec.IntMebibytesBound("32MiB");
|
|
public ParameterizedClass commitlog_compression;
|
|
public FlushCompression flush_compression = FlushCompression.fast;
|
|
public int commitlog_max_compression_buffers_in_pool = 3;
|
|
public DiskAccessMode commitlog_disk_access_mode = DiskAccessMode.legacy;
|
|
public DiskAccessMode compaction_read_disk_access_mode = DiskAccessMode.auto;
|
|
@Replaces(oldName = "periodic_commitlog_sync_lag_block_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public DurationSpec.IntMillisecondsBound periodic_commitlog_sync_lag_block;
|
|
public TransparentDataEncryptionOptions transparent_data_encryption_options = new TransparentDataEncryptionOptions();
|
|
|
|
@Replaces(oldName = "max_mutation_size_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntKibibytesBound max_mutation_size;
|
|
|
|
// Change-data-capture logs
|
|
public boolean cdc_enabled = false;
|
|
// When true, new CDC mutations are rejected/blocked when reaching max CDC storage.
|
|
// When false, new CDC mutations can always be added. But it will remove the oldest CDC commit log segment on full.
|
|
public volatile boolean cdc_block_writes = true;
|
|
// When true, CDC data in SSTable go through commit logs during internodes streaming, e.g. repair
|
|
// When false, it behaves the same as normal streaming.
|
|
public volatile boolean cdc_on_repair_enabled = true;
|
|
public String cdc_raw_directory;
|
|
@Replaces(oldName = "cdc_total_space_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound cdc_total_space = new DataStorageSpec.IntMebibytesBound("0MiB");
|
|
@Replaces(oldName = "cdc_free_space_check_interval_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public DurationSpec.IntMillisecondsBound cdc_free_space_check_interval = new DurationSpec.IntMillisecondsBound("250ms");
|
|
|
|
public String endpoint_snitch;
|
|
public boolean dynamic_snitch = true;
|
|
@Replaces(oldName = "dynamic_snitch_update_interval_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public DurationSpec.IntMillisecondsBound dynamic_snitch_update_interval = new DurationSpec.IntMillisecondsBound("100ms");
|
|
@Replaces(oldName = "dynamic_snitch_reset_interval_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public DurationSpec.IntMillisecondsBound dynamic_snitch_reset_interval = new DurationSpec.IntMillisecondsBound("10m");
|
|
public double dynamic_snitch_badness_threshold = 1.0;
|
|
|
|
public String node_proximity;
|
|
public String initial_location_provider;
|
|
public String addresses_config;
|
|
public boolean prefer_local_connections = false;
|
|
|
|
public String failure_detector = "FailureDetector";
|
|
|
|
public EncryptionOptions.ServerEncryptionOptions server_encryption_options = new EncryptionOptions.ServerEncryptionOptions();
|
|
public EncryptionOptions.ClientEncryptionOptions client_encryption_options = new EncryptionOptions.ClientEncryptionOptions();
|
|
|
|
public JMXServerOptions jmx_server_options;
|
|
|
|
public InternodeCompression internode_compression = InternodeCompression.none;
|
|
|
|
@Replaces(oldName = "hinted_handoff_throttle_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntKibibytesBound hinted_handoff_throttle = new DataStorageSpec.IntKibibytesBound("1024KiB");
|
|
@Replaces(oldName = "batchlog_replay_throttle_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntKibibytesBound batchlog_replay_throttle = new DataStorageSpec.IntKibibytesBound("1024KiB");
|
|
public BatchlogEndpointStrategy batchlog_endpoint_strategy = BatchlogEndpointStrategy.random_remote;
|
|
public int max_hints_delivery_threads = 2;
|
|
@Replaces(oldName = "hints_flush_period_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public DurationSpec.IntMillisecondsBound hints_flush_period = new DurationSpec.IntMillisecondsBound("10s");
|
|
@Replaces(oldName = "max_hints_file_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound max_hints_file_size = new DataStorageSpec.IntMebibytesBound("128MiB");
|
|
public volatile DataStorageSpec.LongBytesBound max_hints_size_per_host = new DataStorageSpec.LongBytesBound("0B"); // 0 means disabled
|
|
|
|
public ParameterizedClass hints_compression;
|
|
public volatile boolean auto_hints_cleanup_enabled = false;
|
|
public volatile boolean transfer_hints_on_decommission = true;
|
|
public volatile boolean use_creation_time_for_hint_ttl = true;
|
|
|
|
public volatile boolean incremental_backups = false;
|
|
public boolean trickle_fsync = false;
|
|
@Replaces(oldName = "trickle_fsync_interval_in_kb", converter = Converters.KIBIBYTES_DATASTORAGE, deprecated = true)
|
|
public DataStorageSpec.IntKibibytesBound trickle_fsync_interval = new DataStorageSpec.IntKibibytesBound("10240KiB");
|
|
|
|
@Nullable
|
|
@Replaces(oldName = "sstable_preemptive_open_interval_in_mb", converter = Converters.NEGATIVE_MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public volatile DataStorageSpec.IntMebibytesBound sstable_preemptive_open_interval = new DataStorageSpec.IntMebibytesBound("50MiB");
|
|
|
|
public volatile boolean key_cache_migrate_during_compaction = true;
|
|
public volatile boolean key_cache_invalidate_after_sstable_deletion = false;
|
|
public volatile int key_cache_keys_to_save = Integer.MAX_VALUE;
|
|
@Replaces(oldName = "key_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_LONG, deprecated = true)
|
|
public DataStorageSpec.LongMebibytesBound key_cache_size = null;
|
|
@Replaces(oldName = "key_cache_save_period", converter = Converters.SECONDS_CUSTOM_DURATION)
|
|
public volatile DurationSpec.IntSecondsBound key_cache_save_period = new DurationSpec.IntSecondsBound("4h");
|
|
|
|
public String row_cache_class_name = "org.apache.cassandra.cache.OHCProvider";
|
|
@Replaces(oldName = "row_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_LONG, deprecated = true)
|
|
public DataStorageSpec.LongMebibytesBound row_cache_size = new DataStorageSpec.LongMebibytesBound("0MiB");
|
|
@Replaces(oldName = "row_cache_save_period", converter = Converters.SECONDS_CUSTOM_DURATION)
|
|
public volatile DurationSpec.IntSecondsBound row_cache_save_period = new DurationSpec.IntSecondsBound("0s");
|
|
public volatile int row_cache_keys_to_save = Integer.MAX_VALUE;
|
|
|
|
@Replaces(oldName = "counter_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_LONG, deprecated = true)
|
|
public DataStorageSpec.LongMebibytesBound counter_cache_size = null;
|
|
@Replaces(oldName = "counter_cache_save_period", converter = Converters.SECONDS_CUSTOM_DURATION)
|
|
public volatile DurationSpec.IntSecondsBound counter_cache_save_period = new DurationSpec.IntSecondsBound("7200s");
|
|
public volatile int counter_cache_keys_to_save = Integer.MAX_VALUE;
|
|
|
|
public volatile DurationSpec.IntSecondsBound compression_dictionary_refresh_interval = new DurationSpec.IntSecondsBound("3600s"); // 1 hour - TODO: re-assess whether daily (86400s) is more appropriate
|
|
public volatile DurationSpec.IntSecondsBound compression_dictionary_refresh_initial_delay = new DurationSpec.IntSecondsBound("10s"); // 10 seconds default
|
|
public volatile int compression_dictionary_cache_size = 10; // max dictionaries per table
|
|
public volatile DurationSpec.IntSecondsBound compression_dictionary_cache_expire = new DurationSpec.IntSecondsBound("24h");
|
|
|
|
public DataStorageSpec.LongMebibytesBound paxos_cache_size = null;
|
|
|
|
public DataStorageSpec.LongMebibytesBound consensus_migration_cache_size = null;
|
|
|
|
@Replaces(oldName = "cache_load_timeout_seconds", converter = Converters.NEGATIVE_SECONDS_DURATION, deprecated = true)
|
|
public DurationSpec.IntSecondsBound cache_load_timeout = new DurationSpec.IntSecondsBound("30s");
|
|
|
|
private static boolean isClientMode = false;
|
|
private static Supplier<Config> overrideLoadConfig = null;
|
|
|
|
@Replaces(oldName = "networking_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound networking_cache_size;
|
|
|
|
@Replaces(oldName = "file_cache_size_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_INT, deprecated = true)
|
|
public DataStorageSpec.IntMebibytesBound file_cache_size;
|
|
|
|
public boolean file_cache_enabled = FILE_CACHE_ENABLED.getBoolean();
|
|
|
|
/**
|
|
* Because of the current {@link org.apache.cassandra.utils.memory.BufferPool} slab sizes of 64 KiB, we
|
|
* store in the file cache buffers that divide 64 KiB, so we need to round the buffer sizes to powers of two.
|
|
* This boolean controls weather they are rounded up or down. Set it to true to round up to the
|
|
* next power of two, set it to false to round down to the previous power of two. Note that buffer sizes are
|
|
* already rounded to 4 KiB and capped between 4 KiB minimum and 64 kb maximum by the {@link DiskOptimizationStrategy}.
|
|
* By default, this boolean is set to round down when {@link #disk_optimization_strategy} is {@code ssd},
|
|
* and to round up when it is {@code spinning}.
|
|
*/
|
|
public Boolean file_cache_round_up;
|
|
|
|
/** @deprecated See CASSANDRA-15358 */
|
|
@Deprecated(since = "4.0")
|
|
public boolean buffer_pool_use_heap_if_exhausted;
|
|
|
|
public DiskOptimizationStrategy disk_optimization_strategy = DiskOptimizationStrategy.ssd;
|
|
|
|
public double disk_optimization_estimate_percentile = 0.95;
|
|
|
|
public double disk_optimization_page_cross_chance = 0.1;
|
|
|
|
public boolean inter_dc_tcp_nodelay = true;
|
|
|
|
public MemtableAllocationType memtable_allocation_type = MemtableAllocationType.heap_buffers;
|
|
|
|
public volatile boolean read_thresholds_enabled = false;
|
|
public volatile DataStorageSpec.LongBytesBound coordinator_read_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound coordinator_read_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound local_read_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound local_read_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound row_index_read_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound row_index_read_size_fail_threshold = null;
|
|
|
|
public volatile int sstables_per_read_log_threshold = 100;
|
|
public volatile int tombstone_warn_threshold = 1000;
|
|
public volatile int tombstone_failure_threshold = 100000;
|
|
|
|
public volatile boolean write_thresholds_enabled = false;
|
|
public volatile DataStorageSpec.LongBytesBound write_size_warn_threshold = null;
|
|
public volatile DurationSpec.LongMillisecondsBound coordinator_write_warn_interval = new DurationSpec.LongMillisecondsBound("1000ms");
|
|
public volatile int write_tombstone_warn_threshold = -1;
|
|
|
|
public TombstonesMetricGranularity tombstone_read_purgeable_metric_granularity = TombstonesMetricGranularity.disabled;
|
|
|
|
public final ReplicaFilteringProtectionOptions replica_filtering_protection = new ReplicaFilteringProtectionOptions();
|
|
|
|
@Replaces(oldName = "index_summary_capacity_in_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_LONG, deprecated = true)
|
|
public volatile DataStorageSpec.LongMebibytesBound index_summary_capacity;
|
|
@Nullable
|
|
@Replaces(oldName = "index_summary_resize_interval_in_minutes", converter = Converters.MINUTES_CUSTOM_DURATION, deprecated = true)
|
|
public volatile DurationSpec.IntMinutesBound index_summary_resize_interval = new DurationSpec.IntMinutesBound("60m");
|
|
|
|
@Replaces(oldName = "gc_log_threshold_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound gc_log_threshold = new DurationSpec.IntMillisecondsBound("200ms");
|
|
@Replaces(oldName = "gc_warn_threshold_in_ms", converter = Converters.MILLIS_DURATION_INT, deprecated = true)
|
|
public volatile DurationSpec.IntMillisecondsBound gc_warn_threshold = new DurationSpec.IntMillisecondsBound("1s");
|
|
public volatile DurationSpec.IntMillisecondsBound gc_concurrent_phase_log_threshold = new DurationSpec.IntMillisecondsBound("1s");
|
|
public volatile DurationSpec.IntMillisecondsBound gc_concurrent_phase_warn_threshold = new DurationSpec.IntMillisecondsBound("2s");
|
|
|
|
// TTL for different types of trace events.
|
|
@Replaces(oldName = "tracetype_query_ttl", converter = Converters.SECONDS_DURATION, deprecated=true)
|
|
public DurationSpec.IntSecondsBound trace_type_query_ttl = new DurationSpec.IntSecondsBound("1d");
|
|
@Replaces(oldName = "tracetype_repair_ttl", converter = Converters.SECONDS_DURATION, deprecated=true)
|
|
public DurationSpec.IntSecondsBound trace_type_repair_ttl = new DurationSpec.IntSecondsBound("7d");
|
|
|
|
/**
|
|
* Maintain statistics on whether writes achieve the ideal consistency level
|
|
* before expiring and becoming hints
|
|
*/
|
|
public volatile ConsistencyLevel ideal_consistency_level = null;
|
|
|
|
/** @deprecated See CASSANDRA-17404 */
|
|
@Deprecated(since = "4.1")
|
|
public int windows_timer_interval = 0;
|
|
|
|
@Deprecated(since = "4.0")
|
|
public String otc_coalescing_strategy = "DISABLED";
|
|
|
|
@Deprecated(since = "4.0")
|
|
public static final int otc_coalescing_window_us_default = 200;
|
|
@Deprecated(since = "4.0")
|
|
public int otc_coalescing_window_us = otc_coalescing_window_us_default;
|
|
@Deprecated(since = "4.0")
|
|
public int otc_coalescing_enough_coalesced_messages = 8;
|
|
@Deprecated(since = "4.0")
|
|
public static final int otc_backlog_expiration_interval_ms_default = 200;
|
|
@Deprecated(since = "4.0")
|
|
public volatile int otc_backlog_expiration_interval_ms = otc_backlog_expiration_interval_ms_default;
|
|
|
|
/**
|
|
* Size of the CQL prepared statements cache in MiB.
|
|
* Defaults to 1/256th of the heap size or 10MiB, whichever is greater.
|
|
*/
|
|
@Replaces(oldName = "prepared_statements_cache_size_mb", converter = Converters.MEBIBYTES_DATA_STORAGE_LONG, deprecated = true)
|
|
public DataStorageSpec.LongMebibytesBound prepared_statements_cache_size = null;
|
|
|
|
@Replaces(oldName = "enable_user_defined_functions", converter = Converters.IDENTITY, deprecated = true)
|
|
public boolean user_defined_functions_enabled = false;
|
|
|
|
/** @deprecated See CASSANDRA-18252 */
|
|
@Deprecated(since = "5.0")
|
|
@Replaces(oldName = "enable_scripted_user_defined_functions", converter = Converters.IDENTITY, deprecated = true)
|
|
public boolean scripted_user_defined_functions_enabled = false;
|
|
|
|
@Replaces(oldName = "enable_materialized_views", converter = Converters.IDENTITY, deprecated = true)
|
|
public boolean materialized_views_enabled = false;
|
|
|
|
// When true, materialized views data in SSTable go through commit logs during internodes streaming, e.g. repair
|
|
// When false, it behaves the same as normal streaming.
|
|
public volatile boolean materialized_views_on_repair_enabled = true;
|
|
|
|
@Replaces(oldName = "enable_transient_replication", converter = Converters.IDENTITY, deprecated = true)
|
|
public boolean transient_replication_enabled = false;
|
|
|
|
@Replaces(oldName = "enable_sasi_indexes", converter = Converters.IDENTITY, deprecated = true)
|
|
public boolean sasi_indexes_enabled = false;
|
|
|
|
@Replaces(oldName = "enable_drop_compact_storage", converter = Converters.IDENTITY, deprecated = true)
|
|
public volatile boolean drop_compact_storage_enabled = false;
|
|
|
|
public boolean cursor_compaction_enabled = CURSOR_COMPACTION_ENABLED.getBoolean();
|
|
|
|
public volatile boolean use_statements_enabled = true;
|
|
|
|
/**
|
|
* Optionally disable asynchronous UDF execution.
|
|
* Disabling asynchronous UDF execution also implicitly disables the security-manager!
|
|
* By default, async UDF execution is enabled to be able to detect UDFs that run too long / forever and be
|
|
* able to fail fast - i.e. stop the Cassandra daemon, which is currently the only appropriate approach to
|
|
* "tell" a user that there's something really wrong with the UDF.
|
|
* When you disable async UDF execution, users MUST pay attention to read-timeouts since these may indicate
|
|
* UDFs that run too long or forever - and this can destabilize the cluster.
|
|
*
|
|
* This requires allow_insecure_udfs to be true
|
|
*/
|
|
// Below parameter is not presented in cassandra.yaml but to be on the safe side that no one was directly using it
|
|
// I still added backward compatibility (CASSANDRA-15234)
|
|
@Replaces(oldName = "enable_user_defined_functions_threads", converter = Converters.IDENTITY, deprecated = true)
|
|
public boolean user_defined_functions_threads_enabled = true;
|
|
|
|
/**
|
|
* Set this to true to allow running insecure UDFs.
|
|
*/
|
|
public boolean allow_insecure_udfs = false;
|
|
|
|
/**
|
|
* Set this to allow UDFs accessing java.lang.System.* methods, which basically allows UDFs to execute any arbitrary code on the system.
|
|
*/
|
|
public boolean allow_extra_insecure_udfs = false;
|
|
|
|
public boolean dynamic_data_masking_enabled = false;
|
|
|
|
/**
|
|
* Time in milliseconds after a warning will be emitted to the log and to the client that a UDF runs too long.
|
|
* (Only valid, if user_defined_functions_threads_enabled==true)
|
|
*/
|
|
@Replaces(oldName = "user_defined_function_warn_timeout", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public DurationSpec.LongMillisecondsBound user_defined_functions_warn_timeout = new DurationSpec.LongMillisecondsBound("500ms");
|
|
/**
|
|
* Time in milliseconds after a fatal UDF run-time situation is detected and action according to
|
|
* user_function_timeout_policy will take place.
|
|
* (Only valid, if user_defined_functions_threads_enabled==true)
|
|
*/
|
|
@Replaces(oldName = "user_defined_function_fail_timeout", converter = Converters.MILLIS_DURATION_LONG, deprecated = true)
|
|
public DurationSpec.LongMillisecondsBound user_defined_functions_fail_timeout = new DurationSpec.LongMillisecondsBound("1500ms");
|
|
/**
|
|
* Defines what to do when a UDF ran longer than user_defined_functions_fail_timeout.
|
|
* Possible options are:
|
|
* - 'die' - i.e. it is able to emit a warning to the client before the Cassandra Daemon will shut down.
|
|
* - 'die_immediate' - shut down C* daemon immediately (effectively prevent the chance that the client will receive a warning).
|
|
* - 'ignore' - just log - the most dangerous option.
|
|
* (Only valid, if user_defined_functions_threads_enabled==true)
|
|
*/
|
|
public UserFunctionTimeoutPolicy user_function_timeout_policy = UserFunctionTimeoutPolicy.die;
|
|
|
|
/** @deprecated See CASSANDRA-15375 */
|
|
@Deprecated(since = "4.0")
|
|
public volatile boolean back_pressure_enabled = false;
|
|
/** @deprecated See CASSANDRA-15375 */
|
|
@Deprecated(since = "4.0")
|
|
public volatile ParameterizedClass back_pressure_strategy;
|
|
|
|
public volatile int concurrent_validations;
|
|
public RepairCommandPoolFullStrategy repair_command_pool_full_strategy = RepairCommandPoolFullStrategy.queue;
|
|
public int repair_command_pool_size = concurrent_validations;
|
|
|
|
/**
|
|
* When a node first starts up it intially considers all other peers as DOWN and is disconnected from all of them.
|
|
* To be useful as a coordinator (and not introduce latency penalties on restart) this node must have successfully
|
|
* opened all three internode TCP connections (gossip, small, and large messages) before advertising to clients.
|
|
* Due to this, by default, Casssandra will prime these internode TCP connections and wait for all but a single
|
|
* node to be DOWN/disconnected in the local datacenter before offering itself as a coordinator, subject to a
|
|
* timeout. See CASSANDRA-13993 and CASSANDRA-14297 for more details.
|
|
*
|
|
* We provide two tunables to control this behavior as some users may want to block until all datacenters are
|
|
* available (global QUORUM/EACH_QUORUM), some users may not want to block at all (clients that already work
|
|
* around the problem), and some users may want to prime the connections but not delay startup.
|
|
*
|
|
* block_for_peers_timeout_in_secs: controls how long this node will wait to connect to peers. To completely disable
|
|
* any startup connectivity checks set this to -1. To trigger the internode connections but immediately continue
|
|
* startup, set this to to 0. The default is 10 seconds.
|
|
*
|
|
* block_for_peers_in_remote_dcs: controls if this node will consider remote datacenters to wait for. The default
|
|
* is to _not_ wait on remote datacenters.
|
|
*/
|
|
public int block_for_peers_timeout_in_secs = 10;
|
|
public boolean block_for_peers_in_remote_dcs = false;
|
|
|
|
public volatile boolean automatic_sstable_upgrade = false;
|
|
public volatile int max_concurrent_automatic_sstable_upgrades = 1;
|
|
public boolean stream_entire_sstables = true;
|
|
|
|
public volatile boolean skip_stream_disk_space_check = false;
|
|
|
|
public volatile AuditLogOptions audit_logging_options = new AuditLogOptions();
|
|
public volatile FullQueryLoggerOptions full_query_logging_options = new FullQueryLoggerOptions();
|
|
|
|
public CorruptedTombstoneStrategy corrupted_tombstone_strategy = CorruptedTombstoneStrategy.disabled;
|
|
|
|
public volatile boolean diagnostic_events_enabled = false;
|
|
|
|
// Default keyspace replication factors allow validation of newly created keyspaces
|
|
// and good defaults if no replication factor is provided by the user
|
|
public volatile int default_keyspace_rf = 1;
|
|
|
|
/**
|
|
* flags for enabling tracking repaired state of data during reads
|
|
* separate flags for range & single partition reads as single partition reads are only tracked
|
|
* when CL > 1 and a digest mismatch occurs. Currently, range queries don't use digests so if
|
|
* enabled for range reads, all such reads will include repaired data tracking. As this adds
|
|
* some overhead, operators may wish to disable it whilst still enabling it for partition reads
|
|
*/
|
|
public volatile boolean repaired_data_tracking_for_range_reads_enabled = false;
|
|
public volatile boolean repaired_data_tracking_for_partition_reads_enabled = false;
|
|
/* If true, unconfirmed mismatches (those which cannot be considered conclusive proof of out of
|
|
* sync repaired data due to the presence of pending repair sessions, or unrepaired partition
|
|
* deletes) will increment a metric, distinct from confirmed mismatches. If false, unconfirmed
|
|
* mismatches are simply ignored by the coordinator.
|
|
* This is purely to allow operators to avoid potential signal:noise issues as these types of
|
|
* mismatches are considerably less actionable than their confirmed counterparts. Setting this
|
|
* to true only disables the incrementing of the counters when an unconfirmed mismatch is found
|
|
* and has no other effect on the collection or processing of the repaired data.
|
|
*/
|
|
public volatile boolean report_unconfirmed_repaired_data_mismatches = false;
|
|
/*
|
|
* If true, when a repaired data mismatch is detected at read time or during a preview repair,
|
|
* a snapshot request will be issued to each particpating replica. These are limited at the replica level
|
|
* so that only a single snapshot per-table per-day can be taken via this method.
|
|
*/
|
|
public volatile boolean snapshot_on_repaired_data_mismatch = false;
|
|
|
|
/**
|
|
* Number of seconds to set nowInSec into the future when performing validation previews against repaired data
|
|
* this (attempts) to prevent a race where validations on different machines are started on different sides of
|
|
* a tombstone being compacted away
|
|
*/
|
|
|
|
@Replaces(oldName = "validation_preview_purge_head_start_in_sec", converter = Converters.NEGATIVE_SECONDS_DURATION, deprecated = true)
|
|
public volatile DurationSpec.IntSecondsBound validation_preview_purge_head_start = new DurationSpec.IntSecondsBound("3600s");
|
|
|
|
public boolean auth_cache_warming_enabled = false;
|
|
|
|
// Using String instead of ConsistencyLevel here to keep static initialization from cascading and starting
|
|
// threads during tool usage mode. See CASSANDRA-12988 and DatabaseDescriptorRefTest for details
|
|
public volatile String auth_read_consistency_level = "LOCAL_QUORUM";
|
|
public volatile String auth_write_consistency_level = "EACH_QUORUM";
|
|
|
|
/** This feature allows denying access to operations on certain key partitions, intended for use by operators to
|
|
* provide another tool to manage cluster health vs application access. See CASSANDRA-12106 and CEP-13 for more details.
|
|
*/
|
|
public volatile boolean partition_denylist_enabled = false;
|
|
|
|
public volatile boolean denylist_writes_enabled = true;
|
|
|
|
public volatile boolean denylist_reads_enabled = true;
|
|
|
|
public volatile boolean denylist_range_reads_enabled = true;
|
|
|
|
public DurationSpec.IntSecondsBound denylist_refresh = new DurationSpec.IntSecondsBound("600s");
|
|
|
|
public DurationSpec.IntSecondsBound denylist_initial_load_retry = new DurationSpec.IntSecondsBound("5s");
|
|
|
|
/** We cap the number of denylisted keys allowed per table to keep things from growing unbounded. Operators will
|
|
* receive warnings and only denylist_max_keys_per_table in natural query ordering will be processed on overflow.
|
|
*/
|
|
public volatile int denylist_max_keys_per_table = 1000;
|
|
|
|
/** We cap the total number of denylisted keys allowed in the cluster to keep things from growing unbounded.
|
|
* Operators will receive warnings on initial cache load that there are too many keys and be directed to trim
|
|
* down the entries to within the configured limits.
|
|
*/
|
|
public volatile int denylist_max_keys_total = 10000;
|
|
|
|
/** Since the denylist in many ways serves to protect the health of the cluster from partitions operators have identified
|
|
* as being in a bad state, we usually want more robustness than just CL.ONE on operations to/from these tables to
|
|
* ensure that these safeguards are in place. That said, we allow users to configure this if they're so inclined.
|
|
*/
|
|
public ConsistencyLevel denylist_consistency_level = ConsistencyLevel.QUORUM;
|
|
|
|
/**
|
|
* The intial capacity for creating RangeTombstoneList.
|
|
*/
|
|
public volatile int initial_range_tombstone_list_allocation_size = 1;
|
|
/**
|
|
* The growth factor to enlarge a RangeTombstoneList.
|
|
*/
|
|
public volatile double range_tombstone_list_growth_factor = 1.5;
|
|
|
|
public StorageAttachedIndexOptions sai_options = new StorageAttachedIndexOptions();
|
|
|
|
/**
|
|
* @deprecated migrate to {@link DatabaseDescriptor#isClientInitialized()} See CASSANDRA-12550
|
|
*/
|
|
@Deprecated(since = "3.10")
|
|
public static boolean isClientMode()
|
|
{
|
|
return isClientMode;
|
|
}
|
|
|
|
/**
|
|
* If true, when rows with duplicate clustering keys are detected during a read or compaction
|
|
* a snapshot will be taken. In the read case, each a snapshot request will be issued to each
|
|
* replica involved in the query, for compaction the snapshot will be created locally.
|
|
* These are limited at the replica level so that only a single snapshot per-day can be taken
|
|
* via this method.
|
|
*
|
|
* This requires check_for_duplicate_rows_during_reads and/or check_for_duplicate_rows_during_compaction
|
|
* below to be enabled
|
|
*/
|
|
public volatile boolean snapshot_on_duplicate_row_detection = false;
|
|
/**
|
|
* If these are enabled duplicate keys will get logged, and if snapshot_on_duplicate_row_detection
|
|
* is enabled, the table will get snapshotted for offline investigation
|
|
*/
|
|
public volatile boolean check_for_duplicate_rows_during_reads = true;
|
|
public volatile boolean check_for_duplicate_rows_during_compaction = true;
|
|
|
|
public boolean autocompaction_on_startup_enabled = AUTOCOMPACTION_ON_STARTUP_ENABLED.getBoolean();
|
|
|
|
// see CASSANDRA-3200 / CASSANDRA-16274
|
|
public volatile boolean auto_optimise_inc_repair_streams = false;
|
|
public volatile boolean auto_optimise_full_repair_streams = false;
|
|
public volatile boolean auto_optimise_preview_repair_streams = false;
|
|
|
|
// see CASSANDRA-17048 and the comment in cassandra.yaml
|
|
public boolean uuid_sstable_identifiers_enabled = false;
|
|
|
|
/**
|
|
* Client mode means that the process is a pure client, that uses C* code base but does
|
|
* not read or write local C* database files.
|
|
*
|
|
* @deprecated migrate to {@link DatabaseDescriptor#clientInitialization(boolean)} See CASSANDRA-12550
|
|
*/
|
|
@Deprecated(since = "3.10")
|
|
public static void setClientMode(boolean clientMode)
|
|
{
|
|
isClientMode = clientMode;
|
|
}
|
|
|
|
public volatile int consecutive_message_errors_threshold = 1;
|
|
|
|
public volatile SubnetGroups client_error_reporting_exclusions = new SubnetGroups();
|
|
public volatile SubnetGroups internode_error_reporting_exclusions = new SubnetGroups();
|
|
public volatile boolean invalid_legacy_protocol_magic_no_spam_enabled = false;
|
|
|
|
@Replaces(oldName = "keyspace_count_warn_threshold", converter = Converters.KEYSPACE_COUNT_THRESHOLD_TO_GUARDRAIL, deprecated = true)
|
|
public volatile int keyspaces_warn_threshold = -1;
|
|
public volatile int keyspaces_fail_threshold = -1;
|
|
@Replaces(oldName = "table_count_warn_threshold", converter = Converters.TABLE_COUNT_THRESHOLD_TO_GUARDRAIL, deprecated = true)
|
|
public volatile int tables_warn_threshold = -1;
|
|
public volatile int tables_fail_threshold = -1;
|
|
public volatile int columns_per_table_warn_threshold = -1;
|
|
public volatile int columns_per_table_fail_threshold = -1;
|
|
public volatile int secondary_indexes_per_table_warn_threshold = -1;
|
|
public volatile int secondary_indexes_per_table_fail_threshold = -1;
|
|
public volatile int materialized_views_per_table_warn_threshold = -1;
|
|
public volatile int materialized_views_per_table_fail_threshold = -1;
|
|
public volatile int page_size_warn_threshold = -1;
|
|
public volatile int page_size_fail_threshold = -1;
|
|
public volatile int partition_keys_in_select_warn_threshold = -1;
|
|
public volatile int partition_keys_in_select_fail_threshold = -1;
|
|
public volatile int in_select_cartesian_product_warn_threshold = -1;
|
|
public volatile int in_select_cartesian_product_fail_threshold = -1;
|
|
public volatile Set<String> table_properties_warned = Collections.emptySet();
|
|
public volatile Set<String> table_properties_ignored = Collections.emptySet();
|
|
public volatile Set<String> table_properties_disallowed = Collections.emptySet();
|
|
public volatile Set<String> keyspace_properties_warned = Collections.emptySet();
|
|
public volatile Set<String> keyspace_properties_ignored = Collections.emptySet();
|
|
public volatile Set<String> keyspace_properties_disallowed = Collections.emptySet();
|
|
public volatile Set<ConsistencyLevel> read_consistency_levels_warned = Collections.emptySet();
|
|
public volatile Set<ConsistencyLevel> read_consistency_levels_disallowed = Collections.emptySet();
|
|
public volatile Set<ConsistencyLevel> write_consistency_levels_warned = Collections.emptySet();
|
|
public volatile Set<ConsistencyLevel> write_consistency_levels_disallowed = Collections.emptySet();
|
|
public volatile boolean user_timestamps_enabled = true;
|
|
public volatile boolean alter_table_enabled = true;
|
|
public volatile boolean group_by_enabled = true;
|
|
public volatile boolean prepared_statements_require_parameters_warned = true;
|
|
public volatile boolean prepared_statements_require_parameters_enabled = false;
|
|
public volatile boolean bulk_load_enabled = true;
|
|
public volatile boolean drop_truncate_table_enabled = true;
|
|
public volatile boolean drop_keyspace_enabled = true;
|
|
public volatile boolean secondary_indexes_enabled = true;
|
|
|
|
/**
|
|
* If we encounter a Gossip bug where {@link org.apache.cassandra.gms.Gossiper#getMinVersion} is
|
|
* unable to accurately report a minimum version for the cluster, optionally force the optimized
|
|
* index status format added in CASSANDRA-20058.
|
|
*/
|
|
public volatile boolean force_optimized_index_status_format = false;
|
|
|
|
public volatile String default_secondary_index = CassandraIndex.NAME;
|
|
public volatile boolean default_secondary_index_enabled = true;
|
|
|
|
public volatile boolean uncompressed_tables_enabled = true;
|
|
public volatile boolean compact_tables_enabled = true;
|
|
public volatile boolean read_before_write_list_operations_enabled = true;
|
|
public volatile boolean allow_filtering_enabled = true;
|
|
public volatile boolean simplestrategy_enabled = true;
|
|
@Replaces(oldName = "compaction_large_partition_warning_threshold_mb", converter = Converters.LONG_BYTES_DATASTORAGE_MEBIBYTES_INT, deprecated = true)
|
|
@Replaces(oldName = "compaction_large_partition_warning_threshold", converter = Converters.LONG_BYTES_DATASTORAGE_MEBIBYTES_DATASTORAGE, deprecated = true)
|
|
public volatile DataStorageSpec.LongBytesBound partition_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound partition_size_fail_threshold = null;
|
|
@Replaces(oldName = "compaction_tombstone_warning_threshold", converter = Converters.INTEGER_PRIMITIVE_LONG, deprecated = true)
|
|
public volatile long partition_tombstones_warn_threshold = -1;
|
|
public volatile long partition_tombstones_fail_threshold = -1;
|
|
public volatile DataStorageSpec.LongBytesBound column_value_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound column_value_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound column_ascii_value_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound column_ascii_value_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound column_blob_value_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound column_blob_value_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound column_text_and_varchar_value_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound column_text_and_varchar_value_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound column_varchar_value_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound column_varchar_value_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound collection_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound collection_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound collection_map_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound collection_map_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound collection_set_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound collection_set_size_fail_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound collection_list_size_warn_threshold = null;
|
|
public volatile DataStorageSpec.LongBytesBound collection_list_size_fail_threshold = null;
|
|
public volatile int items_per_collection_warn_threshold = -1;
|
|
public volatile int items_per_collection_fail_threshold = -1;
|
|
public volatile int fields_per_udt_warn_threshold = -1;
|
|
public volatile int fields_per_udt_fail_threshold = -1;
|
|
public volatile boolean vector_type_enabled = true;
|
|
public volatile int vector_dimensions_warn_threshold = -1;
|
|
public volatile int vector_dimensions_fail_threshold = -1;
|
|
public volatile int data_disk_usage_percentage_warn_threshold = -1;
|
|
public volatile int data_disk_usage_percentage_fail_threshold = -1;
|
|
public volatile DataStorageSpec.LongBytesBound data_disk_usage_max_disk_size = null;
|
|
public volatile boolean data_disk_usage_keyspace_wide_protection_enabled = false;
|
|
public volatile int minimum_replication_factor_warn_threshold = -1;
|
|
public volatile int minimum_replication_factor_fail_threshold = -1;
|
|
public volatile int maximum_replication_factor_warn_threshold = -1;
|
|
public volatile int maximum_replication_factor_fail_threshold = -1;
|
|
public volatile boolean zero_ttl_on_twcs_warned = true;
|
|
public volatile boolean zero_ttl_on_twcs_enabled = true;
|
|
public volatile boolean non_partition_restricted_index_query_enabled = true;
|
|
public volatile boolean intersect_filtering_query_warned = true;
|
|
public volatile boolean intersect_filtering_query_enabled = true;
|
|
public volatile boolean unset_training_min_frequency_warned = true;
|
|
public volatile boolean unset_training_min_frequency_enabled = true;
|
|
|
|
public volatile Map<String, String> minimum_client_driver_versions_warned = Collections.emptyMap();
|
|
public volatile Map<String, String> minimum_client_driver_versions_disallowed = Collections.emptyMap();
|
|
|
|
public volatile int sai_sstable_indexes_per_query_warn_threshold = 32;
|
|
public volatile int sai_sstable_indexes_per_query_fail_threshold = -1;
|
|
public volatile DataStorageSpec.LongBytesBound sai_string_term_size_warn_threshold = new DataStorageSpec.LongBytesBound("1KiB");
|
|
public volatile DataStorageSpec.LongBytesBound sai_string_term_size_fail_threshold = new DataStorageSpec.LongBytesBound("8KiB");
|
|
public volatile DataStorageSpec.LongBytesBound sai_frozen_term_size_warn_threshold = new DataStorageSpec.LongBytesBound("1KiB");
|
|
public volatile DataStorageSpec.LongBytesBound sai_frozen_term_size_fail_threshold = new DataStorageSpec.LongBytesBound("8KiB");
|
|
public volatile DataStorageSpec.LongBytesBound sai_vector_term_size_warn_threshold = new DataStorageSpec.LongBytesBound("16KiB");
|
|
public volatile DataStorageSpec.LongBytesBound sai_vector_term_size_fail_threshold = new DataStorageSpec.LongBytesBound("32KiB");
|
|
|
|
public volatile DurationSpec.LongNanosecondsBound streaming_state_expires = new DurationSpec.LongNanosecondsBound("3d");
|
|
public volatile DataStorageSpec.LongBytesBound streaming_state_size = new DataStorageSpec.LongBytesBound("40MiB");
|
|
|
|
public volatile boolean streaming_stats_enabled = true;
|
|
public volatile DurationSpec.IntSecondsBound streaming_slow_events_log_timeout = new DurationSpec.IntSecondsBound("10s");
|
|
|
|
/** The configuration of startup checks. */
|
|
public volatile Map<String, Map<String, Object>> startup_checks = new HashMap<>();
|
|
|
|
public volatile DurationSpec.LongNanosecondsBound repair_state_expires = new DurationSpec.LongNanosecondsBound("3d");
|
|
public volatile int repair_state_size = 100_000;
|
|
|
|
/** The configuration of timestamp bounds */
|
|
public volatile DurationSpec.LongMicrosecondsBound maximum_timestamp_warn_threshold = null;
|
|
public volatile DurationSpec.LongMicrosecondsBound maximum_timestamp_fail_threshold = null;
|
|
public volatile DurationSpec.LongMicrosecondsBound minimum_timestamp_warn_threshold = null;
|
|
public volatile DurationSpec.LongMicrosecondsBound minimum_timestamp_fail_threshold = null;
|
|
|
|
public volatile boolean password_policy_reconfiguration_enabled = true;
|
|
public volatile boolean role_name_policy_reconfiguration_enabled = true;
|
|
public volatile CustomGuardrailConfig password_policy = new CustomGuardrailConfig();
|
|
public volatile CustomGuardrailConfig role_name_policy = new CustomGuardrailConfig();
|
|
public volatile AutoRepairConfig auto_repair = new AutoRepairConfig();
|
|
|
|
/**
|
|
* The variants of paxos implementation and semantics supported by Cassandra.
|
|
*/
|
|
public enum PaxosVariant
|
|
{
|
|
/**
|
|
* v1 Paxos lacks most optimisations. Expect 4RTs for a write and 2RTs for a read.
|
|
*
|
|
* With legacy semantics for read/read and rejected write linearizability, i.e. not guaranteed.
|
|
*/
|
|
v1_without_linearizable_reads_or_rejected_writes,
|
|
|
|
/**
|
|
* v1 Paxos lacks most optimisations. Expect 4RTs for a write and 3RTs for a read.
|
|
*/
|
|
v1,
|
|
|
|
/**
|
|
* v2 Paxos. With PaxosStatePurging.repaired safe to use ANY Commit consistency.
|
|
* Expect 2RTs for a write and 1RT for a read.
|
|
*
|
|
* With legacy semantics for read/read linearizability, i.e. not guaranteed.
|
|
*/
|
|
v2_without_linearizable_reads,
|
|
|
|
/**
|
|
* v2 Paxos. With PaxosStatePurging.repaired safe to use ANY Commit consistency.
|
|
* Expect 2RTs for a write and 1RT for a read.
|
|
*
|
|
* With legacy semantics for read/read and rejected write linearizability, i.e. not guaranteed.
|
|
*/
|
|
v2_without_linearizable_reads_or_rejected_writes,
|
|
|
|
/**
|
|
* v2 Paxos. With PaxosStatePurging.repaired safe to use ANY Commit consistency.
|
|
* Expect 2RTs for a write, and either 1RT or 2RT for a read.
|
|
*/
|
|
v2
|
|
}
|
|
|
|
/**
|
|
* Select the kind of paxos state purging to use. Migration to repaired is recommended, but requires that
|
|
* regular paxos repairs are performed (which by default run as part of incremental repair).
|
|
*
|
|
* Once migrated from legacy it is unsafe to return to legacy, but gc_grace mode may be used in its place
|
|
* and performs a very similar cleanup process.
|
|
*
|
|
* Should only be modified once paxos_variant = v2.
|
|
*/
|
|
public enum PaxosStatePurging
|
|
{
|
|
/**
|
|
* system.paxos records are written and garbage collected with TTLs. Unsafe to use with Commit consistency ANY.
|
|
* Once migrated from, cannot be migrated back to safely. Must use gc_grace or repaired instead, as TTLs
|
|
* will not have been set.
|
|
*/
|
|
legacy,
|
|
|
|
/**
|
|
* Functionally similar to legacy, but the gc_grace expiry is applied at compaction and read time rather than
|
|
* using TTLs, so may be safely enabled at any point.
|
|
*/
|
|
gc_grace,
|
|
|
|
/**
|
|
* Clears system.paxos records only once they are known to be persisted to a quorum of replica's base tables
|
|
* through the use of paxos repair. Requires that regular paxos repairs are performed on the cluster
|
|
* (which by default are included in incremental repairs if paxos_variant = v2).
|
|
*
|
|
* This setting permits the use of Commit consistency ANY or LOCAL_QUORUM without any loss of durability or consistency,
|
|
* saving 1 RT.
|
|
*/
|
|
repaired;
|
|
|
|
public static PaxosStatePurging fromBoolean(boolean enabled)
|
|
{
|
|
return enabled ? repaired : gc_grace;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* See {@link PaxosVariant}. Defaults to v1, recommend upgrading to v2 at earliest opportunity.
|
|
*/
|
|
public volatile PaxosVariant paxos_variant = PaxosVariant.v1;
|
|
|
|
/**
|
|
* If true, paxos topology change repair will not run on a topology change - this option should only be used in
|
|
* rare operation circumstances e.g. where for some reason the repair is impossible to perform (e.g. too few replicas)
|
|
* and an unsafe topology change must be made
|
|
*/
|
|
public volatile boolean skip_paxos_repair_on_topology_change = SKIP_PAXOS_REPAIR_ON_TOPOLOGY_CHANGE.getBoolean();
|
|
|
|
/**
|
|
* A safety margin when purging paxos state information that has been safely replicated to a quorum.
|
|
* Data for transactions initiated within this grace period will not be expunged.
|
|
*/
|
|
public volatile DurationSpec.LongSecondsBound paxos_purge_grace_period = new DurationSpec.LongSecondsBound("60s");
|
|
|
|
/**
|
|
* A safety mechanism for detecting incorrect paxos state, that may be down either to a bug or incorrect usage of LWTs
|
|
* (most likely due to unsafe mixing of SERIAL and LOCAL_SERIAL operations), and rejecting
|
|
*/
|
|
public enum PaxosOnLinearizabilityViolation
|
|
{
|
|
// reject an operation when a linearizability violation is detected.
|
|
// note this does not guarantee a violation has been averted,
|
|
// as it may be a prior operation that invalidated the state.
|
|
fail,
|
|
// log any detected linearizability violation
|
|
log,
|
|
// ignore any detected linearizability violation
|
|
ignore
|
|
}
|
|
|
|
/**
|
|
* See {@link PaxosOnLinearizabilityViolation}.
|
|
*
|
|
* Default is to ignore, as applications may readily mix SERIAL and LOCAL_SERIAL and this is the most likely source
|
|
* of linearizability violations. this facility should be activated only for debugging Cassandra or by power users
|
|
* who are investigating their own application behaviour.
|
|
*/
|
|
public volatile PaxosOnLinearizabilityViolation paxos_on_linearizability_violations = PaxosOnLinearizabilityViolation.ignore;
|
|
|
|
/**
|
|
* See {@link PaxosStatePurging} default is legacy.
|
|
*/
|
|
public volatile PaxosStatePurging paxos_state_purging;
|
|
|
|
/**
|
|
* Enable/disable paxos repair. This is a global flag that not only determines default behaviour but overrides
|
|
* explicit paxos repair requests, paxos repair on topology changes and paxos auto repairs.
|
|
*/
|
|
public volatile boolean paxos_repair_enabled = true;
|
|
|
|
/**
|
|
* If true, paxos topology change repair only requires a global quorum of live nodes. If false,
|
|
* it requires a global quorum as well as a local quorum for each dc (EACH_QUORUM), with the
|
|
* exception explained in paxos_topology_repair_strict_each_quorum
|
|
*/
|
|
public boolean paxos_topology_repair_no_dc_checks = false;
|
|
|
|
/**
|
|
* If true, a quorum will be required for the global and local quorum checks. If false, we will
|
|
* accept a quorum OR n - 1 live nodes. This is to allow for topologies like 2:2:2, where paxos queries
|
|
* always use SERIAL, and a single node down in a dc should not preclude a paxos repair
|
|
*/
|
|
public boolean paxos_topology_repair_strict_each_quorum = false;
|
|
|
|
/**
|
|
* If necessary for operational purposes, permit certain keyspaces to be ignored for paxos topology repairs
|
|
*/
|
|
public volatile Set<String> skip_paxos_repair_on_topology_change_keyspaces = splitCommaDelimited(SKIP_PAXOS_REPAIR_ON_TOPOLOGY_CHANGE_KEYSPACES.getString());
|
|
|
|
/**
|
|
* See {@link org.apache.cassandra.service.paxos.ContentionStrategy}
|
|
*/
|
|
public String paxos_contention_wait_randomizer;
|
|
|
|
/**
|
|
* See {@link org.apache.cassandra.service.paxos.ContentionStrategy}
|
|
*/
|
|
public String paxos_contention_min_wait;
|
|
|
|
/**
|
|
* See {@link org.apache.cassandra.service.paxos.ContentionStrategy}
|
|
*/
|
|
public String paxos_contention_max_wait;
|
|
|
|
/**
|
|
* See {@link org.apache.cassandra.service.paxos.ContentionStrategy}
|
|
*/
|
|
public String paxos_contention_min_delta;
|
|
|
|
/**
|
|
* The number of keys we may simultaneously attempt to finish incomplete paxos operations for.
|
|
*/
|
|
public volatile int paxos_repair_parallelism = -1;
|
|
|
|
public volatile boolean sstable_read_rate_persistence_enabled = false;
|
|
|
|
public volatile boolean client_request_size_metrics_enabled = true;
|
|
|
|
|
|
public volatile int max_top_size_partition_count = 10;
|
|
public volatile int max_top_tombstone_partition_count = 10;
|
|
public volatile DataStorageSpec.LongBytesBound min_tracked_partition_size = new DataStorageSpec.LongBytesBound("1MiB");
|
|
public volatile long min_tracked_partition_tombstone_count = 5000;
|
|
public volatile boolean top_partitions_enabled = true;
|
|
|
|
public final RepairConfig repair = new RepairConfig();
|
|
|
|
/**
|
|
* Default compaction configuration, used if a table does not specify any.
|
|
*/
|
|
public ParameterizedClass default_compaction = null;
|
|
|
|
public final AccordConfig accord = new AccordConfig();
|
|
|
|
public static Supplier<Config> getOverrideLoadConfig()
|
|
{
|
|
return overrideLoadConfig;
|
|
}
|
|
|
|
public static void setOverrideLoadConfig(Supplier<Config> loadConfig)
|
|
{
|
|
overrideLoadConfig = loadConfig;
|
|
}
|
|
|
|
public enum CommitLogSync
|
|
{
|
|
periodic,
|
|
batch,
|
|
group
|
|
}
|
|
|
|
public enum FlushCompression
|
|
{
|
|
none,
|
|
fast,
|
|
table
|
|
}
|
|
|
|
public enum InternodeCompression
|
|
{
|
|
all, none, dc
|
|
}
|
|
|
|
public enum DiskAccessMode
|
|
{
|
|
auto,
|
|
mmap,
|
|
mmap_index_only,
|
|
standard,
|
|
legacy,
|
|
|
|
/**
|
|
* Direct-I/O is enabled for commitlog disk only.
|
|
* When adding support for direct IO, update {@link org.apache.cassandra.service.StartupChecks#checkKernelBug1057843}
|
|
*/
|
|
direct
|
|
}
|
|
|
|
public enum MemtableAllocationType
|
|
{
|
|
unslabbed_heap_buffers,
|
|
unslabbed_heap_buffers_logged,
|
|
heap_buffers,
|
|
offheap_buffers,
|
|
offheap_objects;
|
|
|
|
public BufferType toBufferType()
|
|
{
|
|
switch (this)
|
|
{
|
|
case unslabbed_heap_buffers:
|
|
case unslabbed_heap_buffers_logged:
|
|
case heap_buffers:
|
|
return BufferType.ON_HEAP;
|
|
case offheap_buffers:
|
|
case offheap_objects:
|
|
return BufferType.OFF_HEAP;
|
|
default:
|
|
throw new AssertionError();
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum DiskFailurePolicy
|
|
{
|
|
best_effort,
|
|
stop,
|
|
ignore,
|
|
stop_paranoid,
|
|
die
|
|
}
|
|
|
|
public enum CommitFailurePolicy
|
|
{
|
|
stop,
|
|
stop_commit,
|
|
ignore,
|
|
die,
|
|
}
|
|
|
|
public enum UserFunctionTimeoutPolicy
|
|
{
|
|
ignore,
|
|
die,
|
|
die_immediate
|
|
}
|
|
|
|
public enum DiskOptimizationStrategy
|
|
{
|
|
ssd,
|
|
spinning
|
|
}
|
|
|
|
public enum RepairCommandPoolFullStrategy
|
|
{
|
|
queue,
|
|
reject
|
|
}
|
|
|
|
public enum CorruptedTombstoneStrategy
|
|
{
|
|
disabled,
|
|
warn,
|
|
exception
|
|
}
|
|
|
|
public enum BatchlogEndpointStrategy
|
|
{
|
|
/**
|
|
* Old, conventional strategy to select batchlog storage endpoints.
|
|
* Purely random, prevents the local rack, if possible.
|
|
*/
|
|
random_remote(false, false),
|
|
|
|
/**
|
|
* Random, except that one of the replications will go to the local rack.
|
|
* Which means this strategy offers lower availability guarantees than
|
|
* {@link #random_remote} or {@link #dynamic_remote}.
|
|
*/
|
|
prefer_local(false, true),
|
|
|
|
/**
|
|
* Strategy using {@link Config#dynamic_snitch} ({@link org.apache.cassandra.locator.DynamicEndpointSnitch})
|
|
* to select batchlog storage endpoints. Prevents the local rack, if possible.
|
|
*
|
|
* This strategy offers the same availability guarantees as {@link #random_remote} but selects the
|
|
* fastest endpoints according to the {@link org.apache.cassandra.locator.DynamicEndpointSnitch}.
|
|
*
|
|
* Hint: {@link org.apache.cassandra.locator.DynamicEndpointSnitch} tracks reads and not writes - i.e.
|
|
* write-only (or mostly-write) workloads might not benefit from this strategy.
|
|
*
|
|
* Note: this strategy will fall back to {@link #random_remote}, if {@link #dynamic_snitch} is not enabled.
|
|
*/
|
|
dynamic_remote(true, false),
|
|
|
|
/**
|
|
* Strategy using {@link Config#dynamic_snitch} ({@link org.apache.cassandra.locator.DynamicEndpointSnitch})
|
|
* to select batchlog storage endpoints. Does not prevent the local rack.
|
|
*
|
|
* Since the local rack is not excluded, this strategy offers lower availability guarantees than
|
|
* {@link #random_remote} or {@link #dynamic_remote}.
|
|
*
|
|
* Hint: {@link org.apache.cassandra.locator.DynamicEndpointSnitch} tracks reads and not writes - i.e.
|
|
* write-only (or mostly-write) workloads might not benefit from this strategy.
|
|
*
|
|
* Note: this strategy will fall back to {@link #random_remote}, if {@link #dynamic_snitch} is not enabled.
|
|
*/
|
|
dynamic(true, true);
|
|
|
|
/**
|
|
* If true, dynamic snitch response times will be used to select more responsive nodes to write the batchlog to.
|
|
* If false, nodes will be randomly selected.
|
|
*/
|
|
public final boolean useDynamicSnitchScores;
|
|
|
|
/**
|
|
* If true, one of the selected nodes will come from the local rack.
|
|
* If false, the local rack will not be used except as a last resort with no other racks available.
|
|
*/
|
|
public final boolean preferLocalRack;
|
|
|
|
BatchlogEndpointStrategy(boolean useDynamicSnitchScores, boolean preferLocalRack)
|
|
{
|
|
this.useDynamicSnitchScores = useDynamicSnitchScores;
|
|
this.preferLocalRack = preferLocalRack;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allow to control the granularity of metrics related to tombstones.
|
|
* It is a trade-off between granularity of a metric vs performance overheads.
|
|
* See CASSANDRA-20132 for more details.
|
|
*/
|
|
public enum TombstonesMetricGranularity
|
|
{
|
|
/**
|
|
* Do not collect the metric at all.
|
|
*/
|
|
disabled,
|
|
/**
|
|
* Track only partition/range/row level tombstone,
|
|
* a good compromise between overheads and usability.
|
|
* For CPU-bound workload you may get less than 1% of overhead for throughput.
|
|
* For IO-bound workload the overhead is negligible.
|
|
*/
|
|
row,
|
|
/**
|
|
* Track partition/range/row/cell level tombstones.
|
|
* This is the most granular option,
|
|
* but it has some performance overheads due to iteration over cells.
|
|
* For CPU-bound workload you may get about 5% of overhead for throughput.
|
|
* For IO-bound workload the overhead is almost negligible.
|
|
*/
|
|
cell
|
|
}
|
|
|
|
private static final Set<String> SENSITIVE_KEYS = new HashSet<String>() {{
|
|
add("client_encryption_options");
|
|
add("server_encryption_options");
|
|
// jmx_server_options output (JMXServerOptions.toString()) doesn't
|
|
// include sensitive encryption config so no need to blocklist here
|
|
}};
|
|
|
|
public static void log(Config config)
|
|
{
|
|
Map<String, String> configMap = new TreeMap<>();
|
|
for (Field field : Config.class.getFields())
|
|
{
|
|
// ignore the constants
|
|
if (Modifier.isFinal(field.getModifiers()))
|
|
continue;
|
|
|
|
String name = field.getName();
|
|
if (SENSITIVE_KEYS.contains(name))
|
|
{
|
|
configMap.put(name, "<REDACTED>");
|
|
continue;
|
|
}
|
|
|
|
String value;
|
|
try
|
|
{
|
|
Object obj = field.get(config);
|
|
value = obj != null ? obj.toString() : "null";
|
|
}
|
|
catch (IllegalAccessException npe)
|
|
{
|
|
value = "null";
|
|
}
|
|
configMap.put(name, value);
|
|
}
|
|
|
|
logger.info("Node configuration:[{}]", Joiner.on("; ").join(configMap.entrySet()));
|
|
}
|
|
|
|
public volatile boolean dump_heap_on_uncaught_exception = false;
|
|
public String heap_dump_path = "heapdump";
|
|
|
|
|
|
public double severity_during_decommission = 0;
|
|
|
|
// TODO Revisit MessagingService::current_version
|
|
public StorageCompatibilityMode storage_compatibility_mode;
|
|
|
|
/**
|
|
* For the purposes of progress barrier we only support ALL, EACH_QUORUM, QUORUM, LOCAL_QUORUM, ANY, and ONE.
|
|
*
|
|
* We will still try all consistency levels above the lowest acceptable, and only fall back to it if we can not
|
|
* collect enough nodes.
|
|
*/
|
|
public volatile ConsistencyLevel progress_barrier_min_consistency_level = ConsistencyLevel.EACH_QUORUM;
|
|
public volatile ConsistencyLevel progress_barrier_default_consistency_level = ConsistencyLevel.EACH_QUORUM;
|
|
|
|
public volatile DurationSpec.LongMillisecondsBound progress_barrier_timeout = new DurationSpec.LongMillisecondsBound("3600000ms");
|
|
public volatile DurationSpec.LongMillisecondsBound progress_barrier_backoff = new DurationSpec.LongMillisecondsBound("1000ms");
|
|
public volatile DurationSpec.LongSecondsBound discovery_timeout = new DurationSpec.LongSecondsBound("30s");
|
|
public boolean unsafe_tcm_mode = false;
|
|
public boolean legacy_state_listener_sync_local_updates = true;
|
|
|
|
public enum TriggersPolicy
|
|
{
|
|
// Execute triggers
|
|
enabled,
|
|
// Don't execute triggers when executing queries
|
|
disabled,
|
|
// Throw an exception when attempting to execute a trigger
|
|
forbidden
|
|
}
|
|
|
|
public TriggersPolicy triggers_policy = TriggersPolicy.enabled;
|
|
|
|
/**
|
|
* Which timestamp should be used to represent a base for replica-side timeouts.
|
|
* Client-side timeout is always based on the QUEUE, and is controlled by native_transport_timeout.
|
|
*/
|
|
public enum CQLStartTime
|
|
{
|
|
REQUEST, // uses a timestamp that represent the start of processing of the request
|
|
QUEUE // uses a timestamp that represents when the request was enqueued
|
|
}
|
|
public volatile CQLStartTime cql_start_time = CQLStartTime.REQUEST;
|
|
|
|
public boolean native_transport_throw_on_overload = false;
|
|
public double native_transport_queue_max_item_age_threshold = Double.MAX_VALUE;
|
|
public DurationSpec.LongMillisecondsBound native_transport_min_backoff_on_queue_overload = new DurationSpec.LongMillisecondsBound("10ms");
|
|
public DurationSpec.LongMillisecondsBound native_transport_max_backoff_on_queue_overload = new DurationSpec.LongMillisecondsBound("200ms");
|
|
|
|
// 3.x Cassandra Driver has its "read" timeout set to 12 seconds, default matches this.
|
|
public DurationSpec.LongMillisecondsBound native_transport_timeout = new DurationSpec.LongMillisecondsBound("12s");
|
|
public boolean enforce_native_deadline_for_hints = false;
|
|
|
|
public boolean paxos_repair_race_wait = true;
|
|
|
|
/**
|
|
* If true, gossip state updates for nodes which have left the cluster will continue to be processed while the
|
|
* node is still present in ClusterMetadata. This enables the gossip expiry time for those nodes (the deadline
|
|
* after which their state is fully purged from gossip) to converge across the remaining nodes in the cluster.
|
|
* This is a change from previous behaviour as historically once a node has advertised a LEFT status further
|
|
* updates to gossip state for it are ignored for a period of time to prevent flapping if older/stale states
|
|
* are encountered.
|
|
* Following CEP-21, most significant state changes are handled by the cluster metadata log, so resurrection
|
|
* of left nodes is not a problem for gossip to solve and so quarantine is not really necessary. However,
|
|
* FailureDetector does still use gossip messages to assess node health and some external systems still use gossip
|
|
* state to inform decisions about topology/node health/etc. For those reasons, for now the disabling of quarantine
|
|
* is off by default and hot-proppable.
|
|
*
|
|
* With quarantine still in effect, expiry from gossip of LEFT nodes will occur at different times on each peer.
|
|
* Also, when there are LEFT nodes in gossip, the state will never fully converge across the cluster as each node
|
|
* will have its own expiry time for a LEFT peer.
|
|
*
|
|
* With quarantine disabled the STATUS_WITH_PORT values for the left node which include the expiry time will
|
|
* converge and peers will all evict it from gossip after the same deadline.
|
|
*
|
|
* Eventually, this configuration option should be removed and quarantine disabled entirely for clusters running
|
|
* 6.0 and later.
|
|
*/
|
|
public volatile boolean gossip_quarantine_disabled = false;
|
|
}
|