private async Task InitImpl(CancellationToken token) { _currentImplementationHelper = await SamHelper.CreateInstance( _settings.ImplementationHelperSettings, token ).ConfigureAwait(false); _currentImplSubscriptions.Add( _currentImplementationHelper.DatagramDataReceived .ObserveOn(TaskPoolScheduler.Default) .Subscribe( x => { if (_handleDatagrams) { _datagramDataReceived.OnNext(x); } } ) ); _currentImplSubscriptions.Add( _currentImplementationHelper.IoExceptionThrown .ObserveOn(TaskPoolScheduler.Default) .Subscribe( i => TryToReconnect(DateTime.UtcNow) ) ); _lastHelperRenewedTime = DateTime.UtcNow; }
private async Task SendProtocolVersion( string destination, int protocolId ) { if (!SamHelper.IsDestinationStringValid(destination)) { throw new ArgumentOutOfRangeException( "destination" ); } using ( var ms = new MemoryStream( sizeof(byte) + sizeof(int) ) ) { using ( var binaryWriter = new EndianBinaryWriter( _littleEndianConverter, ms ) ) { binaryWriter.Write( (byte)ReliableDatagramCodes.ProtocolVersion ); binaryWriter.Write(protocolId); await _samHelper.SendDatagram( destination, ms.ToArray() ).ThrowIfCancelled(_cts.Token).ConfigureAwait(false); } } }
private async Task SendMessageStatus( string destination, uint messageId, MessageStatusArgs.MessageStatusCode statusCode, uint blocksReceived ) { if (!SamHelper.IsDestinationStringValid(destination)) { throw new ArgumentOutOfRangeException("destination"); } using ( var ms = new MemoryStream( sizeof(byte) + sizeof(uint) + sizeof(byte) + sizeof(uint) ) ) { using ( var binaryWriter = new EndianBinaryWriter( _littleEndianConverter, ms ) ) { binaryWriter.Write( (byte)ReliableDatagramCodes.MessageStatus ); binaryWriter.Write(messageId); binaryWriter.Write((byte)statusCode); binaryWriter.Write(blocksReceived); await _samHelper.SendDatagram( destination, ms.ToArray() ).ThrowIfCancelled(_cts.Token).ConfigureAwait(false); } } }
private async Task SendBlockConfirmation( string destination, uint messageId, uint blockId ) { if (!SamHelper.IsDestinationStringValid(destination)) { throw new ArgumentOutOfRangeException( MyNameof.GetLocalVarName(() => destination)); } using ( var ms = new MemoryStream( sizeof(byte) + sizeof(uint) + sizeof(uint) ) ) { using ( var binaryWriter = new EndianBinaryWriter( _littleEndianConverter, ms ) ) { binaryWriter.Write( (byte)ReliableDatagramCodes.BlockConfirmation ); binaryWriter.Write(messageId); binaryWriter.Write(blockId); await _samHelper.SendDatagram( destination, ms.ToArray() ).ThrowIfCancelled(_cts.Token).ConfigureAwait(false); } } }
private async void OnGetProtocolVersionReceived( GetProtocolVersionArgs getProtocolVersionArgs ) { try { using (_stateHelper.GetFuncWrapper()) { string fromDestination = getProtocolVersionArgs.Destination; if (_dropDestinations.Contains(fromDestination)) { return; } if (!SamHelper.IsDestinationStringValid(fromDestination)) { return; } await SendProtocolVersion( fromDestination, _settings.ProtocolVersion ).ConfigureAwait(false); } } catch (OperationCanceledException) { } catch (WrongDisposableObjectStateException) { } catch (Exception exc) { _log.Error( "OnGetProtocolVersionReceived" + " unexpected error '{0}'", exc.ToString() ); } }
//ECreateInstanceErrCodes public static async Task<SamHelper> CreateInstance( SamHelperSettings settings, CancellationToken cancellationToken ) { if(settings == null) throw new ArgumentNullException( MyNameof.GetLocalVarName(() => settings)); if(cancellationToken == null) throw new ArgumentNullException( MyNameof.GetLocalVarName(() => cancellationToken)); settings.CheckMe(); var result = new SamHelper(); result._samTcpClient = new TcpClient(); try { await result._samTcpClient.ConnectAsync( settings.SamServerAddress, settings.SamServerPort ).ThrowIfCancelled(cancellationToken).ConfigureAwait(false); } catch (TimeoutException timeExc) { throw new EnumException<ECreateInstanceErrCodes>( ECreateInstanceErrCodes.ConnectTcpTimeout, innerException: timeExc ); } catch (Exception exc) { throw new EnumException<ECreateInstanceErrCodes>( ECreateInstanceErrCodes.ConnectTcp, innerException: exc ); } try { result._samStream = result._samTcpClient.GetStream(); try { if (!result._samStream.CanWrite) { throw new EnumException<SamHelperExcs>( SamHelperExcs.NetStreamCannotWrite ); } if (!result._samStream.CanRead) { throw new EnumException<SamHelperExcs>( SamHelperExcs.NetStreamCannotRead ); } result._samReader = new SamReader(result._samStream); result._subscriptions.Add( result._samReader.IoExceptionThrown.ObserveOn(TaskPoolScheduler.Default).Subscribe( i => result.IoExceptionThrown.OnNext(null) ) ); result._subscriptions.Add( result._samReader.DatagramDataReceived.ObserveOn(TaskPoolScheduler.Default).Subscribe( result.SamReaderOnDatagramDataReceived ) ); /*******************/ HelloReplyReceivedArgs helloAnswer; try { var writeBuffer = SamBridgeCommandBuilder.HelloReply(); var helloAnswerTask = result._samReader.HelloReplyReceived .FirstAsync() .ToTask(cancellationToken); await result.WriteBuffer(writeBuffer).ConfigureAwait(false); helloAnswer = await helloAnswerTask.ConfigureAwait(false); } catch (OperationCanceledException) { //timeout result._samTcpClient.Close(); throw new EnumException<ECreateInstanceErrCodes>( ECreateInstanceErrCodes.HelloReplyTimeoutExceed ); } if (!helloAnswer.Ok) { result._samTcpClient.Close(); throw new EnumException<ECreateInstanceErrCodes>( ECreateInstanceErrCodes.HelloReplyError, tag: helloAnswer ); } result._stateHelper.SetInitializedState(); try { var sessionName = settings.SessionId ?? Guid.NewGuid().ToString().Replace("-", "").Substring(0, 15); result._samSession = await result.CreateSession( sessionName, cancellationToken, settings.SessionPrivateKeys, settings.I2CpOptions ).ConfigureAwait(false); } catch (EnumException<ECreateSessionErrorCodes> createSessionExc) { throw new EnumException<ECreateInstanceErrCodes>( ECreateInstanceErrCodes.CreateSessionError, innerException: createSessionExc ); } return result; } catch { result._samStream.Close(); throw; } } catch { result._samTcpClient.Close(); throw; } }
public async Task <uint> SendReliableMessage( string destination, byte[] data, IProgress <OutMessageProgressInfo> progress = null, uint messageId = 0, uint replyToMessageId = 0, byte messageKind = 0, CancellationToken token = default(CancellationToken) ) { using (_stateHelper.GetFuncWrapper()) { try { Assert.True(SamHelper.IsDestinationStringValid(destination)); Assert.NotNull(data); Assert.InRange(data.Length, 1, _settings.MaxMesageLength); if (messageId == 0) { messageId = await GetNextOutMessageId().ConfigureAwait(false); } DestinationInfo destinationInfo; using (await _destinationDbLockSem.GetDisposable(token: token).ConfigureAwait(false)) { if (!_destinationDb.ContainsKey(destination)) { _destinationDb.Add(destination, new DestinationInfo()); } destinationInfo = _destinationDb[destination]; } OutMessageInfo outMessageInfo; using (await destinationInfo.OutMessagesDbLockSem.GetDisposable(token: token).ConfigureAwait(false)) { if ( destinationInfo.OutMessagesDb.ContainsKey(messageId) ) { throw new EnumException <SendReliableMessageExcs>( SendReliableMessageExcs.ExistMessageId ); } outMessageInfo = new OutMessageInfo( data, replyToMessageId, _settings.MaxBlockSize, progress ); destinationInfo.OutMessagesDb.Add(messageId, outMessageInfo); } try { uint blocksCount = outMessageInfo.BlockCount; /* * Handshake */ using ( var compositeTokenSource = CancellationTokenSource.CreateLinkedTokenSource( _cts.Token, token ) ) { try { var messageStatusTask = MessageStatusReceived .Where( x => x.Destination == destination && x.MessageId == messageId ) .FirstAsync() .ToTask(compositeTokenSource.Token); byte[] messageHash = GetMessageHash( messageId, replyToMessageId, messageKind, data ); for ( outMessageInfo.HandshakeAttemptNo = 0; outMessageInfo.HandshakeAttemptNo <= _settings.HandshakeAttemptCount; outMessageInfo.HandshakeAttemptNo++ ) { if ( outMessageInfo.HandshakeAttemptNo == _settings.HandshakeAttemptCount ) { throw new EnumException <SendReliableMessageExcs>( SendReliableMessageExcs.HandshakeTimeout ); } await SendHandshakeStart( destination, messageId, replyToMessageId, (uint)data.Length, outMessageInfo.BlockSize, messageHash, outMessageInfo.Data[0], messageKind ).ConfigureAwait(false); var waitTasks = await Task.WhenAny( messageStatusTask, Task.Delay( TimeSpan.FromSeconds( _settings.HandshakeTimeoutSeconds ), compositeTokenSource.Token ) ).ConfigureAwait(false); if (waitTasks == messageStatusTask) { var messageStatus = await messageStatusTask.ConfigureAwait(false); if ( !( messageStatus.StatusCode == MessageStatusArgs.MessageStatusCode.HandshakeOk || ( messageStatus.StatusCode == MessageStatusArgs.MessageStatusCode.AllBlocksReceived && outMessageInfo.BlockCount == 1 ) ) ) { throw new EnumException <SendReliableMessageExcs>( SendReliableMessageExcs.HandshakeError, messageStatus.WriteObjectToJson() ); } break; } } outMessageInfo.Status = OutMessageStatus.HandshakeOk; outMessageInfo.BlockConfirmed[0] = true; if (outMessageInfo.BlockCount > 1) { // Handshake established, start sending blocks DateTime lastBlockConfirmationTime = DateTime.UtcNow; var blocksInProgress = new SortedSet <uint>(); var blocksInProgressLockSem = new SemaphoreSlim(1); var blockSentTimes = new DateTime[blocksCount]; using ( BlockConfirmationReceived .Where(_ => _.Destination == destination && _.MessageId == messageId ) .ObserveOn(TaskPoolScheduler.Default) .Subscribe(async x => { if ( x.BlockId < blocksCount && !outMessageInfo.BlockConfirmed[x.BlockId] ) { await outMessageInfo.ConfirmBlock(x.BlockId).ConfigureAwait(false); lastBlockConfirmationTime = DateTime.UtcNow; using (await blocksInProgressLockSem.GetDisposable().ConfigureAwait(false)) { blocksInProgress.Remove(x.BlockId); } } } ) ) { while (true) { compositeTokenSource.Token.ThrowIfCancellationRequested(); IEnumerable <int> blocksToSend; using ( await blocksInProgressLockSem.GetDisposable(token: compositeTokenSource.Token) .ConfigureAwait(false)) { if ( blocksInProgress.Count == 0 && outMessageInfo.BlockConfirmed.All(x => x) ) { break; } blocksInProgress.RemoveWhere( i => DateTime.UtcNow > ( blockSentTimes[i] + TimeSpan.FromSeconds( _settings .ConfirmationOneBlockTimeoutSeconds ) ) ); blocksToSend = Enumerable.Range(0, (int)blocksCount) .Where( i => !blocksInProgress.Contains((uint)i) && !outMessageInfo.BlockConfirmed[i] ) .Take( Math.Max( 0, _settings.WindowSize - blocksInProgress.Count ) ); } foreach (int blockId in blocksToSend) { await SendBlock( destination, messageId, (uint)blockId ).ConfigureAwait(false); await outMessageInfo.SendBlock( (uint)blockId ).ConfigureAwait(false); using ( await blocksInProgressLockSem.GetDisposable(token: compositeTokenSource.Token) .ConfigureAwait(false)) { blocksInProgress.Add((uint)blockId); } blockSentTimes[blockId] = DateTime.UtcNow; } if ( DateTime.UtcNow > lastBlockConfirmationTime + TimeSpan.FromSeconds( _settings.ConfirmationTimeoutSeconds ) ) { throw new EnumException <SendReliableMessageExcs>( SendReliableMessageExcs.SendBlocksTimeout ); } await Task.Delay(50, compositeTokenSource.Token).ConfigureAwait(false); } } } outMessageInfo.Status = OutMessageStatus.AllBlocksSent; // all blocks sent and confirmed _log.Trace( "{4}, send reliable message of {0} bytes " + "to {1} id={2},rid={3},kind={5}", data.Length, destination.Substring(0, 20), messageId, replyToMessageId, _reliableSamHelperGuid.ToString().Substring(0, 5), messageKind ); return(messageId); } finally { compositeTokenSource.Cancel(); } } } finally { TryRemoveOutMessageInfo(destinationInfo, messageId); } } catch (EnumException <SendReliableMessageExcs> ) { throw; } catch (OperationCanceledException) { throw; } catch (TimeoutException) { throw; } catch (Exception exc) { throw new EnumException <SendReliableMessageExcs>( SendReliableMessageExcs.UnexpectedError, innerException: exc ); } } }
private async Task SendBlock( string destination, uint messageId, uint blockId ) { if (string.IsNullOrWhiteSpace(destination)) { throw new ArgumentNullException("destination"); } if (!SamHelper.IsDestinationStringValid(destination)) { throw new ArgumentOutOfRangeException("destination"); } DestinationInfo destinationInfo; using (await _destinationDbLockSem.GetDisposable().ConfigureAwait(false)) { if (!_destinationDb.ContainsKey(destination)) { throw new ArgumentException("destination"); } destinationInfo = _destinationDb[destination]; } OutMessageInfo outMessageInfo; using (await destinationInfo.OutMessagesDbLockSem.GetDisposable().ConfigureAwait(false)) { if (!destinationInfo.OutMessagesDb.ContainsKey(messageId)) { throw new ArgumentOutOfRangeException("messageId"); } outMessageInfo = destinationInfo.OutMessagesDb[messageId]; } if (blockId >= outMessageInfo.Data.Count) { throw new ArgumentOutOfRangeException("blockId"); } var dataToSend = outMessageInfo.Data[(int)blockId]; using ( var ms = new MemoryStream( sizeof(byte) + sizeof(uint) + sizeof(uint) + dataToSend.Length ) ) { using ( var binaryWriter = new EndianBinaryWriter( _littleEndianConverter, ms ) ) { binaryWriter.Write( (byte)ReliableDatagramCodes.BlockSend ); binaryWriter.Write(messageId); binaryWriter.Write(blockId); binaryWriter.Write(dataToSend); await _samHelper.SendDatagram( destination, ms.ToArray() ).ThrowIfCancelled(_cts.Token).ConfigureAwait(false); } } }
private async void OnHandshakeStartReceived( HandshakeStartArgs handshakeStartArgs ) { try { using (_stateHelper.GetFuncWrapper()) { string fromDestination = handshakeStartArgs.Destination; if (_dropDestinations.Contains(fromDestination)) { return; } if (!SamHelper.IsDestinationStringValid(fromDestination)) { return; } DestinationInfo destinationInfo; using (await _destinationDbLockSem.GetDisposable().ConfigureAwait(false)) { if ( !_destinationDb.ContainsKey( handshakeStartArgs.Destination ) ) { destinationInfo = new DestinationInfo(); _destinationDb.Add( handshakeStartArgs.Destination, destinationInfo ); } else { destinationInfo = _destinationDb[ handshakeStartArgs.Destination ]; } } using (await destinationInfo.InMessagesDbLockSem.GetDisposable().ConfigureAwait(false)) { if ( destinationInfo.InMessagesDb.ContainsKey( handshakeStartArgs.MessageId ) ) { var inMessageInfo = destinationInfo.InMessagesDb[ handshakeStartArgs.MessageId ]; if ( inMessageInfo.Status == InMessageStatus.HandshakeReceived ) { await SendMessageStatus( fromDestination, handshakeStartArgs.MessageId, MessageStatusArgs.MessageStatusCode.HandshakeOk, 0 ).ConfigureAwait(false); return; } else if ( inMessageInfo.Status == InMessageStatus.AllBlocksReceived ) { await SendMessageStatus( fromDestination, handshakeStartArgs.MessageId, MessageStatusArgs.MessageStatusCode.AllBlocksReceived, inMessageInfo.BlocksReceivedCount ).ConfigureAwait(false); return; } else { await SendMessageStatus( fromDestination, handshakeStartArgs.MessageId, MessageStatusArgs .MessageStatusCode .HandshakeErrorDuplicatedId, inMessageInfo.BlocksReceivedCount ).ConfigureAwait(false); return; } } else { if ( handshakeStartArgs.MessageSize > _settings.MaxMesageLength ) { await SendMessageStatus( fromDestination, handshakeStartArgs.MessageId, MessageStatusArgs.MessageStatusCode .HandshakeErrorWrongTotalSize, 0 ).ConfigureAwait(false); return; } if (handshakeStartArgs.BlockSize > _settings.MaxBlockSize) { await SendMessageStatus( fromDestination, handshakeStartArgs.MessageId, MessageStatusArgs.MessageStatusCode .HandshakeErrorWrongBlockSize, 0 ).ConfigureAwait(false); return; } var inMessageInfo = new InMessageInfo( handshakeStartArgs.MessageSize, handshakeStartArgs.BlockSize, handshakeStartArgs.ReplyToMessageId, handshakeStartArgs.MessageKind, handshakeStartArgs.MessageHash ); if ( inMessageInfo.ReceivedDataChunkSizes[0] != handshakeStartArgs.FirstBlockData.Length ) { await SendMessageStatus( fromDestination, handshakeStartArgs.MessageId, MessageStatusArgs.MessageStatusCode .HandshakeErrorWrongBlockSize, 0 ).ConfigureAwait(false); return; } destinationInfo.InMessagesDb.Add( handshakeStartArgs.MessageId, inMessageInfo ); await SendMessageStatus( fromDestination, handshakeStartArgs.MessageId, MessageStatusArgs.MessageStatusCode.HandshakeOk, 0 ).ConfigureAwait(false); OnBlockSendReceived( new BlockSendArgs() { BlockData = handshakeStartArgs.FirstBlockData, BlockId = 0, Destination = handshakeStartArgs.Destination, MessageId = handshakeStartArgs.MessageId } ); return; } } } } catch (OperationCanceledException) { } catch (WrongDisposableObjectStateException) { } catch (Exception exc) { _log.Error( "OnHandshakeStartReceive" + " unexpected error '{0}'", exc.ToString() ); } }
private async void OnGetMessageStatusReceived( GetMessageStatusArgs getMessageStatusArgs ) { try { using (_stateHelper.GetFuncWrapper()) { string fromDestination = getMessageStatusArgs.Destination; if (_dropDestinations.Contains(fromDestination)) { return; } if (!SamHelper.IsDestinationStringValid(fromDestination)) { return; } bool destinationDbContainsKey; using (await _destinationDbLockSem.GetDisposable().ConfigureAwait(false)) { destinationDbContainsKey = _destinationDb.ContainsKey( fromDestination ); } if ( !destinationDbContainsKey ) { await SendMessageStatus( fromDestination, getMessageStatusArgs.MessageId, MessageStatusArgs .MessageStatusCode .UnknownMessageId, 0 ).ConfigureAwait(false); return; } DestinationInfo destinationInfo; using (await _destinationDbLockSem.GetDisposable().ConfigureAwait(false)) { destinationInfo = _destinationDb[fromDestination]; } bool inMessagesDbContainsKey; using (await destinationInfo.InMessagesDbLockSem.GetDisposable().ConfigureAwait(false)) { inMessagesDbContainsKey = destinationInfo.InMessagesDb.ContainsKey( getMessageStatusArgs.MessageId ); } if ( !inMessagesDbContainsKey ) { await SendMessageStatus( fromDestination, getMessageStatusArgs.MessageId, MessageStatusArgs .MessageStatusCode .UnknownMessageId, 0 ).ConfigureAwait(false); return; } InMessageInfo inMessageInfo; using (await destinationInfo.InMessagesDbLockSem.GetDisposable().ConfigureAwait(false)) { inMessageInfo = destinationInfo.InMessagesDb[ getMessageStatusArgs.MessageId ]; } int blocksReceivedCount = inMessageInfo.BlocksReceived.Count(x => x); if ( inMessageInfo.Status == InMessageStatus.HandshakeReceived ) { await SendMessageStatus( fromDestination, getMessageStatusArgs.MessageId, MessageStatusArgs .MessageStatusCode .HandshakeOk, (uint)blocksReceivedCount ).ConfigureAwait(false); return; } if ( inMessageInfo.Status == InMessageStatus.AllBlocksReceived ) { await SendMessageStatus( fromDestination, getMessageStatusArgs.MessageId, MessageStatusArgs .MessageStatusCode .AllBlocksReceived, (uint)inMessageInfo.BlocksReceived.Length ).ConfigureAwait(false); } } } catch (OperationCanceledException) { } catch (WrongDisposableObjectStateException) { } catch (Exception exc) { _log.Error( "OnGetMessageStatusReceived" + " unexpected error '{0}'", exc.ToString() ); } }
private async void OnBlockSendReceived( BlockSendArgs blockSendArgs ) { try { using (_stateHelper.GetFuncWrapper()) { string fromDestination = blockSendArgs.Destination; if (_dropDestinations.Contains(fromDestination)) { return; } if (!SamHelper.IsDestinationStringValid(fromDestination)) { return; } DestinationInfo destinationInfo; using (await _destinationDbLockSem.GetDisposable().ConfigureAwait(false)) { if ( !_destinationDb.ContainsKey( blockSendArgs.Destination ) ) { return; } destinationInfo = _destinationDb[blockSendArgs.Destination]; } InMessageInfo inMessageInfo; using (await destinationInfo.InMessagesDbLockSem.GetDisposable().ConfigureAwait(false)) { if ( !destinationInfo.InMessagesDb.ContainsKey( blockSendArgs.MessageId ) ) { return; } inMessageInfo = destinationInfo.InMessagesDb[ blockSendArgs.MessageId ]; } if ( inMessageInfo.Status == InMessageStatus.AllBlocksReceived ) { return; } if (inMessageInfo.BlockCount > 1) { await SendBlockConfirmation( fromDestination, blockSendArgs.MessageId, blockSendArgs.BlockId ).ConfigureAwait(false); } if ( await inMessageInfo.ReceiveBlock( blockSendArgs.BlockId, blockSendArgs.BlockData ).ConfigureAwait(false) ) { var allData = new List <byte>( (int)inMessageInfo.MessageSize ); foreach ( byte[] blockData in inMessageInfo.ReceivedData ) { allData.AddRange(blockData); } var dataArray = allData.ToArray(); if ( inMessageInfo.MessageHash.SequenceEqual( GetMessageHash( blockSendArgs.MessageId, inMessageInfo.ReplyToMessageId, inMessageInfo.MessageKind, dataArray ) ) ) { ReliableMessageReceived.OnNext( new ReliableMessageReceivedArgs() { Destination = fromDestination, Data = allData.ToArray(), MessageId = blockSendArgs.MessageId, ReplyToMessageId = inMessageInfo.ReplyToMessageId, MessageKind = inMessageInfo.MessageKind } ); } await inMessageInfo.FlushBlocks().ConfigureAwait(false); } } } catch (OperationCanceledException) { } catch (WrongDisposableObjectStateException) { } catch (Exception exc) { _log.Error( "OnBlockSendReceived" + " unexpected error '{0}'", exc.ToString() ); } }
//ECreateInstanceErrCodes public static async Task <SamHelper> CreateInstance( SamHelperSettings settings, CancellationToken cancellationToken ) { if (settings == null) { throw new ArgumentNullException( MyNameof.GetLocalVarName(() => settings)); } if (cancellationToken == null) { throw new ArgumentNullException( MyNameof.GetLocalVarName(() => cancellationToken)); } settings.CheckMe(); var result = new SamHelper(); result._samTcpClient = new TcpClient(); try { await result._samTcpClient.ConnectAsync( settings.SamServerAddress, settings.SamServerPort ).ThrowIfCancelled(cancellationToken).ConfigureAwait(false); } catch (TimeoutException timeExc) { throw new EnumException <ECreateInstanceErrCodes>( ECreateInstanceErrCodes.ConnectTcpTimeout, innerException: timeExc ); } catch (Exception exc) { throw new EnumException <ECreateInstanceErrCodes>( ECreateInstanceErrCodes.ConnectTcp, innerException: exc ); } try { result._samStream = result._samTcpClient.GetStream(); try { if (!result._samStream.CanWrite) { throw new EnumException <SamHelperExcs>( SamHelperExcs.NetStreamCannotWrite ); } if (!result._samStream.CanRead) { throw new EnumException <SamHelperExcs>( SamHelperExcs.NetStreamCannotRead ); } result._samReader = new SamReader(result._samStream); result._subscriptions.Add( result._samReader.IoExceptionThrown.ObserveOn(TaskPoolScheduler.Default).Subscribe( i => result.IoExceptionThrown.OnNext(null) ) ); result._subscriptions.Add( result._samReader.DatagramDataReceived.ObserveOn(TaskPoolScheduler.Default).Subscribe( result.SamReaderOnDatagramDataReceived ) ); /*******************/ HelloReplyReceivedArgs helloAnswer; try { var writeBuffer = SamBridgeCommandBuilder.HelloReply(); var helloAnswerTask = result._samReader.HelloReplyReceived .FirstAsync() .ToTask(cancellationToken); await result.WriteBuffer(writeBuffer).ConfigureAwait(false); helloAnswer = await helloAnswerTask.ConfigureAwait(false); } catch (OperationCanceledException) { //timeout result._samTcpClient.Close(); throw new EnumException <ECreateInstanceErrCodes>( ECreateInstanceErrCodes.HelloReplyTimeoutExceed ); } if (!helloAnswer.Ok) { result._samTcpClient.Close(); throw new EnumException <ECreateInstanceErrCodes>( ECreateInstanceErrCodes.HelloReplyError, tag: helloAnswer ); } result._stateHelper.SetInitializedState(); try { var sessionName = settings.SessionId ?? Guid.NewGuid().ToString().Replace("-", "").Substring(0, 15); result._samSession = await result.CreateSession( sessionName, cancellationToken, settings.SessionPrivateKeys, settings.I2CpOptions ).ConfigureAwait(false); } catch (EnumException <ECreateSessionErrorCodes> createSessionExc) { throw new EnumException <ECreateInstanceErrCodes>( ECreateInstanceErrCodes.CreateSessionError, innerException: createSessionExc ); } return(result); } catch { result._samStream.Close(); throw; } } catch { result._samTcpClient.Close(); throw; } }