anchor.diff: -# Redis configuration file example
  +# Redis configuration file example.
  +#
  +# Note that in order to read the configuration file, Redis must be
  +# started with the file path as first argument:
  +#
  +# ./redis-server /path/to/redis.conf
  +
  +# Note on units: when memory size is needed, it is possible to specify
  +# it in the usual form of 1k 5GB 4M and so forth:
  +#
  +# 1k => 1000 bytes
  +# 1kb => 1024 bytes
  +# 1m => 1000000 bytes
  +# 1mb => 1024*1024 bytes
  +# 1g => 1000000000 bytes
  +# 1gb => 1024*1024*1024 bytes
  +#
  +# units are case insensitive so 1GB 1Gb 1gB are all the same.
  +
  +################################## INCLUDES ###################################
  +
  +# Include one or more other config files here.  This is useful if you
  +# have a standard template that goes to all Redis servers but also need
  +# to customize a few per-server settings.  Include files can include
  +# other files, so use this wisely.
  +#
  +# Notice option "include" won't be rewritten by command "CONFIG REWRITE"
  +# from admin or Redis Sentinel. Since Redis always uses the last processed
  +# line as value of a configuration directive, you'd better put includes
  +# at the beginning of this file to avoid overwriting config change at runtime.
  +#
  +# If instead you are interested in using includes to override configuration
  +# options, it is better to use include as the last line.
  +#
  +# include /path/to/local.conf
  +# include /path/to/other.conf
  +
  +################################ GENERAL  #####################################
   
   # By default Redis does not run as a daemon. Use 'yes' if you need it.
   # Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
   daemonize yes
   
  -# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
  -# You can specify a custom pid file location here.
  +# When running daemonized, Redis writes a pid file in /var/run/redis.pid by
  +# default. You can specify a custom pid file location here.
   pidfile <%= pid_file %>
   
  -# Accept connections on the specified port, default is 6379
  +# Accept connections on the specified port, default is 6379.
  +# If port 0 is specified Redis will not listen on a TCP socket.
   port <%= port %>
   
  -# If you want you can bind a single interface, if the bind option is not
  -# specified all the interfaces will listen for connections.
  -#
  +# TCP listen() backlog.
  +#
  +# In high requests-per-second environments you need an high backlog in order
  +# to avoid slow clients connections issues. Note that the Linux kernel
  +# will silently truncate it to the value of /proc/sys/net/core/somaxconn so
  +# make sure to raise both the value of somaxconn and tcp_max_syn_backlog
  +# in order to get the desired effect.
  +# tcp-backlog 511
  +
  +# By default Redis listens for connections from all the network interfaces
  +# available on the server. It is possible to listen to just one or multiple
  +# interfaces using the "bind" configuration directive, followed by one or
  +# more IP addresses.
  +#
  +# Examples:
  +#
  +# bind 192.168.1.100 10.0.0.1
   # bind 127.0.0.1
  +
  +# Specify the path for the Unix socket that will be used to listen for
  +# incoming connections. There is no default, so Redis will not listen
  +# on a unix socket when not specified.
  +#
  +# unixsocket /tmp/redis.sock
  +# unixsocketperm 700
   
   # Close the connection after a client is idle for N seconds (0 to disable)
   timeout 300
   
  -# Set server verbosity to 'debug'
  -# it can be one of:
  +# TCP keepalive.
  +#
  +# If non-zero, use SO_KEEPALIVE to send TCP ACKs to clients in absence
  +# of communication. This is useful for two reasons:
  +#
  +# 1) Detect dead peers.
  +# 2) Take the connection alive from the point of view of network
  +#    equipment in the middle.
  +#
  +# On Linux, the specified value (in seconds) is the period used to send ACKs.
  +# Note that to close the connection the double of the time is needed.
  +# On other kernels the period depends on the kernel configuration.
  +#
  +# A reasonable value for this option is 60 seconds.
  +tcp-keepalive 0
  +
  +# Specify the server verbosity level.
  +# This can be one of:
   # debug (a lot of information, useful for development/testing)
  +# verbose (many rarely useful info, but not a mess like the debug level)
   # notice (moderately verbose, what you want in production probably)
   # warning (only very important / critical messages are logged)
   loglevel debug
   
  -# Specify the log file name. Also 'stdout' can be used to force
  -# the demon to log on the standard output. Note that if you use standard
  +# Specify the log file name. Also the empty string can be used to force
  +# Redis to log on the standard output. Note that if you use standard
   # output for logging but daemonize, logs will be sent to /dev/null
   logfile <%= log_file %>
  +
  +# To enable logging to the system logger, just set 'syslog-enabled' to yes,
  +# and optionally update the other syslog parameters to suit your needs.
  +# syslog-enabled no
  +
  +# Specify the syslog identity.
  +# syslog-ident redis
  +
  +# Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
  +# syslog-facility local0
   
   # Set the number of databases. The default database is DB 0, you can select
   # a different one on a per-connection basis using SELECT <dbid> where
   # dbid is a number between 0 and 'databases'-1
   databases 16
   
  -################################ SNAPSHOTTING  #################################
  +################################ SNAPSHOTTING  ################################
   #
   # Save the DB on disk:
   #
  
positive.code: # This should stay commented out for backward compatibility and because most
  # people do not need auth (e.g. they run their own servers).
  #
  # requirepass foobared
  
  ################################### LIMITS ####################################
  
  # Set the max number of connected clients at the same time. By default there
  # is no limit, and it's up to the number of file descriptors the Redis process
  # is able to open. The special value '0' means no limts.
  # Once the limit is reached Redis will close all the new connections sending
  # an error 'max number of clients reached'.
  #
  maxclients 128
  
  # Don't use more memory than the specified amount of bytes.
  # When the memory limit is reached Redis will try to remove keys with an
  # EXPIRE set. It will try to start freeing keys that are going to expire
  # in little time and preserve keys with a longer time to live.
  # Redis will also try to remove objects from free lists if possible.
  #
  # If all this fails, Redis will start to reply with errors to commands
  # that will use more memory, like SET, LPUSH, and so on, and will continue
  # to reply to most read-only commands like GET.
  #
  # WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
  # 'state' server or cache, not as a real DB. When Redis is used as a real
  # database the memory usage will grow over the weeks, it will be obvious if
  # it is going to use too much memory in the long run, and you'll have the time
  # to upgrade. With maxmemory after the limit is reached you'll start to get
  # errors for write operations, and this may even lead to DB inconsistency.
  #
  # maxmemory <bytes>
  
  ############################## APPEND ONLY MODE ###############################
  
  # By default Redis asynchronously dumps the dataset on disk. If you can live
  # with the idea that the latest records will be lost if something like a crash
  # happens this is the preferred way to run Redis. If instead you care a lot
  # about your data and don't want to that a single record can get lost you should
  # enable the append only mode: when this mode is enabled Redis will append
  # every write operation received in the file appendonly.log. This file will
  # be read on startup in order to rebuild the full dataset in memory.
  #
  # Note that you can have both the async dumps and the append only file if you
  # like (you have to comment the "save" statements above to disable the dumps).
  # Still if append only mode is enabled Redis will load the data from the
  # log file at startup ignoring the dump.rdb file.
  #
  # The name of the append only file is "appendonly.log"
  #
  # IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append
  # log file in background when it gets too big.
  
  appendonly yes
  
  # The fsync() call tells the Operating System to actually write data on disk
  # instead to wait for more data in the output buffer. Some OS will really flush 
  # data on disk, some other OS will just try to do it ASAP.
  #
  # Redis supports three different modes:
  #
  # no: don't fsync, just let the OS flush the data when it wants. Faster.
  # always: fsync after every write to the append only log . Slow, Safest.
  # everysec: fsync only if one second passed since the last fsync. Compromise.
  #
  # The default is "always" that's the safer of the options. It's up to you to
  # understand if you can relax this to "everysec" that will fsync every second
  # or to "no" that will let the operating system flush the output buffer when
  # it want, for better performances (but if you can live with the idea of
  # some data loss consider the default persistence mode that's snapshotting).
  
  # appendfsync always
  appendfsync everysec
  # appendfsync no
  
  ############################### ADVANCED CONFIG ###############################
  
  # Use object sharing. Can save a lot of memory if you have many common
  # string in your dataset, but performs lookups against the shared objects
  # pool so it uses more CPU and can be a bit slower. Usually it's a good
  # idea.
  #
  # When object sharing is enabled (shareobjects yes) you can use
  # shareobjectspoolsize to control the size of the pool used in order to try
  # object sharing. A bigger pool size will lead to better sharing capabilities.
  # In general you want this value to be at least the double of the number of
  # very common strings you have in your dataset.
  #
  # WARNING: object sharing is experimental, don't enable this feature
  # in production before of Redis 1.0-stable. Still please try this feature in
  # your development environment so that we can test it better.
  # shareobjects no
  # shareobjectspoolsize 1024
  
negative.code: # the dataset will likely be bigger if you have compressible values or keys.
  rdbcompression yes
  
  # Since version 5 of RDB a CRC64 checksum is placed at the end of the file.
  # This makes the format more resistant to corruption but there is a performance
  # hit to pay (around 10%) when saving and loading RDB files, so you can disable it
  # for maximum performances.
  #
  # RDB files created with checksum disabled have a checksum of zero that will
  # tell the loading code to skip the check.
  rdbchecksum yes
  
  # The filename where to dump the DB
  dbfilename dump.rdb
  
  # The working directory.
  #
  # The DB will be written inside this directory, with the filename specified
  # above using the 'dbfilename' configuration directive.
  #
  # The Append Only File will also be created inside this directory.
  #
  # Note that you must specify a directory here, not a file name.
  dir <%= dir %>
  
  ################################# REPLICATION #################################
  
  # Master-Slave replication. Use slaveof to make a Redis instance a copy of
  # another Redis server. A few things to understand ASAP about Redis replication.
  #
  # 1) Redis replication is asynchronous, but you can configure a master to
  #    stop accepting writes if it appears to be not connected with at least
  #    a given number of slaves.
  # 2) Redis slaves are able to perform a partial resynchronization with the
  #    master if the replication link is lost for a relatively small amount of
  #    time. You may want to configure the replication backlog size (see the next
  #    sections of this file) with a sensible value depending on your needs.
  # 3) Replication is automatic and does not need user intervention. After a
  #    network partition slaves automatically try to reconnect to masters
  #    and resynchronize with them.
  #
  # slaveof <masterip> <masterport>
  
  