anchor.diff:  # 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 extend you can improve
  +# 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 yes
   
  +<%- if version_c[0] == 2 && (version_c <=> [2,8,17]) > 0 -%>
  +# Replication SYNC strategy: disk or socket.
  +#
  +# 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
  +<%- end -%>
  +
  +<%- if version_c[0] == 2 && (version_c <=> [2,8,17]) > 0 -%>
  +# 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
  +<%- end -%>
  +
   # 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 a timeout for both Bulk transfer I/O timeout and
  -# master data or ping response timeout. The default value is 60 seconds.
  +# 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
  
positive.code: # By default the priority is 100.
  slave-priority 100
  
  ################################## SECURITY ###################################
  
  # Require clients to issue AUTH <PASSWORD> before processing any other
  
negative.code: # but just the time needed to actually execute the command (this is the only
  # stage of command execution where the thread is blocked and can not serve
  # other requests in the meantime).
  #
  # You can configure the slow log with two parameters: one tells Redis
  # what is the execution time, in microseconds, to exceed in order for the
  # command to get logged, and the other parameter is the length of the
  