private static void ReadIfNeeded(IChannelHandlerContext ctx)
{
if (!ctx.Channel.Configuration.AutoRead)
{
ctx.Read();
}
}
public override void ChannelActive(IChannelHandlerContext context)
{
this.capturedContext = context;
this.publishProcessors = new Dictionary <IMessagingServiceClient, MessageAsyncProcessor <PublishPacket> >(1);
TimeSpan?ackTimeout = this.settings.DeviceReceiveAckCanTimeout ? this.settings.DeviceReceiveAckTimeout : (TimeSpan?)null;
this.publishPubAckProcessor = new RequestAckPairProcessor <AckPendingMessageState, PublishPacket>(this.AcknowledgePublishAsync, this.RetransmitNextPublish, ackTimeout);
this.publishPubAckProcessor.Completion.OnFault(ShutdownOnPubAckFaultAction);
this.publishPubRecProcessor = new RequestAckPairProcessor <AckPendingMessageState, PublishPacket>(this.AcknowledgePublishReceiveAsync, this.RetransmitNextPublish, ackTimeout);
this.publishPubRecProcessor.Completion.OnFault(ShutdownOnPubRecFaultAction);
this.pubRelPubCompProcessor = new RequestAckPairProcessor <CompletionPendingMessageState, PubRelPacket>(this.AcknowledgePublishCompleteAsync, this.RetransmitNextPublishRelease, ackTimeout);
this.pubRelPubCompProcessor.Completion.OnFault(ShutdownOnPubCompFaultAction);
this.stateFlags = StateFlags.WaitingForConnect;
TimeSpan?timeout = this.settings.ConnectArrivalTimeout;
if (timeout.HasValue)
{
context.Executor.ScheduleAsync(CheckConnectTimeoutCallback, context, timeout.Value);
}
base.ChannelActive(context);
context.Read();
}
public override void ChannelActive(IChannelHandlerContext context)
{
this.capturedContext = context;
this.publishProcessors = new Dictionary <IMessagingServiceClient, MessageAsyncProcessor <PublishPacket> >(1);
bool abortOnOutOfOrderAck = this.settings.AbortOnOutOfOrderPubAck;
this.publishPubAckProcessor = new RequestAckPairProcessor <AckPendingMessageState, PublishPacket>(this.AcknowledgePublishAsync, abortOnOutOfOrderAck, this);
this.publishPubAckProcessor.Closed.OnFault(ShutdownOnPubAckFaultAction, this);
this.publishPubRecProcessor = new RequestAckPairProcessor <AckPendingMessageState, PublishPacket>(this.AcknowledgePublishReceiveAsync, abortOnOutOfOrderAck, this);
this.publishPubRecProcessor.Closed.OnFault(ShutdownOnPubRecFaultAction, this);
this.pubRelPubCompProcessor = new RequestAckPairProcessor <CompletionPendingMessageState, PubRelPacket>(this.AcknowledgePublishCompleteAsync, abortOnOutOfOrderAck, this);
this.pubRelPubCompProcessor.Closed.OnFault(ShutdownOnPubCompFaultAction, this);
this.stateFlags = StateFlags.WaitingForConnect;
TimeSpan?timeout = this.settings.ConnectArrivalTimeout;
if (timeout.HasValue)
{
context.Executor.ScheduleAsync(CheckConnectTimeoutCallback, context, timeout.Value);
}
base.ChannelActive(context);
context.Read();
}
private async void Select(IChannelHandlerContext context, string hostName)
{
if (hostName is null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.hostName);
}
ReleaseHandshakeBuffer();
_suppressRead = true;
try
{
var serverTlsSetting = await _serverTlsSniSettings.ServerTlsSettingMap(hostName);
ReplaceHandler(context, serverTlsSetting);
}
catch (Exception ex)
{
ExceptionCaught(context, new DecoderException($"failed to get the server TLS setting for {hostName}, {ex}"));
}
finally
{
_suppressRead = false;
if (_readPending)
{
_readPending = false;
_ = context.Read();
}
}
}
public override void ChannelActive(IChannelHandlerContext ctx)
{
if (!ctx.Channel.Configuration.AutoRead)
{
ctx.Read();
}
}
protected static void ReadIfNeeded(IChannelHandlerContext ctx)
{
if (!ctx.Channel.Configuration.IsAutoRead)
{
_ = ctx.Read();
}
}
void ResumeReadingIfNecessary(IChannelHandlerContext context)
{
if (this.InboundBacklogSize == this.mqttTransportSettings.MaxPendingInboundMessages - 1) // we picked up a packet from full queue - now we have more room so order another read
{
context.Read();
}
}
/// <inheritdoc />
public override void Read(IChannelHandlerContext ctx)
{
if (Logger.IsEnabled(MsLogLevel.Trace))
{
Logger.LogTrace("Channel {0} reading", ctx.Channel);
}
ctx.Read();
}
public override void Read(IChannelHandlerContext ctx)
{
//if (this.Logger.IsEnabled(this.InternalLevel))
{
//this.Logger.Log(this.InternalLevel, this.Format(ctx, "READ"));
}
ctx.Read();
}
public override void ChannelActive(IChannelHandlerContext ctx)
{
_channel = ctx.Channel;
if (!_autoRead)
{
ctx.Read();
}
}
public override void ChannelRead(IChannelHandlerContext context, object message)
{
if (Volatile.Read(ref this.available) > 0)
{
context.Read();
}
base.ChannelRead(context, message);
}
public override void Read(IChannelHandlerContext ctx)
{
if (Logger.IsEnabled(InternalLevel))
{
Logger.Log(InternalLevel, Format(ctx, "READ"));
}
ctx.Read();
}
public override void ChannelReadComplete(IChannelHandlerContext ctx)
{
if (!_autoRead)
{
ctx.Read();
}
base.ChannelReadComplete(ctx);
}
public override void ChannelReadComplete(IChannelHandlerContext context)
{
base.ChannelReadComplete(context);
if (this.InboundBacklogSize < this.mqttTransportSettings.MaxPendingInboundMessages)
{
context.Read();
}
}
public override void ChannelRead(IChannelHandlerContext ctx, object msg)
{
ReferenceCountUtil.Release(msg);
if (_count.Increment() == 1)
{
// Call read the first time, to ensure it is not reset the second time.
ctx.Read(); // Socket BeginRead 没有做重复调用检测
}
}
protected override void ChannelRead0(IChannelHandlerContext ctx, IByteBuffer msg)
{
if (Interlocked.Add(ref this.bytesRead, msg.ReadableBytes) >= this.expectedBytesRead)
{
this.completion.TrySetResult(this.bytesRead);
}
// Because autoread is off, we call read to consume all data until we detect the close.
ctx.Read();
}
public override void ChannelRead(IChannelHandlerContext ctx, object msg)
{
ReferenceCountUtil.Release(msg);
if (Interlocked.Increment(ref this.count) == 1)
{
// Call read the first time, to ensure it is not reset the second time.
ctx.Read();
}
}
public override void ChannelActive(IChannelHandlerContext context)
{
this.stateFlags = StateFlags.NotConnected;
this.Connect(context);
base.ChannelActive(context);
context.Read();
}
private void ReadIfNeeded(IChannelHandlerContext ctx)
{
// if handshake is not finished yet, we need more data
if (!ctx.Channel.Configuration.IsAutoRead && (!_firedChannelRead || !State.HasAny(TlsHandlerState.AuthenticationCompleted)))
{
// No auto-read used and no message was passed through the ChannelPipeline or the handshake was not completed
// yet, which means we need to trigger the read to ensure we will not stall
_ = ctx.Read();
}
}
public override void Read(IChannelHandlerContext context)
{
State oldState = this.state;
if ((oldState & State.AuthenticationCompleted) == 0)
{
this.state = oldState | State.ReadRequestedBeforeAuthenticated;
}
context.Read();
}
public override void Read(IChannelHandlerContext ctx)
{
if (0u >= (uint)Dequeue(ctx, 1))
{
// It seems no messages were consumed. We need to read() some
// messages from upstream and once one arrives it need to be
// relayed to downstream to keep the flow going.
++_readRequestCount;
_ = ctx.Read();
}
}
void ResumeReadingIfNecessary(IChannelHandlerContext context)
{
if (this.InboundBacklogSize == this.settings.MaxPendingInboundMessages - 1) // we picked up a packet from full queue - now we have more room so order another read
{
if (MqttIotHubAdapterEventSource.Log.IsVerboseEnabled)
{
MqttIotHubAdapterEventSource.Log.Verbose("Resuming reading from channel as queue freed up.", $"deviceId: {this.identity}, channel: {context.Channel}");
}
context.Read();
}
}
public override void Read(IChannelHandlerContext context)
{
var oldState = State;
if (!oldState.HasAny(TlsHandlerState.AuthenticationCompleted))
{
State = oldState | TlsHandlerState.ReadRequestedBeforeAuthenticated;
}
_ = context.Read();
}
public override void Read(IChannelHandlerContext ctx)
{
if (this.Dequeue(ctx, 1) == 0)
{
// It seems no messages were consumed. We need to read() some
// messages from upstream and once one arrives it need to be
// relayed to downstream to keep the flow going.
this.shouldConsume = true;
ctx.Read();
}
}
/// <inheritdoc />
public override void ChannelReadComplete(IChannelHandlerContext context)
{
_numReads = 0;
DiscardSomeReadBytes();
if (!_firedChannelRead && !context.Channel.Configuration.IsAutoRead)
{
_ = context.Read();
}
_firedChannelRead = false;
_ = context.FireChannelReadComplete();
}
public override void Read(IChannelHandlerContext ctx, object input)
{
var frame = input as WebSocketFrame;
if (frame != null)
{
Console.WriteLine("[* ws frame {0} '{1}' *]", frame.Type, frame.Text);
}
// Проброс.
ctx.Read(input);
}
public override void ChannelRead(IChannelHandlerContext ctx, object msg)
{
ReferenceCountUtil.Release(msg);
if (Interlocked.Increment(ref this.count) == 1)
{
ctx.Channel.Configuration.AutoRead = false;
}
if (this.callRead)
{
ctx.Read();
}
}
public override void ChannelActive(IChannelHandlerContext context)
{
this.stateFlags = StateFlags.NotConnected;
this.Connect(context);
// TODO #223: this executes in parallel with the Connect(context).
base.ChannelActive(context);
context.Read();
}
public override void ChannelReadComplete(IChannelHandlerContext ctx)
{
_clientReadCompletes.Increment();
if (_bytesRead == _totalServerBytesWritten)
{
_clientReadAllDataLatch.SafeSignal();
}
if (!_autoRead)
{
ctx.Read();
}
}
public override void ChannelActive(IChannelHandlerContext context)
{
this.stateFlags = StateFlags.WaitingForConnect;
TimeSpan?timeout = this.settings.ConnectArrivalTimeout;
if (timeout.HasValue)
{
context.Channel.EventLoop.ScheduleAsync(CheckConnectTimeoutCallback, context, timeout.Value);
}
base.ChannelActive(context);
context.Read();
}
public override void ChannelReadComplete(IChannelHandlerContext context)
{
this.DiscardSomeReadBytes();
if (this.decodeWasNull)
{
this.decodeWasNull = false;
if (!context.Channel.Configuration.AutoRead)
{
context.Read();
}
}
context.FireChannelReadComplete();
}
public override void Read(IChannelHandlerContext context)
{
State oldState = this.state;
if ((oldState & State.AuthenticationCompleted) == 0)
{
this.state = oldState | State.ReadRequestedBeforeAuthenticated;
}
context.Read();
}
public override void ChannelActive(IChannelHandlerContext context)
{
this.stateFlags = StateFlags.WaitingForConnect;
TimeSpan? timeout = this.settings.ConnectArrivalTimeout;
if (timeout.HasValue)
{
context.Channel.EventLoop.Schedule(CheckConnectTimeoutCallback, context, timeout.Value);
}
base.ChannelActive(context);
context.Read();
}
void ResumeReadingIfNecessary(IChannelHandlerContext context)
{
if (this.InboundBacklogSize == this.mqttTransportSettings.MaxPendingInboundMessages - 1) // we picked up a packet from full queue - now we have more room so order another read
{
context.Read();
}
}
void ResumeReadingIfNecessary(IChannelHandlerContext context)
{
if (this.InboundBacklogSize == this.settings.MaxPendingInboundMessages - 1) // we picked up a packet from full queue - now we have more room so order another read
{
if (MqttIotHubAdapterEventSource.Log.IsVerboseEnabled)
{
MqttIotHubAdapterEventSource.Log.Verbose("Resuming reading from channel as queue freed up.", string.Format("deviceId: {0}, channel: {1}", this.deviceId, context.Channel));
}
context.Read();
}
}
public virtual void Read(IChannelHandlerContext context) => context.Read();
public override void ChannelReadComplete(IChannelHandlerContext context)
{
base.ChannelReadComplete(context);
int inboundBacklogSize = this.InboundBacklogSize;
if (inboundBacklogSize < this.settings.MaxPendingInboundMessages)
{
context.Read();
}
else
{
if (MqttIotHubAdapterEventSource.Log.IsVerboseEnabled)
{
MqttIotHubAdapterEventSource.Log.Verbose(
"Not reading per full inbound message queue",
string.Format("deviceId: {0}, messages queued: {1}, channel: {2}", this.deviceId, inboundBacklogSize, context.Channel));
}
}
}
public override void ChannelReadComplete(IChannelHandlerContext context)
{
base.ChannelReadComplete(context);
if (this.InboundBacklogSize < this.mqttTransportSettings.MaxPendingInboundMessages)
{
context.Read();
}
}
