public async Task ProcessDeviceMessageBatch_ConvertsMessages()
{
// Create a mock endpoint capable of returning a mock processor
var processor = Mock.Of <IProcessor>();
var endpoint = new Mock <Endpoint>("myId");
endpoint.Setup(ep => ep.CreateProcessor()).Returns(processor);
endpoint.SetupGet(ep => ep.Id).Returns("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of <IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of <IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny <Endpoint>())).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var endpoints = new HashSet <Endpoint> {
endpoint.Object
};
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
// Create mock message converter to generate a message with source matching the route
var message = Mock.Of <IMessage>();
Mock.Get(message).SetupGet(m => m.MessageSource).Returns(() => TelemetryMessageSource.Instance);
var messageConverter = Mock.Of <Core.IMessageConverter <IMessage> >();
Mock.Get(messageConverter).Setup(mc => mc.FromMessage(It.IsAny <Core.IMessage>())).Returns(message);
// Create mock for IConnectionManager
var connectionManager = Mock.Of <IConnectionManager>();
// Mock of twin manager
var twinManager = Mock.Of <ITwinManager>();
// Test Scenario
var routingEdgeHub = new RoutingEdgeHub(router, messageConverter, connectionManager, twinManager, "testEdgeDevice", Mock.Of <IInvokeMethodHandler>());
var identity = Mock.Of <IIdentity>();
EdgeMessage[] messages = { new Message.Builder(new byte[0]).Build() };
await routingEdgeHub.ProcessDeviceMessageBatch(identity, messages);
// Verify Expectation
Mock.Get(endpointExecutor).Verify(e => e.Invoke(It.IsAny <IMessage>()), Times.Once);
}
public async Task UpdateDesiredPropertiesForwardsToTwinManager()
{
// Create a mock endpoint capable of returning a mock processor
var processor = Mock.Of <IProcessor>();
var endpoint = new Mock <Endpoint>("myId");
endpoint.Setup(ep => ep.CreateProcessor()).Returns(processor);
endpoint.SetupGet(ep => ep.Id).Returns("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of <IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of <IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny <Endpoint>(), new List <uint>()
{
0
})).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoint.Object, 0, 3600);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
var messageConverter = Mock.Of <Core.IMessageConverter <Devices.Routing.Core.IMessage> >();
var connectionManager = Mock.Of <IConnectionManager>();
var twinManager = new Mock <ITwinManager>();
var message = Mock.Of <IMessage>();
IMessage received = new EdgeMessage.Builder(new byte[0]).Build();
twinManager.Setup(t => t.UpdateDesiredPropertiesAsync(It.IsAny <string>(), It.IsAny <IMessage>())).Callback <string, IMessage>((s, m) => received = message).Returns(Task.CompletedTask);
var routingEdgeHub = new RoutingEdgeHub(
router,
messageConverter,
connectionManager,
twinManager.Object,
"testEdgeDevice",
"$edgeHub",
Mock.Of <IInvokeMethodHandler>(),
Mock.Of <ISubscriptionProcessor>(),
Mock.Of <IDeviceScopeIdentitiesCache>());
await routingEdgeHub.UpdateDesiredPropertiesAsync("*", message);
twinManager.Verify(x => x.UpdateDesiredPropertiesAsync("*", message), Times.Once);
Assert.Equal(message, received);
}
public async Task GetTwinForwardsToTwinManager()
{
// Create a mock endpoint capable of returning a mock processor
var processor = Mock.Of <IProcessor>();
var endpoint = new Mock <Endpoint>("myId");
endpoint.Setup(ep => ep.CreateProcessor()).Returns(processor);
endpoint.SetupGet(ep => ep.Id).Returns("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of <IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of <IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny <Endpoint>())).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var endpoints = new HashSet <Endpoint> {
endpoint.Object
};
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
var messageConverter = Mock.Of <Core.IMessageConverter <Devices.Routing.Core.IMessage> >();
var connectionManager = Mock.Of <IConnectionManager>();
var twinManager = new Mock <ITwinManager>();
var message = Mock.Of <IMessage>();
twinManager.Setup(t => t.GetTwinAsync(It.IsAny <string>())).Returns(Task.FromResult(message));
var routingEdgeHub = new RoutingEdgeHub(
router,
messageConverter,
connectionManager,
twinManager.Object,
"testEdgeDevice",
Mock.Of <IInvokeMethodHandler>(),
Mock.Of <ISubscriptionProcessor>());
IMessage received = await routingEdgeHub.GetTwinAsync("*");
twinManager.Verify(x => x.GetTwinAsync("*"), Times.Once);
Assert.Equal(message, received);
}
static async Task <(IEdgeHub, IConnectionManager)> SetupEdgeHub(IEnumerable <string> routes, IoTHub iotHub, string edgeDeviceId)
{
string iotHubName = "testHub";
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1));
TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1);
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
var endpointExecutorConfig = new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true);
var cloudProxy = new Mock <ICloudProxy>();
cloudProxy.Setup(c => c.SendMessageAsync(It.IsAny <IMessage>())).Callback <IMessage>(m => iotHub.ReceivedMessages.Add(m)).Returns(Task.CompletedTask);
cloudProxy.Setup(c => c.SendMessageBatchAsync(It.IsAny <IEnumerable <IMessage> >())).Callback <IEnumerable <IMessage> >(m => iotHub.ReceivedMessages.AddRange(m)).Returns(Task.CompletedTask);
cloudProxy.Setup(c => c.UpdateReportedPropertiesAsync(It.IsAny <IMessage>())).Callback <IMessage>(m => iotHub.ReceivedMessages.Add(m)).Returns(Task.CompletedTask);
cloudProxy.SetupGet(c => c.IsActive).Returns(true);
var cloudConnection = Mock.Of <ICloudConnection>(c => c.IsActive && c.CloudProxy == Option.Some(cloudProxy.Object));
var cloudConnectionProvider = new Mock <ICloudConnectionProvider>();
cloudConnectionProvider.Setup(c => c.Connect(It.IsAny <IClientCredentials>(), It.IsAny <Action <string, CloudConnectionStatus> >())).ReturnsAsync(Try.Success(cloudConnection));
var deviceConnectivityManager = Mock.Of <IDeviceConnectivityManager>();
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider.Object, Mock.Of <ICredentialsCache>(), new IdentityProvider(iotHubName), deviceConnectivityManager);
var routingMessageConverter = new RoutingMessageConverter();
RouteFactory routeFactory = new EdgeRouteFactory(new EndpointFactory(connectionManager, routingMessageConverter, edgeDeviceId, 10, 10));
IEnumerable <Route> routesList = routeFactory.Create(routes).ToList();
IEnumerable <Endpoint> endpoints = routesList.Select(r => r.Endpoint);
var routerConfig = new RouterConfig(endpoints, routesList);
IDbStoreProvider dbStoreProvider = new InMemoryDbStoreProvider();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IMessageStore messageStore = new MessageStore(storeProvider, CheckpointStore.Create(storeProvider), TimeSpan.MaxValue);
IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(1, TimeSpan.FromMilliseconds(10)), messageStore);
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), iotHubName, routerConfig, endpointExecutorFactory);
ITwinManager twinManager = new TwinManager(connectionManager, new TwinCollectionMessageConverter(), new TwinMessageConverter(), Option.None <IEntityStore <string, TwinInfo> >());
var invokeMethodHandler = Mock.Of <IInvokeMethodHandler>();
var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager);
IEdgeHub edgeHub = new RoutingEdgeHub(router, routingMessageConverter, connectionManager, twinManager, edgeDeviceId, invokeMethodHandler, subscriptionProcessor);
return(edgeHub, connectionManager);
}
public async Task ProcessNoOpSubscriptionTest()
{
// Arrange
RoutingEdgeHub edgeHub = await GetTestEdgeHub();
var cloudProxy = new Mock <ICloudProxy>();
// Act
await edgeHub.ProcessSubscription(cloudProxy.Object, DeviceSubscription.ModuleMessages, true);
await edgeHub.ProcessSubscription(cloudProxy.Object, DeviceSubscription.ModuleMessages, false);
await edgeHub.ProcessSubscription(cloudProxy.Object, DeviceSubscription.TwinResponse, true);
await edgeHub.ProcessSubscription(cloudProxy.Object, DeviceSubscription.TwinResponse, false);
await edgeHub.ProcessSubscription(cloudProxy.Object, DeviceSubscription.Unknown, true);
await edgeHub.ProcessSubscription(cloudProxy.Object, DeviceSubscription.Unknown, false);
// Assert
cloudProxy.VerifyAll();
}
public async Task ProcessC2DSubscriptionTest()
{
// Arrange
RoutingEdgeHub edgeHub = await GetTestEdgeHub();
var cloudProxy = new Mock <ICloudProxy>();
cloudProxy.Setup(c => c.StartListening());
// Act
await edgeHub.ProcessSubscription(cloudProxy.Object, DeviceSubscription.C2D, true);
// Assert
cloudProxy.VerifyAll();
// Arrange
cloudProxy = new Mock <ICloudProxy>();
// Act
await edgeHub.ProcessSubscription(cloudProxy.Object, DeviceSubscription.C2D, false);
// Assert
cloudProxy.VerifyAll();
}
protected override void Load(ContainerBuilder builder)
{
// IMessageConverter<IRoutingMessage>
builder.Register(c => new RoutingMessageConverter())
.As <Core.IMessageConverter <IRoutingMessage> >()
.SingleInstance();
// IRoutingPerfCounter
builder.Register(
c =>
{
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
return(Routing.PerfCounter);
})
.As <IRoutingPerfCounter>()
.AutoActivate()
.SingleInstance();
// IRoutingUserAnalyticsLogger
builder.Register(
c =>
{
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
return(Routing.UserAnalyticsLogger);
})
.As <IRoutingUserAnalyticsLogger>()
.AutoActivate()
.SingleInstance();
// IRoutingUserMetricLogger
builder.Register(
c =>
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
return(Routing.UserMetricLogger);
})
.As <IRoutingUserMetricLogger>()
.AutoActivate()
.SingleInstance();
// IMessageConverter<Message>
builder.Register(c => new DeviceClientMessageConverter())
.As <Core.IMessageConverter <Message> >()
.SingleInstance();
// IMessageConverter<Twin>
builder.Register(c => new TwinMessageConverter())
.As <Core.IMessageConverter <Twin> >()
.SingleInstance();
// IMessageConverter<TwinCollection>
builder.Register(c => new TwinCollectionMessageConverter())
.As <Core.IMessageConverter <TwinCollection> >()
.SingleInstance();
// IMessageConverterProvider
builder.Register(
c => new MessageConverterProvider(new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), c.Resolve <Core.IMessageConverter <Message> >() },
{ typeof(Twin), c.Resolve <Core.IMessageConverter <Twin> >() },
{ typeof(TwinCollection), c.Resolve <Core.IMessageConverter <TwinCollection> >() }
}))
.As <Core.IMessageConverterProvider>()
.SingleInstance();
// IDeviceConnectivityManager
builder.Register(
c =>
{
IDeviceConnectivityManager deviceConnectivityManager = new DeviceConnectivityManager(this.connectivityCheckFrequency, TimeSpan.FromMinutes(2));
return(deviceConnectivityManager);
})
.As <IDeviceConnectivityManager>()
.SingleInstance();
// IDeviceClientProvider
builder.Register(c =>
{
IClientProvider underlyingClientProvider = new ClientProvider();
IClientProvider connectivityAwareClientProvider = new ConnectivityAwareClientProvider(underlyingClientProvider, c.Resolve <IDeviceConnectivityManager>());
return(connectivityAwareClientProvider);
})
.As <IClientProvider>()
.SingleInstance();
// ICloudConnectionProvider
builder.Register(c => new CloudConnectionProvider(c.Resolve <Core.IMessageConverterProvider>(), this.connectionPoolSize, c.Resolve <IClientProvider>(), this.upstreamProtocol))
.As <ICloudConnectionProvider>()
.SingleInstance();
if (this.isStoreAndForwardEnabled || this.cacheTokens)
{
// Detect system environment
builder.Register(c => new SystemEnvironment())
.As <ISystemEnvironment>()
.SingleInstance();
// DataBase options
builder.Register(c => new Storage.RocksDb.RocksDbOptionsProvider(c.Resolve <ISystemEnvironment>(), this.optimizeForPerformance))
.As <Storage.RocksDb.IRocksDbOptionsProvider>()
.SingleInstance();
// IDbStore
builder.Register(
c =>
{
var loggerFactory = c.Resolve <ILoggerFactory>();
ILogger logger = loggerFactory.CreateLogger(typeof(RoutingModule));
if (this.usePersistentStorage)
{
// Create partitions for messages and twins
var partitionsList = new List <string> {
Core.Constants.MessageStorePartitionKey, Core.Constants.TwinStorePartitionKey, Core.Constants.CheckpointStorePartitionKey
};
try
{
IDbStoreProvider dbStoreprovider = Storage.RocksDb.DbStoreProvider.Create(c.Resolve <Storage.RocksDb.IRocksDbOptionsProvider>(),
this.storagePath, partitionsList);
logger.LogInformation($"Created persistent store at {this.storagePath}");
return(dbStoreprovider);
}
catch (Exception ex) when(!ExceptionEx.IsFatal(ex))
{
logger.LogError(ex, "Error creating RocksDB store. Falling back to in-memory store.");
return(new InMemoryDbStoreProvider());
}
}
else
{
logger.LogInformation($"Using in-memory store");
return(new InMemoryDbStoreProvider());
}
})
.As <IDbStoreProvider>()
.SingleInstance();
}
// Task<ICredentialsStore>
builder.Register(async c =>
{
if (this.cacheTokens)
{
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IEncryptionProvider encryptionProvider = await this.workloadUri.Map(
async uri => await EncryptionProvider.CreateAsync(
this.storagePath,
new Uri(uri),
Service.Constants.WorkloadApiVersion,
this.edgeModuleId,
this.edgeModuleGenerationId.Expect(() => new InvalidOperationException("Missing generation ID")),
Service.Constants.InitializationVectorFileName) as IEncryptionProvider)
.GetOrElse(() => Task.FromResult <IEncryptionProvider>(NullEncryptionProvider.Instance));
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IEntityStore <string, string> tokenCredentialsEntityStore = storeProvider.GetEntityStore <string, string>("tokenCredentials");
return(new TokenCredentialsStore(tokenCredentialsEntityStore, encryptionProvider));
}
else
{
return(new NullCredentialsStore() as ICredentialsStore);
}
})
.As <Task <ICredentialsStore> >()
.SingleInstance();
// IConnectionManager
builder.Register(c => new ConnectionManager(c.Resolve <ICloudConnectionProvider>(), this.maxConnectedClients))
.As <IConnectionManager>()
.SingleInstance();
// IEndpointFactory
builder.Register(c => new EndpointFactory(c.Resolve <IConnectionManager>(), c.Resolve <Core.IMessageConverter <IRoutingMessage> >(), this.edgeDeviceId))
.As <IEndpointFactory>()
.SingleInstance();
// RouteFactory
builder.Register(c => new EdgeRouteFactory(c.Resolve <IEndpointFactory>()))
.As <RouteFactory>()
.SingleInstance();
// RouterConfig
builder.Register(c => new RouterConfig(Enumerable.Empty <Route>()))
.As <RouterConfig>()
.SingleInstance();
if (!this.isStoreAndForwardEnabled)
{
// EndpointExecutorConfig
builder.Register(
c =>
{
RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1));
TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1);
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
return(new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(c => new SyncEndpointExecutorFactory(c.Resolve <EndpointExecutorConfig>()))
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
var routerConfig = c.Resolve <RouterConfig>();
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory);
return(router);
})
.As <Task <Router> >()
.SingleInstance();
// ITwinManager
builder.Register(c => TwinManager.CreateTwinManager(c.Resolve <IConnectionManager>(), c.Resolve <IMessageConverterProvider>(), Option.None <IStoreProvider>()))
.As <ITwinManager>()
.SingleInstance();
}
else
{
// EndpointExecutorConfig
builder.Register(
c =>
{
// Endpoint executor config values -
// ExponentialBackoff - minBackoff = 1s, maxBackoff = 60s, delta (used to add randomness to backoff) - 1s (default)
// Num of retries = int.MaxValue(we want to keep retrying till the message is sent)
// Revive period - period for which the endpoint should be considered dead if it doesn't respond - 1 min (we want to try continuously till the message expires)
// Timeout - time for which we want for the ack from the endpoint = 30s
// TODO - Should the number of retries be tied to the Store and Forward ttl? Not
// doing that right now as that value can be changed at runtime, but these settings
// cannot. Need to make the number of retries dynamically configurable for that.
TimeSpan minWait = TimeSpan.FromSeconds(1);
TimeSpan maxWait = TimeSpan.FromSeconds(60);
TimeSpan delta = TimeSpan.FromSeconds(1);
int retries = int.MaxValue;
RetryStrategy retryStrategy = new ExponentialBackoff(retries, minWait, maxWait, delta);
TimeSpan timeout = TimeSpan.FromSeconds(30);
TimeSpan revivePeriod = TimeSpan.FromSeconds(30);
return(new EndpointExecutorConfig(timeout, retryStrategy, revivePeriod));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// ICheckpointStore
builder.Register(c => CheckpointStore.Create(c.Resolve <IDbStoreProvider>()))
.As <ICheckpointStore>()
.SingleInstance();
// IMessageStore
builder.Register(
c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, TimeSpan.MaxValue);
return(messageStore);
})
.As <IMessageStore>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(
c =>
{
var endpointExecutorConfig = c.Resolve <EndpointExecutorConfig>();
var messageStore = c.Resolve <IMessageStore>();
IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(10, TimeSpan.FromSeconds(10)), messageStore);
return(endpointExecutorFactory);
})
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var routerConfig = c.Resolve <RouterConfig>();
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
return(await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory, checkpointStore));
})
.As <Task <Router> >()
.SingleInstance();
// ITwinManager
builder.Register(c => TwinManager.CreateTwinManager(c.Resolve <IConnectionManager>(), c.Resolve <IMessageConverterProvider>(), Option.Some <IStoreProvider>(new StoreProvider(c.Resolve <IDbStoreProvider>()))))
.As <ITwinManager>()
.SingleInstance();
}
// IClientCredentials "EdgeHubCredentials"
builder.Register(
c =>
{
var identityFactory = c.Resolve <IClientCredentialsFactory>();
IClientCredentials edgeHubCredentials = this.connectionString.Map(cs => identityFactory.GetWithConnectionString(cs)).GetOrElse(
() => identityFactory.GetWithIotEdged(this.edgeDeviceId, this.edgeModuleId));
return(edgeHubCredentials);
})
.Named <IClientCredentials>("EdgeHubCredentials")
.SingleInstance();
// Task<ICloudProxy> "EdgeHubCloudProxy"
builder.Register(
async c =>
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var connectionManager = c.Resolve <IConnectionManager>();
Try <ICloudProxy> cloudProxyTry = await connectionManager.CreateCloudConnectionAsync(edgeHubCredentials);
if (!cloudProxyTry.Success)
{
throw new EdgeHubConnectionException("Edge hub is unable to connect to IoT Hub", cloudProxyTry.Exception);
}
ICloudProxy cloudProxy = cloudProxyTry.Value;
return(cloudProxy);
})
.Named <Task <ICloudProxy> >("EdgeHubCloudProxy")
.SingleInstance();
// Task<IEdgeHub>
builder.Register(
async c =>
{
Router router = await c.Resolve <Task <Router> >();
IEdgeHub hub = new RoutingEdgeHub(router, c.Resolve <Core.IMessageConverter <IRoutingMessage> >(), c.Resolve <IConnectionManager>(), c.Resolve <ITwinManager>(), this.edgeDeviceId);
return(hub);
})
.As <Task <IEdgeHub> >()
.SingleInstance();
// Task<ConfigUpdater>
builder.Register(
async c =>
{
IMessageStore messageStore = this.isStoreAndForwardEnabled ? c.Resolve <IMessageStore>() : null;
Router router = await c.Resolve <Task <Router> >();
var configUpdater = new ConfigUpdater(router, messageStore);
return(configUpdater);
})
.As <Task <ConfigUpdater> >()
.SingleInstance();
// Task<IConfigSource>
builder.Register(
async c =>
{
var routeFactory = c.Resolve <RouteFactory>();
if (this.useTwinConfig)
{
var connectionManager = c.Resolve <IConnectionManager>();
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var twinCollectionMessageConverter = c.Resolve <Core.IMessageConverter <TwinCollection> >();
var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >();
var twinManager = c.Resolve <ITwinManager>();
ICloudProxy cloudProxy = await c.ResolveNamed <Task <ICloudProxy> >("EdgeHubCloudProxy");
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
IConfigSource edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials.Identity as IModuleIdentity,
edgeHub,
twinManager,
connectionManager,
cloudProxy,
routeFactory,
twinCollectionMessageConverter,
twinMessageConverter,
this.versionInfo
);
return(edgeHubConnection);
}
else
{
return(new LocalConfigSource(routeFactory, this.routes, this.storeAndForwardConfiguration));
}
})
.As <Task <IConfigSource> >()
.SingleInstance();
// Task<IConnectionProvider>
builder.Register(
async c =>
{
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
IConnectionProvider connectionProvider = new ConnectionProvider(c.Resolve <IConnectionManager>(), edgeHub);
return(connectionProvider);
})
.As <Task <IConnectionProvider> >()
.SingleInstance();
base.Load(builder);
}
public async Task TestEdgeHubConnection()
{
const string EdgeDeviceId = "testHubEdgeDevice1";
var twinMessageConverter = new TwinMessageConverter();
var twinCollectionMessageConverter = new TwinCollectionMessageConverter();
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), new DeviceClientMessageConverter() },
{ typeof(Twin), twinMessageConverter },
{ typeof(TwinCollection), twinCollectionMessageConverter }
});
string iotHubConnectionString = await SecretsHelper.GetSecretFromConfigKey("iotHubConnStrKey");
IotHubConnectionStringBuilder iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(iotHubConnectionString);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
await registryManager.OpenAsync();
string iothubHostName = iotHubConnectionStringBuilder.HostName;
var identityProvider = new IdentityProvider(iothubHostName);
var identityFactory = new ClientCredentialsFactory(identityProvider);
(string edgeDeviceId, string deviceConnStr) = await RegistryManagerHelper.CreateDevice(EdgeDeviceId, iotHubConnectionString, registryManager, true, false);
string edgeHubConnectionString = $"{deviceConnStr};ModuleId={EdgeHubModuleId}";
IClientCredentials edgeHubCredentials = identityFactory.GetWithConnectionString(edgeHubConnectionString);
string sasKey = ConnectionStringHelper.GetSharedAccessKey(deviceConnStr);
var signatureProvider = new SharedAccessKeySignatureProvider(sasKey);
var credentialsCache = Mock.Of <ICredentialsCache>();
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
new ClientProvider(),
Option.None <UpstreamProtocol>(),
new ClientTokenProvider(signatureProvider, iothubHostName, edgeDeviceId, TimeSpan.FromMinutes(60)),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
edgeHubCredentials.Identity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object);
var deviceConnectivityManager = Mock.Of <IDeviceConnectivityManager>();
var connectionManager = new ConnectionManager(cloudConnectionProvider, Mock.Of <ICredentialsCache>(), identityProvider, deviceConnectivityManager);
try
{
Mock.Get(credentialsCache)
.Setup(c => c.Get(edgeHubCredentials.Identity))
.ReturnsAsync(Option.Some(edgeHubCredentials));
Assert.NotNull(edgeHubCredentials);
Assert.NotNull(edgeHubCredentials.Identity);
// Set Edge hub desired properties
await this.SetDesiredProperties(registryManager, edgeDeviceId);
var endpointFactory = new EndpointFactory(connectionManager, new RoutingMessageConverter(), edgeDeviceId, 10, 10);
var routeFactory = new EdgeRouteFactory(endpointFactory);
var dbStoreProvider = new InMemoryDbStoreProvider();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IEntityStore <string, TwinInfo> twinStore = storeProvider.GetEntityStore <string, TwinInfo>("twins");
var twinManager = new TwinManager(connectionManager, twinCollectionMessageConverter, twinMessageConverter, Option.Some(twinStore));
var routerConfig = new RouterConfig(Enumerable.Empty <Route>());
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
var endpointExecutorFactory = new SyncEndpointExecutorFactory(new EndpointExecutorConfig(defaultTimeout, new FixedInterval(0, TimeSpan.FromSeconds(1)), defaultTimeout, true));
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), iothubHostName, routerConfig, endpointExecutorFactory);
IInvokeMethodHandler invokeMethodHandler = new InvokeMethodHandler(connectionManager);
var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager);
IEdgeHub edgeHub = new RoutingEdgeHub(router, new RoutingMessageConverter(), connectionManager, twinManager, edgeDeviceId, invokeMethodHandler, subscriptionProcessor);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var versionInfo = new VersionInfo("v1", "b1", "c1");
// Create Edge Hub connection
EdgeHubConnection edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials.Identity,
edgeHub,
twinManager,
connectionManager,
routeFactory,
twinCollectionMessageConverter,
versionInfo,
new NullDeviceScopeIdentitiesCache());
await Task.Delay(TimeSpan.FromMinutes(1));
TwinConfigSource configSource = new TwinConfigSource(edgeHubConnection, edgeHubCredentials.Identity.Id, versionInfo, twinManager, twinMessageConverter, twinCollectionMessageConverter, routeFactory);
// Get and Validate EdgeHubConfig
Option <EdgeHubConfig> edgeHubConfigOption = await configSource.GetConfig();
Assert.True(edgeHubConfigOption.HasValue);
EdgeHubConfig edgeHubConfig = edgeHubConfigOption.OrDefault();
Assert.Equal("1.0", edgeHubConfig.SchemaVersion);
Assert.NotNull(edgeHubConfig.Routes);
Assert.NotNull(edgeHubConfig.StoreAndForwardConfiguration);
Assert.Equal(20, edgeHubConfig.StoreAndForwardConfiguration.TimeToLiveSecs);
IReadOnlyDictionary <string, RouteConfig> routes = edgeHubConfig.Routes;
Assert.Equal(4, routes.Count);
RouteConfig route1 = routes["route1"];
Assert.True(route1.Route.Endpoint.GetType() == typeof(CloudEndpoint));
Assert.Equal("route1", route1.Name);
Assert.Equal("from /* INTO $upstream", route1.Value);
RouteConfig route2 = routes["route2"];
Endpoint endpoint = route2.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module2/input1", endpoint.Id);
Assert.Equal("route2", route2.Name);
Assert.Equal("from /modules/module1 INTO BrokeredEndpoint(\"/modules/module2/inputs/input1\")", route2.Value);
RouteConfig route3 = routes["route3"];
endpoint = route3.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module3/input1", endpoint.Id);
Assert.Equal("route3", route3.Name);
Assert.Equal("from /modules/module2 INTO BrokeredEndpoint(\"/modules/module3/inputs/input1\")", route3.Value);
RouteConfig route4 = routes["route4"];
endpoint = route4.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module4/input1", endpoint.Id);
Assert.Equal("route4", route4.Name);
Assert.Equal("from /modules/module3 INTO BrokeredEndpoint(\"/modules/module4/inputs/input1\")", route4.Value);
// Make sure reported properties were updated appropriately
EdgeHubConnection.ReportedProperties reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.NotNull(reportedProperties.Clients);
Assert.Equal(0, reportedProperties.Clients.Count);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// Simulate a module and a downstream device that connects to Edge Hub.
string moduleId = "module1";
string sasToken = TokenHelper.CreateSasToken($"{iothubHostName}/devices/{edgeDeviceId}/modules/{moduleId}");
string moduleConnectionstring = $"HostName={iothubHostName};DeviceId={edgeDeviceId};ModuleId={moduleId};SharedAccessSignature={sasToken}";
IClientCredentials moduleClientCredentials = identityFactory.GetWithConnectionString(moduleConnectionstring);
var moduleProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
string downstreamDeviceId = "device1";
sasToken = TokenHelper.CreateSasToken($"{iothubHostName}/devices/{downstreamDeviceId}");
string downstreamDeviceConnectionstring = $"HostName={iothubHostName};DeviceId={downstreamDeviceId};SharedAccessSignature={sasToken}";
IClientCredentials downstreamDeviceCredentials = identityFactory.GetWithConnectionString(downstreamDeviceConnectionstring);
var downstreamDeviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
// Connect the module and downstream device and make sure the reported properties are updated as expected.
await connectionManager.AddDeviceConnection(moduleClientCredentials.Identity, moduleProxy);
await connectionManager.AddDeviceConnection(downstreamDeviceCredentials.Identity, downstreamDeviceProxy);
string moduleIdKey = $"{edgeDeviceId}/{moduleId}";
await Task.Delay(TimeSpan.FromSeconds(10));
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(2, reportedProperties.Clients.Count);
Assert.Equal(ConnectionStatus.Connected, reportedProperties.Clients[moduleIdKey].Status);
Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastConnectedTimeUtc);
Assert.Null(reportedProperties.Clients[moduleIdKey].LastDisconnectTimeUtc);
Assert.Equal(ConnectionStatus.Connected, reportedProperties.Clients[downstreamDeviceId].Status);
Assert.NotNull(reportedProperties.Clients[downstreamDeviceId].LastConnectedTimeUtc);
Assert.Null(reportedProperties.Clients[downstreamDeviceId].LastDisconnectTimeUtc);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// Update desired propertied and make sure callback is called with valid values
bool callbackCalled = false;
Task ConfigUpdatedCallback(EdgeHubConfig updatedConfig)
{
Assert.NotNull(updatedConfig);
Assert.NotNull(updatedConfig.StoreAndForwardConfiguration);
Assert.NotNull(updatedConfig.Routes);
routes = updatedConfig.Routes;
Assert.Equal(4, routes.Count);
route1 = routes["route1"];
Assert.True(route1.Route.Endpoint.GetType() == typeof(CloudEndpoint));
Assert.Equal("route1", route1.Name);
Assert.Equal("from /* INTO $upstream", route1.Value);
route2 = routes["route2"];
endpoint = route2.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module2/input1", endpoint.Id);
Assert.Equal("route2", route2.Name);
Assert.Equal("from /modules/module1 INTO BrokeredEndpoint(\"/modules/module2/inputs/input1\")", route2.Value);
route3 = routes["route4"];
endpoint = route3.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module5/input1", endpoint.Id);
Assert.Equal("route4", route3.Name);
Assert.Equal("from /modules/module3 INTO BrokeredEndpoint(\"/modules/module5/inputs/input1\")", route3.Value);
route4 = routes["route5"];
endpoint = route4.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module6/input1", endpoint.Id);
Assert.Equal("route5", route4.Name);
Assert.Equal("from /modules/module5 INTO BrokeredEndpoint(\"/modules/module6/inputs/input1\")", route4.Value);
callbackCalled = true;
return(Task.CompletedTask);
}
configSource.SetConfigUpdatedCallback(ConfigUpdatedCallback);
await this.UpdateDesiredProperties(registryManager, edgeDeviceId);
await Task.Delay(TimeSpan.FromSeconds(5));
Assert.True(callbackCalled);
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.NotNull(reportedProperties.Clients);
Assert.Equal(2, reportedProperties.Clients.Count);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// Disconnect the downstream device and make sure the reported properties are updated as expected.
await connectionManager.RemoveDeviceConnection(moduleIdKey);
await connectionManager.RemoveDeviceConnection(downstreamDeviceId);
await Task.Delay(TimeSpan.FromSeconds(10));
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(1, reportedProperties.Clients.Count);
Assert.True(reportedProperties.Clients.ContainsKey(moduleIdKey));
Assert.False(reportedProperties.Clients.ContainsKey(downstreamDeviceId));
Assert.Equal(ConnectionStatus.Disconnected, reportedProperties.Clients[moduleIdKey].Status);
Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastConnectedTimeUtc);
Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastDisconnectTimeUtc);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// If the edge hub restarts, clear out the connected devices in the reported properties.
await EdgeHubConnection.Create(
edgeHubCredentials.Identity,
edgeHub,
twinManager,
connectionManager,
routeFactory,
twinCollectionMessageConverter,
versionInfo,
new NullDeviceScopeIdentitiesCache());
await Task.Delay(TimeSpan.FromMinutes(1));
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Null(reportedProperties.Clients);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
}
finally
{
try
{
await RegistryManagerHelper.RemoveDevice(edgeDeviceId, registryManager);
}
catch (Exception)
{
// ignored
}
}
}
protected override void Load(ContainerBuilder builder)
{
// IMessageConverter<IRoutingMessage>
builder.Register(c => new RoutingMessageConverter())
.As <Core.IMessageConverter <IRoutingMessage> >()
.SingleInstance();
// IRoutingPerfCounter
builder.Register(
c =>
{
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
return(Routing.PerfCounter);
})
.As <IRoutingPerfCounter>()
.AutoActivate()
.SingleInstance();
// IRoutingUserAnalyticsLogger
builder.Register(
c =>
{
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
return(Routing.UserAnalyticsLogger);
})
.As <IRoutingUserAnalyticsLogger>()
.AutoActivate()
.SingleInstance();
// IRoutingUserMetricLogger
builder.Register(
c =>
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
return(Routing.UserMetricLogger);
})
.As <IRoutingUserMetricLogger>()
.AutoActivate()
.SingleInstance();
// IMessageConverter<Message>
builder.Register(c => new DeviceClientMessageConverter())
.As <Core.IMessageConverter <Message> >()
.SingleInstance();
// IMessageConverter<Twin>
builder.Register(c => new TwinMessageConverter())
.As <Core.IMessageConverter <Twin> >()
.SingleInstance();
// IMessageConverter<TwinCollection>
builder.Register(c => new TwinCollectionMessageConverter())
.As <Core.IMessageConverter <TwinCollection> >()
.SingleInstance();
// IMessageConverterProvider
builder.Register(
c => new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), c.Resolve <Core.IMessageConverter <Message> >() },
{ typeof(Twin), c.Resolve <Core.IMessageConverter <Twin> >() },
{ typeof(TwinCollection), c.Resolve <Core.IMessageConverter <TwinCollection> >() }
}))
.As <IMessageConverterProvider>()
.SingleInstance();
// IDeviceConnectivityManager
builder.Register(
c =>
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
IDeviceConnectivityManager deviceConnectivityManager = this.experimentalFeatures.DisableConnectivityCheck
? new NullDeviceConnectivityManager()
: new DeviceConnectivityManager(this.connectivityCheckFrequency, TimeSpan.FromMinutes(2), edgeHubCredentials.Identity) as IDeviceConnectivityManager;
return(deviceConnectivityManager);
})
.As <IDeviceConnectivityManager>()
.SingleInstance();
// IDeviceClientProvider
builder.Register(
c =>
{
IClientProvider underlyingClientProvider = new ClientProvider();
IClientProvider connectivityAwareClientProvider = new ConnectivityAwareClientProvider(underlyingClientProvider, c.Resolve <IDeviceConnectivityManager>());
return(connectivityAwareClientProvider);
})
.As <IClientProvider>()
.SingleInstance();
// Task<ICloudConnectionProvider>
builder.Register(
async c =>
{
var productInfoStore = await c.Resolve <Task <IProductInfoStore> >();
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
var clientProvider = c.Resolve <IClientProvider>();
var tokenProvider = c.ResolveNamed <ITokenProvider>("EdgeHubClientAuthTokenProvider");
var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >();
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var deviceScopeIdentitiesCacheTask = c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
var proxy = c.Resolve <Option <IWebProxy> >();
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await deviceScopeIdentitiesCacheTask;
ICredentialsCache credentialsCache = await credentialsCacheTask;
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
this.connectionPoolSize,
clientProvider,
this.upstreamProtocol,
tokenProvider,
deviceScopeIdentitiesCache,
credentialsCache,
edgeHubCredentials.Identity,
this.cloudConnectionIdleTimeout,
this.closeCloudConnectionOnIdleTimeout,
this.operationTimeout,
this.useServerHeartbeat,
proxy,
productInfoStore);
return(cloudConnectionProvider);
})
.As <Task <ICloudConnectionProvider> >()
.SingleInstance();
// IIdentityProvider
builder.Register(_ => new IdentityProvider(this.iotHubName))
.As <IIdentityProvider>()
.SingleInstance();
// Task<IConnectionManager>
builder.Register(
async c =>
{
var cloudConnectionProviderTask = c.Resolve <Task <ICloudConnectionProvider> >();
var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >();
var identityProvider = c.Resolve <IIdentityProvider>();
var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>();
ICloudConnectionProvider cloudConnectionProvider = await cloudConnectionProviderTask;
ICredentialsCache credentialsCache = await credentialsCacheTask;
IConnectionManager connectionManager = new ConnectionManager(
cloudConnectionProvider,
credentialsCache,
identityProvider,
deviceConnectivityManager,
this.maxConnectedClients,
this.closeCloudConnectionOnDeviceDisconnect);
return(connectionManager);
})
.As <Task <IConnectionManager> >()
.SingleInstance();
// Task<IEndpointFactory>
builder.Register(
async c =>
{
var messageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(new EndpointFactory(connectionManager, messageConverter, this.edgeDeviceId, this.maxUpstreamBatchSize, this.upstreamFanOutFactor) as IEndpointFactory);
})
.As <Task <IEndpointFactory> >()
.SingleInstance();
// Task<RouteFactory>
builder.Register(async c => new EdgeRouteFactory(await c.Resolve <Task <IEndpointFactory> >()) as RouteFactory)
.As <Task <RouteFactory> >()
.SingleInstance();
// RouterConfig
builder.Register(c => new RouterConfig(Enumerable.Empty <Route>()))
.As <RouterConfig>()
.SingleInstance();
if (!this.isStoreAndForwardEnabled)
{
// EndpointExecutorConfig
builder.Register(
c =>
{
RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1));
TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1);
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
return(new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(c => new SyncEndpointExecutorFactory(c.Resolve <EndpointExecutorConfig>()))
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
var routerConfig = c.Resolve <RouterConfig>();
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory);
return(router);
})
.As <Task <Router> >()
.SingleInstance();
// Task<ITwinManager>
builder.Register(
async c =>
{
if (!this.useV1TwinManager)
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
ITwinManager twinManager = new PassThroughTwinManager(connectionManager, messageConverterProvider);
return(twinManager);
}
else
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>()));
}
})
.As <Task <ITwinManager> >()
.SingleInstance();
}
else
{
// EndpointExecutorConfig
builder.Register(
c =>
{
// Endpoint executor config values -
// ExponentialBackoff - minBackoff = 1s, maxBackoff = 60s, delta (used to add randomness to backoff) - 1s (default)
// Num of retries = int.MaxValue(we want to keep retrying till the message is sent)
// Revive period - period for which the endpoint should be considered dead if it doesn't respond - 1 min (we want to try continuously till the message expires)
// Timeout - time for which we want for the ack from the endpoint = 30s
// TODO - Should the number of retries be tied to the Store and Forward ttl? Not
// doing that right now as that value can be changed at runtime, but these settings
// cannot. Need to make the number of retries dynamically configurable for that.
TimeSpan minWait = TimeSpan.FromSeconds(1);
TimeSpan maxWait = TimeSpan.FromSeconds(60);
TimeSpan delta = TimeSpan.FromSeconds(1);
int retries = int.MaxValue;
RetryStrategy retryStrategy = new ExponentialBackoff(retries, minWait, maxWait, delta);
TimeSpan timeout = TimeSpan.FromSeconds(30);
TimeSpan revivePeriod = TimeSpan.FromSeconds(30);
return(new EndpointExecutorConfig(timeout, retryStrategy, revivePeriod));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// Task<ICheckpointStore>
builder.Register(
async c =>
{
var dbStoreProvider = await c.Resolve <Task <IDbStoreProvider> >();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
ICheckpointStore checkpointStore = CheckpointStore.Create(storeProvider);
return(checkpointStore);
})
.As <Task <ICheckpointStore> >()
.SingleInstance();
// Task<IMessageStore>
builder.Register(
async c =>
{
var checkpointStore = await c.Resolve <Task <ICheckpointStore> >();
var dbStoreProvider = await c.Resolve <Task <IDbStoreProvider> >();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, this.storeAndForwardConfiguration.TimeToLive, this.checkEntireQueueOnCleanup);
return(messageStore);
})
.As <Task <IMessageStore> >()
.SingleInstance();
// Task<IEndpointExecutorFactory>
builder.Register(
async c =>
{
var endpointExecutorConfig = c.Resolve <EndpointExecutorConfig>();
var messageStore = await c.Resolve <Task <IMessageStore> >();
IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(10, TimeSpan.FromSeconds(10)), messageStore);
return(endpointExecutorFactory);
})
.As <Task <IEndpointExecutorFactory> >()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var checkpointStore = await c.Resolve <Task <ICheckpointStore> >();
var routerConfig = c.Resolve <RouterConfig>();
var endpointExecutorFactory = await c.Resolve <Task <IEndpointExecutorFactory> >();
return(await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory, checkpointStore));
})
.As <Task <Router> >()
.SingleInstance();
// Task<ITwinManager>
builder.Register(
async c =>
{
if (this.useV1TwinManager)
{
var dbStoreProvider = await c.Resolve <Task <IDbStoreProvider> >();
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.Some <IStoreProvider>(new StoreProvider(dbStoreProvider))));
}
else
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>();
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
IEntityStore <string, TwinStoreEntity> entityStore = await this.GetTwinStore(c);
IConnectionManager connectionManager = await connectionManagerTask;
ITwinManager twinManager = StoringTwinManager.Create(
connectionManager,
messageConverterProvider,
entityStore,
deviceConnectivityManager,
new ReportedPropertiesValidator(),
this.minTwinSyncPeriod,
this.reportedPropertiesSyncFrequency);
return(twinManager);
}
})
.As <Task <ITwinManager> >()
.SingleInstance();
}
// IClientCredentials "EdgeHubCredentials"
builder.Register(
c =>
{
var identityFactory = c.Resolve <IClientCredentialsFactory>();
IClientCredentials edgeHubCredentials = this.connectionString.Map(cs => identityFactory.GetWithConnectionString(cs)).GetOrElse(
() => identityFactory.GetWithIotEdged(this.edgeDeviceId, this.edgeModuleId));
return(edgeHubCredentials);
})
.Named <IClientCredentials>("EdgeHubCredentials")
.SingleInstance();
// Task<IInvokeMethodHandler>
builder.Register(
async c =>
{
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(new InvokeMethodHandler(connectionManager) as IInvokeMethodHandler);
})
.As <Task <IInvokeMethodHandler> >()
.SingleInstance();
// Task<ISubscriptionProcessor>
builder.Register(
async c =>
{
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
if (this.experimentalFeatures.DisableCloudSubscriptions)
{
return(new LocalSubscriptionProcessor(await connectionManagerTask) as ISubscriptionProcessor);
}
else
{
var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >();
var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>();
IConnectionManager connectionManager = await connectionManagerTask;
IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask;
return(new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager) as ISubscriptionProcessor);
}
})
.As <Task <ISubscriptionProcessor> >()
.SingleInstance();
// Task<IEdgeHub>
builder.Register(
async c =>
{
var routingMessageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >();
var routerTask = c.Resolve <Task <Router> >();
var twinManagerTask = c.Resolve <Task <ITwinManager> >();
var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >();
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
var subscriptionProcessorTask = c.Resolve <Task <ISubscriptionProcessor> >();
Router router = await routerTask;
ITwinManager twinManager = await twinManagerTask;
IConnectionManager connectionManager = await connectionManagerTask;
IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask;
ISubscriptionProcessor subscriptionProcessor = await subscriptionProcessorTask;
IEdgeHub hub = new RoutingEdgeHub(
router,
routingMessageConverter,
connectionManager,
twinManager,
this.edgeDeviceId,
invokeMethodHandler,
subscriptionProcessor);
return(hub);
})
.As <Task <IEdgeHub> >()
.SingleInstance();
// Task<ConfigUpdater>
builder.Register(
async c =>
{
IMessageStore messageStore = this.isStoreAndForwardEnabled ? await c.Resolve <Task <IMessageStore> >() : null;
var storageSpaceChecker = c.Resolve <IStorageSpaceChecker>();
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
RouteFactory routeFactory = await c.Resolve <Task <RouteFactory> >();
Router router = await c.Resolve <Task <Router> >();
var twinManagerTask = c.Resolve <Task <ITwinManager> >();
var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >();
var twinManager = await twinManagerTask;
var configUpdater = new ConfigUpdater(router, messageStore, this.configUpdateFrequency, storageSpaceChecker);
return(configUpdater);
})
.As <Task <ConfigUpdater> >()
.SingleInstance();
// Task<IConfigSource>
builder.Register <Task <IConfigSource> >(
async c =>
{
RouteFactory routeFactory = await c.Resolve <Task <RouteFactory> >();
if (this.useTwinConfig)
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var twinCollectionMessageConverter = c.Resolve <Core.IMessageConverter <TwinCollection> >();
var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >();
var twinManagerTask = c.Resolve <Task <ITwinManager> >();
var edgeHubTask = c.Resolve <Task <IEdgeHub> >();
ITwinManager twinManager = await twinManagerTask;
IEdgeHub edgeHub = await edgeHubTask;
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
var edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials.Identity,
edgeHub,
twinManager,
connectionManager,
routeFactory,
twinCollectionMessageConverter,
this.versionInfo,
deviceScopeIdentitiesCache);
return(new TwinConfigSource(edgeHubConnection, edgeHubCredentials.Identity.Id, this.versionInfo, twinManager, twinMessageConverter, twinCollectionMessageConverter, routeFactory));
}
else
{
return(new LocalConfigSource(routeFactory, this.routes, this.storeAndForwardConfiguration));
}
})
.As <Task <IConfigSource> >()
.SingleInstance();
// Task<IConnectionProvider>
builder.Register(
async c =>
{
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
var edgeHubTask = c.Resolve <Task <IEdgeHub> >();
IConnectionManager connectionManager = await connectionManagerTask;
IEdgeHub edgeHub = await edgeHubTask;
IConnectionProvider connectionProvider = new ConnectionProvider(connectionManager, edgeHub, this.messageAckTimeout);
return(connectionProvider);
})
.As <Task <IConnectionProvider> >()
.SingleInstance();
base.Load(builder);
}
public async Task EdgeHubChecksMessageSize()
{
// Create a mock endpoint capable of returning a mock processor
var processor = Mock.Of <IProcessor>();
var endpoint = new Mock <Endpoint>("myId");
endpoint.Setup(ep => ep.CreateProcessor()).Returns(processor);
endpoint.SetupGet(ep => ep.Id).Returns("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of <IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of <IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny <Endpoint>())).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var endpoints = new HashSet <Endpoint> {
endpoint.Object
};
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
// Create mock for IConnectionManager
var connectionManager = Mock.Of <IConnectionManager>();
// Mock of twin manager
var twinManager = Mock.Of <ITwinManager>();
// Mock of identity
var identity = new Mock <IIdentity>();
identity.SetupGet(id => id.Id).Returns("something");
var messageConverter = new RoutingMessageConverter();
Message badMessage = new EdgeMessage.Builder(new byte[300 * 1024]).Build();
var routingEdgeHub = new RoutingEdgeHub(
router,
messageConverter,
connectionManager,
twinManager,
"testEdgeDevice",
Mock.Of <IInvokeMethodHandler>(),
Mock.Of <ISubscriptionProcessor>());
await Assert.ThrowsAsync <EdgeHubMessageTooLargeException>(() => routingEdgeHub.ProcessDeviceMessage(identity.Object, badMessage));
string badString = Encoding.UTF8.GetString(new byte[300 * 1024], 0, 300 * 1024);
var badProperties = new Dictionary <string, string> {
["toolong"] = badString
};
badMessage = new EdgeMessage.Builder(new byte[1]).SetProperties(badProperties).Build();
await Assert.ThrowsAsync <EdgeHubMessageTooLargeException>(() => routingEdgeHub.ProcessDeviceMessage(identity.Object, badMessage));
badMessage = new Message(new byte[1], new Dictionary <string, string>(), badProperties);
await Assert.ThrowsAsync <EdgeHubMessageTooLargeException>(() => routingEdgeHub.ProcessDeviceMessage(identity.Object, badMessage));
}
public async Task AddEdgeSystemPropertiesTest()
{
// Create a mock endpoint capable of returning a mock processor
var endpoint = new Mock <Endpoint>("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of <IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of <IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny <Endpoint>())).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var endpoints = new HashSet <Endpoint> {
endpoint.Object
};
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
var messageConverter = Mock.Of <Core.IMessageConverter <Devices.Routing.Core.IMessage> >();
// Create mock for IConnectionManager
var connectionManager = Mock.Of <IConnectionManager>();
// Mock of twin manager
var twinManager = Mock.Of <ITwinManager>();
string edgeDeviceId = "testEdgeDevice";
// Test Scenario
var routingEdgeHub = new RoutingEdgeHub(
router,
messageConverter,
connectionManager,
twinManager,
edgeDeviceId,
Mock.Of <IInvokeMethodHandler>(),
Mock.Of <ISubscriptionProcessor>());
Message clientMessage1 = new EdgeMessage.Builder(new byte[0]).Build();
clientMessage1.SystemProperties[SystemProperties.ConnectionDeviceId] = edgeDeviceId;
routingEdgeHub.AddEdgeSystemProperties(clientMessage1);
Assert.True(clientMessage1.SystemProperties.ContainsKey(SystemProperties.EdgeHubOriginInterface));
Assert.True(clientMessage1.SystemProperties.ContainsKey(SystemProperties.EdgeMessageId));
Assert.Equal(Constants.InternalOriginInterface, clientMessage1.SystemProperties[SystemProperties.EdgeHubOriginInterface]);
Message clientMessage2 = new EdgeMessage.Builder(new byte[0]).Build();
clientMessage2.SystemProperties[SystemProperties.ConnectionDeviceId] = "downstreamDevice";
routingEdgeHub.AddEdgeSystemProperties(clientMessage2);
Assert.True(clientMessage2.SystemProperties.ContainsKey(SystemProperties.EdgeHubOriginInterface));
Assert.True(clientMessage2.SystemProperties.ContainsKey(SystemProperties.EdgeMessageId));
Assert.Equal(Constants.DownstreamOriginInterface, clientMessage2.SystemProperties[SystemProperties.EdgeHubOriginInterface]);
Message clientMessage3 = new EdgeMessage.Builder(new byte[0]).Build();
routingEdgeHub.AddEdgeSystemProperties(clientMessage3);
Assert.False(clientMessage3.SystemProperties.ContainsKey(SystemProperties.EdgeHubOriginInterface));
Assert.True(clientMessage3.SystemProperties.ContainsKey(SystemProperties.EdgeMessageId));
}
public async Task InvokeMethodLateSubscriptionTest()
{
// Create a mock endpoint capable of returning a mock processor
var processor = Mock.Of <IProcessor>();
var endpoint = new Mock <Endpoint>("myId");
endpoint.Setup(ep => ep.CreateProcessor()).Returns(processor);
endpoint.SetupGet(ep => ep.Id).Returns("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of <IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of <IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny <Endpoint>())).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var endpoints = new HashSet <Endpoint> {
endpoint.Object
};
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
// Create mock message converter to generate a message with source matching the route
var messageConverter = Mock.Of <Core.IMessageConverter <Devices.Routing.Core.IMessage> >();
var methodRequest = new DirectMethodRequest("device1/module1", "shutdown", null, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(20));
// Mock of twin manager
var twinManager = Mock.Of <ITwinManager>();
// DeviceListener
var identity = Mock.Of <IModuleIdentity>(m => m.DeviceId == "device1" && m.ModuleId == "module1" && m.Id == "device1/module1");
var cloudProxy = new Mock <ICloudProxy>();
// ICloudConnectionProvider
var cloudConnection = Mock.Of <ICloudConnection>(c => c.IsActive && c.CloudProxy == Option.Some(cloudProxy.Object));
var cloudConnectionProvider = new Mock <ICloudConnectionProvider>();
cloudConnectionProvider.Setup(c => c.Connect(It.IsAny <IIdentity>(), It.IsAny <Action <string, CloudConnectionStatus> >()))
.ReturnsAsync(Try.Success(cloudConnection));
var deviceConnectivitymanager = Mock.Of <IDeviceConnectivityManager>();
var connectionManager = new ConnectionManager(cloudConnectionProvider.Object, Mock.Of <ICredentialsCache>(), new IdentityProvider("myIotHub"), deviceConnectivitymanager);
IInvokeMethodHandler invokeMethodHandler = new InvokeMethodHandler(connectionManager);
var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, Mock.Of <IDeviceConnectivityManager>());
// RoutingEdgeHub
var routingEdgeHub = new RoutingEdgeHub(
router,
messageConverter,
connectionManager,
twinManager,
"testEdgeDevice",
invokeMethodHandler,
subscriptionProcessor);
var deviceMessageHandler = new DeviceMessageHandler(identity, routingEdgeHub, connectionManager);
var underlyingDeviceProxy = new Mock <IDeviceProxy>();
// Arrange
Message message = new EdgeMessage.Builder(new byte[0]).Build();
message.Properties[SystemProperties.CorrelationId] = methodRequest.CorrelationId;
message.Properties[SystemProperties.StatusCode] = "200";
underlyingDeviceProxy.Setup(d => d.InvokeMethodAsync(It.IsAny <DirectMethodRequest>()))
.Callback(() => deviceMessageHandler.ProcessMethodResponseAsync(message))
.ReturnsAsync(default(DirectMethodResponse));
underlyingDeviceProxy.SetupGet(d => d.IsActive).Returns(true);
// Act
deviceMessageHandler.BindDeviceProxy(underlyingDeviceProxy.Object);
Task <DirectMethodResponse> responseTask = routingEdgeHub.InvokeMethodAsync(identity.Id, methodRequest);
// Assert
Assert.False(responseTask.IsCompleted);
// Act
await routingEdgeHub.AddSubscription(identity.Id, DeviceSubscription.Methods);
await Task.Delay(TimeSpan.FromSeconds(5));
// Assert
Assert.True(responseTask.IsCompleted);
Assert.Equal(methodRequest.CorrelationId, responseTask.Result.CorrelationId);
Assert.Equal(200, responseTask.Result.Status);
Assert.False(responseTask.Result.Exception.HasValue);
Assert.Equal(HttpStatusCode.OK, responseTask.Result.HttpStatusCode);
}
protected override void Load(ContainerBuilder builder)
{
// IMessageConverter<IRoutingMessage>
builder.Register(c => new RoutingMessageConverter())
.As <Core.IMessageConverter <IRoutingMessage> >()
.SingleInstance();
// IRoutingPerfCounter
builder.Register(
c =>
{
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
return(Routing.PerfCounter);
})
.As <IRoutingPerfCounter>()
.AutoActivate()
.SingleInstance();
// IRoutingUserAnalyticsLogger
builder.Register(
c =>
{
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
return(Routing.UserAnalyticsLogger);
})
.As <IRoutingUserAnalyticsLogger>()
.AutoActivate()
.SingleInstance();
// IRoutingUserMetricLogger
builder.Register(
c =>
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
return(Routing.UserMetricLogger);
})
.As <IRoutingUserMetricLogger>()
.AutoActivate()
.SingleInstance();
// IMessageConverter<Message>
builder.Register(c => new DeviceClientMessageConverter())
.As <Core.IMessageConverter <Message> >()
.SingleInstance();
// IMessageConverter<Twin>
builder.Register(c => new TwinMessageConverter())
.As <Core.IMessageConverter <Twin> >()
.SingleInstance();
// IMessageConverter<TwinCollection>
builder.Register(c => new TwinCollectionMessageConverter())
.As <Core.IMessageConverter <TwinCollection> >()
.SingleInstance();
// IMessageConverterProvider
builder.Register(
c => new MessageConverterProvider(new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), c.Resolve <Core.IMessageConverter <Message> >() },
{ typeof(Twin), c.Resolve <Core.IMessageConverter <Twin> >() },
{ typeof(TwinCollection), c.Resolve <Core.IMessageConverter <TwinCollection> >() }
}))
.As <IMessageConverterProvider>()
.SingleInstance();
// IDeviceConnectivityManager
builder.Register(
c =>
{
IDeviceConnectivityManager deviceConnectivityManager = new DeviceConnectivityManager(this.connectivityCheckFrequency, TimeSpan.FromMinutes(2));
return(deviceConnectivityManager);
})
.As <IDeviceConnectivityManager>()
.SingleInstance();
// IDeviceClientProvider
builder.Register(c =>
{
IClientProvider underlyingClientProvider = new ClientProvider();
IClientProvider connectivityAwareClientProvider = new ConnectivityAwareClientProvider(underlyingClientProvider, c.Resolve <IDeviceConnectivityManager>());
return(connectivityAwareClientProvider);
})
.As <IClientProvider>()
.SingleInstance();
// Task<ICloudConnectionProvider>
builder.Register(
async c =>
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
var clientProvider = c.Resolve <IClientProvider>();
var tokenProvider = c.ResolveNamed <ITokenProvider>("EdgeHubClientAuthTokenProvider");
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
this.connectionPoolSize,
clientProvider,
this.upstreamProtocol,
tokenProvider,
deviceScopeIdentitiesCache,
TimeSpan.FromMinutes(60));
return(cloudConnectionProvider);
})
.As <Task <ICloudConnectionProvider> >()
.SingleInstance();
// Task<ICredentialsStore>
builder.Register(async c =>
{
if (this.cacheTokens)
{
IKeyValueStore <string, string> encryptedStore = await c.ResolveNamed <Task <IKeyValueStore <string, string> > >("EncryptedStore");
return(new TokenCredentialsStore(encryptedStore));
}
else
{
return(new NullCredentialsStore() as ICredentialsStore);
}
})
.As <Task <ICredentialsStore> >()
.SingleInstance();
// Task<IConnectionManager>
builder.Register(
async c =>
{
ICloudConnectionProvider cloudConnectionProvider = await c.Resolve <Task <ICloudConnectionProvider> >();
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, this.maxConnectedClients);
return(connectionManager);
})
.As <Task <IConnectionManager> >()
.SingleInstance();
// Task<IEndpointFactory>
builder.Register(async c =>
{
var messageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(new EndpointFactory(connectionManager, messageConverter, this.edgeDeviceId) as IEndpointFactory);
})
.As <Task <IEndpointFactory> >()
.SingleInstance();
// Task<RouteFactory>
builder.Register(async c => new EdgeRouteFactory(await c.Resolve <Task <IEndpointFactory> >()) as RouteFactory)
.As <Task <RouteFactory> >()
.SingleInstance();
// RouterConfig
builder.Register(c => new RouterConfig(Enumerable.Empty <Route>()))
.As <RouterConfig>()
.SingleInstance();
if (!this.isStoreAndForwardEnabled)
{
// EndpointExecutorConfig
builder.Register(
c =>
{
RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1));
TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1);
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
return(new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(c => new SyncEndpointExecutorFactory(c.Resolve <EndpointExecutorConfig>()))
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
var routerConfig = c.Resolve <RouterConfig>();
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory);
return(router);
})
.As <Task <Router> >()
.SingleInstance();
// Task<ITwinManager>
builder.Register(async c =>
{
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>()));
})
.As <Task <ITwinManager> >()
.SingleInstance();
}
else
{
// EndpointExecutorConfig
builder.Register(
c =>
{
// Endpoint executor config values -
// ExponentialBackoff - minBackoff = 1s, maxBackoff = 60s, delta (used to add randomness to backoff) - 1s (default)
// Num of retries = int.MaxValue(we want to keep retrying till the message is sent)
// Revive period - period for which the endpoint should be considered dead if it doesn't respond - 1 min (we want to try continuously till the message expires)
// Timeout - time for which we want for the ack from the endpoint = 30s
// TODO - Should the number of retries be tied to the Store and Forward ttl? Not
// doing that right now as that value can be changed at runtime, but these settings
// cannot. Need to make the number of retries dynamically configurable for that.
TimeSpan minWait = TimeSpan.FromSeconds(1);
TimeSpan maxWait = TimeSpan.FromSeconds(60);
TimeSpan delta = TimeSpan.FromSeconds(1);
int retries = int.MaxValue;
RetryStrategy retryStrategy = new ExponentialBackoff(retries, minWait, maxWait, delta);
TimeSpan timeout = TimeSpan.FromSeconds(30);
TimeSpan revivePeriod = TimeSpan.FromSeconds(30);
return(new EndpointExecutorConfig(timeout, retryStrategy, revivePeriod));
})
.As <EndpointExecutorConfig>()
.SingleInstance();
// ICheckpointStore
builder.Register(c => CheckpointStore.Create(c.Resolve <IDbStoreProvider>()))
.As <ICheckpointStore>()
.SingleInstance();
// IMessageStore
builder.Register(
c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, TimeSpan.MaxValue);
return(messageStore);
})
.As <IMessageStore>()
.SingleInstance();
// IEndpointExecutorFactory
builder.Register(
c =>
{
var endpointExecutorConfig = c.Resolve <EndpointExecutorConfig>();
var messageStore = c.Resolve <IMessageStore>();
IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(10, TimeSpan.FromSeconds(10)), messageStore);
return(endpointExecutorFactory);
})
.As <IEndpointExecutorFactory>()
.SingleInstance();
// Task<Router>
builder.Register(
async c =>
{
var checkpointStore = c.Resolve <ICheckpointStore>();
var routerConfig = c.Resolve <RouterConfig>();
var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>();
return(await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory, checkpointStore));
})
.As <Task <Router> >()
.SingleInstance();
// Task<ITwinManager>
builder.Register(async c =>
{
var dbStoreProvider = c.Resolve <IDbStoreProvider>();
var messageConverterProvider = c.Resolve <IMessageConverterProvider>();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.Some <IStoreProvider>(new StoreProvider(dbStoreProvider))));
})
.As <Task <ITwinManager> >()
.SingleInstance();
}
// IClientCredentials "EdgeHubCredentials"
builder.Register(
c =>
{
var identityFactory = c.Resolve <IClientCredentialsFactory>();
IClientCredentials edgeHubCredentials = this.connectionString.Map(cs => identityFactory.GetWithConnectionString(cs)).GetOrElse(
() => identityFactory.GetWithIotEdged(this.edgeDeviceId, this.edgeModuleId));
return(edgeHubCredentials);
})
.Named <IClientCredentials>("EdgeHubCredentials")
.SingleInstance();
// Task<ICloudProxy> "EdgeHubCloudProxy"
builder.Register(
async c =>
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
Try <ICloudProxy> cloudProxyTry = await connectionManager.CreateCloudConnectionAsync(edgeHubCredentials);
if (!cloudProxyTry.Success)
{
throw new EdgeHubConnectionException("Edge hub is unable to connect to IoT Hub", cloudProxyTry.Exception);
}
ICloudProxy cloudProxy = cloudProxyTry.Value;
return(cloudProxy);
})
.Named <Task <ICloudProxy> >("EdgeHubCloudProxy")
.SingleInstance();
// Task<IInvokeMethodHandler>
builder.Register(async c =>
{
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
return(new InvokeMethodHandler(connectionManager) as IInvokeMethodHandler);
})
.As <Task <IInvokeMethodHandler> >()
.SingleInstance();
// Task<IEdgeHub>
builder.Register(
async c =>
{
var routingMessageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >();
var routerTask = c.Resolve <Task <Router> >();
var twinManagerTask = c.Resolve <Task <ITwinManager> >();
var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >();
var connectionManagerTask = c.Resolve <Task <IConnectionManager> >();
Router router = await routerTask;
ITwinManager twinManager = await twinManagerTask;
IConnectionManager connectionManager = await connectionManagerTask;
IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask;
IEdgeHub hub = new RoutingEdgeHub(router, routingMessageConverter,
connectionManager, twinManager, this.edgeDeviceId, invokeMethodHandler);
return(hub);
})
.As <Task <IEdgeHub> >()
.SingleInstance();
// Task<ConfigUpdater>
builder.Register(
async c =>
{
IMessageStore messageStore = this.isStoreAndForwardEnabled ? c.Resolve <IMessageStore>() : null;
Router router = await c.Resolve <Task <Router> >();
var configUpdater = new ConfigUpdater(router, messageStore);
return(configUpdater);
})
.As <Task <ConfigUpdater> >()
.SingleInstance();
// Task<IConfigSource>
builder.Register(
async c =>
{
RouteFactory routeFactory = await c.Resolve <Task <RouteFactory> >();
if (this.useTwinConfig)
{
var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials");
var twinCollectionMessageConverter = c.Resolve <Core.IMessageConverter <TwinCollection> >();
var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >();
ITwinManager twinManager = await c.Resolve <Task <ITwinManager> >();
ICloudProxy cloudProxy = await c.ResolveNamed <Task <ICloudProxy> >("EdgeHubCloudProxy");
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await c.Resolve <Task <IDeviceScopeIdentitiesCache> >();
IConfigSource edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials,
edgeHub,
twinManager,
connectionManager,
cloudProxy,
routeFactory,
twinCollectionMessageConverter,
twinMessageConverter,
this.versionInfo,
deviceScopeIdentitiesCache
);
return(edgeHubConnection);
}
else
{
return(new LocalConfigSource(routeFactory, this.routes, this.storeAndForwardConfiguration));
}
})
.As <Task <IConfigSource> >()
.SingleInstance();
// Task<IConnectionProvider>
builder.Register(
async c =>
{
IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >();
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
IConnectionProvider connectionProvider = new ConnectionProvider(connectionManager, edgeHub);
return(connectionProvider);
})
.As <Task <IConnectionProvider> >()
.SingleInstance();
base.Load(builder);
}
async Task <(IMessageConsumer, IMessageConsumer, NullBrokerConnector)> SetupEnvironment()
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
var defaultRetryStrategy = new FixedInterval(5, TimeSpan.FromSeconds(5));
var defaultRevivePeriod = TimeSpan.FromHours(1);
var defaultTimeout = TimeSpan.FromSeconds(60);
var endpointExecutorConfig = new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true);
var cloudProxyDispatcher = new BrokeredCloudProxyDispatcher();
var cloudConnectionProvider = new BrokeredCloudConnectionProvider(cloudProxyDispatcher);
var identityProvider = new IdentityProvider(iotHubName);
var deviceConnectivityManager = new BrokeredDeviceConnectivityManager(cloudProxyDispatcher);
var connectionManager = new ConnectionManager(cloudConnectionProvider, Mock.Of <ICredentialsCache>(), new IdentityProvider(iotHubName), deviceConnectivityManager);
var routingMessageConverter = new RoutingMessageConverter();
var routeFactory = new EdgeRouteFactory(new EndpointFactory(connectionManager, routingMessageConverter, edgeDeviceId, 10, 10));
var routesList = new[] { routeFactory.Create("FROM /messages INTO $upstream") };
var endpoints = routesList.Select(r => r.Endpoint);
var routerConfig = new RouterConfig(endpoints, routesList);
var dbStoreProvider = new InMemoryDbStoreProvider();
var storeProvider = new StoreProvider(dbStoreProvider);
var messageStore = new MessageStore(storeProvider, CheckpointStore.Create(storeProvider), TimeSpan.MaxValue, false, 1800);
var endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(1, TimeSpan.FromMilliseconds(10)), messageStore);
var router = await Router.CreateAsync(Guid.NewGuid().ToString(), iotHubName, routerConfig, endpointExecutorFactory);
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Twin), new TwinMessageConverter() },
{ typeof(TwinCollection), new TwinCollectionMessageConverter() }
});
var twinManager = TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>());
var invokeMethodHandler = Mock.Of <IInvokeMethodHandler>();
var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager);
var edgeHub = new RoutingEdgeHub(router, routingMessageConverter, connectionManager, twinManager, edgeDeviceId, edgeModuleName, invokeMethodHandler, subscriptionProcessor, Mock.Of <IDeviceScopeIdentitiesCache>());
var brokerConnector = new NullBrokerConnector(cloudProxyDispatcher);
cloudProxyDispatcher.SetConnector(brokerConnector);
cloudProxyDispatcher.BindEdgeHub(edgeHub);
var connectionProvider = new ConnectionProvider(connectionManager, edgeHub, TimeSpan.FromSeconds(30));
var authenticator = new NullAuthenticator();
var edgeHubIdentity = new ModuleIdentity(iotHubName, edgeDeviceId, edgeModuleName);
var tokenCredentials = new TokenCredentials(edgeHubIdentity, "qwerty", "test-product", Option.Some("test-model"), Option.None <string>(), false);
var systemComponentProvider = new SystemComponentIdProvider(tokenCredentials);
var connectionHandler = default(ConnectionHandler);
connectionHandler = new ConnectionHandler(
Task.FromResult <IConnectionProvider>(connectionProvider),
Task.FromResult <IAuthenticator>(authenticator),
identityProvider,
systemComponentProvider,
DeviceProxyFactory);
DeviceProxy DeviceProxyFactory(IIdentity identity, bool isDirectClient)
{
return(new DeviceProxy(identity, isDirectClient, connectionHandler, Mock.Of <ITwinHandler>(), Mock.Of <IModuleToModuleMessageHandler>(), Mock.Of <ICloud2DeviceMessageHandler>(), Mock.Of <IDirectMethodHandler>()));
}
var cloud2DeviceMessageHandler = new Cloud2DeviceMessageHandler(connectionHandler);
var moduleToModuleMessageHandler = new ModuleToModuleMessageHandler(connectionHandler, identityProvider, new ModuleToModuleResponseTimeout(TimeSpan.FromSeconds(10)));
var directMethodHandler = new DirectMethodHandler(connectionHandler, identityProvider);
var twinHandler = new TwinHandler(connectionHandler, identityProvider);
var subscriptionChangeHandler = new SubscriptionChangeHandler(
cloud2DeviceMessageHandler,
moduleToModuleMessageHandler,
directMethodHandler,
twinHandler,
connectionHandler,
identityProvider);
return(subscriptionChangeHandler, cloudProxyDispatcher, brokerConnector);
}
public async Task InvokeMethodNoSubscriptionTest()
{
// Create a mock endpoint capable of returning a mock processor
var processor = Mock.Of <IProcessor>();
var endpoint = new Mock <Endpoint>("myId");
endpoint.Setup(ep => ep.CreateProcessor()).Returns(processor);
endpoint.SetupGet(ep => ep.Id).Returns("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of <IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of <IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny <Endpoint>())).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var endpoints = new HashSet <Endpoint> {
endpoint.Object
};
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
// Create mock message converter to generate a message with source matching the route
var messageConverter = Mock.Of <Core.IMessageConverter <IMessage> >();
// Mock of twin manager
var twinManager = Mock.Of <ITwinManager>();
// DeviceListener
var identity = Mock.Of <IModuleIdentity>(m => m.DeviceId == "device1" && m.ModuleId == "module1" && m.Id == "device1/module1");
var cloudProxy = new Mock <ICloudProxy>();
cloudProxy.Setup(c => c.BindCloudListener(It.IsAny <ICloudListener>()));
var underlyingDeviceProxy = new Mock <IDeviceProxy>();
underlyingDeviceProxy.Setup(d => d.InvokeMethodAsync(It.IsAny <DirectMethodRequest>())).ReturnsAsync(default(DirectMethodResponse));
underlyingDeviceProxy.SetupGet(d => d.IsActive).Returns(true);
// ICloudConnectionProvider
var cloudConnection = Mock.Of <ICloudConnection>(c => c.IsActive && c.CloudProxy == Option.Some(cloudProxy.Object));
var cloudConnectionProvider = new Mock <ICloudConnectionProvider>();
cloudConnectionProvider.Setup(c => c.Connect(It.IsAny <IClientCredentials>(), It.IsAny <Action <string, CloudConnectionStatus> >()))
.ReturnsAsync(Try.Success(cloudConnection));
var connectionManager = new ConnectionManager(cloudConnectionProvider.Object);
// RoutingEdgeHub
var routingEdgeHub = new RoutingEdgeHub(router, messageConverter, connectionManager, twinManager, "testEdgeDevice");
var deviceMessageHandler = new DeviceMessageHandler(identity, routingEdgeHub, connectionManager);
var methodRequest = new DirectMethodRequest("device1/module1", "shutdown", null, TimeSpan.FromSeconds(2), TimeSpan.FromMilliseconds(10));
// Act
deviceMessageHandler.BindDeviceProxy(underlyingDeviceProxy.Object);
Task <DirectMethodResponse> responseTask = routingEdgeHub.InvokeMethodAsync(identity.Id, methodRequest);
// Assert
Assert.True(responseTask.IsCompleted);
Assert.Equal(404, responseTask.Result.Status);
}
public async Task ProcessSubscriptionsOnDeviceConnected()
{
// Arrange
string d1 = "d1";
var deviceIdentity = Mock.Of <IIdentity>(d => d.Id == d1);
string m1 = "d2/m1";
var moduleIdentity = Mock.Of <IIdentity>(m => m.Id == m1);
var connectedClients = new List <IIdentity>
{
deviceIdentity,
moduleIdentity
};
IReadOnlyDictionary <DeviceSubscription, bool> device1Subscriptions = new Dictionary <DeviceSubscription, bool>()
{
[DeviceSubscription.Methods] = true,
[DeviceSubscription.DesiredPropertyUpdates] = true
};
IReadOnlyDictionary <DeviceSubscription, bool> module1Subscriptions = new Dictionary <DeviceSubscription, bool>()
{
[DeviceSubscription.Methods] = true,
[DeviceSubscription.ModuleMessages] = true
};
var device1CloudProxy = Mock.Of <ICloudProxy>(dc => dc.SetupDesiredPropertyUpdatesAsync() == Task.CompletedTask &&
dc.SetupCallMethodAsync() == Task.CompletedTask);
Mock.Get(device1CloudProxy).SetupGet(d => d.IsActive).Returns(true);
var module1CloudProxy = Mock.Of <ICloudProxy>(mc => mc.SetupCallMethodAsync() == Task.CompletedTask && mc.IsActive);
var invokeMethodHandler = Mock.Of <IInvokeMethodHandler>(m =>
m.ProcessInvokeMethodSubscription(d1) == Task.CompletedTask &&
m.ProcessInvokeMethodSubscription(m1) == Task.CompletedTask);
var connectionManager = Mock.Of <IConnectionManager>(c =>
c.GetConnectedClients() == connectedClients &&
c.GetSubscriptions(d1) == Option.Some(device1Subscriptions) &&
c.GetSubscriptions(m1) == Option.Some(module1Subscriptions) &&
c.GetCloudConnection(d1) == Task.FromResult(Option.Some(device1CloudProxy)) &&
c.GetCloudConnection(m1) == Task.FromResult(Option.Some(module1CloudProxy)));
var endpoint = new Mock <Endpoint>("myId");
var endpointExecutor = Mock.Of <IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of <IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny <Endpoint>())).ReturnsAsync(endpointExecutor);
var endpoints = new HashSet <Endpoint> {
endpoint.Object
};
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints);
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
var deviceConnectivityManager = Mock.Of <IDeviceConnectivityManager>();
var edgeHub = new RoutingEdgeHub(
router,
Mock.Of <Core.IMessageConverter <IMessage> >(),
connectionManager,
Mock.Of <ITwinManager>(),
"ed1",
invokeMethodHandler,
deviceConnectivityManager);
// Act
Mock.Get(deviceConnectivityManager).Raise(d => d.DeviceConnected += null, new EventArgs());
// Assert
Mock.Get(device1CloudProxy).Verify(d => d.SetupDesiredPropertyUpdatesAsync(), Times.Once);
Mock.Get(device1CloudProxy).Verify(d => d.SetupCallMethodAsync(), Times.Once);
Mock.Get(module1CloudProxy).Verify(m => m.SetupCallMethodAsync(), Times.Once);
Mock.Get(invokeMethodHandler).VerifyAll();
Mock.Get(connectionManager).VerifyAll();
}
