Add sentinel tests on .NET Core

Author: xplicit

src/sentinel/redis-6380/redis.windows.conf

@@ -34,7 +34,7 @@
 
 # On Windows, daemonize and pidfile are not supported.
 # However, you can run redis as a Windows service, and specify a logfile.
-# The logfile will contain the pid.
+# The logfile will contain the pid. 
 
 # Accept connections on the specified port, default is 6379.
 # If port 0 is specified Redis will not listen on a TCP socket.
@@ -96,12 +96,12 @@ tcp-keepalive 0
 loglevel verbose
 
 # Specify the log file name. Also 'stdout' can be used to force
-# Redis to log on the standard output.
+# Redis to log on the standard output. 
 logfile ""
 
-# To enable logging to the Windows EventLog, just set 'syslog-enabled' to
+# To enable logging to the Windows EventLog, just set 'syslog-enabled' to 
 # yes, and optionally update the other syslog parameters to suit your needs.
-# If Redis is installed and launched as a Windows Service, this will
+# If Redis is installed and launched as a Windows Service, this will 
 # automatically be enabled.
 # syslog-enabled no
 
@@ -176,9 +176,9 @@ dbfilename "dump.rdb"
 #
 # 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 "C:\\src\\ServiceStack.Redis\\src\\sentinel\\redis-6380"
 
@@ -379,7 +379,7 @@ slave-priority 100
 #
 # This should stay commented out for backward compatibility and because most
 # people do not need auth (e.g. they run their own servers).
-#
+# 
 # Warning: since Redis is pretty fast an outside user can try up to
 # 150k passwords per second against a good box. This means that you should
 # use a very strong password otherwise it will be very easy to break.
@@ -418,63 +418,14 @@ slave-priority 100
 #
 # maxclients 10000
 
-# The Linux version of Redis relies on the system call fork() to perform
-# point-in-time snapshots of the heap. In addition to the AOF and RDB backup
-# mechanism, the master-slave synchronization and clustering features are
-# dependent on this behavior of fork(). In order for the Windows version to
-# perform like the Linux version we had to simulate this aspect of fork().
-# Doing so meant moving the Redis heap into a memory mapped file that can
-# be shared with a child process.
-#
-# *** There must be disk space available for this file in order for Redis
-# to launch. *** The default configuration places this file in the local
-# appdata directory. If you wish to move this file to another local disk,
-# use the heapdir flag as described below.
-#
-# The maxheap flag controls the maximum size of this memory mapped file,
-# as well as the total usable space for the Redis heap. Running Redis
-# without either maxheap or maxmemory will result in a memory mapped file
-# being created that is equal to the size of physical memory. During
-# fork() operations the total page file commit will max out at around:
-#
-#    (size of physical memory) + (2 * size of maxheap)
-#
-# For instance, on a machine with 8GB of physical RAM, the max page file
-# commit with the default maxheap size will be (8)+(2*8) GB , or 24GB. The
-# default page file sizing of Windows will allow for this without having
-# to reconfigure the system. Larger heap sizes are possible, but the maximum
-# page file size will have to be increased accordingly.
-#
-# The Redis heap must be larger than the value specified by the maxmemory
-# flag, as the heap allocator has its own memory requirements and
-# fragmentation of the heap is inevitable. If only the maxmemory flag is
-# specified, maxheap will be set at 1.5*maxmemory. If the maxheap flag is
-# specified along with maxmemory, the maxheap flag will be automatically
-# increased if it is smaller than 1.5*maxmemory.
-#
-# maxheap <bytes>
-maxheap 1gb
-
-# The heap memory mapped file must reside on a local path for heap sharing
-# between processes to work. A UNC path will not suffice here. For maximum
-# performance this should be located on the fastest local drive available.
-# This value defaults to the local application data folder(e.g.,
-# "%USERPROFILE%\AppData\Local"). Since this file can be very large, you
-# may wish to place this on a drive other than the one the operating system
-# is installed on.
-#
-# Note that you must specify a directory here, not a file name.
-# heapdir <directory path(absolute or relative)>
-heapdir C:\\src\\ServiceStack.Redis\\src\\sentinel\\redis-6380
-
 # If Redis is to be used as an in-memory-only cache without any kind of
 # persistence, then the fork() mechanism used by the background AOF/RDB
-# persistence is unneccessary. As an optimization, all persistence can be
-# turned off in the Windows version of Redis. This will disable the creation of
-# the memory mapped heap file, redirect heap allocations to the system heap
-# allocator, and disable commands that would otherwise cause fork() operations:
-# BGSAVE and BGREWRITEAOF. This flag may not be combined with any of the other
-# flags that configure AOF and RDB operations.
+# persistence is unnecessary. As an optimization, all persistence can be
+# turned off in the Windows version of Redis. This will redirect heap
+# allocations to the system heap allocator, and disable commands that would
+# otherwise cause fork() operations: BGSAVE and BGREWRITEAOF.
+# This flag may not be combined with any of the other flags that configure
+# AOF and RDB operations.
 # persistence-available [(yes)|no]
 
 # Don't use more memory than the specified amount of bytes.
@@ -500,18 +451,33 @@ heapdir C:\\src\\ServiceStack.Redis\\src\\sentinel\\redis-6380
 # limit for maxmemory so that there is some free RAM on the system for slave
 # output buffers (but this is not needed if the policy is 'noeviction').
 #
+# WARNING: not setting maxmemory will cause Redis to terminate with an
+# out-of-memory exception if the heap limit is reached.
+#
+# NOTE: since Redis uses the system paging file to allocate the heap memory,
+# the Working Set memory usage showed by the Windows Task Manager or by other
+# tools such as ProcessExplorer will not always be accurate. For example, right
+# after a background save of the RDB or the AOF files, the working set value
+# may drop significantly. In order to check the correct amount of memory used
+# by the redis-server to store the data, use the INFO client command. The INFO
+# command shows only the memory used to store the redis data, not the extra
+# memory used by the Windows process for its own requirements. Th3 extra amount
+# of memory not reported by the INFO command can be calculated subtracting the
+# Peak Working Set reported by the Windows Task Manager and the used_memory_peak
+# reported by the INFO command.
+#
 # maxmemory <bytes>
 
 # MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
 # is reached. You can select among five behaviors:
-#
+# 
 # volatile-lru -> remove the key with an expire set using an LRU algorithm
 # allkeys-lru -> remove any key according to the LRU algorithm
 # volatile-random -> remove a random key with an expire set
 # allkeys-random -> remove a random key, any key
 # volatile-ttl -> remove the key with the nearest expire time (minor TTL)
 # noeviction -> don't expire at all, just return an error on write operations
-#
+# 
 # Note: with any of the above policies, Redis will return an error on write
 #       operations, when there are no suitable keys for eviction.
 #
@@ -600,15 +566,15 @@ appendfsync everysec
 # the same as "appendfsync none". In practical terms, this means that it is
 # possible to lose up to 30 seconds of log in the worst scenario (with the
 # default Linux settings).
-#
+# 
 # If you have latency problems turn this to "yes". Otherwise leave it as
 # "no" that is the safest pick from the point of view of durability.
 no-appendfsync-on-rewrite no
 
 # Automatic rewrite of the append only file.
 # Redis is able to automatically rewrite the log file implicitly calling
 # BGREWRITEAOF when the AOF log size grows by the specified percentage.
-#
+# 
 # This is how it works: Redis remembers the size of the AOF file after the
 # latest rewrite (if no rewrite has happened since the restart, the size of
 # the AOF at startup is used).
@@ -667,6 +633,114 @@ aof-load-truncated yes
 # Set it to 0 or a negative value for unlimited execution without warnings.
 lua-time-limit 5000
 
+################################ REDIS CLUSTER  ###############################
+#
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+# WARNING EXPERIMENTAL: Redis Cluster is considered to be stable code, however
+# in order to mark it as "mature" we need to wait for a non trivial percentage
+# of users to deploy it in production.
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#
+# Normal Redis instances can't be part of a Redis Cluster; only nodes that are
+# started as cluster nodes can. In order to start a Redis instance as a
+# cluster node enable the cluster support uncommenting the following:
+#
+# cluster-enabled yes
+
+# Every cluster node has a cluster configuration file. This file is not
+# intended to be edited by hand. It is created and updated by Redis nodes.
+# Every Redis Cluster node requires a different cluster configuration file.
+# Make sure that instances running in the same system do not have
+# overlapping cluster configuration file names.
+#
+# cluster-config-file nodes-6379.conf
+
+# Cluster node timeout is the amount of milliseconds a node must be unreachable
+# for it to be considered in failure state.
+# Most other internal time limits are multiple of the node timeout.
+#
+# cluster-node-timeout 15000
+
+# A slave of a failing master will avoid to start a failover if its data
+# looks too old.
+#
+# There is no simple way for a slave to actually have a exact measure of
+# its "data age", so the following two checks are performed:
+#
+# 1) If there are multiple slaves able to failover, they exchange messages
+#    in order to try to give an advantage to the slave with the best
+#    replication offset (more data from the master processed).
+#    Slaves will try to get their rank by offset, and apply to the start
+#    of the failover a delay proportional to their rank.
+#
+# 2) Every single slave computes the time of the last interaction with
+#    its master. This can be the last ping or command received (if the master
+#    is still in the "connected" state), or the time that elapsed since the
+#    disconnection with the master (if the replication link is currently down).
+#    If the last interaction is too old, the slave will not try to failover
+#    at all.
+#
+# The point "2" can be tuned by user. Specifically a slave will not perform
+# the failover if, since the last interaction with the master, the time
+# elapsed is greater than:
+#
+#   (node-timeout * slave-validity-factor) + repl-ping-slave-period
+#
+# So for example if node-timeout is 30 seconds, and the slave-validity-factor
+# is 10, and assuming a default repl-ping-slave-period of 10 seconds, the
+# slave will not try to failover if it was not able to talk with the master
+# for longer than 310 seconds.
+#
+# A large slave-validity-factor may allow slaves with too old data to failover
+# a master, while a too small value may prevent the cluster from being able to
+# elect a slave at all.
+#
+# For maximum availability, it is possible to set the slave-validity-factor
+# to a value of 0, which means, that slaves will always try to failover the
+# master regardless of the last time they interacted with the master.
+# (However they'll always try to apply a delay proportional to their
+# offset rank).
+#
+# Zero is the only value able to guarantee that when all the partitions heal
+# the cluster will always be able to continue.
+#
+# cluster-slave-validity-factor 10
+
+# Cluster slaves are able to migrate to orphaned masters, that are masters
+# that are left without working slaves. This improves the cluster ability
+# to resist to failures as otherwise an orphaned master can't be failed over
+# in case of failure if it has no working slaves.
+#
+# Slaves migrate to orphaned masters only if there are still at least a
+# given number of other working slaves for their old master. This number
+# is the "migration barrier". A migration barrier of 1 means that a slave
+# will migrate only if there is at least 1 other working slave for its master
+# and so forth. It usually reflects the number of slaves you want for every
+# master in your cluster.
+#
+# Default is 1 (slaves migrate only if their masters remain with at least
+# one slave). To disable migration just set it to a very large value.
+# A value of 0 can be set but is useful only for debugging and dangerous
+# in production.
+#
+# cluster-migration-barrier 1
+
+# By default Redis Cluster nodes stop accepting queries if they detect there
+# is at least an hash slot uncovered (no available node is serving it).
+# This way if the cluster is partially down (for example a range of hash slots
+# are no longer covered) all the cluster becomes, eventually, unavailable.
+# It automatically returns available as soon as all the slots are covered again.
+#
+# However sometimes you want the subset of the cluster which is working,
+# to continue to accept queries for the part of the key space that is still
+# covered. In order to do so, just set the cluster-require-full-coverage
+# option to no.
+#
+# cluster-require-full-coverage yes
+
+# In order to setup your cluster make sure to read the documentation
+# available at http://redis.io web site.
+
 ################################## SLOW LOG ###################################
 
 # The Redis Slow Log is a system to log queries that exceeded a specified
@@ -675,7 +749,7 @@ lua-time-limit 5000
 # 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
@@ -806,7 +880,7 @@ hll-sparse-max-bytes 3000
 # that is rehashing, the more rehashing "steps" are performed, so if the
 # server is idle the rehashing is never complete and some more memory is used
 # by the hash table.
-#
+# 
 # The default is to use this millisecond 10 times every second in order to
 # actively rehash the main dictionaries, freeing memory when possible.
 #