anchor.diff:  # 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
   
  -# For default save/load DB in/from the working directory
  -# Note that you must specify a directory not a file name.
  +# 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. Note that the configuration is local to the slave
  -# so for example it is possible to configure the slave to save the DB with a
  -# different interval, or to listen to another port, and so on.
  +# 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>
   
  
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: #
  # masterauth <master-password>
  
  # When a slave loses its connection with the master, or when the replication
  # is still in progress, the slave can act in two different ways:
  #
  # 1) if slave-serve-stale-data is set to 'yes' (the default) the slave will
  #    still reply to client requests, possibly with out of date data, or the
  #    data set may just be empty if this is the first synchronization.
  #
  # 2) if slave-serve-stale-data is set to 'no' the slave will reply with
  #    an error "SYNC with master in progress" to all the kind of commands
  #    but to INFO and SLAVEOF.
  #
  slave-serve-stale-data yes
  
  # You can configure a slave instance to accept writes or not. Writing against
  # a slave instance may be useful to store some ephemeral data (because data
  # written on a slave will be easily deleted after resync with the master) but
  # may also cause problems if clients are writing to it because of a
  # misconfiguration.
  #
  # Since Redis 2.6 by default slaves are read-only.
  #
  # Note: read only slaves are not designed to be exposed to untrusted clients
  # on the internet. It's just a protection layer against misuse of the instance.
  # Still a read only slave exports by default all the administrative commands
  # such as CONFIG, DEBUG, and so forth. To a limited extent you can improve
  # security of read only slaves using 'rename-command' to shadow all the
  # administrative / dangerous commands.
  slave-read-only no
  
  # Replication SYNC strategy: disk or socket.
  #
  # -------------------------------------------------------
  # WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY
  # -------------------------------------------------------
  #
  # New slaves and reconnecting slaves that are not able to continue the replication
  # process just receiving differences, need to do what is called a "full
  # synchronization". An RDB file is transmitted from the master to the slaves.
  # The transmission can happen in two different ways:
  #
  # 1) Disk-backed: The Redis master creates a new process that writes the RDB
  #                 file on disk. Later the file is transferred by the parent
  #                 process to the slaves incrementally.
  # 2) Diskless: The Redis master creates a new process that directly writes the
  #              RDB file to slave sockets, without touching the disk at all.
  #
  # With disk-backed replication, while the RDB file is generated, more slaves
  # can be queued and served with the RDB file as soon as the current child producing
  # the RDB file finishes its work. With diskless replication instead once
  # the transfer starts, new slaves arriving will be queued and a new transfer
  # will start when the current one terminates.
  #
  # When diskless replication is used, the master waits a configurable amount of
  # time (in seconds) before starting the transfer in the hope that multiple slaves
  # will arrive and the transfer can be parallelized.
  #
  # With slow disks and fast (large bandwidth) networks, diskless replication
  # works better.
  repl-diskless-sync no
  
  # When diskless replication is enabled, it is possible to configure the delay
  # the server waits in order to spawn the child that trnasfers the RDB via socket
  # to the slaves.
  #
  # This is important since once the transfer starts, it is not possible to serve
  # new slaves arriving, that will be queued for the next RDB transfer, so the server
  # waits a delay in order to let more slaves arrive.
  #
  # The delay is specified in seconds, and by default is 5 seconds. To disable
  # it entirely just set it to 0 seconds and the transfer will start ASAP.
  repl-diskless-sync-delay 5
  
  # Slaves send PINGs to server in a predefined interval. It's possible to change
  # this interval with the repl_ping_slave_period option. The default value is 10
  # seconds.
  #
  # repl-ping-slave-period 10
  
  # The following option sets the replication timeout for:
  #
  # 1) Bulk transfer I/O during SYNC, from the point of view of slave.
  # 2) Master timeout from the point of view of slaves (data, pings).
  # 3) Slave timeout from the point of view of masters (REPLCONF ACK pings).
  #
  # It is important to make sure that this value is greater than the value
  # specified for repl-ping-slave-period otherwise a timeout will be detected
  # every time there is low traffic between the master and the slave.
  #
  # repl-timeout 60
  
  # Disable TCP_NODELAY on the slave socket after SYNC?
  #
  # If you select "yes" Redis will use a smaller number of TCP packets and
  # less bandwidth to send data to slaves. But this can add a delay for
  # the data to appear on the slave side, up to 40 milliseconds with
  # Linux kernels using a default configuration.
  #
  # If you select "no" the delay for data to appear on the slave side will
  # be reduced but more bandwidth will be used for replication.
  #
  # By default we optimize for low latency, but in very high traffic conditions
  # or when the master and slaves are many hops away, turning this to "yes" may
  # be a good idea.
  repl-disable-tcp-nodelay no
  
  # Set the replication backlog size. The backlog is a buffer that accumulates
  # slave data when slaves are disconnected for some time, so that when a slave
  # wants to reconnect again, often a full resync is not needed, but a partial
  # resync is enough, just passing the portion of data the slave missed while
  # disconnected.
  #
  # The bigger the replication backlog, the longer the time the slave can be
  # disconnected and later be able to perform a partial resynchronization.
  #
  # The backlog is only allocated once there is at least a slave connected.
  #
  # repl-backlog-size 1mb
  
  # After a master has no longer connected slaves for some time, the backlog
  # will be freed. The following option configures the amount of seconds that
  # need to elapse, starting from the time the last slave disconnected, for
  # the backlog buffer to be freed.
  #
  # A value of 0 means to never release the backlog.
  #
  # repl-backlog-ttl 3600
  
  # The slave priority is an integer number published by Redis in the INFO output.
  # It is used by Redis Sentinel in order to select a slave to promote into a
  # master if the master is no longer working correctly.
  #
  # A slave with a low priority number is considered better for promotion, so
  # for instance if there are three slaves with priority 10, 100, 25 Sentinel will
  # pick the one with priority 10, that is the lowest.
  #
  # However a special priority of 0 marks the slave as not able to perform the
  # role of master, so a slave with priority of 0 will never be selected by
  # Redis Sentinel for promotion.
  #
  # By default the priority is 100.
  slave-priority 100
  
  # It is possible for a master to stop accepting writes if there are less than
  # N slaves connected, having a lag less or equal than M seconds.
  #
  # The N slaves need to be in "online" state.
  #
  # The lag in seconds, that must be <= the specified value, is calculated from
  # the last ping received from the slave, that is usually sent every second.
  #
  # This option does not GUARANTEE that N replicas will accept the write, but
  # will limit the window of exposure for lost writes in case not enough slaves
  # are available, to the specified number of seconds.
  #
  # For example to require at least 3 slaves with a lag <= 10 seconds use:
  #
  # min-slaves-to-write 3
  # min-slaves-max-lag 10
  #
  # Setting one or the other to 0 disables the feature.
  #
  # By default min-slaves-to-write is set to 0 (feature disabled) and
  # min-slaves-max-lag is set to 10.
  
  ################################## SECURITY ###################################
  
  # Require clients to issue AUTH <PASSWORD> before processing any other
  