public static IConnectionMultiplexer GetConnectionRedisMultiplexer()
{
if (_connMultiplexer == null || !_connMultiplexer.IsConnected)
{
lock (_obj)
{
if (_connMultiplexer == null || !_connMultiplexer.IsConnected)
{
var config = new ConfigurationOptions
{
AbortOnConnectFail = false,
AllowAdmin = true,
ConnectTimeout = 15000,
SyncTimeout = 5000,
ResponseTimeout = 15000,
Password = ConfigurationManager.GetValue("Redis:Password"),
EndPoints = { EndPointCollection.TryParse(ConfigurationManager.GetValue("Redis:Connection")) }
};
_connMultiplexer = ConnectionMultiplexer.Connect(config);
}
}
}
return(_connMultiplexer);
}
public static void ConnectingToEndpoints(ILogger logger, EndPointCollection endpoints, string serverName)
{
if (logger.IsEnabled(LogLevel.Information) && endpoints.Count > 0)
{
_connectingToEndpoints(logger, string.Join(", ", endpoints.Select(e => EndPointCollection.ToString(e))), serverName, null);
}
}
protected static EndPointCollection ParseSlaveEndPoints(params KeyValuePair <string, string>[][] slaveInfos)
{
if (slaveInfos == null || slaveInfos.Length == 0)
{
return(null);
}
var slaveEndPoints = new EndPointCollection();
string ip, port, flags;
foreach (var slaveInfo in slaveInfos.Select(m => m.ToDictionary()))
{
slaveInfo.TryGetValue("flags", out flags);
slaveInfo.TryGetValue("ip", out ip);
slaveInfo.TryGetValue("port", out port);
if (!string.IsNullOrEmpty(ip) && !string.IsNullOrEmpty(port) &&
!flags.Contains("s_down") && !flags.Contains("o_down"))
{
slaveEndPoints.Add(string.Format("{0}:{1}", ip, port));
}
}
return(slaveEndPoints);
}
void IConfigurationSettingHostService.Attach(IConfigurationSettingItem setting)
{
this.setting = (RedisCacheSetting)setting;
options = new ConfigurationOptions
{
DefaultDatabase = this.setting.DefaultDb,
Password = this.setting.Password,
AllowAdmin = true
};
var endPoints = new EndPointCollection();
foreach (var h in this.setting.Hosts)
{
if (h.Port == 0)
{
options.EndPoints.Add(h.Server);
}
else
{
options.EndPoints.Add(h.Server, h.Port);
}
}
}
public void NoticesConnectFail()
{
SetExpectedAmbientFailureCount(-1);
using (var conn = Create(allowAdmin: true))
{
var server = conn.GetServer(conn.GetEndPoints()[0]);
conn.IgnoreConnect = true;
conn.ConnectionFailed += (s, a) =>
Output.WriteLine("Disconnected: " + EndPointCollection.ToString(a.EndPoint));
conn.ConnectionRestored += (s, a) =>
Output.WriteLine("Reconnected: " + EndPointCollection.ToString(a.EndPoint));
server.SimulateConnectionFailure();
Thread.Sleep(2000);
try
{
server.Ping();
Assert.True(false, "Did not expect PING to succeed");
}
catch (RedisConnectionException) { /* expected */ }
conn.IgnoreConnect = false;
Thread.Sleep(2000);
var time = server.Ping();
Output.WriteLine(time.ToString());
}
}
protected static EndPointCollection ParseSentinelEndPoints(params string[] sentinelHosts)
{
if (sentinelHosts == null || sentinelHosts.Length == 0)
{
return(null);
}
var sentinelEndPoints = new EndPointCollection();
for (var i = 0; i < sentinelHosts.Length; i++)
{
var sentinelHost = sentinelHosts[i];
var hostPortArr = sentinelHost.Split(':');
if (hostPortArr.Length > 2)
{
continue; //invalid hostAndPort string
}
if (hostPortArr.Length == 1)
{
sentinelHost = string.Format("{0}:{1}", hostPortArr[0], defaultSentinelPort);
}
sentinelEndPoints.Add(sentinelHost);
}
return(sentinelEndPoints);
}
private static void NoSqlInit()
{
lazyRedisConnections = new Lazy <ConnectionMultiplexer>(() =>
{
var options = ConfigurationOptions.Parse($"{ConfigHelper.RedisConnectionString}");
var muxer = ConnectionMultiplexer.Connect(options);
muxer.ConnectionFailed += (sender, e) =>
{
Console.WriteLine("redis failed: " + EndPointCollection.ToString(e.EndPoint) + "/" + e.ConnectionType);
};
muxer.ConnectionRestored += (sender, e) =>
{
Console.WriteLine("redis restored: " + EndPointCollection.ToString(e.EndPoint) + "/" + e.ConnectionType);
};
return(muxer);
});
lazyDistributedLockService = new Lazy <RedLockFactory>(() =>
{
return(RedLockFactory.Create(new List <RedLockMultiplexer>()
{
lazyRedisConnections.Value
}));
});
}
public async Task QueuesAndFlushesAfterReconnectingClusterAsync()
{
try
{
var options = ConfigurationOptions.Parse(TestConfig.Current.ClusterServersAndPorts);
options.BacklogPolicy = BacklogPolicy.Default;
options.AbortOnConnectFail = false;
options.ConnectTimeout = 1000;
options.ConnectRetry = 2;
options.SyncTimeout = 10000;
options.KeepAlive = 10000;
options.AsyncTimeout = 5000;
options.AllowAdmin = true;
options.SocketManager = SocketManager.ThreadPool;
using var muxer = await ConnectionMultiplexer.ConnectAsync(options, Writer);
muxer.ErrorMessage += (s, e) => Log($"Error Message {e.EndPoint}: {e.Message}");
muxer.InternalError += (s, e) => Log($"Internal Error {e.EndPoint}: {e.Exception.Message}");
muxer.ConnectionFailed += (s, a) => Log("Disconnected: " + EndPointCollection.ToString(a.EndPoint));
muxer.ConnectionRestored += (s, a) => Log("Reconnected: " + EndPointCollection.ToString(a.EndPoint));
var db = muxer.GetDatabase();
Writer.WriteLine("Test: Initial (connected) ping");
await db.PingAsync();
RedisKey meKey = Me();
var getMsg = Message.Create(0, CommandFlags.None, RedisCommand.GET, meKey);
ServerEndPoint?server = null; // Get the server specifically for this message's hash slot
await UntilConditionAsync(TimeSpan.FromSeconds(10), () => (server = muxer.SelectServer(getMsg)) != null);
Assert.NotNull(server);
var stats = server.GetBridgeStatus(ConnectionType.Interactive);
Assert.Equal(0, stats.BacklogMessagesPending); // Everything's normal
/// <summary>
/// Slave this instance to another instance
/// </summary>
public bool SlaveTo(string address)
{
var newMaster = EndPointCollection.TryParse(address);
this._connection.GetSingleServer().SlaveOf(newMaster);
return(true);
}
public async Task NoticesConnectFail()
{
SetExpectedAmbientFailureCount(-1);
using (var conn = Create(allowAdmin: true))
{
var server = conn.GetServer(conn.GetEndPoints()[0]);
conn.ConnectionFailed += (s, a) =>
Log("Disconnected: " + EndPointCollection.ToString(a.EndPoint));
conn.ConnectionRestored += (s, a) =>
Log("Reconnected: " + EndPointCollection.ToString(a.EndPoint));
// No need to delay, we're going to try a disconnected connection immediately so it'll fail...
conn.IgnoreConnect = true;
Log("simulating failure");
server.SimulateConnectionFailure();
Log("simulated failure");
conn.IgnoreConnect = false;
Log("pinging - expect failure");
Assert.Throws <RedisConnectionException>(() => server.Ping());
Log("pinged");
// Heartbeat should reconnect by now
await Task.Delay(5000).ConfigureAwait(false);
Log("pinging - expect success");
var time = server.Ping();
Log("pinged");
Log(time.ToString());
}
}
protected void OnConnectionFailed(object sender, ConnectionFailedEventArgs e)
{
Interlocked.Increment(ref privateFailCount);
lock (privateExceptions)
{
privateExceptions.Add("Connection failed: " + EndPointCollection.ToString(e.EndPoint) + "/" + e.ConnectionType);
}
}
protected void OnInternalError(object sender, InternalErrorEventArgs e)
{
Interlocked.Increment(ref privateFailCount);
lock (privateExceptions)
{
privateExceptions.Add("Internal error: " + e.Origin + ", " + EndPointCollection.ToString(e.EndPoint) + "/" + e.ConnectionType);
}
}
private void OnMasterChanged(object sender, EndPointEventArgs args)
{
var handler = MasterChanged;
if (handler != null)
{
handler(EndPointCollection.ToString(args.EndPoint));
}
}
/// <summary>
/// Slave this instance to another instance
/// </summary>
public async Task <bool> SlaveToAsync(string address)
{
var newMaster = EndPointCollection.TryParse(address);
await _connection.GetSingleServer().SlaveOfAsync(newMaster);
var newMasterInstance = GetInstance(address);
await newMasterInstance?.PublishSERedisReconfigureAsync();
return(true);
}
/// <summary>
/// Kill a particular client's connection
/// </summary>
public bool KillClient(string address)
{
var endpoint = EndPointCollection.TryParse(address);
if (endpoint == null)
{
return(false);
}
this._connection.GetSingleServer().ClientKill(endpoint);
return(true);
}
internal ThreadedServer(IServerCompanion?companion, ServerConfiguration configuration, IHandler handler)
{
Version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
Companion = companion;
Configuration = configuration;
_EndPoints = new EndPointCollection(this, configuration.EndPoints, configuration.Network);
Handler = handler;
}
private void SetEndPoints(ConfigurationOptions options)
{
var endPoints = new EndPointCollection();
BedrockConfiguration.Cache.Redis.EndPoints.Each(ep => endPoints.Add(ep.Host, ep.Port));
options
.GetType()
.GetField("endpoints", BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(options, endPoints);
}
/// <summary>
/// Kill a particular client's connection
/// </summary>
/// <param name="address">The address or the client to kill</param>
public async Task <bool> KillClientAsync(string address)
{
var endpoint = EndPointCollection.TryParse(address);
if (endpoint == null)
{
return(false);
}
await _connection.GetSingleServer().ClientKillAsync(endpoint).ConfigureAwait(false);
return(true);
}
/// <summary>
/// Replicate to this instance from another instance.
/// </summary>
/// <param name="address">The address of the <see cref="RedisInstance"/> to replicate from.</param>
public async Task <bool> ReplicateFromAsync(string address)
{
var newMaster = EndPointCollection.TryParse(address);
await _connection.GetSingleServer().ReplicaOfAsync(newMaster);
var newMasterInstance = Module.GetInstance(address);
if (newMasterInstance != null)
{
await newMasterInstance.PublishSERedisReconfigureAsync();
}
return(true);
}
/// <summary>
/// Sets the StackExchange.Redis tiebreaker key on this node.
/// </summary>
public bool SetSERedisTiebreaker()
{
RedisKey tieBreakerKey = SERedisTiebreakerKey;
var myEndPoint = this._connection.GetEndPoints().FirstOrDefault();
RedisValue tieBreakerValue = EndPointCollection.ToString(myEndPoint);
var result = this._connection.GetDatabase()
.StringSet(tieBreakerKey, tieBreakerValue, flags: CommandFlags.NoRedirect | CommandFlags.HighPriority);
Tiebreaker.Poll(true);
return(result);
}
/// <summary>
/// Slave this instance to another instance
/// </summary>
public bool SlaveTo(string address)
{
var newMaster = EndPointCollection.TryParse(address);
this._connection.GetSingleServer().SlaveOf(newMaster);
var newMasterInstance = GetInstance(address);
if (newMasterInstance != null)
{
newMasterInstance.PublishSERedisReconfigure();
}
return(true);
}
/// <summary>
/// Sets the StackExchange.Redis tiebreaker key on this node.
/// </summary>
public async Task <bool> SetSERedisTiebreakerAsync()
{
RedisKey tieBreakerKey = SERedisTiebreakerKey;
var myEndPoint = _connection.GetEndPoints().FirstOrDefault();
RedisValue tieBreakerValue = EndPointCollection.ToString(myEndPoint);
var result = await _connection.GetDatabase()
.StringSetAsync(tieBreakerKey, tieBreakerValue, flags: CommandFlags.NoRedirect);
await Tiebreaker.PollAsync(true);
return(result);
}
private void Connect()
{
var configuration = new ConfigurationOptions
{
Password = RedisOptions.Value.Password,
DefaultDatabase = RedisOptions.Value.Db
};
foreach (string endPoint in RedisOptions.Value.EndPoints)
{
configuration.EndPoints.Add(EndPointCollection.TryParse(endPoint));
}
_pool = ConnectionMultiplexer.Connect(configuration);
}
string IRedisLite.GetInfo(bool allowTalkToServer)
{
var server = AsyncRedisConnection.TryGetServer(subscriber, false);
if (server == null)
{
return("");
}
return("AsyncRedis; " + EndPointCollection.ToString(server.EndPoint) + Environment.NewLine
+ "Server version: " + server.Version + Environment.NewLine + Environment.NewLine
+ server.Features + Environment.NewLine
+ server.GetCounters().ToString() + Environment.NewLine + Environment.NewLine
+ (allowTalkToServer ? (GetFormattedInfo() + Environment.NewLine + Environment.NewLine) : "")
+ StackRedis.AsyncDelayedRedisCache.GetExpensiveQueries());
}
public string GetConfigurationOverview(out string[] availableEndpoints)
{
using (var log = new StringWriter())
{
muxer.Configure(log);
var eps = muxer.GetEndPoints(true);
availableEndpoints = new string[eps.Length];
for (int i = 0; i < eps.Length; i++)
{
availableEndpoints[i] = EndPointCollection.ToString(eps[i]);
}
return(log.ToString());
}
}
internal static ConfigurationOptions ConvertConfigurationOptions(this EndPointCollection endPoints)
{
if (endPoints == null || endPoints.Count == 0)
{
return(null);
}
var configOptions = new ConfigurationOptions();
foreach (var endPoint in endPoints)
{
configOptions.EndPoints.Add(endPoint);
}
return(configOptions);
}
public void EndpointIteratorIsReliableOverChanges()
{
var eps = new EndPointCollection
{
{ IPAddress.Loopback, 7999 },
{ IPAddress.Loopback, 8000 },
};
using var iter = eps.GetEnumerator();
Assert.True(iter.MoveNext());
Assert.Equal(7999, ((IPEndPoint)iter.Current).Port);
eps[1] = new IPEndPoint(IPAddress.Loopback, 8001); // boom
Assert.True(iter.MoveNext());
Assert.Equal(8001, ((IPEndPoint)iter.Current).Port);
Assert.False(iter.MoveNext());
}
public void ParseEndpoints()
{
var eps = new EndPointCollection
{
{ "127.0.0.1", 1000 },
{ "::1", 1001 },
{ "localhost", 1002 }
};
Assert.Equal(AddressFamily.InterNetwork, eps[0].AddressFamily);
Assert.Equal(AddressFamily.InterNetworkV6, eps[1].AddressFamily);
Assert.Equal(AddressFamily.Unspecified, eps[2].AddressFamily);
Assert.Equal("127.0.0.1:1000", eps[0].ToString());
Assert.Equal("[::1]:1001", eps[1].ToString());
Assert.Equal("Unspecified/localhost:1002", eps[2].ToString());
}
public string SwitchMaster(string newMaster)
{
var ep = EndPointCollection.TryParse(newMaster);
if (ep == null)
{
throw new ArgumentException("newMaster");
}
var server = muxer.GetServer(ep);
using (StringWriter log = new StringWriter())
{
server.MakeMaster(ReplicationChangeOptions.SetTiebreaker | ReplicationChangeOptions.EnslaveSubordinates | ReplicationChangeOptions.Broadcast, log);
return(log.ToString());
}
}
internal static bool IsAzureEndpoint(EndPointCollection endPoints)
{
bool flag = false;
foreach (DnsEndPoint dnsEndPoint in endPoints.Select(endpoint => endpoint as DnsEndPoint).Where(ep => ep != null))
{
int startIndex = dnsEndPoint.Host.IndexOf('.');
if (startIndex >= 0)
{
string lowerInvariant = dnsEndPoint.Host.Substring(startIndex).ToLowerInvariant();
if (lowerInvariant == ".redis.cache.windows.net" || lowerInvariant == ".redis.cache.chinacloudapi.cn" || (lowerInvariant == ".redis.cache.usgovcloudapi.net" || lowerInvariant == ".redis.cache.cloudapi.de"))
{
return(true);
}
}
}
return(flag);
}
