private void ConnectOrFail(ITcpClient socket, AmqpTcpEndpoint endpoint, TimeSpan timeout) { try { socket.ConnectAsync(endpoint.HostName, endpoint.Port) .TimeoutAfter(timeout) .ConfigureAwait(false) // this ensures exceptions aren't wrapped in an AggregateException .GetAwaiter() .GetResult(); } catch (ArgumentException e) { throw new ConnectFailureException("Connection failed", e); } catch (SocketException e) { throw new ConnectFailureException("Connection failed", e); } catch (NotSupportedException e) { throw new ConnectFailureException("Connection failed", e); } catch (TimeoutException e) { throw new ConnectFailureException("Connection failed", e); } }
/// <summary> /// Opens the transport connection with the specified Uri and begins to read from the stream. /// </summary> /// <param name="uri"></param> /// <param name="cancellationToken"></param> /// <returns></returns> /// <exception cref="System.NotImplementedException"></exception> protected override async Task PerformOpenAsync(Uri uri, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!_tcpClient.Connected) { if (uri == null) { throw new ArgumentNullException(nameof(uri), "The uri is mandatory for a not connected TCP client"); } if (uri.Scheme != UriSchemeNetTcp) { throw new ArgumentException($"Invalid URI scheme. Expected is '{UriSchemeNetTcp}'.", nameof(uri)); } if (string.IsNullOrWhiteSpace(_hostName)) { _hostName = uri.Host; } await _tcpClient.ConnectAsync(uri.Host, uri.Port).ConfigureAwait(false); } _stream = _tcpClient.GetStream(); }
/// <summary> /// Opens the transport connection with /// the specified Uri and begins to /// read from the stream /// </summary> /// <param name="uri"></param> /// <param name="cancellationToken"></param> /// <returns></returns> /// <exception cref="System.NotImplementedException"></exception> public async override Task OpenAsync(Uri uri, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); if (!_tcpClient.Connected) { if (uri == null) { throw new ArgumentNullException("uri"); } if (uri.Scheme != Uri.UriSchemeNetTcp) { throw new ArgumentException(string.Format("Invalid URI scheme. Expected is '{0}'.", Uri.UriSchemeNetTcp)); } if (string.IsNullOrWhiteSpace(_hostName)) { _hostName = uri.Host; } await _tcpClient.ConnectAsync(uri.Host, uri.Port).ConfigureAwait(false); } _stream = _tcpClient.GetStream(); }
/// <summary> /// Opens the transport connection with the specified Uri and begins to read from the stream. /// </summary> /// <param name="uri"></param> /// <param name="cancellationToken"></param> /// <returns></returns> /// <exception cref="System.NotImplementedException"></exception> protected override async Task PerformOpenAsync(Uri uri, CancellationToken cancellationToken) { // TODO: It is required to call OpenAsync in a server transport, which doesn't make much sense. The server transport is passive and it will be always be open after its creation. // We should refactor the transports to remove this need on the server side. if (!_tcpClient.Connected) { if (uri == null) { throw new ArgumentNullException(nameof(uri), "The uri is mandatory for a not connected TCP client"); } if (uri.Scheme != UriSchemeNetTcp) { throw new ArgumentException($"Invalid URI scheme. Expected is '{UriSchemeNetTcp}'.", nameof(uri)); } if (string.IsNullOrWhiteSpace(_hostName)) { _hostName = uri.Host; } await _tcpClient.ConnectAsync(uri.Host, uri.Port).ConfigureAwait(false); } _stream = _tcpClient.GetStream(); await _envelopePipe.StartAsync(cancellationToken); }
public async Task SendAsync(IRequest request) { if (!_tcpClient.Connected) { await _tcpClient.ConnectAsync(IPAddress.Parse(_userSettings.GetString("ServerIP")), _userSettings.GetInt32("ServerPort")); } if (request is IConnectionRequiredRequest connectionRequiredRequest) { connectionRequiredRequest.ConnectionIdentifier0 = _connectionIdentification.Current[0]; connectionRequiredRequest.ConnectionIdentifier1 = _connectionIdentification.Current[1]; connectionRequiredRequest.ConnectionIdentifier2 = _connectionIdentification.Current[2]; connectionRequiredRequest.ConnectionIdentifier3 = _connectionIdentification.Current[3]; } request.Counter = ++_counter; await _tcpClient.WriteAsync(_requestBuilder.Build(request)); var dataBytes = await _tcpClient.ReadAsync(); var response = _responseParser.Parse(dataBytes); if (response.IsNotConnectedResponse()) { await SendAsync(new ConnectDataRequest()); await SendAsync(request); } ReceiveData?.Invoke(response); }
private async Task <IReadOnlyList <IMailReference> > TrySendToMx( string target, IReadOnlyList <IMailReference> mails, int port, CancellationToken token) { _log.Verbose($"Looking up information for MX {target}"); IPAddress targetIp = await _dns.QueryIp(target, token); if (targetIp == null) { _log.Warning($"Failed to resolve A or AAAA record for MX record {target}"); return(mails); } using (ITcpClient mxClient = _tcp.GetClient()) { _log.Information($"Connecting to MX {target} at {targetIp} on port {port}"); await mxClient.ConnectAsync(targetIp, port); using (Stream mxStream = mxClient.GetStream()) { mails = await TrySendMailsToStream(target, mails, mxStream, token); } } return(mails); }
private async Task ConnectAsyncImpl(IPAddress ipAddress, int port) { try { Disconnecting = false; _tcpClient = _getTcpClient(); OnConnecting(_tcpClient); await _tcpClient.ConnectAsync(ipAddress, port).ConfigureAwait(false); OnConnected(_tcpClient); await TcpReceiver.ReceiveAsync(_tcpClient).ConfigureAwait(false); } catch (Exception exception) { throw new TcpIpClientConnectFailedException(exception); } }
public async Task <EnvironmentResponse> ConnectAsync(IClient client, ITcpClient tcpClient, Configuration configuration) { await this.semaphore.WaitAsync(); try { await tcpClient.ConnectAsync(configuration.Hostname, configuration.Port); using (var session = this.sessionFactory.Create(client)) { return(await this.startRequestWriter.WriteStartAsync(session, configuration.Mode, configuration.Secret)); } } finally { this.semaphore.Release(); } }
public async Task Start(string ip, int port) { if (State != WorkState.NotStarted && State != WorkState.Stopped) { State = WorkState.Errored; await Task.WhenAll(receiver.Stop(), sender.Stop()); throw new AdminPortException("This Client is working atm. Please Stop it before starting it again."); } this.ip = ip; this.port = port; await tcpClient.ConnectAsync(ip, port); await Task.WhenAll( sender.Start(tcpClient.GetStream()), receiver.Start(tcpClient.GetStream())); State = WorkState.Working; }
public async Task OpenConnectionAsync(IDeviceClient deviceClient, IClientWebSocket clientWebSocket, ITcpClient tcpClient, CancellationTokenSource cancellationTokenSource) { DeviceStreamRequest streamRequest = await deviceClient.WaitForDeviceStreamRequestAsync(cancellationTokenSource.Token).ConfigureAwait(false); if (streamRequest != null) { await deviceClient.AcceptDeviceStreamRequestAsync(streamRequest, cancellationTokenSource.Token).ConfigureAwait(false); Console.WriteLine($"Device stream accepted from IoT Hub, at {DateTime.UtcNow}"); clientWebSocket.Options.SetRequestHeader("Authorization", $"Bearer {streamRequest.AuthorizationToken}"); await clientWebSocket.ConnectAsync(streamRequest.Url, cancellationTokenSource.Token).ConfigureAwait(false); Console.WriteLine($"Device stream connected to IoT Hub, at {DateTime.UtcNow}"); await tcpClient.ConnectAsync(this.HostName, this.Port).ConfigureAwait(false); Console.WriteLine($"Device stream connected to local endpoint, at {DateTime.UtcNow}"); using (var localStream = tcpClient.GetStream()) { await Task.WhenAny( this.HandleIncomingDataAsync(clientWebSocket, localStream, cancellationTokenSource.Token), this.HandleOutgoingDataAsync(clientWebSocket, localStream, cancellationTokenSource.Token) ).ConfigureAwait(false); localStream.Close(); Console.WriteLine($"Device stream closed to local endpoint, at {DateTime.UtcNow}"); } await clientWebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationTokenSource.Token).ConfigureAwait(false); } else { await deviceClient.RejectDeviceStreamRequestAsync(streamRequest, cancellationTokenSource.Token).ConfigureAwait(false); } }
public Task ConnectAsync(IPAddress parse, int port) { return(_client.ConnectAsync(parse, port)); }
private void Connect(ITcpClient socket, AmqpTcpEndpoint endpoint, int timeout) { try { socket.ConnectAsync(endpoint.HostName, endpoint.Port) .TimeoutAfter(timeout) .ConfigureAwait(false) .GetAwaiter()//this ensures exceptions aren't wrapped in an AggregateException .GetResult(); } catch (ArgumentException e) { throw new ConnectFailureException("Connection failed", e); } catch (SocketException e) { throw new ConnectFailureException("Connection failed", e); } catch (NotSupportedException e) { throw new ConnectFailureException("Connection failed", e); } catch (TimeoutException e) { throw new ConnectFailureException("Connection failed", e); } }
protected override async Task Run(CancellationToken cancellationToken) { ITcpClient client = null; try { if (!_messageService.CanSend(_userId, typeof(TMessage))) { throw new SecurityAccessDeniedException(string.Format("Access denied for type message {0}", typeof(TMessage))); } client = _clientFactory.CreateTcpClient(); await client.ConnectAsync(_userId); var definition = _messageService.GetDefinition <TMessage>(); var buffer = BitConverter.GetBytes(_messageService.CreateMessageHash(definition)); await client.WriteStream.WriteAsync(buffer, 0, buffer.Length, cancellationToken); await client.WriteStream.FlushAsync(cancellationToken); if (!await GetResponse(client.ReadStream, cancellationToken)) { return; } if (IsCancellationRequested) { throw new OperationCanceledException(); } using (var memoryBuffer = new MemoryStream()) { await _serializer.WriteMessage(_message, memoryBuffer); await Send(cancellationToken, client.WriteStream, memoryBuffer.ToArray()); } if (IsCancellationRequested) { throw new OperationCanceledException(); } await client.WriteStream.FlushAsync(cancellationToken); if (!await GetResponse(client.ReadStream, cancellationToken)) { return; } //TODO: Check variable streaming for correct implementation! var streaming = Message as IStreamingMessage; if (streaming != null) { var readedCount = 0; ulong readed = 0; RaiseReport(new ProgressInfo <TMessage>(_message, streaming.StreamLength, readed)); buffer = new byte[2048]; do { readedCount = await streaming.Stream.ReadAsync(buffer, 0, buffer.Length); await client.WriteStream.WriteAsync(buffer, 0, readedCount, cancellationToken); await client.WriteStream.FlushAsync(cancellationToken); if (IsCancellationRequested) { throw new OperationCanceledException(); } readed += (ulong)readedCount; RaiseReport(new ProgressInfo <TMessage>(_message, streaming.StreamLength, readed)); } while (readedCount > 0); } RaiseSuccess(Message); await client.DisconnectAsync(); } finally { if (client != null) { client.Dispose(); } } }