void ContinueScenarioExecution(IChannelHandlerContext context)
{
if (!this.testScenario.MoveNext())
{
context.CloseAsync()
.ContinueWith(
t => this.completion.TrySetException(t.Exception),
TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously);
this.completion.TryComplete();
return;
}
foreach (object message in this.testScenario.Current.SendMessages)
{
context.WriteAsync(message)
.ContinueWith(
t => this.completion.TrySetException(t.Exception),
TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously);
}
context.Flush();
}
public void Flush(IChannelHandlerContext context)
{
context.Flush();
}
public override void Flush(IChannelHandlerContext ctx)
{
Logger().LogDebug($"Channel {ctx.Channel} flushing");
ctx.Flush();
}
public static void NotifyHandshakeFailure(IChannelHandlerContext ctx, Exception cause)
{
// We have may haven written some parts of data before an exception was thrown so ensure we always flush.
// See https://github.com/netty/netty/issues/3900#issuecomment-172481830
ctx.Flush();
ctx.FireUserEventTriggered(new TlsHandshakeCompletionEvent(cause));
ctx.CloseAsync();
}
void ExecuteStep(IChannelHandlerContext context, TestScenarioStep currentStep)
{
if (!context.Channel.Open)
{
// todo: dispose scheduled work in case of channel closure instead?
return;
}
Task lastTask = null;
object lastMessage = null;
foreach (object message in currentStep.Messages)
{
lastMessage = message;
var writeTimeoutCts = new CancellationTokenSource();
Task task = context.WriteAsync(message);
object timeoutExcMessage = message;
context.Channel.EventLoop.Schedule(
() => this.completion.TrySetException(new TimeoutException(string.Format("Sending of message did not complete in time: {0}", timeoutExcMessage))),
this.sendTimeout,
writeTimeoutCts.Token);
task.ContinueWith(
t => writeTimeoutCts.Cancel(),
TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously);
task.OnFault(t => this.completion.TrySetException(t.Exception));
lastTask = task;
}
if (currentStep.WaitForFeedback)
{
if (this.responseTimeout > TimeSpan.Zero)
{
this.responseTimeoutCts = new CancellationTokenSource();
if (lastTask == null)
{
this.ScheduleReadTimeoutCheck(context, null);
}
else
{
lastTask.ContinueWith(
t => this.ScheduleReadTimeoutCheck(context, lastMessage),
TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.ExecuteSynchronously);
}
}
}
context.Flush();
if (!currentStep.WaitForFeedback)
{
context.Channel.EventLoop.Execute(
ctx => this.ContinueScenarioExecution((IChannelHandlerContext)ctx),
context);
}
}
async void ProcessPendingSubscriptionChanges(IChannelHandlerContext context)
{
try
{
do
{
ISessionState newState = this.sessionState.Copy();
Queue<Packet> queue = this.SubscriptionChangeQueue;
var acks = new List<Packet>(queue.Count);
foreach (Packet packet in queue) // todo: if can queue be null here, don't force creation
{
switch (packet.PacketType)
{
case PacketType.SUBSCRIBE:
acks.Add(Util.AddSubscriptions(newState, (SubscribePacket)packet, this.maxSupportedQosToClient));
break;
case PacketType.UNSUBSCRIBE:
acks.Add(Util.RemoveSubscriptions(newState, (UnsubscribePacket)packet));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
queue.Clear();
if (!this.sessionState.IsTransient)
{
// save updated session state, make it current once successfully set
await this.sessionStateManager.SetAsync(this.deviceId, newState);
}
this.sessionState = newState;
// release ACKs
var tasks = new List<Task>(acks.Count);
foreach (Packet ack in acks)
{
tasks.Add(context.WriteAsync(ack));
}
context.Flush();
await Task.WhenAll(tasks);
PerformanceCounters.PacketsSentPerSecond.IncrementBy(acks.Count);
}
while (this.subscriptionChangeQueue.Count > 0);
this.ResetState(StateFlags.ChangingSubscriptions);
}
catch (Exception ex)
{
ShutdownOnError(context, "-> UN/SUBSCRIBE", ex);
}
}
public override void ChannelActive(IChannelHandlerContext context)
{
// write a large enough blob of data that it has to be split into multiple writes
var channel = context.Channel;
_tasks.Enqueue(
context.WriteAsync(context.Allocator.Buffer().WriteZero(1048576))
.ContinueWith(tr => channel.CloseAsync(),
TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnRanToCompletion)
.Unwrap());
_tasks.Enqueue(context.WriteAsync(context.Allocator.Buffer().WriteZero(1048576)));
context.Flush();
_tasks.Enqueue(context.WriteAsync(context.Allocator.Buffer().WriteZero(1048576)));
context.Flush();
}
void DoFlush(IChannelHandlerContext context)
{
IChannel channel = context.Channel;
if (!channel.Active)
{
this.Discard();
return;
}
bool requiresFlush = true;
IByteBufferAllocator allocator = context.Allocator;
while (channel.IsWritable)
{
if (this.currentWrite == null)
{
this.currentWrite = this.queue.Count > 0 ? this.queue.Dequeue() : null;
}
if (this.currentWrite == null)
{
break;
}
PendingWrite current = this.currentWrite;
object pendingMessage = current.Message;
if (pendingMessage is IChunkedInput <T> chunks)
{
bool endOfInput;
bool suspend;
object message = null;
try
{
message = chunks.ReadChunk(allocator);
endOfInput = chunks.IsEndOfInput;
if (message == null)
{
// No need to suspend when reached at the end.
suspend = !endOfInput;
}
else
{
suspend = false;
}
}
catch (Exception exception)
{
this.currentWrite = null;
if (message != null)
{
ReferenceCountUtil.Release(message);
}
current.Fail(exception);
CloseInput(chunks);
break;
}
if (suspend)
{
// ChunkedInput.nextChunk() returned null and it has
// not reached at the end of input. Let's wait until
// more chunks arrive. Nothing to write or notify.
break;
}
if (message == null)
{
// If message is null write an empty ByteBuf.
// See https://github.com/netty/netty/issues/1671
message = Unpooled.Empty;
}
Task future = context.WriteAsync(message);
if (endOfInput)
{
this.currentWrite = null;
// Register a listener which will close the input once the write is complete.
// This is needed because the Chunk may have some resource bound that can not
// be closed before its not written.
//
// See https://github.com/netty/netty/issues/303
future.ContinueWith((_, state) =>
{
var pendingTask = (PendingWrite)state;
CloseInput((IChunkedInput <T>)pendingTask.Message);
pendingTask.Success();
},
current,
TaskContinuationOptions.ExecuteSynchronously);
}
else if (channel.IsWritable)
{
future.ContinueWith((task, state) =>
{
var pendingTask = (PendingWrite)state;
if (task.IsFaulted)
{
CloseInput((IChunkedInput <T>)pendingTask.Message);
pendingTask.Fail(task.Exception);
}
else
{
pendingTask.Progress(chunks.Progress, chunks.Length);
}
},
current,
TaskContinuationOptions.ExecuteSynchronously);
}
else
{
future.ContinueWith((task, state) =>
{
var handler = (ChunkedWriteHandler <T>)state;
if (task.IsFaulted)
{
CloseInput((IChunkedInput <T>)handler.currentWrite.Message);
handler.currentWrite.Fail(task.Exception);
}
else
{
handler.currentWrite.Progress(chunks.Progress, chunks.Length);
if (channel.IsWritable)
{
handler.ResumeTransfer();
}
}
},
this,
TaskContinuationOptions.ExecuteSynchronously);
}
// Flush each chunk to conserve memory
context.Flush();
requiresFlush = false;
}
else
{
context.WriteAsync(pendingMessage)
.ContinueWith((task, state) =>
{
var pendingTask = (PendingWrite)state;
if (task.IsFaulted)
{
pendingTask.Fail(task.Exception);
}
else
{
pendingTask.Success();
}
},
current,
TaskContinuationOptions.ExecuteSynchronously);
this.currentWrite = null;
requiresFlush = true;
}
if (!channel.Active)
{
this.Discard(new ClosedChannelException());
break;
}
}
if (requiresFlush)
{
context.Flush();
}
}
public void ChannelReadComplete(IChannelHandlerContext ctx)
{
ctx.Flush();
}
public override void ChannelReadComplete(IChannelHandlerContext context)
{
context.Flush();
//base.ChannelReadComplete(context);
}
public IChannelHandlerContext Flush()
{
_ = _ctx.Flush();
return(this);
}
protected override void ChannelRead0(IChannelHandlerContext ctx, string msg)
{
if (msg == null)
{
throw new ArgumentNullException(nameof(msg));
}
Channel msgChannel;
try
{
msgChannel = JsonConvert.DeserializeObject <Channel>(msg);
}
catch (Exception ex)
{
Logger.Log.Error(
string.Format(LogLanguage.Instance.GetMessageFromKey(LanguageKey.UNRECOGNIZED_MASTER_PACKET), ex));
return;
}
if (!IsAuthenticated)
{
if (msgChannel.Password == Password)
{
IsAuthenticated = true;
Logger.Log.Debug(string.Format(
LogLanguage.Instance.GetMessageFromKey(LanguageKey.AUTHENTICATED_SUCCESS), _id.ToString()));
if (MasterClientListSingleton.Instance.WorldServers == null)
{
MasterClientListSingleton.Instance.WorldServers = new List <WorldServerInfo>();
}
try
{
_id = MasterClientListSingleton.Instance.WorldServers.Select(s => s.Id).Max() + 1;
}
catch
{
_id = 0;
}
var servtype = (ServerType)Enum.Parse(typeof(ServerType), msgChannel.ClientType.ToString());
if (servtype == ServerType.WorldServer)
{
var serv = new WorldServerInfo
{
Name = msgChannel.ClientName,
Host = msgChannel.Host,
Port = msgChannel.Port,
Id = _id,
connectedAccountLimit = msgChannel.connectedAccountLimit,
WebApi = msgChannel.WebApi
};
MasterClientListSingleton.Instance.WorldServers.Add(serv);
msgChannel.ChannelId = _id;
WriteAsync(ctx, msgChannel);
}
ctx.Flush();
}
else
{
ctx.CloseAsync();
Logger.Log.Error(
string.Format(LogLanguage.Instance.GetMessageFromKey(LanguageKey.AUTHENTICATED_ERROR)));
}
}
}
public override void ChannelReadComplete(IChannelHandlerContext context)
{
string Success = string.Empty;
context.Flush();
}
public override void Flush(IChannelHandlerContext context)
{
RegisterFiredEvent(SupportedEvent.Flush);
context.Flush();
}
public override void Flush(IChannelHandlerContext context)
{
context.Flush();
}
public override void Flush(IChannelHandlerContext context)
{
Log(Event.FLUSH);
context.Flush();
}
/// <summary>
/// Is called when a read timeout was detected.
/// </summary>
/// <param name="context">Context.</param>
protected virtual void ReadTimedOut(IChannelHandlerContext context)
{
if(!this.closed)
{
context.FireExceptionCaught(ReadTimeoutException.Instance);
context.Flush();
this.closed = true;
}
}
public override void Flush(IChannelHandlerContext context)
{
Log.Debug($"{context.Name}: Flush");
context.Flush();
}
public override void ChannelReadComplete(IChannelHandlerContext context) => context?.Flush();
public override void ChannelReadComplete(IChannelHandlerContext context)
{
base.ChannelReadComplete(context);
context.Flush();
RecordLogEvent?.Invoke("ChannelReadComplete:" + context);
}
public override void Flush(IChannelHandlerContext ctx)
{
if (this.Logger.IsEnabled(this.InternalLevel))
{
this.Logger.Log(this.InternalLevel, this.Format(ctx, "FLUSH"));
}
ctx.Flush();
}
/// <summary>
/// 消息接收完毕
/// </summary>
/// <param name="context">通道处理上下文</param>
public override void ChannelReadComplete(IChannelHandlerContext context)
{
base.ChannelReadComplete(context);
context.Flush();
ClientEventHandler.RecordLogEvent?.Invoke(true, "ChannelReadComplete");
}
public void Flush(IChannelHandlerContext context)
{
context.Flush();
}
public override void ChannelReadComplete(IChannelHandlerContext context) => context.Flush(); public override void ExceptionCaught(IChannelHandlerContext context, Exception exception)
public override void ChannelReadComplete(IChannelHandlerContext context)
{
context.Flush();
}
public override void Flush(IChannelHandlerContext ctx)
{
log.Debug("Channel {0} flushing", ctx.Channel);
ctx.Flush();
}
public virtual void Flush(IChannelHandlerContext context) => context.Flush();
private void FlushNow(IChannelHandlerContext ctx)
{
CancelScheduledFlush();
_flushPendingCount = 0;
ctx.Flush();
}