app/netcache/netcached.ini

[task_server]

; Logging of request-start and request-stop entries in the log.
;log_requests = true

; Size of per-thread buffer used for logging
;log_thread_buf_size = 10 MB

; Maximum period in seconds between actual writing of log records to file
;log_flush_period = 60

; Period in seconds for reopening log file (to allow log file rotation)
;log_reopen_period = 60

; Log visible severity ::= Trace | Info | Warning | Error | Critical | Fatal
;log_visible = Warning

; What to do on SoftFatal error ::= abort | shutdown | log
; (mostly experimental, CXX-8803)
;soft_fatal_action = abort

; v6.12.1: added
; report timing details of commands which take longer than this number of milliseconds
;log_long_cmd_after = 30000

; Maximum number of worker threads in the server
;max_threads = 20

; Maximum number of sockets after which server starts to close the least
; recently active ones (see min_socket_inactivity below).
;soft_sockets_limit = 1000

; Maximum number of sockets after which server stops accepting new ones.
;hard_sockets_limit = 2000

; Minimum period (in seconds) socket should be inactive for to be considered
; for server-side closing (see soft_socket_limit above).
;min_socket_inactivity = 300

; Connection timeout (in milliseconds) for sockets opened by server.
;connection_timeout = 100

; Size of per-thread batch processing to close inactive sockets (used only
; when soft_sockets_limit and min_socket_inactivity come to play).
;sockets_cleaning_batch = 10

; v6.12.1: added
; report accept() calls which take longer than this number of milliseconds
;socket_accept_delay = 1000

; Timeout (in seconds) for "soft shutdown" phase activated after SHUTDOWN
; command.
;slow_shutdown_timeout = 10

; Timeout (in seconds) for "soft shutdown" phase activated by SIGTERM or SIGINT.
; Timeout should be small enough to allow normal exit if server is rebooting.
;fast_shutdown_timeout = 2

; Maximum time (in seconds) server can be in "soft" and "hard" shutdown phases
; when it should be aborted. If the value is 0 then server never aborts itself.
; Parameter should be necessary only as a protection against bugs.
;max_shutdown_time = 0

; Number of "jiffies" per second. Changing of the parameter is not recommended.
;jiffies_per_sec = 100

; "Maximum" time allowed for task to wait in scheduling queue. It's not exactly
; maximum but scheduler tries to make it like that.
;max_task_delay = 500

; Maximum time (in seconds) for thread to stay idle before it will be stopped.
;idle_thread_stop_timeout = 300

; v6.14.5: added
; Default task priority. Positive integer. Higher value means lower priority
;task_priority_default = 1


[netcache]

; Port numbers server responds to clients on. Along with control_port value
; NetCache cannot have more than 16 unique port values to listen on.
;ports = 9000, 9001

; Control port for communication between servers and administrative commands
;control_port = 9010

; Name of client to be used for execution of all administrative commands (like
; database re-initialization, server re-configuration, shutdown etc).
; If an attempt will be made to execute these commands with any other client
; name an error will be the result.
;admin_client_name = netcache_control

; Turn on special debugging mode of NetCache. Never turn it on in production.
;debug_mode = false

; Priority of client's parameters involved in determining their specific
; settings. Priority is from more important one to less important. So the following
; value will divide all clients first by cache name they have provided in the command
; (in case of ICache) and then by the port they are connected to.
; Default value is "cache, port"
; To ignore contents of "app_setup" sections, specify "disable" here.
; v6.9.3: changed  (CXX-7659)
;app_setup_priority = cache, port

; The following values are default settings for all clients and can be overridden
; for specific clients later. Description of all parameters is given only in this
; section.

; Disable the client completely, do not allow him to execute any command.
;disable_client = false

; Lifespan TTL. If not zero, blob cannot live longer than this number of seconds,
; even though it is prolonged and actively used.
; Sure, the value should not be too small; maybe several times bigger than blob_ttl.
;lifespan_ttl = 0

; Maximal blob expiration timeout in seconds
;max_ttl = 2592000

; Default blob expiration timeout in seconds
;blob_ttl = 3600

; Default expiration timeout for blob's version (works only for ICache)
;ver_ttl = 3600

; Granularity of expiration time measuring. Any change in that time less than
; this value won't be recorded. Bigger values can save some writes to database
; and thus some disk activity and performance.
;ttl_unit = 300

; Update blob's time stamp on every read and calculate its expiration time
; from the last read.
;prolong_on_read = true

; Try to find blob on other servers if it's not found locally
;search_on_read = true

; Number of servers required to process the command before it's reported to
; client as successfully finished. 0 means all available servers should process
; the command.
; Please also see related "fast_quorum_on_main" parameter.
;quorum = 2

; Disregard the quorum and search_on_read value when executing command
; on the main server for the blob (on the server which IP is in blob key)
; and work as if quorum == 1 and search_on_read == false. If this value
; is FALSE then values for quorum and search_on_read parameters will be always
; respected no matter which server executes the command.
;fast_quorum_on_main = true

; Policy of using passwords for accessing blobs in NetCache. Possible values:
;   no_password - only commands without passwords are accepted
;   with_password - only commands with password are accepted
;   any - any type of command can be sent, either with password or without it
;blob_password_policy=any


; The following is an example of client-by-client specific parameters. Each
; clients group should be described by section with name starting with
; 'app_setup_'. This section should contain client's parameters that identify
; the group and section name that contains specific parameters. Meaning of all
; specific parameters is described in the "netcache" section.

;[app_setup_1h]
; Parameters identifying clients.
;port = 9000
; Name of the section with specific parameters.
;setup = app_group_1h

;[app_setup_24h]
;port = 9001
;setup = app_group_24h

;[app_setup_blobs]
;port = 9002
;cache = blobs
;setup = app_group_objcache

;[app_setup_ids]
;port = 9002
;cache = ids
;setup = app_group_ids

;[app_setup_bad_cache]
;port = 9001
;cache = foo
;setup = app_group_bad


;[app_group_1h]
;blob_ttl = 3600
;prolong_on_read = true

;[app_group_24h]
;blob_ttl = 184000
;ttl_unit = 3600

;[app_group_objcache]
;blob_ttl = 184000
;ver_ttl = 3600
;prolong_on_read = true

;[app_group_ids]
;blob_ttl = 3600
;prolong_on_read = false

;[app_group_bad]
;disable_client = true


[storage]
; Directory to keep the database.
;path = ./cache

; Prefix for all files in the database
;prefix = nccache

; Name of the file containing pid of currently running NetCache process and
; serving as an exclusive lock between different NetCache instances trying
; to access the same database. If this parameter is empty then NetCache uses
; name as follows: <path>/__ncbi_netcache_started__.<prefix>. BUT it's
; recommended to put this file into some other directory under some other
; mount point (probably /var/pid/ is a good place for that), because if for
; some reason there's no space on the disk with database and NetCache will
; have to restart then it won't be able to start at all (attempts to create
; the guard file will fail with error "No disk space available").
;guard_file_name =

; Size of each file in the storage
;each_file_size = 100 MB

; Maximum percentage of garbage allowed. When amount of garbage exceeds this
; value NetCache will try to compact the storage.
;max_garbage_pct = 20

; Minimum size of storage when compaction makes sense. If total size of storage
; is less than this value NetCache won't compact it no matter how much garbage
; it has.
;min_storage_size = 1 GB

; Minimum time that blob is left to live for NetCache to consider it worth
; moving during compaction.
;min_lifetime_to_move = 1000

; Delay in seconds between attempts to clean the same database file if first
; attempt failed.
;failed_move_delay = 10

; Garbage collector processes blobs in groups of specified amount.
;gc_batch_size = 500

; Periods of syncing all written data to disk (in seconds). 0 means do not
; perform any syncs at all - kernel will flush data to disk at its own
; convenience.
;sync_time_period = 0

; Limit for database size when garbage collector starts/stops deletion of oldest
; blobs even though they are not yet expired. Value of 0 for db_limit_del_old_on
; means that this feature shouldn't be activated.
;db_limit_del_old_on = 0
;db_limit_del_old_off = 0

; Limit for database size when NetCache stops/starts accepting any new blobs
; from client (even it's just re-writing of the old blob). Value of 0 for
; db_limit_stop_write_on means that this feature shouldn't be activated.
;db_limit_stop_write_on = 0
;db_limit_stop_write_off = 0

; Limit in free disk space when NetCache stops/starts accepting any new blobs
; from clients.
;disk_free_limit = 5 GB

; Limit in free disk space when NetCache stops/starts accepting any new blobs
; from peer servers.
;critical_disk_free_limit = 1 GB

; Percentage of allowed database size to issue disk free space alert.
; Allowed database size is minimum among value of db_limit_stop_write_on and
; total available disk apce without disk_free_limit or critical_disk_free_limit.
; When database grows above db_limit_percentage_alert of allowed database size
; NetCache logs Critical message about that. When database size is back down below
; (db_limit_percentage_alert - db_limit_percentage_alert_delta) of allowed
; database size NetCache logs another Critical message that database size is back
; to normal.
;db_limit_percentage_alert = 65
;db_limit_percentage_alert_delta = 5

; Minimum time that should pass between two consecutive saves of current record
; number in synchronization log.
;min_rec_no_save_period = 30

; Maximum amount of memory allowed to be consumed by write-back cache. Above this
; limit NC tries to release least recently used memory, but total memory consumption
; can still grow while memory is being released.
; v6.8.6: lowered from 4GB to 3GB   (CXX-5798)
;write_back_soft_size_limit = 3 GB

; "Hard" limit for amount of memory consumed by write-back cache. Above this limit
; NC deploys extreme measures to avoid further growth of memory consumption. This
; limit can be reached only if some other application hogs disks on the server and
; NC can't work properly.
; v6.8.6: lowered from 6GB to 4GB   (CXX-5798)
;write_back_hard_size_limit = 4 GB

; Maximum timeout (in seconds) between data coming into write-back cache and going
; out of it to the database. This one is active AFTER initial synchronization is done,
;write_back_timeout = 1000

; v6.7.0 (CXX-4527)
; Maximum timeout (in seconds) between data coming into write-back cache and going
; out of it to the database. This one is active DURING initial synchronization,
;write_back_timeout_startup = 1000

; Delay (in seconds) to take after a write operation to the database failed.
; Parameter should be needed in extremely exceptional cases.
;write_back_failed_delay = 2

; v6.7.0  (CXX-3314)
; Max count of blob keys to store for which blob data was not written successfully
; (for reasons other than disk space shortage).
; If this server is primary storage for a blob and the blob write fails,
; client might put the blob to another server. If blob read request then comes
; after failed write but before periodic synchronization, server can return wrong blob.
; Server can remember such failed writes (blob keys only), and consult other servers
; in uncertain situations.
;failed_write_blob_key_count = 0

; v6.7.0  (CXX-4842)
; Blobs which size exceeds this limit (in bytes) will not be stored.
;max_blob_size_store = 1 GB

; v6.14.5: added
; Priority of write-back cache memory release task.
;Positive integer. Higher value means lower priority
;task_priority_wb_memrelease = 10


[mirror]
; Set of servers participating in the mirroring and replication.
; All servers are in the format <group>:<server name>:<control port>.
; Contents of group name doesn't matter - its string value is considered as group
; identification. When each server needs to proxy some client requests it will
; direct them to members of their own group first.
;server_0 = be:nctest11.be-md:9120
;server_1 = be:nctest21.be-md:9120
;server_2 = st:nctest31.st-va:9120
;server_3 = st:nctest32.st-va:9120
;server_4 = be:nctest11.be-md:9121
;server_5 = be:nctest21.be-md:9121
;server_6 = st:nctest31.st-va:9121
;server_7 = st:nctest32.st-va:9121

; Set of slot numbers served by each server participating in the mirroring
;srv_slots_0 = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25
;srv_slots_1 = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25
;srv_slots_2 = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25
;srv_slots_3 = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25
;srv_slots_4 = 26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50
;srv_slots_5 = 26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50
;srv_slots_6 = 26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50
;srv_slots_7 = 26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50

; Server credentials
; if a blob exists on lower trust server and does not exist on higher trust server - it is NOT mirrored
;   (on an attempt to read it, it will be found if search_on_read is TRUE)
; if a blob exists on higher trust server and does not exist on low trust server - it is mirrored
;before v6.14.1:   if a blob exists on both servers - it is mirrored
;after  v6.14.1:   if a blob exists on both servers - it is mirrored from higher to lower trust server only
;   that is, if it is updated on lower trust one, the update is not propagated to higher server
;        and if it is updated on higher trust one, the update is propagated
;srv_trust_0 = 0
;srv_trust_1 = 0


; Number of additional parts to split all blobs into to avoid too big contention between
; different clients.
;cnt_slot_buckets = 10

; File names to output some statistical information useful for building some graphs
; about NetCache's performance
; there is no default (default is empty), these are optional
;mirroring_log_file = ./mirroring.log
;periodic_log_file = ./periodic.log
;copy_delay_log_file = ./copy_delay.log

; Filename to store event logs on server shutdown for future synchronization with other
; servers. It's better to be in the same directory as database
;sync_log_file = ./cache/sync_events.log

; Maximum number of records to store in event logs for each slot
;max_slot_log_records = 100000

; Number of records to leave as a reserve below limit when cleaning happens because number
; of records hit the limit
;clean_slot_log_reserve = 1000

; Maximum number of records in the event log to clean in one cleaning transaction
;max_clean_log_batch = 10000

; Minimum time period that should pass between two consecutive forced cleanings (when all
; synchronizations on the slot are aborted to allow cleaning to proceed).
;min_forced_clean_log_period = 10

; Time interval between attempts to clean event log
;clean_log_attempt_interval = 1

; Time interval between periodic synchronizations
;deferred_sync_interval = 10

; Timeout of inactivity in periodic sync when server can be considered out of service
;deferred_sync_timeout = 10

; Time interval between periodic sync retries when sync fails for some reason
;failed_sync_retry_delay = 1

; Time interval during which network errors should occur with some server to consider
; that server out of service and not requiring initial synchronization.
;network_error_timeout = 300

; Blobs that are larger than this size (in KB) are considered "large".
; These blobs are mirrored at a lesser priority than smaller blobs.
;small_blob_max_size = 100

; Maximum number of active deferred synchronization transactions to hold. More
; synchronization transactions still can be supported in the passive mode
; (i.e. initiated by other servers).
;max_active_syncs = 4

; Maximum allowed number of active deferred synchronization transactions with the same
; peer. This parameter is important when some server with completely wiped out
; database is launched. If this parameter is not low enough then all servers start
; all their active syncs with the new peer and nobody performs sync with each other.
;max_syncs_one_server = 2

; Maximum number of connections to each peer NetCache
;max_peer_connections = 100

; Maximum number of connections to each peer which can execute background tasks
; (instant or deferred synchronization).
;max_peer_bg_connections = 50

; Number of consecutive network errors to happen before the peer NetCache will be
; throttled (no physical attempts to connect to it will be made).
;peer_errors_for_throttle = 10

; Time in seconds to not attempt any physical connections to peer.
;peer_throttle_period = 10

; v6.7.0  (CXX-4247)
; Number of consecutive throttles to happen before server checks for possibly changed peer IP address.
; that is, it assumes same peer name and port, but maybe different IP address
;peer_throttles_for_ip_change = 10

; Timeout in seconds for network communication with peer
;peer_communication_timeout = 2

; Timeout in seconds for requesting a blob list from peer
;peer_blob_list_timeout = 10

; Maximum amount of events pending to each peer for instant synchronization. Any events
; above this limit will be immediately discarded.
;max_instant_queue_size = 10000

; v6.7.0  (CXX-4842)
; Blobs which size exceeds this limit (in bytes) will not be synchronized to other servers.
; this should be true:  small_blob_max_size <= max_blob_size_sync <= max_blob_size_store
; v6.8.0 (CXX-5189)
; '0' is special case, it means no size checks, no mirroring and no warnings
;max_blob_size_sync = 1 GB

; v6.8.0  (CXX-5189)
; Log warnings about blobs which size exceeds 'max_blob_size_sync'
;warn_blob_size_sync = true

; v6.7.0  (CXX-3363)
; Briefly notify peers when blob is updated on the server
; (it comes faster than blob data copying, and lets others serve request correctly)
;blob_update_hotline = true

; v6.9.0  (CXX-6246)
; How to calculate ICache blob slot
; slot# is calculated either by whole key (cache,key,subkey), or by "key" only
; this parameter must be identical for all servers in the cluster
;slot_calculation_by_key_only = false

; v6.14.5: added
; Priority of synchronization task.
;Positive integer. Higher value means lower priority
;task_priority_sync = 10