public static TransportBase CreateTransport(string host, int port, string sslHost, bool doSslUpgrade, SaslHandler saslHandler)
{
AmqpSettings settings = GetAmqpSettings(true, sslHost, doSslUpgrade, saslHandler);
TransportSettings transportSettings = GetTcpSettings(host, port, false);
if (!doSslUpgrade && sslHost != null)
{
TlsTransportSettings tlsSettings = new TlsTransportSettings(transportSettings);
tlsSettings.TargetHost = sslHost;
tlsSettings.CertificateValidationCallback = (s, c, h, e) => { return(true); };
transportSettings = tlsSettings;
}
ManualResetEvent complete = new ManualResetEvent(false);
AmqpTransportInitiator initiator = new AmqpTransportInitiator(settings, transportSettings);
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.CompletedCallback = (a) => { complete.Set(); };
initiator.ConnectAsync(TimeSpan.FromSeconds(120), args);
complete.WaitOne();
complete.Dispose();
if (args.Exception != null)
{
throw args.Exception;
}
return(args.Transport);
}
internal async Task <TransportBase> InitializeAsync(CancellationToken cancellationToken)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, nameof(InitializeAsync));
}
TransportBase transport;
switch (_amqpTransportSettings.GetTransportType())
{
case TransportType.Amqp_WebSocket_Only:
transport = _clientWebSocketTransport = (ClientWebSocketTransport) await CreateClientWebSocketTransportAsync(cancellationToken)
.ConfigureAwait(false);
break;
case TransportType.Amqp_Tcp_Only:
var amqpTransportInitiator = new AmqpTransportInitiator(_amqpSettings, _tlsTransportSettings);
transport = await amqpTransportInitiator.ConnectAsync(cancellationToken).ConfigureAwait(false);
break;
default:
throw new InvalidOperationException("AmqpTransportSettings must specify WebSocketOnly or TcpOnly");
}
if (Logging.IsEnabled)
{
Logging.Exit(this, nameof(InitializeAsync));
}
return(transport);
}
public ConnectAsyncResult(string host, int port, AmqpSettings amqpSettings, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
{
if (port <= 0)
{
port = 5672;
}
this.amqpSettings = amqpSettings;
TcpTransportSettings tcpTransportSetting = new TcpTransportSettings()
{
Host = host,
Port = port
};
AmqpTransportInitiator amqpTransportInitiator = new AmqpTransportInitiator(this.amqpSettings, tcpTransportSetting);
TransportAsyncCallbackArgs transportAsyncCallbackArg = new TransportAsyncCallbackArgs()
{
CompletedCallback = new Action <TransportAsyncCallbackArgs>(this.OnTransportCallback),
UserToken = this
};
amqpTransportInitiator.ConnectAsync(timeout, transportAsyncCallbackArg);
}
public static TransportBase CreateTransport(string host, int port, string sslHost, bool doSslUpgrade, SaslHandler saslHandler)
{
AmqpSettings settings = GetAmqpSettings(true, sslHost, doSslUpgrade, saslHandler);
TransportSettings transportSettings = GetTcpSettings(host, port, false);
if (!doSslUpgrade && sslHost != null)
{
TlsTransportSettings tlsSettings = new TlsTransportSettings(transportSettings);
tlsSettings.TargetHost = sslHost;
tlsSettings.CertificateValidationCallback = (s, c, h, e) => { return true; };
transportSettings = tlsSettings;
}
ManualResetEvent complete = new ManualResetEvent(false);
AmqpTransportInitiator initiator = new AmqpTransportInitiator(settings, transportSettings);
TransportAsyncCallbackArgs args = new TransportAsyncCallbackArgs();
args.CompletedCallback = (a) => { complete.Set(); };
initiator.ConnectAsync(TimeSpan.FromSeconds(120), args);
complete.WaitOne();
complete.Dispose();
if (args.Exception != null)
{
throw args.Exception;
}
return args.Transport;
}
public async Task OpenAsync(
bool useWebSocket,
X509Certificate2 clientCert,
IWebProxy proxy,
RemoteCertificateValidationCallback remoteCerificateValidationCallback,
CancellationToken cancellationToken)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, $"{nameof(AmqpClientConnection)}.{nameof(OpenAsync)}");
}
string hostName = _uri.Host;
var tcpSettings = new TcpTransportSettings {
Host = hostName, Port = _uri.Port != -1 ? _uri.Port : AmqpConstants.DefaultSecurePort
};
TransportSettings = new TlsTransportSettings(tcpSettings)
{
TargetHost = hostName,
Certificate = clientCert,
CertificateValidationCallback = remoteCerificateValidationCallback,
};
if (useWebSocket)
{
_transport = await CreateClientWebSocketTransportAsync(proxy, cancellationToken).ConfigureAwait(false);
SaslTransportProvider provider = _amqpSettings.GetTransportProvider <SaslTransportProvider>();
if (provider != null)
{
if (Logging.IsEnabled)
{
Logging.Info(this, $"{nameof(AmqpClientConnection)}.{nameof(OpenAsync)}: Using SaslTransport");
}
_sentHeader = new ProtocolHeader(provider.ProtocolId, provider.DefaultVersion);
using var buffer = new ByteBuffer(new byte[AmqpConstants.ProtocolHeaderSize]);
_sentHeader.Encode(buffer);
_tcs = new TaskCompletionSource <TransportBase>();
var args = new TransportAsyncCallbackArgs();
args.SetBuffer(buffer.Buffer, buffer.Offset, buffer.Length);
args.CompletedCallback = OnWriteHeaderComplete;
args.Transport = _transport;
bool operationPending = _transport.WriteAsync(args);
if (Logging.IsEnabled)
{
Logging.Info(
this,
$"{nameof(AmqpClientConnection)}.{nameof(OpenAsync)}: " +
$"Sent Protocol Header: {_sentHeader} operationPending: {operationPending} completedSynchronously: {args.CompletedSynchronously}");
}
if (!operationPending)
{
args.CompletedCallback(args);
}
_transport = await _tcs.Task.ConfigureAwait(false);
await _transport.OpenAsync(cancellationToken).ConfigureAwait(false);
}
}
else
{
var tcpInitiator = new AmqpTransportInitiator(_amqpSettings, TransportSettings);
_transport = await tcpInitiator.ConnectAsync(cancellationToken).ConfigureAwait(false);
}
AmqpConnection = new AmqpConnection(_transport, _amqpSettings, AmqpConnectionSettings);
AmqpConnection.Closed += OnConnectionClosed;
await AmqpConnection.OpenAsync(cancellationToken).ConfigureAwait(false);
IsConnectionClosed = false;
}
