public SocketFrameHandler_0_9(AmqpTcpEndpoint endpoint) { m_endpoint = endpoint; m_socket = new TcpClient(); m_socket.Connect(endpoint.HostName, endpoint.Port); // disable Nagle's algorithm, for more consistently low latency m_socket.NoDelay = true; Stream netstream = m_socket.GetStream(); m_reader = new NetworkBinaryReader(netstream); m_writer = new NetworkBinaryWriter(netstream); }
public SocketFrameHandler(AmqpTcpEndpoint endpoint, Func<AddressFamily, ITcpClient> socketFactory, int connectionTimeout, int readTimeout, int writeTimeout) { Endpoint = endpoint; m_socket = null; if (Socket.OSSupportsIPv6) { try { m_socket = socketFactory(AddressFamily.InterNetworkV6); Connect(m_socket, endpoint, connectionTimeout); } catch (ConnectFailureException) // could not connect using IPv6 { m_socket = null; } // Mono might raise a SocketException when using IPv4 addresses on // an OS that supports IPv6 catch (SocketException) { m_socket = null; } } if (m_socket == null) { m_socket = socketFactory(AddressFamily.InterNetwork); Connect(m_socket, endpoint, connectionTimeout); } Stream netstream = m_socket.GetStream(); netstream.ReadTimeout = readTimeout; netstream.WriteTimeout = writeTimeout; if (endpoint.Ssl.Enabled) { try { netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl); } catch (Exception) { Close(); throw; } } m_reader = new NetworkBinaryReader(new BufferedStream(netstream)); m_writer = new NetworkBinaryWriter(new BufferedStream(netstream)); m_writeableStateTimeout = writeTimeout; }
public void TestCreateConnectionWithAutoRecoveryUsesInvalidAmqpTcpEndpoint() { var cf = new ConnectionFactory(); cf.AutomaticRecoveryEnabled = true; var ep = new AmqpTcpEndpoint("localhost", 1234); Assert.That(() => { using (var conn = cf.CreateConnection(new System.Collections.Generic.List <AmqpTcpEndpoint> { ep })); }, Throws.TypeOf <BrokerUnreachableException>()); }
private ITcpClient ConnectUsingAddressFamily(AmqpTcpEndpoint endpoint, Func <AddressFamily, ITcpClient> socketFactory, int timeout, AddressFamily family) { ITcpClient socket = socketFactory(family); try { ConnectOrFail(socket, endpoint, timeout); return(socket); } catch (ConnectFailureException e) { socket.Dispose(); throw e; } }
private IConnection CreateConnection(AmqpConfiguration configuration) { try { var endpoint = new AmqpTcpEndpoint(configuration.Host, configuration.Port, _sslOption); return(_connectionFactory.CreateConnection(new List <AmqpTcpEndpoint> { endpoint })); } catch (Exception ex) { throw new FiksIOAmqpConnectionFailedException($"Unable to create connection. Host: {configuration.Host}; Port: {configuration.Port}; UserName:{_connectionFactory.UserName}; SslOption.Enabled: {_sslOption?.Enabled};SslOption.ServerName: {_sslOption?.ServerName}", ex); } }
public SocketFrameHandler(AmqpTcpEndpoint endpoint, ConnectionFactoryBase.ObtainSocket socketFactory, int timeout) { m_endpoint = endpoint; m_socket = null; if (Socket.OSSupportsIPv6) { try { m_socket = socketFactory(AddressFamily.InterNetworkV6); Connect(m_socket, endpoint, timeout); } catch (ConnectFailureException) // could not connect using IPv6 { m_socket = null; } // Mono might raise a SocketException when using IPv4 addresses on // an OS that supports IPv6 catch (SocketException) { m_socket = null; } } if (m_socket == null) { m_socket = socketFactory(AddressFamily.InterNetwork); Connect(m_socket, endpoint, timeout); } Stream netstream = m_socket.GetStream(); netstream.ReadTimeout = timeout; netstream.WriteTimeout = timeout; if (endpoint.Ssl.Enabled) { try { netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl); } catch (Exception) { Close(); throw; } } m_reader = new NetworkBinaryReader(new BufferedStream(netstream)); m_writer = new NetworkBinaryWriter(new BufferedStream(netstream)); }
public void TestCreateConnectionWithForcedAddressFamily() { var cf = new ConnectionFactory { HostName = "not_localhost" }; var ep = new AmqpTcpEndpoint("localhost") { AddressFamily = System.Net.Sockets.AddressFamily.InterNetwork }; cf.Endpoint = ep; using (IConnection conn = cf.CreateConnection()) { }; }
public void TestCreateConnectionWithAutoRecoveryUsesAmqpTcpEndpoint() { var cf = new ConnectionFactory { AutomaticRecoveryEnabled = true, HostName = "not_localhost", Port = 1234 }; var ep = new AmqpTcpEndpoint("localhost"); using (IConnection conn = cf.CreateConnection(new System.Collections.Generic.List <AmqpTcpEndpoint> { ep })) { } }
private async Task <Socket> ConnectUsingAddressFamily(AmqpTcpEndpoint endpoint, Func <AddressFamily, Socket> socketFactory, int timeout, AddressFamily family) { Socket socket = socketFactory(family); try { await ConnectOrFail(socket, endpoint, timeout); return(socket); } catch (ConnectFailureException e) { socket.Dispose(); throw e; } }
public static IFrameHandler CreateFrameHandler( #pragma warning disable RCS1175 // Unused this parameter. #pragma warning disable IDE0060 // Remove unused parameter this IProtocol protocol, #pragma warning restore IDE0060 // Remove unused parameter #pragma warning restore RCS1175 // Unused this parameter. AmqpTcpEndpoint endpoint, Func <AddressFamily, ITcpClient> socketFactory, int connectionTimeout, int readTimeout, int writeTimeout) { return(new SocketFrameHandler(endpoint, socketFactory, connectionTimeout, readTimeout, writeTimeout)); }
public SocketFrameHandler(AmqpTcpEndpoint endpoint, Func <AddressFamily, ITcpClient> socketFactory, TimeSpan connectionTimeout, TimeSpan readTimeout, TimeSpan writeTimeout) { Endpoint = endpoint; if (ShouldTryIPv6(endpoint)) { try { _socket = ConnectUsingIPv6(endpoint, socketFactory, connectionTimeout); } catch (ConnectFailureException) { _socket = null; } } if (_socket == null && endpoint.AddressFamily != AddressFamily.InterNetworkV6) { _socket = ConnectUsingIPv4(endpoint, socketFactory, connectionTimeout); } Stream netstream = _socket.GetStream(); netstream.ReadTimeout = (int)readTimeout.TotalMilliseconds; netstream.WriteTimeout = (int)writeTimeout.TotalMilliseconds; if (endpoint.Ssl.Enabled) { try { netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl); } catch (Exception) { Close(); throw; } } _reader = new BufferedStream(netstream, _socket.Client.ReceiveBufferSize); _writer = new BufferedStream(netstream, _socket.Client.SendBufferSize); WriteTimeout = writeTimeout; _frameWriter = Task.Run(WriteFrameImpl); }
public IEnumerable <AmqpTcpEndpoint> All() { _lastNode = _nodes[_nextHostIndex % _nodes.Length]; var hostName = _lastNode.HostName; var port = _lastNode.Port ?? _settings.Port; Interlocked.Increment(ref _nextHostIndex); LogContext.Debug?.Log("Returning next host: {Host}:{Port}", hostName, port); var endpoint = new AmqpTcpEndpoint(hostName, port); _settings.ApplySslOptions(endpoint.Ssl); yield return(endpoint); }
public SocketFrameHandler(AmqpTcpEndpoint endpoint, Func <AddressFamily, ITcpClient> socketFactory, int connectionTimeout, int readTimeout, int writeTimeout) { Endpoint = endpoint; if (ShouldTryIPv6(endpoint)) { try { m_socket = ConnectUsingIPv6(endpoint, socketFactory, connectionTimeout); } catch (ConnectFailureException) { m_socket = null; } } if (m_socket == null && endpoint.AddressFamily != AddressFamily.InterNetworkV6) { m_socket = ConnectUsingIPv4(endpoint, socketFactory, connectionTimeout); } Stream netstream = m_socket.GetStream(); netstream.ReadTimeout = readTimeout; netstream.WriteTimeout = writeTimeout; if (endpoint.Ssl.Enabled) { try { netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl); _ssl = true; } catch (Exception) { Close(); throw; } } m_reader = new NetworkBinaryReader(new BufferedStream(netstream, m_socket.Client.ReceiveBufferSize)); m_writer = new NetworkBinaryWriter(netstream); m_writeableStateTimeout = writeTimeout; }
private async Task <IModel> ConnectAsync(CancellationToken cancellationToken) { ExceptionDispatchInfo?edi = null; for (var i = 0; i < 5; i++) { try { AmqpTcpEndpoint endpoint; var connectionString = _configuration["connectionstring:rabbit"]; if (connectionString == null) { var host = _configuration["service:rabbit:host"]; var port = int.Parse(_configuration["service:rabbit:port"]); endpoint = new AmqpTcpEndpoint(host, port); } else { endpoint = new AmqpTcpEndpoint(new Uri(connectionString)); } var factory = new ConnectionFactory() { Endpoint = endpoint, }; var connection = factory.CreateConnection(); return(connection.CreateModel()); } catch (Exception ex) { if (i == 4) { edi = ExceptionDispatchInfo.Capture(ex); } _logger.LogError(0, ex, "Failed to start listening to rabbit mq"); } await Task.Delay(5000, cancellationToken); } edi !.Throw(); throw null; //unreachable }
public SocketFrameHandler(AmqpTcpEndpoint endpoint, ConnectionFactory.ObtainSocket socketFactory, int timeout) { m_endpoint = endpoint; m_socket = null; if (Socket.OSSupportsIPv6) { try { m_socket = socketFactory(AddressFamily.InterNetworkV6); Connect(m_socket, endpoint, timeout); } catch (ConnectFailureException) // could not connect using IPv6 { m_socket = null; } catch (SocketException) // Mono might raise a SocketException when using IPv4 addresses on an OS that supports IPv6 { m_socket = null; } } if (m_socket == null) { m_socket = socketFactory(AddressFamily.InterNetwork); Connect(m_socket, endpoint, timeout); } Stream netstream = m_socket.GetStream(); if (endpoint.Ssl.Enabled) { try { netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl, timeout); } catch (Exception) { Close(); throw; } } m_reader = new NetworkBinaryReader(new BufferedStream(netstream)); m_writer = new NetworkBinaryWriter(new BufferedStream(netstream)); }
public static LoggerSinkConfiguration RabbitMq( this LoggerSinkConfiguration configuration, Action <RabbitMqSinkOptions> optionsSetup, AmqpTcpEndpoint endpoint, Action <ConnectionFactory> connectionFactorySetup, IBinaryFormatter binaryFormatter, LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose, LoggingLevelSwitch levelSwitch = null, string clientProviderName = null) { RabbitMqSinkOptions options = configuration.Create(optionsSetup); RabbitMqSink rabbitMqSink = new RabbitMqSink(options, endpoint, connectionFactorySetup, binaryFormatter, clientProviderName); configuration.Sink(rabbitMqSink, restrictedToMinimumLevel, levelSwitch); return(configuration); }
public void Connect(string amqpUri, TimeSpan timeout) { var amqpTcpEndpoint = new AmqpTcpEndpoint(new Uri(amqpUri)); Logger.Current.Write(string.Format("Establishing connection to host:{0}, port:{1}", amqpTcpEndpoint.HostName, amqpTcpEndpoint.Port), TraceEventType.Information); _connectionFactory = new ConnectionFactory { Uri = amqpUri }; _messagePublisher = new MessagePublisher(_connectionFactory.UserName, _configurationModel.PublishRouteConfiguration, _configurationModel.ConsumeRouteConfiguration, _configurationModel.DefaultSerializationStrategy, _configurationModel.ConnectionDownQueueStrategy); InitializeConnection(_connectionFactory, timeout); RegisterAutoSubscriptions(_configurationModel); }
public SocketFrameHandler(AmqpTcpEndpoint endpoint, Func <StreamSocket> socketFactory, int connectionTimeout, int _readTimeout, int _writeTimeout) { Endpoint = endpoint; m_socket = socketFactory(); Connect(m_socket, endpoint, connectionTimeout); if (endpoint.Ssl.Enabled) { IAsyncAction ar = null; try { var cts = new CancellationTokenSource(); if (this.defaultTimeout.HasValue) { cts.CancelAfter(this.defaultTimeout.Value); } ar = this.m_socket.UpgradeToSslAsync( SocketProtectionLevel.Ssl, new HostName(endpoint.Ssl.ServerName)); ar.AsTask(cts.Token).Wait(); ar.GetResults(); } catch (Exception) { Close(); throw; } finally { if (ar != null) { ar.Close(); } } } m_reader = new NetworkBinaryReader(m_socket.InputStream.AsStreamForRead()); m_writer = new NetworkBinaryWriter(m_socket.OutputStream.AsStreamForWrite()); }
private void Connect(StreamSocket socket, AmqpTcpEndpoint endpoint, int timeout) { IAsyncAction ar = null; try { var cts = new CancellationTokenSource(); if (this.defaultTimeout.HasValue) { cts.CancelAfter(this.defaultTimeout.Value); } ar = socket.ConnectAsync(new HostName(endpoint.HostName), endpoint.Port.ToString(), SocketProtectionLevel.PlainSocket); if (!ar.AsTask(cts.Token).Wait(timeout)) { socket.Dispose(); throw new TimeoutException("Connection to " + endpoint + " timed out"); } ar.GetResults(); } catch (ArgumentException e) { throw new ConnectFailureException("Connection failed", e); } catch (Exception e) { // If this is an unknown status it means that the error is fatal and retry will likely fail. if (SocketError.GetStatus(e.HResult) == SocketErrorStatus.Unknown) { throw; } throw new ConnectFailureException("Connection failed", e); } finally { if (ar != null) { ar.Close(); } } }
public SocketFrameHandler_0_9(AmqpTcpEndpoint endpoint) { m_endpoint = endpoint; m_socket = new TcpClient(); m_socket.Connect(endpoint.HostName, endpoint.Port); // disable Nagle's algorithm, for more consistently low latency m_socket.NoDelay = true; Stream netstream = m_socket.GetStream(); if (endpoint.Ssl.Enabled) { try { netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl); } catch (Exception) { Close(); throw; } } m_reader = new NetworkBinaryReader(new BufferedStream(netstream)); m_writer = new NetworkBinaryWriter(new BufferedStream(netstream)); }
public virtual void SetAddresses(string addresses) { if (!string.IsNullOrEmpty(addresses)) { var endpoints = AmqpTcpEndpoint.ParseMultiple(addresses); if (endpoints.Length > 0) { Addresses = endpoints.ToList(); if (PublisherConnectionFactory != null) { AbstractPublisherConnectionFactory.SetAddresses(addresses); } return; } } _logger?.LogInformation("SetAddresses() called with an empty value, will be using the host+port properties for connections"); Addresses = null; }
public static LoggerAuditSinkConfiguration RabbitMq( this LoggerAuditSinkConfiguration configuration, Action <RabbitMqSinkOptions> optionsSetup, AmqpTcpEndpoint endpoint, Action <ConnectionFactory> connectionFactorySetup, LogEventJsonConverterOptions jsonConverterOptions = null, LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose, LoggingLevelSwitch levelSwitch = null, string clientProviderName = null) { RabbitMqSinkOptions options = configuration.Create(optionsSetup); RabbitMqSink rabbitMqSink = new RabbitMqSink(options, endpoint, connectionFactorySetup, new JsonToUtf8BytesFormatter(jsonConverterOptions ?? new LogEventJsonConverterOptions()), clientProviderName); configuration.Sink(rabbitMqSink, restrictedToMinimumLevel, levelSwitch); return(configuration); }
public void ToAmqpTcpEndpoints() { Assert.IsNull(Rabbit.ToAmqpTcpEndpoints(null)); IList <Uri> list = new List <Uri>(); string uri1Text = "amqps://*****:*****@localhost:5671/"; Uri uri1 = new Uri(uri1Text); list.Add(uri1); IList <AmqpTcpEndpoint> expected = Rabbit.ToAmqpTcpEndpoints(list); Assert.IsNotNull(expected); Assert.IsTrue(expected.Count > 0); AmqpTcpEndpoint amqpTcpEndpoint1 = expected[0]; Assert.AreEqual("localhost", amqpTcpEndpoint1.HostName); Assert.AreEqual(5671, amqpTcpEndpoint1.Port); Assert.IsTrue(amqpTcpEndpoint1.Protocol.ApiName.Contains("AMQP")); Assert.IsTrue(amqpTcpEndpoint1.Ssl.Enabled); }
private void Init(AmqpTcpEndpoint endpoint) { m_delegate = new Connection(m_factory, false, m_factory.CreateFrameHandler(endpoint), this.ClientProvidedName); AutorecoveringConnection self = this; EventHandler <ShutdownEventArgs> recoveryListener = (_, args) => { lock (recoveryLockTarget) { if (ShouldTriggerConnectionRecovery(args)) { try { self.BeginAutomaticRecovery(); } catch (Exception e) { // TODO: logging #if NETFX_CORE System.Diagnostics.Debug.WriteLine( #else Console.WriteLine( #endif "BeginAutomaticRecovery() failed: {0}", e); } } } }; lock (m_eventLock) { ConnectionShutdown += recoveryListener; if (!m_recordedShutdownEventHandlers.Contains(recoveryListener)) { m_recordedShutdownEventHandlers.Add(recoveryListener); } } }
public IConnection CreateConnection() { var connectionString = _configuration.RabbitMqConnectionString; if (connectionString == null) { _logger?.Fatal("Not connection string found for RabbitMQ. Can not create a bus. Aborting..."); throw new ConfigurationErrorsException("Could not find a connection string for RabbitMQ. Please add a connection string in the <connectionStrings> section of the application's configuration file. For example: <add name=\"RabbitMQ\" connectionString=\"host=localhost\" />"); } try { _factory.Uri = new Uri(connectionString); if (!_configuration.LogSensitiveData && !String.IsNullOrWhiteSpace(_factory.Uri.UserInfo)) { connectionString = connectionString.Replace($"{_factory.Uri.UserInfo}@", "*** BLOCKED ***@"); } if (_configuration.RabbitMqAutomaticRecoveryEnabled && _factory is ConnectionFactory connectionFactory) { connectionFactory.AutomaticRecoveryEnabled = true; } if (_configuration.RabbitMqClusterHosts == null) { _logger?.Verbose("Creating RabbitMQ connection. connection-string={RabbitConnectionString}, automatic-recovery-enabled={RabbitAutomaticRecoveryEnabled}", connectionString, _configuration.RabbitMqAutomaticRecoveryEnabled); return(_factory.CreateConnection()); } _logger?.Verbose("Creating RabbitMQ cluster connection. connection-string={RabbitConnectionString}, cluster-hosts={RabbitClusterHosts}, automatic-recovery-enabled={RabbitAutomaticRecoveryEnabled}", connectionString, _configuration.RabbitMqClusterHosts, _configuration.RabbitMqAutomaticRecoveryEnabled); return(_factory.CreateConnection(AmqpTcpEndpoint.ParseMultiple(_configuration.RabbitMqClusterHosts))); } catch (Exception ex) { _logger?.Fatal(ex, "Cannot connect to RabbitMQ using the provided configuration."); throw; } }
public SocketFrameHandler(AmqpTcpEndpoint endpoint, Func<StreamSocket> socketFactory, int connectionTimeout, int _readTimeout, int _writeTimeout) { Endpoint = endpoint; m_socket = socketFactory(); Connect(m_socket, endpoint, connectionTimeout); if (endpoint.Ssl.Enabled) { IAsyncAction ar = null; try { var cts = new CancellationTokenSource(); if (this.defaultTimeout.HasValue) cts.CancelAfter(this.defaultTimeout.Value); ar = this.m_socket.UpgradeToSslAsync( SocketProtectionLevel.Ssl, new HostName(endpoint.Ssl.ServerName)); ar.AsTask(cts.Token).Wait(); ar.GetResults(); } catch (Exception) { Close(); throw; } finally { if (ar != null) ar.Close(); } } m_reader = new NetworkBinaryReader(m_socket.InputStream.AsStreamForRead()); m_writer = new NetworkBinaryWriter(m_socket.OutputStream.AsStreamForWrite()); }
private void ApplySettings(ConnectionFactory connectionFactory, ConnectionSettings settings) { var endpoint = settings.Endpoint; if (!string.IsNullOrWhiteSpace(settings.Connection)) { endpoint = _configuration?.GetSection(settings.Connection).Value; } if (!string.IsNullOrWhiteSpace(endpoint)) { connectionFactory.Endpoint = AmqpTcpEndpoint.Parse(endpoint); } if (settings.UserName != null) { connectionFactory.UserName = settings.UserName; } if (settings.Password != null) { connectionFactory.Password = settings.Password; } if (settings.HostName != null) { connectionFactory.HostName = settings.HostName; } if (settings.Port.HasValue) { connectionFactory.Port = settings.Port.Value; } if (settings.VirtualHost != null) { connectionFactory.VirtualHost = settings.VirtualHost; } }
public SocketFrameHandler_0_9(AmqpTcpEndpoint endpoint) { m_endpoint = endpoint; m_socket = new TcpClient(); m_socket.Connect(endpoint.HostName, endpoint.Port); // disable Nagle's algorithm, for more consistently low latency m_socket.NoDelay = true; Stream netstream = m_socket.GetStream(); if (endpoint.Ssl.Enabled) { try { netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl); } catch (Exception) { Close(); throw; } } m_reader = new NetworkBinaryReader(new BufferedStream(netstream)); m_writer = new NetworkBinaryWriter(new BufferedStream(netstream)); }
private IAutorecoveringConnection Connect() { var endpoints = configuration.Hosts.Select(x => { var endpoint = new AmqpTcpEndpoint(x.Host, x.Port); if (x.Ssl.Enabled) { endpoint.Ssl = x.Ssl; } else if (configuration.Ssl.Enabled) { endpoint.Ssl = configuration.Ssl; } return(endpoint); }).ToArray(); var connection = connectionFactory.CreateConnection(endpoints) as IAutorecoveringConnection; if (connection == null) { throw new NotSupportedException("Non-recoverable connection is not supported"); } connection.ConnectionShutdown += OnConnectionShutdown; connection.ConnectionBlocked += OnConnectionBlocked; connection.ConnectionUnblocked += OnConnectionUnblocked; connection.RecoverySucceeded += OnConnectionRecovered; logger.InfoFormat( "Connected to broker {broker}, port {port}", connection.Endpoint.HostName, connection.Endpoint.Port ); eventBus.Publish(new ConnectionCreatedEvent(connection.Endpoint)); return(connection); }
public void ConfigureServices(IServiceCollection services) { services.AddAuthorization(); services.AddCodeFirstGrpc(); services.AddSingleton(sp => { AmqpTcpEndpoint endpoint; var connectionString = Configuration["connectionstring:rabbit"]; if (connectionString == null) { var host = Configuration["service:rabbit:host"]; var port = int.Parse(Configuration["service:rabbit:port"]); endpoint = new AmqpTcpEndpoint(host, port); } else { endpoint = new AmqpTcpEndpoint(new Uri(connectionString)); } var factory = new ConnectionFactory() { Endpoint = endpoint, }; var connection = factory.CreateConnection(); var channel = connection.CreateModel(); channel.QueueDeclare(queue: "orders", durable: false, exclusive: false, autoDelete: false, arguments: null); return(channel); }); }
private ITcpClient ConnectUsingIPv4(AmqpTcpEndpoint endpoint, Func <AddressFamily, ITcpClient> socketFactory, TimeSpan timeout) { return(ConnectUsingAddressFamily(endpoint, socketFactory, timeout, AddressFamily.InterNetwork)); }
private bool ShouldTryIPv6(AmqpTcpEndpoint endpoint) { return(Socket.OSSupportsIPv6 && endpoint.AddressFamily != AddressFamily.InterNetwork); }
public void TestMultipleNone() { AmqpTcpEndpoint[] es = AmqpTcpEndpoint.ParseMultiple(" "); Assert.AreEqual(0, es.Length); }
public SocketFrameHandler(AmqpTcpEndpoint endpoint, Func <AddressFamily, ITcpClient> socketFactory, TimeSpan connectionTimeout, TimeSpan readTimeout, TimeSpan writeTimeout) { Endpoint = endpoint; _frameHeaderBuffer = new byte[6]; var channel = Channel.CreateUnbounded <ReadOnlyMemory <byte> >( new UnboundedChannelOptions { AllowSynchronousContinuations = false, SingleReader = true, SingleWriter = false }); _channelReader = channel.Reader; _channelWriter = channel.Writer; // Resolve the hostname to know if it's even possible to even try IPv6 IPAddress[] adds = Dns.GetHostAddresses(endpoint.HostName); IPAddress ipv6 = TcpClientAdapterHelper.GetMatchingHost(adds, AddressFamily.InterNetworkV6); if (ipv6 == default(IPAddress)) { if (endpoint.AddressFamily == AddressFamily.InterNetworkV6) { throw new ConnectFailureException("Connection failed", new ArgumentException($"No IPv6 address could be resolved for {endpoint.HostName}")); } } else if (ShouldTryIPv6(endpoint)) { try { _socket = ConnectUsingIPv6(new IPEndPoint(ipv6, endpoint.Port), socketFactory, connectionTimeout); } catch (ConnectFailureException) { // We resolved to a ipv6 address and tried it but it still didn't connect, try IPv4 _socket = null; } } if (_socket == null) { IPAddress ipv4 = TcpClientAdapterHelper.GetMatchingHost(adds, AddressFamily.InterNetwork); if (ipv4 == default(IPAddress)) { throw new ConnectFailureException("Connection failed", new ArgumentException($"No ip address could be resolved for {endpoint.HostName}")); } _socket = ConnectUsingIPv4(new IPEndPoint(ipv4, endpoint.Port), socketFactory, connectionTimeout); } Stream netstream = _socket.GetStream(); netstream.ReadTimeout = (int)readTimeout.TotalMilliseconds; netstream.WriteTimeout = (int)writeTimeout.TotalMilliseconds; if (endpoint.Ssl.Enabled) { try { netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl); } catch (Exception) { Close(); throw; } } _reader = new BufferedStream(netstream, _socket.Client.ReceiveBufferSize); _writer = new BufferedStream(netstream, _socket.Client.SendBufferSize); WriteTimeout = writeTimeout; _writerTask = Task.Run(WriteLoop, CancellationToken.None); }
public abstract IFrameHandler CreateFrameHandler(AmqpTcpEndpoint endpoint);
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); } }
private void Connect(TcpClient socket, AmqpTcpEndpoint endpoint, int timeout) { IAsyncResult ar = null; try { ar = socket.BeginConnect(endpoint.HostName, endpoint.Port, null, null); if (!ar.AsyncWaitHandle.WaitOne(timeout, false)) { socket.Close(); throw new TimeoutException("Connection to " + endpoint + " timed out"); } socket.EndConnect(ar); } catch (ArgumentException e) { throw new ConnectFailureException("Connection failed", e); } catch (SocketException e) { throw new ConnectFailureException("Connection failed", e); } finally { if (ar != null) ar.AsyncWaitHandle.Close(); } }
private void Connect(StreamSocket socket, AmqpTcpEndpoint endpoint, int timeout) { IAsyncAction ar = null; try { var cts = new CancellationTokenSource(); if (this.defaultTimeout.HasValue) cts.CancelAfter(this.defaultTimeout.Value); ar = socket.ConnectAsync(new HostName(endpoint.HostName), endpoint.Port.ToString(), SocketProtectionLevel.PlainSocket); if (!ar.AsTask(cts.Token).Wait(timeout)) { socket.Dispose(); throw new TimeoutException("Connection to " + endpoint + " timed out"); } ar.GetResults(); } catch (ArgumentException e) { throw new ConnectFailureException("Connection failed", e); } catch (Exception e) { // If this is an unknown status it means that the error is fatal and retry will likely fail. if (SocketError.GetStatus(e.HResult) == SocketErrorStatus.Unknown) { throw; } throw new ConnectFailureException("Connection failed", e); } finally { if (ar != null) { ar.Close(); } } }