public static AmqpSettings GetAmqpSettings(bool client, string sslValue, bool doSslUpgrade, params SaslHandler[] saslHandlers)
{
AmqpSettings settings = new AmqpSettings();
if ((client && doSslUpgrade) || (!client && sslValue != null))
{
TlsTransportSettings tlsSettings = new TlsTransportSettings();
if (client)
{
tlsSettings.TargetHost = sslValue;
tlsSettings.CertificateValidationCallback = (s, c, h, e) => { return true; };
}
else
{
tlsSettings.IsInitiator = false;
tlsSettings.Certificate = GetCertificate(sslValue); ;
}
TlsTransportProvider tlsProvider = new TlsTransportProvider(tlsSettings);
tlsProvider.Versions.Add(new AmqpVersion(1, 0, 0));
settings.TransportProviders.Add(tlsProvider);
}
if (saslHandlers != null && saslHandlers.Length >= 1 && saslHandlers[0] != null)
{
SaslTransportProvider saslProvider = new SaslTransportProvider();
saslProvider.Versions.Add(new AmqpVersion(1, 0, 0));
foreach (SaslHandler handler in saslHandlers)
{
saslProvider.AddHandler(handler);
}
settings.TransportProviders.Add(saslProvider);
}
AmqpTransportProvider amqpProvider = new AmqpTransportProvider();
amqpProvider.Versions.Add(new AmqpVersion(1, 0, 0));
settings.TransportProviders.Add(amqpProvider);
return settings;
}
public static AmqpSettings GetAmqpSettings(bool client, string sslValue, bool doSslUpgrade, params SaslHandler[] saslHandlers)
{
AmqpSettings settings = new AmqpSettings();
if ((client && doSslUpgrade) || (!client && sslValue != null))
{
TlsTransportSettings tlsSettings = new TlsTransportSettings();
if (client)
{
tlsSettings.TargetHost = sslValue;
tlsSettings.CertificateValidationCallback = (s, c, h, e) => { return(true); };
}
else
{
tlsSettings.IsInitiator = false;
tlsSettings.Certificate = GetCertificate(sslValue);;
}
TlsTransportProvider tlsProvider = new TlsTransportProvider(tlsSettings, AmqpVersion.V100);
settings.TransportProviders.Add(tlsProvider);
}
if (saslHandlers != null && saslHandlers.Length >= 1 && saslHandlers[0] != null)
{
SaslTransportProvider saslProvider = new SaslTransportProvider(AmqpVersion.V100);
foreach (SaslHandler handler in saslHandlers)
{
saslProvider.AddHandler(handler);
}
settings.TransportProviders.Add(saslProvider);
}
AmqpTransportProvider amqpProvider = new AmqpTransportProvider(AmqpVersion.V100);
settings.TransportProviders.Add(amqpProvider);
return(settings);
}
TlsTransportSettings CreateTlsTransportSettings()
{
var tcpTransportSettings = new TcpTransportSettings()
{
Host = this.hostName,
Port = this.port
};
var tlsTransportSettings = new TlsTransportSettings(tcpTransportSettings)
{
TargetHost = this.hostName,
Certificate = null,
CertificateValidationCallback = this.AmqpTransportSettings.RemoteCertificateValidationCallback ?? OnRemoteCertificateValidation
};
if (this.AmqpTransportSettings.ClientCertificate != null)
{
tlsTransportSettings.Certificate = this.AmqpTransportSettings.ClientCertificate;
}
return(tlsTransportSettings);
}
public AmqpIoTTransport(AmqpSettings amqpSettings, AmqpTransportSettings amqpTransportSettings, string hostName, bool disableServerCertificateValidation)
{
_amqpSettings = amqpSettings;
_amqpTransportSettings = amqpTransportSettings;
_hostName = hostName;
_disableServerCertificateValidation = disableServerCertificateValidation;
var tcpTransportSettings = new TcpTransportSettings
{
Host = hostName,
Port = AmqpConstants.DefaultSecurePort,
};
SslProtocols protocols = TlsVersions.Instance.Preferred;
#if NET451
// Requires hardcoding in NET451 otherwise yields error:
// System.ArgumentException: The specified value is not valid in the 'SslProtocolType' enumeration.
if (amqpTransportSettings.GetTransportType() == TransportType.Amqp_Tcp_Only &&
protocols == SslProtocols.None)
{
protocols = TlsVersions.Instance.MinimumTlsVersions;
}
#endif
_tlsTransportSettings = new TlsTransportSettings(tcpTransportSettings)
{
TargetHost = hostName,
Certificate = null,
CertificateValidationCallback = _amqpTransportSettings.RemoteCertificateValidationCallback ?? OnRemoteCertificateValidation,
Protocols = protocols,
};
if (_amqpTransportSettings.ClientCertificate != null)
{
_tlsTransportSettings.Certificate = _amqpTransportSettings.ClientCertificate;
}
}
protected ConnectionListener(
Uri addressUri,
AmqpSettings amqpSettings,
AmqpConnectionSettings connectionSettings)
{
amqpSettings.ValidateListenerSettings();
this.listenAddress = addressUri;
this.amqpSettings = amqpSettings;
this.connectionSettings = connectionSettings;
this.onAcceptTransport = this.OnAcceptTransport;
TcpTransportSettings tcpSettings = new TcpTransportSettings();
tcpSettings.SetEndPoint(addressUri.Host, addressUri.Port, true);
TransportListener tpListener = null;
if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqps, StringComparison.OrdinalIgnoreCase))
{
TlsTransportProvider tlsProvider = this.amqpSettings.GetTransportProvider <TlsTransportProvider>();
if (tlsProvider == null)
{
throw Fx.Exception.ArgumentNull("TlsSecurityProvider");
}
Fx.Assert(tlsProvider.Settings.Certificate != null, "Must have a valid certificate.");
TlsTransportSettings tlsSettings = new TlsTransportSettings(tcpSettings, false);
tlsSettings.Certificate = tlsProvider.Settings.Certificate;
tpListener = tlsSettings.CreateListener();
}
else
{
tpListener = tcpSettings.CreateListener();
}
this.transportListener = new AmqpTransportListener(new TransportListener[] { tpListener }, this.amqpSettings);
this.onConnectionOpenComplete = new AsyncCallback(this.OnConnectionOpenComplete);
}
/// <summary>
/// Opens a connection to the specified address.
/// </summary>
/// <param name="addressUri">The address Uri. User info is ignored.</param>
/// <param name="saslHandler">The SASL handler which determines the SASL mechanism. Null means no SASL handshake.</param>
/// <param name="timeout">The operation timeout.</param>
/// <returns>An AMQP connection.</returns>
public async Task <AmqpConnection> OpenConnectionAsync(Uri addressUri, SaslHandler saslHandler, TimeSpan timeout)
{
TransportSettings transportSettings;
if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqp, StringComparison.OrdinalIgnoreCase))
{
transportSettings = new TcpTransportSettings()
{
Host = addressUri.Host,
Port = addressUri.Port > -1 ? addressUri.Port : AmqpConstants.DefaultPort
};
}
else if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqps, StringComparison.OrdinalIgnoreCase))
{
TcpTransportSettings tcpSettings = new TcpTransportSettings()
{
Host = addressUri.Host,
Port = addressUri.Port > -1 ? addressUri.Port : AmqpConstants.DefaultSecurePort
};
var tls = new TlsTransportSettings(tcpSettings)
{
TargetHost = addressUri.Host
};
TlsTransportProvider tlsProvider = this.settings.GetTransportProvider <TlsTransportProvider>();
if (tlsProvider != null)
{
tls.CertificateValidationCallback = tlsProvider.Settings.CertificateValidationCallback;
tls.CheckCertificateRevocation = tlsProvider.Settings.CheckCertificateRevocation;
tls.Certificate = tlsProvider.Settings.Certificate;
tls.Protocols = tlsProvider.Settings.Protocols;
}
transportSettings = tls;
}
else if (addressUri.Scheme.Equals(WebSocketTransportSettings.WebSockets, StringComparison.OrdinalIgnoreCase) ||
addressUri.Scheme.Equals(WebSocketTransportSettings.SecureWebSockets, StringComparison.OrdinalIgnoreCase))
{
transportSettings = new WebSocketTransportSettings()
{
Uri = addressUri
};
}
else
{
throw new NotSupportedException(addressUri.Scheme);
}
AmqpSettings settings = this.settings.Clone();
settings.TransportProviders.Clear();
if (saslHandler != null)
{
// Provider for "AMQP3100"
SaslTransportProvider saslProvider = new SaslTransportProvider(AmqpVersion.V100);
saslProvider.AddHandler(saslHandler);
settings.TransportProviders.Add(saslProvider);
}
// Provider for "AMQP0100"
AmqpTransportProvider amqpProvider = new AmqpTransportProvider(AmqpVersion.V100);
settings.TransportProviders.Add(amqpProvider);
AmqpTransportInitiator initiator = new AmqpTransportInitiator(settings, transportSettings);
TransportBase transport = await Task.Factory.FromAsync(
(c, s) => initiator.BeginConnect(timeout, c, s),
(r) => initiator.EndConnect(r),
null).ConfigureAwait(false);
try
{
AmqpConnectionSettings connectionSettings = new AmqpConnectionSettings()
{
ContainerId = Guid.NewGuid().ToString(),
HostName = addressUri.Host
};
AmqpConnection connection = new AmqpConnection(transport, settings, connectionSettings);
await connection.OpenAsync(timeout).ConfigureAwait(false);
return(connection);
}
catch
{
transport.Abort();
throw;
}
}
public async Task OpenAsync(TimeSpan timeout, bool useWebSocket, X509Certificate2 clientCert, IWebProxy proxy, RemoteCertificateValidationCallback remoteCerificateValidationCallback)
{
if (Logging.IsEnabled)
{
Logging.Enter(this, $"{nameof(AmqpClientConnection)}.{nameof(OpenAsync)}");
}
var 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,
};
TransportBase transport;
if (useWebSocket)
{
transport = await CreateClientWebSocketTransportAsync(timeout, proxy).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);
ByteBuffer 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.ToString()} operationPending: {operationPending} completedSynchronously: {args.CompletedSynchronously}");
}
if (!operationPending)
{
args.CompletedCallback(args);
}
transport = await _tcs.Task.ConfigureAwait(false);
await transport.OpenAsync(timeout).ConfigureAwait(false);
}
}
else
{
var tcpInitiator = new AmqpTransportInitiator(_amqpSettings, TransportSettings);
transport = await tcpInitiator.ConnectTaskAsync(timeout).ConfigureAwait(false);
}
AmqpConnection = new AmqpConnection(transport, _amqpSettings, AmqpConnectionSettings);
AmqpConnection.Closed += OnConnectionClosed;
await AmqpConnection.OpenAsync(timeout).ConfigureAwait(false);
_isConnectionClosed = false;
}
/// <summary>
/// Performs the tasks needed to build and open a connection to the IoT Hub
/// service.
/// </summary>
/// <param name="serviceEndpoint">The endpoint of the IoT Hub service to connect to.</param>
/// <param name="iotHubName">The name of the IoT Hub to connect to.</param>
/// <param name="sharedAccessKeyName">The name of the shared access key being used for authentication.</param>
/// <param name="sharedAccessKey">The shared access key being used for authentication.</param>
/// <param name="timeout">The maximum amount of time that establishing the connection should be allowed to take.</param>
/// <returns>An <see cref="AmqpConnection" /> to the requested IoT Hub.</returns>
/// <seealso href="https://docs.microsoft.com/en-us/azure/iot-hub/iot-hub-amqp-support"/>
private static async Task <AmqpConnection> CreateAndOpenConnectionAsync(
Uri serviceEndpoint,
string iotHubName,
string sharedAccessKeyName,
string sharedAccessKey,
TimeSpan timeout)
{
var hostName = serviceEndpoint.Host;
var userName = $"{ sharedAccessKeyName }@sas.root.{ iotHubName }";
var signature = BuildSignature($"{ hostName }{ serviceEndpoint.AbsolutePath }", sharedAccessKeyName, sharedAccessKey, TimeSpan.FromMinutes(5));
var port = 5671;
// Create the layers of settings needed to establish the connection.
var amqpVersion = new Version(1, 0, 0, 0);
var tcpSettings = new TcpTransportSettings
{
Host = hostName,
Port = port,
ReceiveBufferSize = AmqpConstants.TransportBufferSize,
SendBufferSize = AmqpConstants.TransportBufferSize
};
var transportSettings = new TlsTransportSettings(tcpSettings)
{
TargetHost = hostName,
};
var connectionSettings = new AmqpConnectionSettings
{
IdleTimeOut = (uint)TimeSpan.FromMinutes(1).TotalMilliseconds,
MaxFrameSize = AmqpConstants.DefaultMaxFrameSize,
ContainerId = Guid.NewGuid().ToString(),
HostName = hostName
};
var saslProvider = new SaslTransportProvider();
saslProvider.Versions.Add(new AmqpVersion(amqpVersion));
saslProvider.AddHandler(new SaslPlainHandler {
AuthenticationIdentity = userName, Password = signature
});
var amqpProvider = new AmqpTransportProvider();
amqpProvider.Versions.Add(new AmqpVersion(amqpVersion));
var amqpSettings = new AmqpSettings();
amqpSettings.TransportProviders.Add(saslProvider);
amqpSettings.TransportProviders.Add(amqpProvider);
// Create and open the connection, respecting the timeout constraint
// that was received.
var stopWatch = Stopwatch.StartNew();
var initiator = new AmqpTransportInitiator(amqpSettings, transportSettings);
var transport = await initiator.ConnectTaskAsync(timeout).ConfigureAwait(false);
try
{
var connection = new AmqpConnection(transport, amqpSettings, connectionSettings);
await connection.OpenAsync(timeout.Subtract(stopWatch.Elapsed)).ConfigureAwait(false);
return(connection);
}
catch
{
transport.Abort();
throw;
}
finally
{
stopWatch.Stop();
}
}
public TestAmqpBroker(IList <string> endpoints, string userInfo, string sslValue, string[] queues)
{
this.containerId = "TestAmqpBroker-P" + Process.GetCurrentProcess().Id;
this.maxFrameSize = 64 * 1024;
this.txnManager = new TxnManager();
this.connections = new Dictionary <SequenceNumber, AmqpConnection>();
this.queues = new Dictionary <string, TestQueue>();
if (queues != null)
{
foreach (string q in queues)
{
this.queues.Add(q, new TestQueue(this));
}
}
else
{
this.implicitQueue = true;
}
// create and initialize AmqpSettings
AmqpSettings settings = new AmqpSettings();
X509Certificate2 certificate = sslValue == null ? null : GetCertificate(sslValue);
settings.RuntimeProvider = this;
SaslHandler saslHandler;
if (userInfo != null)
{
string[] creds = userInfo.Split(':');
string usernanme = Uri.UnescapeDataString(creds[0]);
string password = creds.Length == 1 ? string.Empty : Uri.UnescapeDataString(creds[1]);
saslHandler = new SaslPlainHandler(new TestPlainAuthenticator(userInfo, password));
}
else
{
saslHandler = new SaslAnonymousHandler();
}
SaslTransportProvider saslProvider = new SaslTransportProvider();
saslProvider.AddHandler(saslHandler);
saslProvider.Versions.Add(new AmqpVersion(1, 0, 0));
settings.TransportProviders.Add(saslProvider);
AmqpTransportProvider amqpProvider = new AmqpTransportProvider();
amqpProvider.Versions.Add(new AmqpVersion(1, 0, 0));
settings.TransportProviders.Add(amqpProvider);
// create and initialize transport listeners
TransportListener[] listeners = new TransportListener[endpoints.Count];
for (int i = 0; i < endpoints.Count; i++)
{
Uri addressUri = new Uri(endpoints[i]);
if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqps, StringComparison.OrdinalIgnoreCase))
{
if (certificate == null)
{
throw new InvalidOperationException("/cert option was not set when amqps address is specified.");
}
TcpTransportSettings tcpSettings = new TcpTransportSettings()
{
Host = addressUri.Host, Port = addressUri.Port
};
TlsTransportSettings tlsSettings = new TlsTransportSettings(tcpSettings)
{
Certificate = certificate, IsInitiator = false
};
listeners[i] = tlsSettings.CreateListener();
}
else if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqp, StringComparison.OrdinalIgnoreCase))
{
TcpTransportSettings tcpSettings = new TcpTransportSettings()
{
Host = addressUri.Host, Port = addressUri.Port
};
listeners[i] = tcpSettings.CreateListener();
}
#if !NETSTANDARD
else if (addressUri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase))
{
WebSocketTransportSettings wsSettings = new WebSocketTransportSettings()
{
Uri = addressUri
};
listeners[i] = wsSettings.CreateListener();
}
#endif
else
{
throw new NotSupportedException(addressUri.Scheme);
}
}
this.transportListener = new AmqpTransportListener(listeners, settings);
this.settings = settings;
}
public async Task <AmqpConnection> OpenConnectionAsync(Uri addressUri, SaslHandler saslHandler, TimeSpan timeout)
{
TransportSettings transportSettings;
if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqp, StringComparison.OrdinalIgnoreCase))
{
transportSettings = new TcpTransportSettings()
{
Host = addressUri.Host,
Port = addressUri.Port > -1 ? addressUri.Port : AmqpConstants.DefaultPort
};
}
else if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqps, StringComparison.OrdinalIgnoreCase))
{
TcpTransportSettings tcpSettings = new TcpTransportSettings()
{
Host = addressUri.Host,
Port = addressUri.Port > -1 ? addressUri.Port : AmqpConstants.DefaultSecurePort
};
transportSettings = new TlsTransportSettings(tcpSettings)
{
TargetHost = addressUri.Host
};
}
#if NET45
else if (addressUri.Scheme.Equals(WebSocketTransport.WebSockets, StringComparison.OrdinalIgnoreCase) ||
addressUri.Scheme.Equals(WebSocketTransport.SecureWebSockets, StringComparison.OrdinalIgnoreCase))
{
transportSettings = new WebSocketTransportSettings()
{
Uri = addressUri
};
}
#endif
else
{
throw new NotSupportedException(addressUri.Scheme);
}
AmqpSettings settings = new AmqpSettings();
if (saslHandler != null)
{
// Provider for "AMQP3100"
SaslTransportProvider saslProvider = new SaslTransportProvider();
saslProvider.Versions.Add(new AmqpVersion(1, 0, 0));
saslProvider.AddHandler(saslHandler);
settings.TransportProviders.Add(saslProvider);
}
// Provider for "AMQP0100"
AmqpTransportProvider amqpProvider = new AmqpTransportProvider();
amqpProvider.Versions.Add(new AmqpVersion(new Version(1, 0, 0, 0)));
settings.TransportProviders.Add(amqpProvider);
AmqpTransportInitiator initiator = new AmqpTransportInitiator(settings, transportSettings);
TransportBase transport = await Task.Factory.FromAsync(
(c, s) => initiator.BeginConnect(timeout, c, s),
(r) => initiator.EndConnect(r),
null);
try
{
AmqpConnectionSettings connectionSettings = new AmqpConnectionSettings()
{
ContainerId = Guid.NewGuid().ToString(),
HostName = addressUri.Host
};
AmqpConnection connection = new AmqpConnection(transport, settings, connectionSettings);
await connection.OpenAsync(timeout);
return(connection);
}
catch
{
transport.Abort();
throw;
}
}
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 static AmqpTransportListener CreateListener(string host, int port, string certFindValue, bool doSslUpgrade, SaslHandler saslHandler)
{
AmqpSettings settings = GetAmqpSettings(false, certFindValue, doSslUpgrade, saslHandler);
TransportSettings transportSettings = GetTcpSettings(host, port, true);
if (!doSslUpgrade && certFindValue != null)
{
TlsTransportSettings tlsSettings = new TlsTransportSettings(transportSettings, false);
tlsSettings.Certificate = GetCertificate(certFindValue);
transportSettings = tlsSettings;
}
TransportListener listener = transportSettings.CreateListener();
return new AmqpTransportListener(new TransportListener[] { listener }, settings);
}
protected override TlsTransport OnCreateTransport(TransportBase innerTransport, TlsTransportSettings tlsTransportSettings) => new EdgeTlsTransport(innerTransport, tlsTransportSettings, this.authenticator, this.clientCredentialsProvider);
protected virtual async Task <AmqpSession> CreateSessionAsync(TimeSpan timeout)
{
this.OnCreateSession();
var timeoutHelper = new TimeoutHelper(timeout);
AmqpSettings amqpSettings = CreateAmqpSettings();
TransportBase transport;
switch (this.AmqpTransportSettings.GetTransportType())
{
#if !WINDOWS_UWP
case TransportType.Amqp_WebSocket_Only:
transport = await this.CreateClientWebSocketTransportAsync(timeoutHelper.RemainingTime());
break;
#endif
case TransportType.Amqp_Tcp_Only:
TlsTransportSettings tlsTransportSettings = this.CreateTlsTransportSettings();
var amqpTransportInitiator = new AmqpTransportInitiator(amqpSettings, tlsTransportSettings);
transport = await amqpTransportInitiator.ConnectTaskAsync(timeoutHelper.RemainingTime());
break;
default:
throw new InvalidOperationException("AmqpTransportSettings must specify WebSocketOnly or TcpOnly");
}
var amqpConnectionSettings = new AmqpConnectionSettings()
{
MaxFrameSize = AmqpConstants.DefaultMaxFrameSize,
ContainerId = Guid.NewGuid().ToString("N"),
HostName = this.hostName
};
var amqpConnection = new AmqpConnection(transport, amqpSettings, amqpConnectionSettings);
try
{
await amqpConnection.OpenAsync(timeoutHelper.RemainingTime());
var sessionSettings = new AmqpSessionSettings()
{
Properties = new Fields()
};
AmqpSession amqpSession = amqpConnection.CreateSession(sessionSettings);
await amqpSession.OpenAsync(timeoutHelper.RemainingTime());
// This adds itself to amqpConnection.Extensions
var cbsLink = new AmqpCbsLink(amqpConnection);
return(amqpSession);
}
catch (Exception ex) when(!ex.IsFatal())
{
if (amqpConnection.TerminalException != null)
{
throw AmqpClientHelper.ToIotHubClientContract(amqpConnection.TerminalException);
}
amqpConnection.SafeClose(ex);
throw;
}
}
protected virtual async Task <AmqpSession> CreateSessionAsync(TimeSpan timeout, CancellationToken token)
{
try
{
if (Logging.IsEnabled)
{
Logging.Enter(this, timeout, token, $"{nameof(IotHubConnection)}.{nameof(CreateSessionAsync)}");
}
this.OnCreateSession();
var timeoutHelper = new TimeoutHelper(timeout);
AmqpSettings amqpSettings = CreateAmqpSettings();
TransportBase transport;
token.ThrowIfCancellationRequested();
switch (this.AmqpTransportSettings.GetTransportType())
{
case TransportType.Amqp_WebSocket_Only:
transport = await this.CreateClientWebSocketTransportAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
break;
case TransportType.Amqp_Tcp_Only:
TlsTransportSettings tlsTransportSettings = this.CreateTlsTransportSettings();
var amqpTransportInitiator = new AmqpTransportInitiator(amqpSettings, tlsTransportSettings);
transport = await amqpTransportInitiator.ConnectTaskAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
break;
default:
throw new InvalidOperationException("AmqpTransportSettings must specify WebSocketOnly or TcpOnly");
}
var amqpConnectionSettings = new AmqpConnectionSettings()
{
MaxFrameSize = AmqpConstants.DefaultMaxFrameSize,
ContainerId = Guid.NewGuid().ToString("N"),
HostName = this.hostName
};
var amqpConnection = new AmqpConnection(transport, amqpSettings, amqpConnectionSettings);
try
{
token.ThrowIfCancellationRequested();
await amqpConnection.OpenAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
var sessionSettings = new AmqpSessionSettings()
{
Properties = new Fields()
};
AmqpSession amqpSession = amqpConnection.CreateSession(sessionSettings);
token.ThrowIfCancellationRequested();
await amqpSession.OpenAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
// This adds itself to amqpConnection.Extensions
var cbsLink = new AmqpCbsLink(amqpConnection);
return(amqpSession);
}
catch (Exception ex) when(!ex.IsFatal())
{
if (amqpConnection.TerminalException != null)
{
throw AmqpClientHelper.ToIotHubClientContract(amqpConnection.TerminalException);
}
amqpConnection.SafeClose(ex);
throw;
}
}
finally
{
if (Logging.IsEnabled)
{
Logging.Exit(this, timeout, token, $"{nameof(IotHubConnection)}.{nameof(CreateSessionAsync)}");
}
}
}
private async Task <AmqpSession> CreateSessionAsync(TimeSpan timeout)
{
var timeoutHelper = new TimeoutHelper(timeout);
_refreshTokenTimer.Cancel();
AmqpSettings amqpSettings = CreateAmqpSettings();
TransportBase transport;
if (_useWebSocketOnly)
{
// Try only Amqp transport over WebSocket
transport = await CreateClientWebSocketTransport(timeoutHelper.RemainingTime()).ConfigureAwait(false);
}
else
{
TlsTransportSettings tlsTransportSettings = CreateTlsTransportSettings();
var amqpTransportInitiator = new AmqpTransportInitiator(amqpSettings, tlsTransportSettings);
try
{
transport = await amqpTransportInitiator.ConnectTaskAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
}
#if !NETSTANDARD1_3
catch (AuthenticationException)
{
throw;
}
#endif
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
// Amqp transport over TCP failed. Retry Amqp transport over WebSocket
if (timeoutHelper.RemainingTime() != TimeSpan.Zero)
{
transport = await CreateClientWebSocketTransport(timeoutHelper.RemainingTime()).ConfigureAwait(false);
}
else
{
throw;
}
}
}
var amqpConnectionSettings = new AmqpConnectionSettings
{
MaxFrameSize = AmqpConstants.DefaultMaxFrameSize,
ContainerId = Guid.NewGuid()
#if NETSTANDARD1_3
.ToString("N"),
#else
.ToString("N", CultureInfo.InvariantCulture), // Use a human readable link name to help with debugging
#endif
HostName = ConnectionString.AmqpEndpoint.Host,
};
var amqpConnection = new AmqpConnection(transport, amqpSettings, amqpConnectionSettings);
await amqpConnection.OpenAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
var sessionSettings = new AmqpSessionSettings
{
Properties = new Fields(),
};
try
{
AmqpSession amqpSession = amqpConnection.CreateSession(sessionSettings);
await amqpSession.OpenAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
// This adds itself to amqpConnection.Extensions
var cbsLink = new AmqpCbsLink(amqpConnection);
await SendCbsTokenAsync(cbsLink, timeoutHelper.RemainingTime()).ConfigureAwait(false);
return(amqpSession);
}
catch (Exception ex) when(!ex.IsFatal())
{
if (amqpConnection.TerminalException != null)
{
throw AmqpClientHelper.ToIotHubClientContract(amqpConnection.TerminalException);
}
amqpConnection.SafeClose(ex);
throw;
}
}
protected override IEnumerator <IteratorTask <object> .TaskStep> GetTasks()
{
ConnectivityMode connectivityMode;
object obj = null;
bool flag = false;
try
{
object thisLock = this.relay.ThisLock;
object obj1 = thisLock;
obj = thisLock;
Monitor.Enter(obj1, ref flag);
if (this.relay.State != AmqpObjectState.OpenReceived && this.relay.State != AmqpObjectState.Opened)
{
goto Label0;
}
}
finally
{
if (flag)
{
Monitor.Exit(obj);
}
}
Microsoft.ServiceBus.Common.TimeoutHelper timeoutHelper = new Microsoft.ServiceBus.Common.TimeoutHelper(this.timeout);
string host = this.relay.serviceBusUri.Host;
AmqpSettings amqpSetting = AmqpRelay.ConnectTask.CreateAmqpSettings();
connectivityMode = (this.relay.connectivitySettings != null ? this.relay.connectivitySettings.Mode : ServiceBusEnvironment.SystemConnectivity.Mode);
ConnectivityMode connectivityMode1 = connectivityMode;
if (connectivityMode1 == ConnectivityMode.Tcp)
{
TcpTransportSettings tcpTransportSetting = new TcpTransportSettings()
{
Host = host,
Port = 5671
};
TlsTransportSettings tlsTransportSetting = new TlsTransportSettings(tcpTransportSetting)
{
TargetHost = host
};
AmqpTransportInitiator amqpTransportInitiator = new AmqpTransportInitiator(amqpSetting, tlsTransportSetting);
yield return(base.CallTask(amqpTransportInitiator.ConnectTaskAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
}
else if (connectivityMode1 == ConnectivityMode.Http || this.relay.httpConnectivitySettings != null)
{
WebSocketTransportSettings webSocketTransportSetting = new WebSocketTransportSettings(this.relay.serviceBusUri);
AmqpTransportInitiator amqpTransportInitiator1 = new AmqpTransportInitiator(amqpSetting, webSocketTransportSetting);
yield return(base.CallTask(amqpTransportInitiator1.ConnectTaskAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
}
else
{
TcpTransportSettings tcpTransportSetting1 = new TcpTransportSettings()
{
Host = host,
Port = 5671
};
TlsTransportSettings tlsTransportSetting1 = new TlsTransportSettings(tcpTransportSetting1)
{
TargetHost = host
};
AmqpTransportInitiator amqpTransportInitiator2 = new AmqpTransportInitiator(amqpSetting, tlsTransportSetting1);
yield return(base.CallTask(amqpTransportInitiator2.ConnectTaskAsync(Microsoft.ServiceBus.Common.TimeoutHelper.Divide(timeoutHelper.RemainingTime(), 2)), IteratorTask <TResult> .ExceptionPolicy.Continue));
if (base.LastTask.Exception != null)
{
if (timeoutHelper.RemainingTime() == TimeSpan.Zero)
{
throw base.LastTask.Exception;
}
WebSocketTransportSettings webSocketTransportSetting1 = new WebSocketTransportSettings(this.relay.serviceBusUri);
AmqpTransportInitiator amqpTransportInitiator3 = new AmqpTransportInitiator(amqpSetting, webSocketTransportSetting1);
yield return(base.CallTask(amqpTransportInitiator3.ConnectTaskAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
}
}
TransportBase transportBase = base.LastTaskResult <TransportBase>();
string[] strArrays = host.Split(new char[] { '.' });
strArrays[0] = string.Concat(strArrays[0], "-relay");
AmqpConnectionSettings amqpConnectionSetting = new AmqpConnectionSettings()
{
ContainerId = Guid.NewGuid().ToString(),
HostName = string.Join(".", strArrays)
};
this.relay.connection = new AmqpConnection(transportBase, amqpSetting, amqpConnectionSetting);
yield return(base.CallTask(this.relay.connection.OpenAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
AmqpSessionSettings amqpSessionSetting = new AmqpSessionSettings();
AmqpSession amqpSession = this.relay.connection.CreateSession(amqpSessionSetting);
yield return(base.CallTask(amqpSession.OpenAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
AmqpLinkSettings amqpLinkSetting = new AmqpLinkSettings()
{
Role = new bool?(false),
InitialDeliveryCount = new uint?(0),
LinkName = string.Concat("HttpRelayServer_Link_", Guid.NewGuid()),
Target = new Target(this.relay.serviceBusUri),
Source = new Source(this.relay.serviceBusUri),
TotalLinkCredit = 1000,
AutoSendFlow = true
};
AmqpLinkSettings amqpLinkSetting1 = amqpLinkSetting;
if (this.relay.tokenRenewer != null)
{
amqpLinkSetting1.AddProperty(AmqpConstants.SimpleWebTokenPropertyName, this.relay.tokenRenewer.CurrentToken.Token);
}
if (!this.relay.TransportSecurityRequired)
{
amqpLinkSetting1.AddProperty(ClientConstants.TransportSecurityRequiredName, false);
}
if (!this.relay.RelayClientAuthorizationRequired)
{
amqpLinkSetting1.AddProperty(ClientConstants.ClientAuthenticationRequiredName, false);
}
if (this.relay.PublishToRegistry)
{
amqpLinkSetting1.AddProperty(ClientConstants.RequiresPublicRegistry, true);
}
if (!string.IsNullOrEmpty(this.relay.ClientAgent))
{
amqpLinkSetting1.AddProperty(ClientConstants.ClientAgent, this.relay.ClientAgent);
}
if (!string.IsNullOrEmpty(this.relay.DisplayName))
{
amqpLinkSetting1.AddProperty(ClientConstants.DisplayName, this.relay.DisplayName);
}
amqpLinkSetting1.AddProperty(ClientConstants.DynamicRelay, this.relay.IsDynamic);
amqpLinkSetting1.AddProperty(ClientConstants.ListenerTypeName, this.relay.ListenerType.ToString());
this.relay.link = new DuplexAmqpLink(amqpSession, amqpLinkSetting1);
yield return(base.CallTask(this.relay.link.OpenAsync(timeoutHelper.RemainingTime()), IteratorTask <TResult> .ExceptionPolicy.Transfer));
this.relay.link.SafeAddClosed(this.relay.onAmqpObjectClosed);
this.relay.link.RegisterMessageListener((AmqpMessage msg) => this.relay.messageListener(this.relay.link, msg));
this.relay.OnOnline();
Label0:
yield break;
}
private async Task <AmqpSession> CreateSessionAsync(TimeSpan timeout)
{
Logging.Enter(this, timeout, nameof(CreateSessionAsync));
TransportBase transport = null;
try
{
var timeoutHelper = new TimeoutHelper(timeout);
_refreshTokenTimer.Cancel();
AmqpSettings amqpSettings = CreateAmqpSettings();
if (_useWebSocketOnly)
{
// Try only AMQP transport over WebSocket
transport = _clientWebSocketTransport = (ClientWebSocketTransport) await CreateClientWebSocketTransportAsync(timeoutHelper.RemainingTime())
.ConfigureAwait(false);
}
else
{
TlsTransportSettings tlsTransportSettings = CreateTlsTransportSettings();
var amqpTransportInitiator = new AmqpTransportInitiator(amqpSettings, tlsTransportSettings);
try
{
transport = await amqpTransportInitiator.ConnectTaskAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
}
catch (Exception e) when(!(e is AuthenticationException))
{
Logging.Error(this, e, nameof(CreateSessionAsync));
if (Fx.IsFatal(e))
{
throw;
}
// AMQP transport over TCP failed. Retry AMQP transport over WebSocket
if (timeoutHelper.RemainingTime() != TimeSpan.Zero)
{
transport = _clientWebSocketTransport = (ClientWebSocketTransport) await CreateClientWebSocketTransportAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
}
else
{
throw;
}
}
}
Logging.Info(this, $"Initialized {nameof(TransportBase)}, ws={_useWebSocketOnly}");
var amqpConnectionSettings = new AmqpConnectionSettings
{
MaxFrameSize = AmqpConstants.DefaultMaxFrameSize,
ContainerId = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture), // Use a human readable link name to help with debugging
HostName = ConnectionString.AmqpEndpoint.Host,
};
var amqpConnection = new AmqpConnection(transport, amqpSettings, amqpConnectionSettings);
await amqpConnection.OpenAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
Logging.Info(this, $"{nameof(AmqpConnection)} opened.");
var sessionSettings = new AmqpSessionSettings
{
Properties = new Fields(),
};
try
{
AmqpSession amqpSession = amqpConnection.CreateSession(sessionSettings);
await amqpSession.OpenAsync(timeoutHelper.RemainingTime()).ConfigureAwait(false);
Logging.Info(this, $"{nameof(AmqpSession)} opened.");
// This adds itself to amqpConnection.Extensions
var cbsLink = new AmqpCbsLink(amqpConnection);
await SendCbsTokenAsync(cbsLink, timeoutHelper.RemainingTime()).ConfigureAwait(false);
return(amqpSession);
}
catch (Exception ex) when(!ex.IsFatal())
{
Logging.Error(this, ex, nameof(CreateSessionAsync));
_clientWebSocketTransport?.Dispose();
_clientWebSocketTransport = null;
if (amqpConnection.TerminalException != null)
{
throw AmqpClientHelper.ToIotHubClientContract(amqpConnection.TerminalException);
}
amqpConnection.SafeClose(ex);
throw;
}
}
finally
{
Logging.Exit(this, timeout, nameof(CreateSessionAsync));
}
}
public void Start()
{
// create and initialize AmqpSettings
AmqpSettings settings = new AmqpSettings();
X509Certificate2 certificate = this.sslValue == null ? null : GetCertificate(this.sslValue);
settings.RuntimeProvider = this;
SaslHandler saslHandler;
if (this.userInfo != null)
{
string[] creds = this.userInfo.Split(':');
string usernanme = Uri.UnescapeDataString(creds[0]);
string password = creds.Length == 1 ? string.Empty : Uri.UnescapeDataString(creds[1]);
saslHandler = new SaslPlainHandler(new TestPlainAuthenticator(this.userInfo, password));
}
else
{
saslHandler = new SaslAnonymousHandler();
}
SaslTransportProvider saslProvider = new SaslTransportProvider(AmqpVersion.V100);
saslProvider.AddHandler(saslHandler);
settings.TransportProviders.Add(saslProvider);
AmqpTransportProvider amqpProvider = new AmqpTransportProvider(AmqpVersion.V100);
settings.TransportProviders.Add(amqpProvider);
// create and initialize transport listeners
TransportListener[] listeners = new TransportListener[this.endpoints.Count];
for (int i = 0; i < this.endpoints.Count; i++)
{
Uri addressUri = new Uri(this.endpoints[i]);
if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqps, StringComparison.OrdinalIgnoreCase))
{
if (certificate == null)
{
throw new InvalidOperationException("/cert option was not set when amqps address is specified.");
}
TcpTransportSettings tcpSettings = new TcpTransportSettings()
{
Host = addressUri.Host, Port = addressUri.Port
};
TlsTransportSettings tlsSettings = new TlsTransportSettings(tcpSettings)
{
Certificate = certificate, IsInitiator = false
};
listeners[i] = tlsSettings.CreateListener();
}
else if (addressUri.Scheme.Equals(AmqpConstants.SchemeAmqp, StringComparison.OrdinalIgnoreCase))
{
TcpTransportSettings tcpSettings = new TcpTransportSettings()
{
Host = addressUri.Host, Port = addressUri.Port
};
listeners[i] = tcpSettings.CreateListener();
}
else if (addressUri.Scheme.Equals("ws", StringComparison.OrdinalIgnoreCase))
{
WebSocketTransportSettings wsSettings = new WebSocketTransportSettings()
{
Uri = addressUri
};
listeners[i] = wsSettings.CreateListener();
}
else
{
throw new NotSupportedException(addressUri.Scheme);
}
}
this.settings = settings;
this.transportListener = new AmqpTransportListener(listeners, settings);
this.transportListener.Listen(this.OnAcceptTransport);
}
