public async void TestStartAsyncDoesNotThrowIfCreateConnectionThrows()
{
AmqpSettings amqpSettings = AmqpSettingsProvider.GetDefaultAmqpSettings(IotHubHostName, Mock.Of <IAuthenticator>(), Mock.Of <IClientCredentialsFactory>(), Mock.Of <ILinkHandlerProvider>(), Mock.Of <IConnectionProvider>(), new NullCredentialsCache());
var runtimeProvider = new Mock <IRuntimeProvider>();
amqpSettings.RuntimeProvider = runtimeProvider.Object;
runtimeProvider.Setup(rp => rp.CreateConnection(It.IsAny <TransportBase>(), It.IsAny <ProtocolHeader>(), false, It.IsAny <AmqpSettings>(), It.IsAny <AmqpConnectionSettings>()))
.Throws(new ApplicationException("No donuts"));
var tcpTransportListener = new Mock <TransportListener>("TCP");
var amqpTransportSettings = new Mock <TransportSettings>();
amqpTransportSettings.Setup(ts => ts.CreateListener()).Returns(tcpTransportListener.Object);
var transportSettings = new Mock <ITransportSettings>();
transportSettings.SetupGet(sp => sp.Settings).Returns(amqpTransportSettings.Object);
var amqpTransportListener = new TestHelperTransportListener(
"AMQP",
new TransportAsyncCallbackArgs()
{
CompletedSynchronously = false
});
var transportListenerProvider = new Mock <ITransportListenerProvider>();
transportListenerProvider.Setup(tlp => tlp.Create(
It.Is <IEnumerable <TransportListener> >(listeners => listeners.Contains(tcpTransportListener.Object)),
amqpSettings
)).Returns(amqpTransportListener);
var protocolHead = new AmqpProtocolHead(transportSettings.Object, amqpSettings, transportListenerProvider.Object, Mock.Of <IWebSocketListenerRegistry>(), Mock.Of <IAuthenticator>(), Mock.Of <IClientCredentialsFactory>());
await protocolHead.StartAsync();
}
public async void TestStartAsyncThrowsIfTransportListenerCallbackArgsHasException()
{
AmqpSettings amqpSettings = AmqpSettingsProvider.GetDefaultAmqpSettings(IotHubHostName, Mock.Of <IAuthenticator>(), Mock.Of <IClientCredentialsFactory>(), Mock.Of <ILinkHandlerProvider>(), Mock.Of <IConnectionProvider>(), new NullCredentialsCache());
var tcpTransportListener = new Mock <TransportListener>("TCP");
var amqpTransportSettings = new Mock <TransportSettings>();
amqpTransportSettings.Setup(ts => ts.CreateListener()).Returns(tcpTransportListener.Object);
var transportSettings = new Mock <ITransportSettings>();
transportSettings.SetupGet(sp => sp.Settings).Returns(amqpTransportSettings.Object);
var amqpTransportListener = new TestHelperTransportListener(
"AMQP",
new TransportAsyncCallbackArgs()
{
Exception = new ApplicationException("No donuts"),
CompletedSynchronously = false
});
var transportListenerProvider = new Mock <ITransportListenerProvider>();
transportListenerProvider.Setup(tlp => tlp.Create(
It.Is <IEnumerable <TransportListener> >(listeners => listeners.Contains(tcpTransportListener.Object)),
amqpSettings
)).Returns(amqpTransportListener);
var protocolHead = new AmqpProtocolHead(transportSettings.Object, amqpSettings, transportListenerProvider.Object, Mock.Of <IWebSocketListenerRegistry>(), Mock.Of <IAuthenticator>(), Mock.Of <IClientCredentialsFactory>());
await Assert.ThrowsAsync <ApplicationException>(() => protocolHead.StartAsync());
}
public async void TestStartAsyncDoesNotThrowIfConnectionOpenAsyncThrows()
{
AmqpSettings amqpSettings = AmqpSettingsProvider.GetDefaultAmqpSettings(IotHubHostName, Mock.Of <IAuthenticator>(), Mock.Of <IClientCredentialsFactory>(), Mock.Of <ILinkHandlerProvider>(), Mock.Of <IConnectionProvider>(), new NullCredentialsCache());
var runtimeProvider = new Mock <IRuntimeProvider>();
amqpSettings.RuntimeProvider = runtimeProvider.Object;
var tcpTransport = new Mock <TransportBase>("TCP");
TestHelperAmqpConnection amqpConnection = null;
runtimeProvider.Setup(rp => rp.CreateConnection(tcpTransport.Object, It.IsAny <ProtocolHeader>(), false, It.IsAny <AmqpSettings>(), It.IsAny <AmqpConnectionSettings>()))
.Callback(
(
TransportBase transport,
ProtocolHeader protocolHeader,
bool isInitiator,
AmqpSettings settings,
AmqpConnectionSettings connectionSettings) =>
{
amqpConnection = new TestHelperAmqpConnection(transport, protocolHeader, isInitiator, settings, connectionSettings);
amqpConnection.OnOpenInternal = () => throw new OperationCanceledException("No donuts for you");
})
.Returns(() => amqpConnection);
var tcpTransportListener = new Mock <TransportListener>("TCP");
var amqpTransportSettings = new Mock <TransportSettings>();
amqpTransportSettings.Setup(ts => ts.CreateListener()).Returns(tcpTransportListener.Object);
var transportSettings = new Mock <ITransportSettings>();
transportSettings.SetupGet(sp => sp.Settings).Returns(amqpTransportSettings.Object);
var amqpTransportListener = new TestHelperTransportListener(
"AMQP",
new TransportAsyncCallbackArgs()
{
CompletedSynchronously = false,
Transport = tcpTransport.Object
});
var transportListenerProvider = new Mock <ITransportListenerProvider>();
transportListenerProvider.Setup(
tlp => tlp.Create(
It.Is <IEnumerable <TransportListener> >(listeners => listeners.Contains(tcpTransportListener.Object)),
amqpSettings)).Returns(amqpTransportListener);
var protocolHead = new AmqpProtocolHead(transportSettings.Object, amqpSettings, transportListenerProvider.Object, Mock.Of <IWebSocketListenerRegistry>(), Mock.Of <IAuthenticator>(), Mock.Of <IClientCredentialsFactory>());
await protocolHead.StartAsync();
// check if close on the connection was called
Assert.NotNull(amqpConnection);
Assert.True(amqpConnection.WasClosed);
}
async Task StartProtocolHead()
{
string certificateValue = await SecretsHelper.GetSecret("IotHubMqttHeadCert");
byte[] cert = Convert.FromBase64String(certificateValue);
var certificate = new X509Certificate2(cert);
// TODO for now this is empty as will suffice for SAS X.509 thumbprint auth but we will need other CA certs for X.509 CA validation
var trustBundle = new List <X509Certificate2>();
string edgeDeviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("edgeCapableDeviceConnStrKey");
// TODO - After IoTHub supports MQTT, remove this and move to using MQTT for upstream connections
await ConnectToIotHub(edgeDeviceConnectionString);
ConfigHelper.TestConfig[EdgeHubConstants.ConfigKey.IotHubConnectionString] = edgeDeviceConnectionString;
IDependencyManager dependencyManager = new DependencyManager(ConfigHelper.TestConfig, certificate, trustBundle, this.sslProtocols);
Hosting hosting = Hosting.Initialize(ConfigHelper.TestConfig, certificate, dependencyManager, true, this.sslProtocols);
this.hosting = hosting;
IContainer container = hosting.Container;
// CloudConnectionProvider and RoutingEdgeHub have a circular dependency. So set the
// EdgeHub on the CloudConnectionProvider before any other operation
ICloudConnectionProvider cloudConnectionProvider = await container.Resolve <Task <ICloudConnectionProvider> >();
IEdgeHub edgeHub = await container.Resolve <Task <IEdgeHub> >();
cloudConnectionProvider.BindEdgeHub(edgeHub);
IConfigSource configSource = await container.Resolve <Task <IConfigSource> >();
ConfigUpdater configUpdater = await container.Resolve <Task <ConfigUpdater> >();
await configUpdater.Init(configSource);
ILogger logger = container.Resolve <ILoggerFactory>().CreateLogger("EdgeHub");
MqttProtocolHead mqttProtocolHead = await container.Resolve <Task <MqttProtocolHead> >();
AmqpProtocolHead amqpProtocolHead = await container.Resolve <Task <AmqpProtocolHead> >();
var httpProtocolHead = new HttpProtocolHead(hosting.WebHost);
this.protocolHead = new EdgeHubProtocolHead(new List <IProtocolHead> {
mqttProtocolHead, amqpProtocolHead, httpProtocolHead
}, logger);
await this.protocolHead.StartAsync();
}
public async void TestStartAsyncThrowsIfCreateListenerThrows()
{
AmqpSettings amqpSettings = AmqpSettingsProvider.GetDefaultAmqpSettings(IotHubHostName, Mock.Of <IAuthenticator>(), Mock.Of <IClientCredentialsFactory>(), Mock.Of <ILinkHandlerProvider>(), Mock.Of <IConnectionProvider>(), new NullCredentialsCache());
var amqpTransportSettings = new Mock <TransportSettings>();
amqpTransportSettings.Setup(ts => ts.CreateListener()).Throws(new ApplicationException("No donuts for you"));
var transportSettings = new Mock <ITransportSettings>();
transportSettings.SetupGet(sp => sp.Settings).Returns(amqpTransportSettings.Object);
var protocolHead = new AmqpProtocolHead(transportSettings.Object, amqpSettings, Mock.Of <ITransportListenerProvider>(), Mock.Of <IWebSocketListenerRegistry>(), Mock.Of <IAuthenticator>(), Mock.Of <IClientCredentialsFactory>());
await Assert.ThrowsAsync <ApplicationException>(() => protocolHead.StartAsync());
}
public async void TestStartAsyncThrowsIfOpenAsyncOrListenThrows(TransportListener amqpTransportListener)
{
AmqpSettings amqpSettings = AmqpSettingsProvider.GetDefaultAmqpSettings(IotHubHostName, Mock.Of <IAuthenticator>(), Mock.Of <IClientCredentialsFactory>(), Mock.Of <ILinkHandlerProvider>(), Mock.Of <IConnectionProvider>(), new NullCredentialsCache());
var tcpTransportListener = new Mock <TransportListener>("TCP");
var amqpTransportSettings = new Mock <TransportSettings>();
amqpTransportSettings.Setup(ts => ts.CreateListener()).Returns(tcpTransportListener.Object);
var transportSettings = new Mock <ITransportSettings>();
transportSettings.SetupGet(sp => sp.Settings).Returns(amqpTransportSettings.Object);
var transportListenerProvider = new Mock <ITransportListenerProvider>();
transportListenerProvider.Setup(tlp => tlp.Create(
It.Is <IEnumerable <TransportListener> >(listeners => listeners.Contains(tcpTransportListener.Object)),
amqpSettings
)).Returns(amqpTransportListener);
var protocolHead = new AmqpProtocolHead(transportSettings.Object, amqpSettings, transportListenerProvider.Object);
await Assert.ThrowsAsync <ApplicationException>(() => protocolHead.StartAsync());
}
async Task StartProtocolHead()
{
const int ConnectionPoolSize = 10;
string certificateValue = await SecretsHelper.GetSecret("IotHubMqttHeadCert");
byte[] cert = Convert.FromBase64String(certificateValue);
var certificate = new X509Certificate2(cert);
string edgeDeviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("edgeCapableDeviceConnStrKey");
// TODO - After IoTHub supports MQTT, remove this and move to using MQTT for upstream connections
await ConnectToIotHub(edgeDeviceConnectionString);
string edgeHubConnectionString = $"{edgeDeviceConnectionString};ModuleId=$edgeHub";
Client.IotHubConnectionStringBuilder iotHubConnectionStringBuilder = Client.IotHubConnectionStringBuilder.Create(edgeHubConnectionString);
var topics = new MessageAddressConversionConfiguration(this.inboundTemplates, this.outboundTemplates);
var builder = new ContainerBuilder();
builder.RegisterModule(new LoggingModule());
var mqttSettingsConfiguration = new Mock <IConfiguration>();
mqttSettingsConfiguration.Setup(c => c.GetSection(It.IsAny <string>())).Returns(Mock.Of <IConfigurationSection>(s => s.Value == null));
builder.RegisterBuildCallback(
c =>
{
// set up loggers for dotnetty
var loggerFactory = c.Resolve <ILoggerFactory>();
InternalLoggerFactory.DefaultFactory = loggerFactory;
var eventListener = new LoggerEventListener(loggerFactory.CreateLogger("ProtocolGateway"));
eventListener.EnableEvents(CommonEventSource.Log, EventLevel.Informational);
});
var versionInfo = new VersionInfo("v1", "b1", "c1");
var storeAndForwardConfiguration = new StoreAndForwardConfiguration(-1);
builder.RegisterModule(new CommonModule(string.Empty, iotHubConnectionStringBuilder.HostName, iotHubConnectionStringBuilder.DeviceId));
builder.RegisterModule(
new RoutingModule(
iotHubConnectionStringBuilder.HostName,
iotHubConnectionStringBuilder.DeviceId, iotHubConnectionStringBuilder.ModuleId,
Option.Some(edgeHubConnectionString),
this.routes, false, false, storeAndForwardConfiguration,
string.Empty, ConnectionPoolSize, false, versionInfo, Option.Some(UpstreamProtocol.Amqp),
true, TimeSpan.FromSeconds(5), 101, false, Option.None <string>(), Option.None <string>())
);
builder.RegisterModule(new HttpModule());
builder.RegisterModule(new MqttModule(mqttSettingsConfiguration.Object, topics, certificate, false, false, string.Empty, false));
builder.RegisterModule(new AmqpModule("amqps", 5671, certificate, iotHubConnectionStringBuilder.HostName));
this.container = builder.Build();
IConfigSource configSource = await this.container.Resolve <Task <IConfigSource> >();
ConfigUpdater configUpdater = await this.container.Resolve <Task <ConfigUpdater> >();
await configUpdater.Init(configSource);
ILogger logger = this.container.Resolve <ILoggerFactory>().CreateLogger("EdgeHub");
MqttProtocolHead mqttProtocolHead = await this.container.Resolve <Task <MqttProtocolHead> >();
AmqpProtocolHead amqpProtocolHead = await this.container.Resolve <Task <AmqpProtocolHead> >();
this.protocolHead = new EdgeHubProtocolHead(new List <IProtocolHead> {
mqttProtocolHead, amqpProtocolHead
}, logger);
await this.protocolHead.StartAsync();
}
