public override Task WriteAsync(IChannelHandlerContext context, object message)
{
if (message is int)
{
var buf = Unpooled.Buffer(4).WriteInt((int) message);
return context.WriteAsync(buf);
}
return context.WriteAsync(message);
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
var buffer = message as IByteBuffer;
if (buffer != null)
{
Console.WriteLine("Received from client: " + buffer.ToString(Encoding.UTF8));
}
context.WriteAsync(message);
}
public override Task WriteAsync(IChannelHandlerContext context, object message)
{
if (message is int)
{
State = State.WriteMessages((int) message);
Logger.Debug("[Client-Write] Writing: {0}", message);
}
return context.WriteAsync(message);
}
public override Task WriteAsync(IChannelHandlerContext context, object message)
{
var packet = message as PublishPacket;
if (packet != null)
{
IByteBuffer result = ApplyCompression(packet.Payload, CompressionMode.Compress);
packet.Payload = result;
}
return context.WriteAsync(message);
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
var byteBuffer = message as IByteBuffer;
if (byteBuffer != null)
{
this.buffer.Initialize();
byteBuffer.Duplicate().ReadBytes(this.buffer, 0, byteBuffer.ReadableBytes);
string msg = Encoding.UTF8.GetString(this.buffer);
Console.WriteLine("Received from server: " + msg);
}
context.WriteAsync(message);
}
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();
}
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 Task WriteAsync(IChannelHandlerContext ctx, object msg)
{
if (this.Logger.IsEnabled(this.InternalLevel))
{
this.Logger.Log(this.InternalLevel, this.Format(ctx, "WRITE", msg));
}
return ctx.WriteAsync(msg);
}
public override Task WriteAsync(IChannelHandlerContext context, object message)
{
var buf = message as IByteBuffer;
if (buf != null)
{
var tcs = new TaskCompletionSource<int>(buf);
this.sslStreamWriteQueue.Enqueue(tcs);
State oldState = this.state;
if ((oldState & (State.WriteInProgress | State.Authenticated)) == State.Authenticated) // authenticated but not writing already
{
this.state = oldState | State.WriteInProgress;
this.ScheduleWriteToSslStream(buf);
}
return tcs.Task;
}
else
{
// it's not IByteBuffer - passthrough
// todo: non-leaking termination policy?
return context.WriteAsync(message);
}
}
public override async Task WriteAsync(IChannelHandlerContext ctx, object message)
{
Logger().LogDebug($"Channel {ctx.Channel} writing a message ({message}) of type [{(message == null ? "NULL" : message.GetType().TypeQualifiedName())}]");
await ctx.WriteAsync(message);
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
var buffer = (IByteBuffer)message;
if (_logger.IsEnabled(LogLevel.Information))
_logger.Information($"接收到消息：{buffer.ToString(Encoding.UTF8)}。");
var content = buffer.ToArray();
TransportMessage<RemoteInvokeMessage> transportMessage;
try
{
transportMessage = _serializer.Deserialize<TransportMessage<RemoteInvokeMessage>>(content);
}
catch (Exception exception)
{
_logger.Error($"将接收到的消息反序列化成 TransportMessage<RemoteInvokeMessage> 时发送了错误，消息内容：{{buffer.ToString(Encoding.UTF8)}}。", exception);
return;
}
var invokeMessage = transportMessage.Content;
var entry = _serviceEntryLocate.Locate(invokeMessage);
if (entry == null)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.Error($"根据服务Id：{invokeMessage.ServiceId}，找不到服务条目。");
return;
}
if (_logger.IsEnabled(LogLevel.Debug))
_logger.Debug("准备执行本地逻辑。");
object result;
try
{
result = entry.Func(invokeMessage.Parameters);
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.Error("执行本地逻辑时候发生了错误。", exception);
result = null;
}
try
{
if (_logger.IsEnabled(LogLevel.Debug))
_logger.Debug("准备发送响应消息。");
var resultData = _serializer.Serialize(new TransportMessage
{
Content = result,
Id = transportMessage.Id
});
buffer = Unpooled.Buffer(resultData.Length);
buffer.WriteBytes(resultData);
context.WriteAsync(buffer);
if (_logger.IsEnabled(LogLevel.Debug))
_logger.Debug("响应消息发送成功。");
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.Error("发送响应消息时候发生了异常。", exception);
}
}
public override Task WriteAsync(IChannelHandlerContext ctx, object msg)
{
this.logger.LogInformation(this.Format(ctx, "SEND", msg));
return(ctx.WriteAsync(msg));
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
context.WriteAsync(message);
}
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();
}
public override Task WriteAsync(IChannelHandlerContext context, object message)
{
this.throughput.Increment();
return context.WriteAsync(message);
}
public override Task WriteAsync(IChannelHandlerContext context, object message)
{
if (this.writerIdleTime.Ticks > 0 || this.allIdleTime.Ticks > 0)
{
Task task = context.WriteAsync(message);
task.ContinueWith(this.writeListener);
return task;
}
return context.WriteAsync(message);
}
public virtual Task WriteAsync(IChannelHandlerContext context, object message) => context.WriteAsync(message);
public virtual Task WriteAsync(IChannelHandlerContext context, object message)
{
return(context.WriteAsync(message));
}
