internal void KeepAlive()
{
var commandMap = Multiplexer.CommandMap;
Message msg = null;
switch (ConnectionType)
{
case ConnectionType.Interactive:
msg = ServerEndPoint.GetTracerMessage(false);
msg.SetSource(ResultProcessor.Tracer, null);
break;
case ConnectionType.Subscription:
if (commandMap.IsAvailable(RedisCommand.UNSUBSCRIBE))
{
msg = Message.Create(-1, CommandFlags.FireAndForget, RedisCommand.UNSUBSCRIBE,
(RedisChannel)Guid.NewGuid().ToByteArray());
msg.SetSource(ResultProcessor.TrackSubscriptions, null);
}
break;
}
if (msg != null)
{
msg.SetInternalCall();
Multiplexer.Trace("Enqueue: " + msg);
if (!TryEnqueue(msg, ServerEndPoint.IsSlave))
{
OnInternalError(ExceptionFactory.NoConnectionAvailable(Multiplexer.IncludeDetailInExceptions, Multiplexer.IncludePerformanceCountersInExceptions, msg.Command, msg, ServerEndPoint, Multiplexer.GetServerSnapshot()));
}
}
}
public void Execute()
{
var snapshot = pending;
pending = null;
if (snapshot == null || snapshot.Count == 0)
{
return;
}
// group into per-bridge chunks
var byBridge = new Dictionary <PhysicalBridge, List <Message> >();
// optimisation: assume most things are in a single bridge
PhysicalBridge lastBridge = null;
List <Message> lastList = null;
foreach (var message in snapshot)
{
var server = multiplexer.SelectServer(message);
if (server == null)
{
FailNoServer(snapshot);
throw ExceptionFactory.NoConnectionAvailable(multiplexer.IncludeDetailInExceptions, multiplexer.IncludePerformanceCountersInExceptions, message.Command, message, server, multiplexer.GetServerSnapshot());
}
var bridge = server.GetBridge(message.Command);
if (bridge == null)
{
FailNoServer(snapshot);
throw ExceptionFactory.NoConnectionAvailable(multiplexer.IncludeDetailInExceptions, multiplexer.IncludePerformanceCountersInExceptions, message.Command, message, server, multiplexer.GetServerSnapshot());
}
// identity a list
List <Message> list;
if (bridge == lastBridge)
{
list = lastList;
}
else if (!byBridge.TryGetValue(bridge, out list))
{
list = new List <Message>();
byBridge.Add(bridge, list);
}
lastBridge = bridge;
lastList = list;
list.Add(message);
}
foreach (var pair in byBridge)
{
if (!pair.Key.TryEnqueue(pair.Value, pair.Key.ServerEndPoint.IsSlave))
{
FailNoServer(pair.Value);
}
}
}
internal Task <T> QueueDirectAsync <T>(Message message, ResultProcessor <T> processor, object asyncState = null, PhysicalBridge bridge = null)
{
var tcs = TaskSource.CreateDenyExecSync <T>(asyncState);
var source = ResultBox <T> .Get(tcs);
message.SetSource(processor, source);
if (!(bridge ?? GetBridge(message.Command)).TryEnqueue(message, isSlave))
{
ConnectionMultiplexer.ThrowFailed(tcs, ExceptionFactory.NoConnectionAvailable(multiplexer.IncludeDetailInExceptions, message.Command, message, this));
}
return(tcs.Task);
}
internal Task <T> QueueDirectAsync <T>(Message message, ResultProcessor <T> processor, object asyncState = null, PhysicalBridge bridge = null)
{
var tcs = TaskSource.Create <T>(asyncState);
var source = ResultBox <T> .Get(tcs);
message.SetSource(processor, source);
if (bridge == null)
{
bridge = GetBridge(message.Command);
}
if (!bridge.TryEnqueue(message, isSlave))
{
ConnectionMultiplexer.ThrowFailed(tcs, ExceptionFactory.NoConnectionAvailable(Multiplexer.IncludeDetailInExceptions, Multiplexer.IncludePerformanceCountersInExceptions, message.Command, message, this, Multiplexer.GetServerSnapshot()));
}
return(tcs.Task);
}
internal override T ExecuteSync <T>(Message message, ResultProcessor <T> processor, ServerEndPoint server = null)
{ // inject our expected server automatically
if (server == null)
{
server = this.server;
}
FixFlags(message, server);
if (!server.IsConnected)
{
if (message == null || message.IsFireAndForget)
{
return(default(T));
}
throw ExceptionFactory.NoConnectionAvailable(multiplexer.IncludeDetailInExceptions, message.Command, message, server);
}
return(base.ExecuteSync <T>(message, processor, server));
}
internal override Task <T> ExecuteAsync <T>(Message message, ResultProcessor <T> processor, ServerEndPoint server = null)
{ // inject our expected server automatically
if (server == null)
{
server = this.server;
}
FixFlags(message, server);
if (!server.IsConnected)
{
if (message == null)
{
return(CompletedTask <T> .Default(asyncState));
}
if (message.IsFireAndForget)
{
return(CompletedTask <T> .Default(null)); // F+F explicitly does not get async-state
}
// no need to deny exec-sync here; will be complete before they see if
var tcs = TaskSource.Create <T>(asyncState);
ConnectionMultiplexer.ThrowFailed(tcs, ExceptionFactory.NoConnectionAvailable(multiplexer.IncludeDetailInExceptions, message.Command, message, server));
return(tcs.Task);
}
return(base.ExecuteAsync <T>(message, processor, server));
}
