public async Task SendPacketAsync(MqttBasePacket packet, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); using (await _syncRoot.WaitAsync(cancellationToken).ConfigureAwait(false)) { // Check for cancellation here again because "WaitAsync" might take some time. cancellationToken.ThrowIfCancellationRequested(); try { var packetData = PacketFormatterAdapter.Encode(packet); await _channel.WriteAsync(packetData.Array, packetData.Offset, packetData.Count, cancellationToken).ConfigureAwait(false); Interlocked.Add(ref _bytesReceived, packetData.Count); _logger.Verbose("TX ({0} bytes) >>> {1}", packetData.Count, packet); } catch (Exception exception) { if (IsWrappedException(exception)) { throw; } WrapAndThrowException(exception); } finally { PacketFormatterAdapter.FreeBuffer(); } } }
public async Task <MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); try { ReceivedMqttPacket receivedMqttPacket; if (timeout == TimeSpan.Zero) { receivedMqttPacket = await ReceiveAsync(cancellationToken).ConfigureAwait(false); } else { receivedMqttPacket = await MqttTaskTimeout.WaitAsync(ReceiveAsync, timeout, cancellationToken).ConfigureAwait(false); } if (receivedMqttPacket == null || cancellationToken.IsCancellationRequested) { return(null); } Interlocked.Add(ref _bytesSent, receivedMqttPacket.TotalLength); if (PacketFormatterAdapter.ProtocolVersion == MqttProtocolVersion.Unknown) { PacketFormatterAdapter.DetectProtocolVersion(receivedMqttPacket); } var packet = PacketFormatterAdapter.Decode(receivedMqttPacket); if (packet == null) { throw new MqttProtocolViolationException("Received malformed packet."); } _logger.Verbose("RX ({0} bytes) <<< {1}", receivedMqttPacket.TotalLength, packet); return(packet); } catch (OperationCanceledException) { } catch (ObjectDisposedException) { } catch (Exception exception) { if (IsWrappedException(exception)) { throw; } WrapException(exception); } return(null); }
public async Task SendPacketAsync(MqttBasePacket packet, TimeSpan timeout, CancellationToken cancellationToken) { ThrowIfDisposed(); cancellationToken.ThrowIfCancellationRequested(); try { await _writerSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false); } catch (ObjectDisposedException) { throw new OperationCanceledException(); } try { var packetData = PacketFormatterAdapter.Encode(packet); if (timeout == TimeSpan.Zero) { await _channel.WriteAsync(packetData.Array, packetData.Offset, packetData.Count, cancellationToken).ConfigureAwait(false); } else { await MqttTaskTimeout.WaitAsync( t => _channel.WriteAsync(packetData.Array, packetData.Offset, packetData.Count, t), timeout, cancellationToken).ConfigureAwait(false); } Interlocked.Add(ref _bytesReceived, packetData.Count); _logger.Verbose("TX ({0} bytes) >>> {1}", packetData.Count, packet); } catch (Exception exception) { if (IsWrappedException(exception)) { throw; } WrapException(exception); } finally { PacketFormatterAdapter.FreeBuffer(); try { _writerSemaphore.Release(); } catch (ObjectDisposedException) { throw new OperationCanceledException(); } } }
public async Task <MqttBasePacket> ReceivePacketAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); ThrowIfDisposed(); try { _packetInspectorHandler.BeginReceivePacket(); var receivedPacket = await ReceiveAsync(cancellationToken).ConfigureAwait(false); if (receivedPacket == null || cancellationToken.IsCancellationRequested) { return(null); } _packetInspectorHandler.EndReceivePacket(); Interlocked.Add(ref _bytesSent, receivedPacket.TotalLength); if (PacketFormatterAdapter.ProtocolVersion == MqttProtocolVersion.Unknown) { PacketFormatterAdapter.DetectProtocolVersion(receivedPacket); } var packet = PacketFormatterAdapter.Decode(receivedPacket); if (packet == null) { throw new MqttProtocolViolationException("Received malformed packet."); } _logger.Verbose("RX ({0} bytes) <<< {1}", receivedPacket.TotalLength, packet); return(packet); } catch (OperationCanceledException) { } catch (ObjectDisposedException) { } catch (Exception exception) { if (IsWrappedException(exception)) { throw; } WrapAndThrowException(exception); } return(null); }
public async Task <MqttBasePacket> ReceivePacketAsync(CancellationToken cancellationToken) { var input = Connection.Transport.Input; try { while (!cancellationToken.IsCancellationRequested) { ReadResult readResult; var readTask = input.ReadAsync(cancellationToken); if (readTask.IsCompleted) { readResult = readTask.Result; } else { readResult = await readTask.ConfigureAwait(false); } var buffer = readResult.Buffer; var consumed = buffer.Start; var observed = buffer.Start; try { if (!buffer.IsEmpty) { if (PacketFormatterAdapter.TryDecode(_reader, buffer, out var packet, out consumed, out observed, out var received)) { BytesReceived += received; return(packet); } else { // we did receive something but the message is not yet complete IsReadingPacket = true; } } else if (readResult.IsCompleted) { throw new MqttCommunicationException("Connection Aborted"); } } finally { // The buffer was sliced up to where it was consumed, so we can just advance to the start. // We mark examined as buffer.End so that if we didn't receive a full frame, we'll wait for more data // before yielding the read again. input.AdvanceTo(consumed, observed); } }