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)); }