apache-log4j-2.12.4-src.tar.gz: .../cassandra.yaml

"Fossies" - the Fresh Open Source Software Archive

Member "apache-log4j-2.12.4-src/log4j-cassandra/src/test/resources/cassandra.yaml" (20 Dec 2021, 43218 Bytes) of package /linux/misc/apache-log4j-2.12.4-src.tar.gz:

As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Ansible YAML source code syntax highlighting (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file. See also the last Fossies "Diffs" side-by-side code changes report for "cassandra.yaml":

2.18.0_vs_2.19.0.

1 # Licensed to the Apache Software Foundation (ASF) under one or more 2 # contributor license agreements. See the NOTICE file distributed with 3 # this work for additional information regarding copyright ownership. 4 # The ASF licenses this file to You under the Apache license, Version 2.0 5 # (the "License"); you may not use this file except in compliance with 6 # the License. You may obtain a copy of the License at 7 # 8 # http://www.apache.org/licenses/LICENSE-2.0 9 # 10 # Unless required by applicable law or agreed to in writing, software 11 # distributed under the License is distributed on an "AS IS" BASIS, 12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 # See the license for the specific language governing permissions and 14 # limitations under the license. 15 16 # Cassandra storage config YAML 17 18 # NOTE: 19 # See http://wiki.apache.org/cassandra/StorageConfiguration for 20 # full explanations of configuration directives 21 # /NOTE 22 23 # The name of the cluster. This is mainly used to prevent machines in 24 # one logical cluster from joining another. 25 cluster_name: 'Test Cluster' 26 27 # This defines the number of tokens randomly assigned to this node on the ring 28 # The more tokens, relative to other nodes, the larger the proportion of data 29 # that this node will store. You probably want all nodes to have the same number 30 # of tokens assuming they have equal hardware capability. 31 # 32 # If you leave this unspecified, Cassandra will use the default of 1 token for legacy compatibility, 33 # and will use the initial_token as described below. 34 # 35 # Specifying initial_token will override this setting on the node's initial start, 36 # on subsequent starts, this setting will apply even if initial token is set. 37 # 38 # If you already have a cluster with 1 token per node, and wish to migrate to 39 # multiple tokens per node, see http://wiki.apache.org/cassandra/Operations 40 num_tokens: 256 41 42 # initial_token allows you to specify tokens manually. While you can use # it with 43 # vnodes (num_tokens > 1, above) -- in which case you should provide a 44 # comma-separated list -- it's primarily used when adding nodes # to legacy clusters 45 # that do not have vnodes enabled. 46 # initial_token: 47 48 # See http://wiki.apache.org/cassandra/HintedHandoff 49 # May either be "true" or "false" to enable globally, or contain a list 50 # of data centers to enable per-datacenter. 51 # hinted_handoff_enabled: DC1,DC2 52 hinted_handoff_enabled: true 53 # this defines the maximum amount of time a dead host will have hints 54 # generated. After it has been dead this long, new hints for it will not be 55 # created until it has been seen alive and gone down again. 56 max_hint_window_in_ms: 10800000 # 3 hours 57 # Maximum throttle in KBs per second, per delivery thread. This will be 58 # reduced proportionally to the number of nodes in the cluster. (If there 59 # are two nodes in the cluster, each delivery thread will use the maximum 60 # rate; if there are three, each will throttle to half of the maximum, 61 # since we expect two nodes to be delivering hints simultaneously.) 62 hinted_handoff_throttle_in_kb: 1024 63 # Number of threads with which to deliver hints; 64 # Consider increasing this number when you have multi-dc deployments, since 65 # cross-dc handoff tends to be slower 66 max_hints_delivery_threads: 2 67 68 # Maximum throttle in KBs per second, total. This will be 69 # reduced proportionally to the number of nodes in the cluster. 70 batchlog_replay_throttle_in_kb: 1024 71 72 # Authentication backend, implementing IAuthenticator; used to identify users 73 # Out of the box, Cassandra provides org.apache.cassandra.auth.{AllowAllAuthenticator, 74 # PasswordAuthenticator}. 75 # 76 # - AllowAllAuthenticator performs no checks - set it to disable authentication. 77 # - PasswordAuthenticator relies on username/password pairs to authenticate 78 # users. It keeps usernames and hashed passwords in system_auth.credentials table. 79 # Please increase system_auth keyspace replication factor if you use this authenticator. 80 # If using PasswordAuthenticator, CassandraRoleManager must also be used (see below) 81 authenticator: AllowAllAuthenticator 82 83 # Authorization backend, implementing IAuthorizer; used to limit access/provide permissions 84 # Out of the box, Cassandra provides org.apache.cassandra.auth.{AllowAllAuthorizer, 85 # CassandraAuthorizer}. 86 # 87 # - AllowAllAuthorizer allows any action to any user - set it to disable authorization. 88 # - CassandraAuthorizer stores permissions in system_auth.permissions table. Please 89 # increase system_auth keyspace replication factor if you use this authorizer. 90 authorizer: AllowAllAuthorizer 91 92 # Part of the Authentication & Authorization backend, implementing IRoleManager; used 93 # to maintain grants and memberships between roles. 94 # Out of the box, Cassandra provides org.apache.cassandra.auth.CassandraRoleManager, 95 # which stores role information in the system_auth keyspace. Most functions of the 96 # IRoleManager require an authenticated login, so unless the configured IAuthenticator 97 # actually implements authentication, most of this functionality will be unavailable. 98 # 99 # - CassandraRoleManager stores role data in the system_auth keyspace. Please 100 # increase system_auth keyspace replication factor if you use this role manager. 101 role_manager: CassandraRoleManager 102 103 # Validity period for roles cache (fetching permissions can be an 104 # expensive operation depending on the authorizer). Granted roles are cached for 105 # authenticated sessions in AuthenticatedUser and after the period specified 106 # here, become eligible for (async) reload. 107 # Defaults to 2000, set to 0 to disable. 108 # Will be disabled automatically for AllowAllAuthenticator. 109 roles_validity_in_ms: 2000 110 111 # Refresh interval for roles cache (if enabled). 112 # After this interval, cache entries become eligible for refresh. Upon next 113 # access, an async reload is scheduled and the old value returned until it 114 # completes. If roles_validity_in_ms is non-zero, then this must be 115 # also. 116 # Defaults to the same value as roles_validity_in_ms. 117 # roles_update_interval_in_ms: 1000 118 119 # Validity period for permissions cache (fetching permissions can be an 120 # expensive operation depending on the authorizer, CassandraAuthorizer is 121 # one example). Defaults to 2000, set to 0 to disable. 122 # Will be disabled automatically for AllowAllAuthorizer. 123 permissions_validity_in_ms: 2000 124 125 # Refresh interval for permissions cache (if enabled). 126 # After this interval, cache entries become eligible for refresh. Upon next 127 # access, an async reload is scheduled and the old value returned until it 128 # completes. If permissions_validity_in_ms is non-zero, then this must be 129 # also. 130 # Defaults to the same value as permissions_validity_in_ms. 131 # permissions_update_interval_in_ms: 1000 132 133 # The partitioner is responsible for distributing groups of rows (by 134 # partition key) across nodes in the cluster. You should leave this 135 # alone for new clusters. The partitioner can NOT be changed without 136 # reloading all data, so when upgrading you should set this to the 137 # same partitioner you were already using. 138 # 139 # Besides Murmur3Partitioner, partitioners included for backwards 140 # compatibility include RandomPartitioner, ByteOrderedPartitioner, and 141 # OrderPreservingPartitioner. 142 # 143 partitioner: org.apache.cassandra.dht.Murmur3Partitioner 144 145 # Directories where Cassandra should store data on disk. Cassandra 146 # will spread data evenly across them, subject to the granularity of 147 # the configured compaction strategy. 148 # If not set, the default directory is $CASSANDRA_HOME/data/data. 149 # data_file_directories: 150 # - /var/lib/cassandra/data 151 152 # commit log. when running on magnetic HDD, this should be a 153 # separate spindle than the data directories. 154 # If not set, the default directory is $CASSANDRA_HOME/data/commitlog. 155 # commitlog_directory: /var/lib/cassandra/commitlog 156 157 # policy for data disk failures: 158 # die: shut down gossip and client transports and kill the JVM for any fs errors or 159 # single-sstable errors, so the node can be replaced. 160 # stop_paranoid: shut down gossip and client transports even for single-sstable errors, 161 # kill the JVM for errors during startup. 162 # stop: shut down gossip and client transports, leaving the node effectively dead, but 163 # can still be inspected via JMX, kill the JVM for errors during startup. 164 # best_effort: stop using the failed disk and respond to requests based on 165 # remaining available sstables. This means you WILL see obsolete 166 # data at CL.ONE! 167 # ignore: ignore fatal errors and let requests fail, as in pre-1.2 Cassandra 168 disk_failure_policy: stop 169 170 # policy for commit disk failures: 171 # die: shut down gossip and Thrift and kill the JVM, so the node can be replaced. 172 # stop: shut down gossip and Thrift, leaving the node effectively dead, but 173 # can still be inspected via JMX. 174 # stop_commit: shutdown the commit log, letting writes collect but 175 # continuing to service reads, as in pre-2.0.5 Cassandra 176 # ignore: ignore fatal errors and let the batches fail 177 commit_failure_policy: stop 178 179 # Maximum size of the key cache in memory. 180 # 181 # Each key cache hit saves 1 seek and each row cache hit saves 2 seeks at the 182 # minimum, sometimes more. The key cache is fairly tiny for the amount of 183 # time it saves, so it's worthwhile to use it at large numbers. 184 # The row cache saves even more time, but must contain the entire row, 185 # so it is extremely space-intensive. It's best to only use the 186 # row cache if you have hot rows or static rows. 187 # 188 # NOTE: if you reduce the size, you may not get you hottest keys loaded on startup. 189 # 190 # Default value is empty to make it "auto" (min(5% of Heap (in MB), 100MB)). Set to 0 to disable key cache. 191 key_cache_size_in_mb: 192 193 # Duration in seconds after which Cassandra should 194 # save the key cache. Caches are saved to saved_caches_directory as 195 # specified in this configuration file. 196 # 197 # Saved caches greatly improve cold-start speeds, and is relatively cheap in 198 # terms of I/O for the key cache. Row cache saving is much more expensive and 199 # has limited use. 200 # 201 # Default is 14400 or 4 hours. 202 key_cache_save_period: 14400 203 204 # Number of keys from the key cache to save 205 # Disabled by default, meaning all keys are going to be saved 206 # key_cache_keys_to_save: 100 207 208 # Row cache implementation class name. 209 # Available implementations: 210 # org.apache.cassandra.cache.OHCProvider Fully off-heap row cache implementation (default). 211 # org.apache.cassandra.cache.SerializingCacheProvider This is the row cache implementation availabile 212 # in previous releases of Cassandra. 213 # row_cache_class_name: org.apache.cassandra.cache.OHCProvider 214 215 # Maximum size of the row cache in memory. 216 # Please note that OHC cache implementation requires some additional off-heap memory to manage 217 # the map structures and some in-flight memory during operations before/after cache entries can be 218 # accounted against the cache capacity. This overhead is usually small compared to the whole capacity. 219 # Do not specify more memory that the system can afford in the worst usual situation and leave some 220 # headroom for OS block level cache. Do never allow your system to swap. 221 # 222 # Default value is 0, to disable row caching. 223 row_cache_size_in_mb: 0 224 225 # Duration in seconds after which Cassandra should save the row cache. 226 # Caches are saved to saved_caches_directory as specified in this configuration file. 227 # 228 # Saved caches greatly improve cold-start speeds, and is relatively cheap in 229 # terms of I/O for the key cache. Row cache saving is much more expensive and 230 # has limited use. 231 # 232 # Default is 0 to disable saving the row cache. 233 row_cache_save_period: 0 234 235 # Number of keys from the row cache to save. 236 # Specify 0 (which is the default), meaning all keys are going to be saved 237 # row_cache_keys_to_save: 100 238 239 # Maximum size of the counter cache in memory. 240 # 241 # Counter cache helps to reduce counter locks' contention for hot counter cells. 242 # In case of RF = 1 a counter cache hit will cause Cassandra to skip the read before 243 # write entirely. With RF > 1 a counter cache hit will still help to reduce the duration 244 # of the lock hold, helping with hot counter cell updates, but will not allow skipping 245 # the read entirely. Only the local (clock, count) tuple of a counter cell is kept 246 # in memory, not the whole counter, so it's relatively cheap. 247 # 248 # NOTE: if you reduce the size, you may not get you hottest keys loaded on startup. 249 # 250 # Default value is empty to make it "auto" (min(2.5% of Heap (in MB), 50MB)). Set to 0 to disable counter cache. 251 # NOTE: if you perform counter deletes and rely on low gcgs, you should disable the counter cache. 252 counter_cache_size_in_mb: 253 254 # Duration in seconds after which Cassandra should 255 # save the counter cache (keys only). Caches are saved to saved_caches_directory as 256 # specified in this configuration file. 257 # 258 # Default is 7200 or 2 hours. 259 counter_cache_save_period: 7200 260 261 # Number of keys from the counter cache to save 262 # Disabled by default, meaning all keys are going to be saved 263 # counter_cache_keys_to_save: 100 264 265 # saved caches 266 # If not set, the default directory is $CASSANDRA_HOME/data/saved_caches. 267 # saved_caches_directory: /var/lib/cassandra/saved_caches 268 269 # commitlog_sync may be either "periodic" or "batch." 270 # 271 # When in batch mode, Cassandra won't ack writes until the commit log 272 # has been fsynced to disk. It will wait 273 # commitlog_sync_batch_window_in_ms milliseconds between fsyncs. 274 # This window should be kept short because the writer threads will 275 # be unable to do extra work while waiting. (You may need to increase 276 # concurrent_writes for the same reason.) 277 # 278 # commitlog_sync: batch 279 # commitlog_sync_batch_window_in_ms: 2 280 # 281 # the other option is "periodic" where writes may be acked immediately 282 # and the CommitLog is simply synced every commitlog_sync_period_in_ms 283 # milliseconds. 284 commitlog_sync: periodic 285 commitlog_sync_period_in_ms: 10000 286 287 # The size of the individual commitlog file segments. A commitlog 288 # segment may be archived, deleted, or recycled once all the data 289 # in it (potentially from each columnfamily in the system) has been 290 # flushed to sstables. 291 # 292 # The default size is 32, which is almost always fine, but if you are 293 # archiving commitlog segments (see commitlog_archiving.properties), 294 # then you probably want a finer granularity of archiving; 8 or 16 MB 295 # is reasonable. 296 commitlog_segment_size_in_mb: 32 297 298 # Compression to apply to the commit log. If omitted, the commit log 299 # will be written uncompressed. LZ4, Snappy, and Deflate compressors 300 # are supported. 301 #commitlog_compression: 302 # - class_name: LZ4Compressor 303 # parameters: 304 # - 305 306 # any class that implements the SeedProvider interface and has a 307 # constructor that takes a Map<String, String> of parameters will do. 308 seed_provider: 309 # Addresses of hosts that are deemed contact points. 310 # Cassandra nodes use this list of hosts to find each other and learn 311 # the topology of the ring. You must change this if you are running 312 # multiple nodes! 313 - class_name: org.apache.cassandra.locator.SimpleSeedProvider 314 parameters: 315 # seeds is actually a comma-delimited list of addresses. 316 # Ex: "<ip1>,<ip2>,<ip3>" 317 - seeds: "127.0.0.1" 318 319 # For workloads with more data than can fit in memory, Cassandra's 320 # bottleneck will be reads that need to fetch data from 321 # disk. "concurrent_reads" should be set to (16 * number_of_drives) in 322 # order to allow the operations to enqueue low enough in the stack 323 # that the OS and drives can reorder them. Same applies to 324 # "concurrent_counter_writes", since counter writes read the current 325 # values before incrementing and writing them back. 326 # 327 # On the other hand, since writes are almost never IO bound, the ideal 328 # number of "concurrent_writes" is dependent on the number of cores in 329 # your system; (8 * number_of_cores) is a good rule of thumb. 330 concurrent_reads: 32 331 concurrent_writes: 32 332 concurrent_counter_writes: 32 333 334 # Total memory to use for sstable-reading buffers. Defaults to 335 # the smaller of 1/4 of heap or 512MB. 336 # file_cache_size_in_mb: 512 337 338 # Total permitted memory to use for memtables. Cassandra will stop 339 # accepting writes when the limit is exceeded until a flush completes, 340 # and will trigger a flush based on memtable_cleanup_threshold 341 # If omitted, Cassandra will set both to 1/4 the size of the heap. 342 # memtable_heap_space_in_mb: 2048 343 # memtable_offheap_space_in_mb: 2048 344 345 # Ratio of occupied non-flushing memtable size to total permitted size 346 # that will trigger a flush of the largest memtable. Larger mct will 347 # mean larger flushes and hence less compaction, but also less concurrent 348 # flush activity which can make it difficult to keep your disks fed 349 # under heavy write load. 350 # 351 # memtable_cleanup_threshold defaults to 1 / (memtable_flush_writers + 1) 352 # memtable_cleanup_threshold: 0.11 353 354 # Specify the way Cassandra allocates and manages memtable memory. 355 # Options are: 356 # heap_buffers: on heap nio buffers 357 # offheap_buffers: off heap (direct) nio buffers 358 # offheap_objects: native memory, eliminating nio buffer heap overhead 359 memtable_allocation_type: heap_buffers 360 361 # Total space to use for commit logs on disk. 362 # 363 # If space gets above this value, Cassandra will flush every dirty CF 364 # in the oldest segment and remove it. So a small total commitlog space 365 # will tend to cause more flush activity on less-active columnfamilies. 366 # 367 # The default value is the smaller of 8192, and 1/4 of the total space 368 # of the commitlog volume. 369 # 370 # commitlog_total_space_in_mb: 8192 371 372 # This sets the amount of memtable flush writer threads. These will 373 # be blocked by disk io, and each one will hold a memtable in memory 374 # while blocked. 375 # 376 # memtable_flush_writers defaults to the smaller of (number of disks, 377 # number of cores), with a minimum of 2 and a maximum of 8. 378 # 379 # If your data directories are backed by SSD, you should increase this 380 # to the number of cores. 381 #memtable_flush_writers: 8 382 383 # A fixed memory pool size in MB for for SSTable index summaries. If left 384 # empty, this will default to 5% of the heap size. If the memory usage of 385 # all index summaries exceeds this limit, SSTables with low read rates will 386 # shrink their index summaries in order to meet this limit. However, this 387 # is a best-effort process. In extreme conditions Cassandra may need to use 388 # more than this amount of memory. 389 index_summary_capacity_in_mb: 390 391 # How frequently index summaries should be resampled. This is done 392 # periodically to redistribute memory from the fixed-size pool to sstables 393 # proportional their recent read rates. Setting to -1 will disable this 394 # process, leaving existing index summaries at their current sampling level. 395 index_summary_resize_interval_in_minutes: 60 396 397 # Whether to, when doing sequential writing, fsync() at intervals in 398 # order to force the operating system to flush the dirty 399 # buffers. Enable this to avoid sudden dirty buffer flushing from 400 # impacting read latencies. Almost always a good idea on SSDs; not 401 # necessarily on platters. 402 trickle_fsync: false 403 trickle_fsync_interval_in_kb: 10240 404 405 # TCP port, for commands and data 406 # For security reasons, you should not expose this port to the internet. Firewall it if needed. 407 storage_port: 7000 408 409 # SSL port, for encrypted communication. Unused unless enabled in 410 # encryption_options 411 # For security reasons, you should not expose this port to the internet. Firewall it if needed. 412 ssl_storage_port: 7001 413 414 # Address or interface to bind to and tell other Cassandra nodes to connect to. 415 # You _must_ change this if you want multiple nodes to be able to communicate! 416 # 417 # Set listen_address OR listen_interface, not both. Interfaces must correspond 418 # to a single address, IP aliasing is not supported. 419 # 420 # Leaving it blank leaves it up to InetAddress.getLocalHost(). This 421 # will always do the Right Thing _if_ the node is properly configured 422 # (hostname, name resolution, etc), and the Right Thing is to use the 423 # address associated with the hostname (it might not be). 424 # 425 # Setting listen_address to 0.0.0.0 is always wrong. 426 # 427 # If you choose to specify the interface by name and the interface has an ipv4 and an ipv6 address 428 # you can specify which should be chosen using listen_interface_prefer_ipv6. If false the first ipv4 429 # address will be used. If true the first ipv6 address will be used. Defaults to false preferring 430 # ipv4. If there is only one address it will be selected regardless of ipv4/ipv6. 431 listen_address: localhost 432 # listen_interface: eth0 433 # listen_interface_prefer_ipv6: false 434 435 # Address to broadcast to other Cassandra nodes 436 # Leaving this blank will set it to the same value as listen_address 437 # broadcast_address: 1.2.3.4 438 439 # When using multiple physical network interfaces, set this 440 # to true to listen on broadcast_address in addition to 441 # the listen_address, allowing nodes to communicate in both 442 # interfaces. 443 # Ignore this property if the network configuration automatically 444 # routes between the public and private networks such as EC2. 445 # listen_on_broadcast_address: false 446 447 # Internode authentication backend, implementing IInternodeAuthenticator; 448 # used to allow/disallow connections from peer nodes. 449 # internode_authenticator: org.apache.cassandra.auth.AllowAllInternodeAuthenticator 450 451 # Whether to start the native transport server. 452 # Please note that the address on which the native transport is bound is the 453 # same as the rpc_address. The port however is different and specified below. 454 start_native_transport: true 455 # port for the CQL native transport to listen for clients on 456 # For security reasons, you should not expose this port to the internet. Firewall it if needed. 457 native_transport_port: 9042 458 # The maximum threads for handling requests when the native transport is used. 459 # This is similar to rpc_max_threads though the default differs slightly (and 460 # there is no native_transport_min_threads, idle threads will always be stopped 461 # after 30 seconds). 462 # native_transport_max_threads: 128 463 # 464 # The maximum size of allowed frame. Frame (requests) larger than this will 465 # be rejected as invalid. The default is 256MB. 466 # native_transport_max_frame_size_in_mb: 256 467 468 # The maximum number of concurrent client connections. 469 # The default is -1, which means unlimited. 470 # native_transport_max_concurrent_connections: -1 471 472 # The maximum number of concurrent client connections per source ip. 473 # The default is -1, which means unlimited. 474 # native_transport_max_concurrent_connections_per_ip: -1 475 476 # Whether to start the thrift rpc server. 477 start_rpc: false 478 479 # The address or interface to bind the Thrift RPC service and native transport 480 # server to. 481 # 482 # Set rpc_address OR rpc_interface, not both. Interfaces must correspond 483 # to a single address, IP aliasing is not supported. 484 # 485 # Leaving rpc_address blank has the same effect as on listen_address 486 # (i.e. it will be based on the configured hostname of the node). 487 # 488 # Note that unlike listen_address, you can specify 0.0.0.0, but you must also 489 # set broadcast_rpc_address to a value other than 0.0.0.0. 490 # 491 # For security reasons, you should not expose this port to the internet. Firewall it if needed. 492 # 493 # If you choose to specify the interface by name and the interface has an ipv4 and an ipv6 address 494 # you can specify which should be chosen using rpc_interface_prefer_ipv6. If false the first ipv4 495 # address will be used. If true the first ipv6 address will be used. Defaults to false preferring 496 # ipv4. If there is only one address it will be selected regardless of ipv4/ipv6. 497 rpc_address: localhost 498 # rpc_interface: eth1 499 # rpc_interface_prefer_ipv6: false 500 501 # port for Thrift to listen for clients on 502 rpc_port: 9160 503 504 # RPC address to broadcast to drivers and other Cassandra nodes. This cannot 505 # be set to 0.0.0.0. If left blank, this will be set to the value of 506 # rpc_address. If rpc_address is set to 0.0.0.0, broadcast_rpc_address must 507 # be set. 508 # broadcast_rpc_address: 1.2.3.4 509 510 # enable or disable keepalive on rpc/native connections 511 rpc_keepalive: true 512 513 # Cassandra provides two out-of-the-box options for the RPC Server: 514 # 515 # sync -> One thread per thrift connection. For a very large number of clients, memory 516 # will be your limiting factor. On a 64 bit JVM, 180KB is the minimum stack size 517 # per thread, and that will correspond to your use of virtual memory (but physical memory 518 # may be limited depending on use of stack space). 519 # 520 # hsha -> Stands for "half synchronous, half asynchronous." All thrift clients are handled 521 # asynchronously using a small number of threads that does not vary with the amount 522 # of thrift clients (and thus scales well to many clients). The rpc requests are still 523 # synchronous (one thread per active request). If hsha is selected then it is essential 524 # that rpc_max_threads is changed from the default value of unlimited. 525 # 526 # The default is sync because on Windows hsha is about 30% slower. On Linux, 527 # sync/hsha performance is about the same, with hsha of course using less memory. 528 # 529 # Alternatively, can provide your own RPC server by providing the fully-qualified class name 530 # of an o.a.c.t.TServerFactory that can create an instance of it. 531 rpc_server_type: sync 532 533 # Uncomment rpc_min|max_thread to set request pool size limits. 534 # 535 # Regardless of your choice of RPC server (see above), the number of maximum requests in the 536 # RPC thread pool dictates how many concurrent requests are possible (but if you are using the sync 537 # RPC server, it also dictates the number of clients that can be connected at all). 538 # 539 # The default is unlimited and thus provides no protection against clients overwhelming the server. You are 540 # encouraged to set a maximum that makes sense for you in production, but do keep in mind that 541 # rpc_max_threads represents the maximum number of client requests this server may execute concurrently. 542 # 543 # rpc_min_threads: 16 544 # rpc_max_threads: 2048 545 546 # uncomment to set socket buffer sizes on rpc connections 547 # rpc_send_buff_size_in_bytes: 548 # rpc_recv_buff_size_in_bytes: 549 550 # Uncomment to set socket buffer size for internode communication 551 # Note that when setting this, the buffer size is limited by net.core.wmem_max 552 # and when not setting it it is defined by net.ipv4.tcp_wmem 553 # See: 554 # /proc/sys/net/core/wmem_max 555 # /proc/sys/net/core/rmem_max 556 # /proc/sys/net/ipv4/tcp_wmem 557 # /proc/sys/net/ipv4/tcp_wmem 558 # and: man tcp 559 # internode_send_buff_size_in_bytes: 560 # internode_recv_buff_size_in_bytes: 561 562 # Frame size for thrift (maximum message length). 563 thrift_framed_transport_size_in_mb: 15 564 565 # Set to true to have Cassandra create a hard link to each sstable 566 # flushed or streamed locally in a backups/ subdirectory of the 567 # keyspace data. Removing these links is the operator's 568 # responsibility. 569 incremental_backups: false 570 571 # Whether or not to take a snapshot before each compaction. Be 572 # careful using this option, since Cassandra won't clean up the 573 # snapshots for you. Mostly useful if you're paranoid when there 574 # is a data format change. 575 snapshot_before_compaction: false 576 577 # Whether or not a snapshot is taken of the data before keyspace truncation 578 # or dropping of column families. The STRONGLY advised default of true 579 # should be used to provide data safety. If you set this flag to false, you will 580 # lose data on truncation or drop. 581 auto_snapshot: true 582 583 # When executing a scan, within or across a partition, we need to keep the 584 # tombstones seen in memory so we can return them to the coordinator, which 585 # will use them to make sure other replicas also know about the deleted rows. 586 # With workloads that generate a lot of tombstones, this can cause performance 587 # problems and even exaust the server heap. 588 # (http://www.datastax.com/dev/blog/cassandra-anti-patterns-queues-and-queue-like-datasets) 589 # Adjust the thresholds here if you understand the dangers and want to 590 # scan more tombstones anyway. These thresholds may also be adjusted at runtime 591 # using the StorageService mbean. 592 tombstone_warn_threshold: 1000 593 tombstone_failure_threshold: 100000 594 595 # Granularity of the collation index of rows within a partition. 596 # Increase if your rows are large, or if you have a very large 597 # number of rows per partition. The competing goals are these: 598 # 1) a smaller granularity means more index entries are generated 599 # and looking up rows withing the partition by collation column 600 # is faster 601 # 2) but, Cassandra will keep the collation index in memory for hot 602 # rows (as part of the key cache), so a larger granularity means 603 # you can cache more hot rows 604 column_index_size_in_kb: 64 605 606 607 # Log WARN on any batch size exceeding this value. 5kb per batch by default. 608 # Caution should be taken on increasing the size of this threshold as it can lead to node instability. 609 batch_size_warn_threshold_in_kb: 5 610 611 # Fail any batch exceeding this value. 50kb (10x warn threshold) by default. 612 batch_size_fail_threshold_in_kb: 50 613 614 # Log WARN on any batches not of type LOGGED than span across more partitions than this limit 615 unlogged_batch_across_partitions_warn_threshold: 10 616 617 # Number of simultaneous compactions to allow, NOT including 618 # validation "compactions" for anti-entropy repair. Simultaneous 619 # compactions can help preserve read performance in a mixed read/write 620 # workload, by mitigating the tendency of small sstables to accumulate 621 # during a single long running compactions. The default is usually 622 # fine and if you experience problems with compaction running too 623 # slowly or too fast, you should look at 624 # compaction_throughput_mb_per_sec first. 625 # 626 # concurrent_compactors defaults to the smaller of (number of disks, 627 # number of cores), with a minimum of 2 and a maximum of 8. 628 # 629 # If your data directories are backed by SSD, you should increase this 630 # to the number of cores. 631 #concurrent_compactors: 1 632 633 # Throttles compaction to the given total throughput across the entire 634 # system. The faster you insert data, the faster you need to compact in 635 # order to keep the sstable count down, but in general, setting this to 636 # 16 to 32 times the rate you are inserting data is more than sufficient. 637 # Setting this to 0 disables throttling. Note that this account for all types 638 # of compaction, including validation compaction. 639 compaction_throughput_mb_per_sec: 16 640 641 # Log a warning when compacting partitions larger than this value 642 compaction_large_partition_warning_threshold_mb: 100 643 644 # When compacting, the replacement sstable(s) can be opened before they 645 # are completely written, and used in place of the prior sstables for 646 # any range that has been written. This helps to smoothly transfer reads 647 # between the sstables, reducing page cache churn and keeping hot rows hot 648 sstable_preemptive_open_interval_in_mb: 50 649 650 # Throttles all outbound streaming file transfers on this node to the 651 # given total throughput in Mbps. This is necessary because Cassandra does 652 # mostly sequential IO when streaming data during bootstrap or repair, which 653 # can lead to saturating the network connection and degrading rpc performance. 654 # When unset, the default is 200 Mbps or 25 MB/s. 655 # stream_throughput_outbound_megabits_per_sec: 200 656 657 # Throttles all streaming file transfer between the datacenters, 658 # this setting allows users to throttle inter dc stream throughput in addition 659 # to throttling all network stream traffic as configured with 660 # stream_throughput_outbound_megabits_per_sec 661 # When unset, the default is 200 Mbps or 25 MB/s 662 # inter_dc_stream_throughput_outbound_megabits_per_sec: 200 663 664 # How long the coordinator should wait for read operations to complete 665 read_request_timeout_in_ms: 5000 666 # How long the coordinator should wait for seq or index scans to complete 667 range_request_timeout_in_ms: 10000 668 # How long the coordinator should wait for writes to complete 669 write_request_timeout_in_ms: 2000 670 # How long the coordinator should wait for counter writes to complete 671 counter_write_request_timeout_in_ms: 5000 672 # How long a coordinator should continue to retry a CAS operation 673 # that contends with other proposals for the same row 674 cas_contention_timeout_in_ms: 1000 675 # How long the coordinator should wait for truncates to complete 676 # (This can be much longer, because unless auto_snapshot is disabled 677 # we need to flush first so we can snapshot before removing the data.) 678 truncate_request_timeout_in_ms: 60000 679 # The default timeout for other, miscellaneous operations 680 request_timeout_in_ms: 10000 681 682 # Enable operation timeout information exchange between nodes to accurately 683 # measure request timeouts. If disabled, replicas will assume that requests 684 # were forwarded to them instantly by the coordinator, which means that 685 # under overload conditions we will waste that much extra time processing 686 # already-timed-out requests. 687 # 688 # Warning: before enabling this property make sure to ntp is installed 689 # and the times are synchronized between the nodes. 690 cross_node_timeout: false 691 692 # Set socket timeout for streaming operation. 693 # The stream session is failed if no data/ack is received by any of the participants 694 # within that period, which means this should also be sufficient to stream a large 695 # sstable or rebuild table indexes. 696 # Default value is 86400000ms, which means stale streams timeout after 24 hours. 697 # A value of zero means stream sockets should never time out. 698 # streaming_socket_timeout_in_ms: 86400000 699 700 # phi value that must be reached for a host to be marked down. 701 # most users should never need to adjust this. 702 # phi_convict_threshold: 8 703 704 # endpoint_snitch -- Set this to a class that implements 705 # IEndpointSnitch. The snitch has two functions: 706 # - it teaches Cassandra enough about your network topology to route 707 # requests efficiently 708 # - it allows Cassandra to spread replicas around your cluster to avoid 709 # correlated failures. It does this by grouping machines into 710 # "datacenters" and "racks." Cassandra will do its best not to have 711 # more than one replica on the same "rack" (which may not actually 712 # be a physical location) 713 # 714 # CASSANDRA WILL NOT ALLOW YOU TO SWITCH TO AN INCOMPATIBLE SNITCH 715 # ONCE DATA IS INSERTED INTO THE CLUSTER. This would cause data loss. 716 # This means that if you start with the default SimpleSnitch, which 717 # locates every node on "rack1" in "datacenter1", your only options 718 # if you need to add another datacenter are GossipingPropertyFileSnitch 719 # (and the older PFS). From there, if you want to migrate to an 720 # incompatible snitch like Ec2Snitch you can do it by adding new nodes 721 # under Ec2Snitch (which will locate them in a new "datacenter") and 722 # decommissioning the old ones. 723 # 724 # Out of the box, Cassandra provides 725 # - SimpleSnitch: 726 # Treats Strategy order as proximity. This can improve cache 727 # locality when disabling read repair. Only appropriate for 728 # single-datacenter deployments. 729 # - GossipingPropertyFileSnitch 730 # This should be your go-to snitch for production use. The rack 731 # and datacenter for the local node are defined in 732 # cassandra-rackdc.properties and propagated to other nodes via 733 # gossip. If cassandra-topology.properties exists, it is used as a 734 # fallback, allowing migration from the PropertyFileSnitch. 735 # - PropertyFileSnitch: 736 # Proximity is determined by rack and data center, which are 737 # explicitly configured in cassandra-topology.properties. 738 # - Ec2Snitch: 739 # Appropriate for EC2 deployments in a single Region. Loads Region 740 # and Availability Zone information from the EC2 API. The Region is 741 # treated as the datacenter, and the Availability Zone as the rack. 742 # Only private IPs are used, so this will not work across multiple 743 # Regions. 744 # - Ec2MultiRegionSnitch: 745 # Uses public IPs as broadcast_address to allow cross-region 746 # connectivity. (Thus, you should set seed addresses to the public 747 # IP as well.) You will need to open the storage_port or 748 # ssl_storage_port on the public IP firewall. (For intra-Region 749 # traffic, Cassandra will switch to the private IP after 750 # establishing a connection.) 751 # - RackInferringSnitch: 752 # Proximity is determined by rack and data center, which are 753 # assumed to correspond to the 3rd and 2nd octet of each node's IP 754 # address, respectively. Unless this happens to match your 755 # deployment conventions, this is best used as an example of 756 # writing a custom Snitch class and is provided in that spirit. 757 # 758 # You can use a custom Snitch by setting this to the full class name 759 # of the snitch, which will be assumed to be on your classpath. 760 endpoint_snitch: SimpleSnitch 761 762 # controls how often to perform the more expensive part of host score 763 # calculation 764 dynamic_snitch_update_interval_in_ms: 100 765 # controls how often to reset all host scores, allowing a bad host to 766 # possibly recover 767 dynamic_snitch_reset_interval_in_ms: 600000 768 # if set greater than zero and read_repair_chance is < 1.0, this will allow 769 # 'pinning' of replicas to hosts in order to increase cache capacity. 770 # The badness threshold will control how much worse the pinned host has to be 771 # before the dynamic snitch will prefer other replicas over it. This is 772 # expressed as a double which represents a percentage. Thus, a value of 773 # 0.2 means Cassandra would continue to prefer the static snitch values 774 # until the pinned host was 20% worse than the fastest. 775 dynamic_snitch_badness_threshold: 0.1 776 777 # request_scheduler -- Set this to a class that implements 778 # RequestScheduler, which will schedule incoming client requests 779 # according to the specific policy. This is useful for multi-tenancy 780 # with a single Cassandra cluster. 781 # NOTE: This is specifically for requests from the client and does 782 # not affect inter node communication. 783 # org.apache.cassandra.scheduler.NoScheduler - No scheduling takes place 784 # org.apache.cassandra.scheduler.RoundRobinScheduler - Round robin of 785 # client requests to a node with a separate queue for each 786 # request_scheduler_id. The scheduler is further customized by 787 # request_scheduler_options as described below. 788 request_scheduler: org.apache.cassandra.scheduler.NoScheduler 789 790 # Scheduler Options vary based on the type of scheduler 791 # NoScheduler - Has no options 792 # RoundRobin 793 # - throttle_limit -- The throttle_limit is the number of in-flight 794 # requests per client. Requests beyond 795 # that limit are queued up until 796 # running requests can complete. 797 # The value of 80 here is twice the number of 798 # concurrent_reads + concurrent_writes. 799 # - default_weight -- default_weight is optional and allows for 800 # overriding the default which is 1. 801 # - weights -- Weights are optional and will default to 1 or the 802 # overridden default_weight. The weight translates into how 803 # many requests are handled during each turn of the 804 # RoundRobin, based on the scheduler id. 805 # 806 # request_scheduler_options: 807 # throttle_limit: 80 808 # default_weight: 5 809 # weights: 810 # Keyspace1: 1 811 # Keyspace2: 5 812 813 # request_scheduler_id -- An identifier based on which to perform 814 # the request scheduling. Currently the only valid option is keyspace. 815 # request_scheduler_id: keyspace 816 817 # Enable or disable inter-node encryption 818 # Default settings are TLS v1, RSA 1024-bit keys (it is imperative that 819 # users generate their own keys) TLS_RSA_WITH_AES_128_CBC_SHA as the cipher 820 # suite for authentication, key exchange and encryption of the actual data transfers. 821 # Use the DHE/ECDHE ciphers if running in FIPS 140 compliant mode. 822 # NOTE: No custom encryption options are enabled at the moment 823 # The available internode options are : all, none, dc, rack 824 # 825 # If set to dc cassandra will encrypt the traffic between the DCs 826 # If set to rack cassandra will encrypt the traffic between the racks 827 # 828 # The passwords used in these options must match the passwords used when generating 829 # the keystore and truststore. For instructions on generating these files, see: 830 # http://download.oracle.com/javase/6/docs/technotes/guides/security/jsse/JSSERefGuide.html#CreateKeystore 831 # 832 server_encryption_options: 833 internode_encryption: none 834 keystore: conf/.keystore 835 keystore_password: cassandra 836 truststore: conf/.truststore 837 truststore_password: cassandra 838 # More advanced defaults below: 839 # protocol: TLS 840 # algorithm: SunX509 841 # store_type: JKS 842 # cipher_suites: [TLS_RSA_WITH_AES_128_CBC_SHA,TLS_RSA_WITH_AES_256_CBC_SHA,TLS_DHE_RSA_WITH_AES_128_CBC_SHA,TLS_DHE_RSA_WITH_AES_256_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA] 843 # require_client_auth: false 844 845 # enable or disable client/server encryption. 846 client_encryption_options: 847 enabled: false 848 # If enabled and optional is set to true encrypted and unencrypted connections are handled. 849 optional: false 850 keystore: conf/.keystore 851 keystore_password: cassandra 852 # require_client_auth: false 853 # Set trustore and truststore_password if require_client_auth is true 854 # truststore: conf/.truststore 855 # truststore_password: cassandra 856 # More advanced defaults below: 857 # protocol: TLS 858 # algorithm: SunX509 859 # store_type: JKS 860 # cipher_suites: [TLS_RSA_WITH_AES_128_CBC_SHA,TLS_RSA_WITH_AES_256_CBC_SHA,TLS_DHE_RSA_WITH_AES_128_CBC_SHA,TLS_DHE_RSA_WITH_AES_256_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA] 861 862 # internode_compression controls whether traffic between nodes is 863 # compressed. 864 # can be: all - all traffic is compressed 865 # dc - traffic between different datacenters is compressed 866 # none - nothing is compressed. 867 internode_compression: all 868 869 # Enable or disable tcp_nodelay for inter-dc communication. 870 # Disabling it will result in larger (but fewer) network packets being sent, 871 # reducing overhead from the TCP protocol itself, at the cost of increasing 872 # latency if you block for cross-datacenter responses. 873 inter_dc_tcp_nodelay: false 874 875 # TTL for different trace types used during logging of the repair process. 876 tracetype_query_ttl: 86400 877 tracetype_repair_ttl: 604800 878 879 # By default, Cassandra logs GC Pauses greater than 200 ms at INFO level 880 # This threshold can be adjusted to minimize logging if necessary 881 # gc_log_threshold_in_ms: 200 882 883 # GC Pauses greater than gc_warn_threshold_in_ms will be logged at WARN level 884 # If unset, all GC Pauses greater than gc_log_threshold_in_ms will log at 885 # INFO level 886 # Adjust the threshold based on your application throughput requirement 887 # gc_warn_threshold_in_ms: 1000 888 889 # UDFs (user defined functions) are disabled by default. 890 # As of Cassandra 2.2, there is no security manager or anything else in place that 891 # prevents execution of evil code. CASSANDRA-9402 will fix this issue for Cassandra 3.0. 892 # This will inherently be backwards-incompatible with any 2.2 UDF that perform insecure 893 # operations such as opening a socket or writing to the filesystem. 894 enable_user_defined_functions: false 895 896 # The default Windows kernel timer and scheduling resolution is 15.6ms for power conservation. 897 # Lowering this value on Windows can provide much tighter latency and better throughput, however 898 # some virtualized environments may see a negative performance impact from changing this setting 899 # below their system default. The sysinternals 'clockres' tool can confirm your system's default 900 # setting. 901 windows_timer_interval: 1