public MqttProtocolHead(
ISettingsProvider settingsProvider,
X509Certificate tlsCertificate,
IMqttConnectionProvider mqttConnectionProvider,
IAuthenticator authenticator,
IUsernameParser usernameParser,
IClientCredentialsFactory clientCredentialsFactory,
ISessionStatePersistenceProvider sessionProvider,
IWebSocketListenerRegistry webSocketListenerRegistry,
IByteBufferAllocator byteBufferAllocator,
IMetadataStore metadataStore,
bool clientCertAuthAllowed,
SslProtocols sslProtocols)
{
this.settingsProvider = Preconditions.CheckNotNull(settingsProvider, nameof(settingsProvider));
this.tlsCertificate = Preconditions.CheckNotNull(tlsCertificate, nameof(tlsCertificate));
this.mqttConnectionProvider = Preconditions.CheckNotNull(mqttConnectionProvider, nameof(mqttConnectionProvider));
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.usernameParser = Preconditions.CheckNotNull(usernameParser, nameof(usernameParser));
this.clientCredentialsFactory = Preconditions.CheckNotNull(clientCredentialsFactory, nameof(clientCredentialsFactory));
this.sessionProvider = Preconditions.CheckNotNull(sessionProvider, nameof(sessionProvider));
this.webSocketListenerRegistry = Preconditions.CheckNotNull(webSocketListenerRegistry, nameof(webSocketListenerRegistry));
this.byteBufferAllocator = Preconditions.CheckNotNull(byteBufferAllocator);
this.clientCertAuthAllowed = clientCertAuthAllowed;
this.metadataStore = Preconditions.CheckNotNull(metadataStore, nameof(metadataStore));
this.sslProtocols = sslProtocols;
}
public AuthAgentController(IAuthenticator authenticator, IUsernameParser usernameParser, IClientCredentialsFactory clientCredentialsFactory, ISystemComponentIdProvider systemComponentIdProvider)
{
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.usernameParser = Preconditions.CheckNotNull(usernameParser, nameof(usernameParser));
this.clientCredentialsFactory = Preconditions.CheckNotNull(clientCredentialsFactory, nameof(clientCredentialsFactory));
this.systemComponentIdProvider = Preconditions.CheckNotNull(systemComponentIdProvider, nameof(systemComponentIdProvider));
}
public CbsNode(IClientCredentialsFactory identityFactory, string iotHubHostName, IAuthenticator authenticator, ICredentialsCache credentialsCache)
{
this.clientCredentialsFactory = identityFactory;
this.iotHubHostName = iotHubHostName;
this.authenticator = authenticator;
this.credentialsCache = credentialsCache;
}
public AmqpWebSocketListener(IAuthenticator authenticator,
IClientCredentialsFactory clientCredentialsFactory)
: base(Constants.WebSocketListenerName)
{
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.clientCredentialsFactory = Preconditions.CheckNotNull(clientCredentialsFactory, nameof(clientCredentialsFactory));
}
public MqttWebSocketListener(
Settings settings,
MessagingBridgeFactoryFunc messagingBridgeFactoryFunc,
IAuthenticator authenticator,
IUsernameParser usernameParser,
IClientCredentialsFactory clientCredentialsFactory,
Func <ISessionStatePersistenceProvider> sessionProviderFactory,
IEventLoopGroup workerGroup,
IByteBufferAllocator byteBufferAllocator,
bool autoRead,
int mqttDecoderMaxMessageSize,
bool clientCertAuthAllowed,
IMetadataStore metadataStore)
{
this.settings = Preconditions.CheckNotNull(settings, nameof(settings));
this.messagingBridgeFactoryFunc = Preconditions.CheckNotNull(messagingBridgeFactoryFunc, nameof(messagingBridgeFactoryFunc));
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.usernameParser = Preconditions.CheckNotNull(usernameParser, nameof(usernameParser));
this.clientCredentialsFactory = Preconditions.CheckNotNull(clientCredentialsFactory, nameof(clientCredentialsFactory));
this.sessionProviderFactory = Preconditions.CheckNotNull(sessionProviderFactory, nameof(sessionProviderFactory));
this.workerGroup = Preconditions.CheckNotNull(workerGroup, nameof(workerGroup));
this.byteBufferAllocator = Preconditions.CheckNotNull(byteBufferAllocator, nameof(byteBufferAllocator));
this.autoRead = autoRead;
this.mqttDecoderMaxMessageSize = mqttDecoderMaxMessageSize;
this.clientCertAuthAllowed = clientCertAuthAllowed;
this.metadataStore = Preconditions.CheckNotNull(metadataStore, nameof(metadataStore));
}
public AmqpProtocolHead(
ITransportSettings transportSettings,
AmqpSettings amqpSettings,
ITransportListenerProvider transportListenerProvider,
IWebSocketListenerRegistry webSocketListenerRegistry,
IAuthenticator authenticator,
IClientCredentialsFactory clientCredentialsFactory)
{
this.syncLock = new AsyncLock();
this.transportSettings = Preconditions.CheckNotNull(transportSettings, nameof(transportSettings));
this.amqpSettings = Preconditions.CheckNotNull(amqpSettings, nameof(amqpSettings));
this.transportListenerProvider = Preconditions.CheckNotNull(transportListenerProvider);
this.webSocketListenerRegistry = Preconditions.CheckNotNull(webSocketListenerRegistry);
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.clientCredentialsFactory = Preconditions.CheckNotNull(clientCredentialsFactory, nameof(clientCredentialsFactory));
this.connectionSettings = new AmqpConnectionSettings
{
ContainerId = "DeviceGateway_" + Guid.NewGuid().ToString("N"),
HostName = transportSettings.HostName,
// 'IdleTimeOut' on connection settings will be used to close connection if server hasn't
// received any packet for 'IdleTimeout'
// Open frame send to client will have the IdleTimeout set and the client will do heart beat
// every 'IdleTimeout * 7 / 8'
// If server doesn't receive any packet till 'ServiceMaxConnectionIdleTimeout' the connection will be closed
IdleTimeOut = Constants.DefaultAmqpConnectionIdleTimeoutInMilliSeconds
};
this.incomingConnectionMap = new ConcurrentDictionary <uint, AmqpConnection>();
}
public DeviceIdentityProvider(IAuthenticator authenticator, IClientCredentialsFactory clientCredentialsFactory, bool clientCertAuthAllowed)
{
this.authenticator = authenticator;
this.clientCredentialsFactory = clientCredentialsFactory;
this.clientCertAuthAllowed = clientCertAuthAllowed;
this.remoteCertificate = Option.None <X509Certificate2>();
this.remoteCertificateChain = new List <X509Certificate2>();
}
public CbsNode(IClientCredentialsFactory identityFactory, string iotHubHostName, IAuthenticator authenticator, ICredentialsCache credentialsCache)
{
this.clientCredentialsFactory = identityFactory;
this.iotHubHostName = iotHubHostName;
this.authenticator = authenticator;
this.credentialsCache = credentialsCache;
this.authenticationUpdateTask = Task.FromResult(AmqpAuthentication.Unauthenticated);
}
public HttpRequestAuthenticator(
IAuthenticator authenticator,
IClientCredentialsFactory identityFactory,
string iotHubName)
{
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.identityFactory = Preconditions.CheckNotNull(identityFactory, nameof(identityFactory));
this.iotHubName = Preconditions.CheckNonWhiteSpace(iotHubName, nameof(iotHubName));
}
public EdgeTlsTransportListener(
TlsTransportSettings transportSettings,
IAuthenticator authenticator,
IClientCredentialsFactory clientCredentialsProvider)
: base(transportSettings)
{
this.clientCredentialsProvider = Preconditions.CheckNotNull(clientCredentialsProvider, nameof(clientCredentialsProvider));
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
}
public static AmqpSettings GetDefaultAmqpSettings(
string iotHubHostName,
IAuthenticator authenticator,
IClientCredentialsFactory identityFactory,
ILinkHandlerProvider linkHandlerProvider,
IConnectionProvider connectionProvider,
ICredentialsCache credentialsCache)
{
Preconditions.CheckNotNull(authenticator, nameof(authenticator));
Preconditions.CheckNotNull(identityFactory, nameof(identityFactory));
Preconditions.CheckNotNull(linkHandlerProvider, nameof(linkHandlerProvider));
Preconditions.CheckNonWhiteSpace(iotHubHostName, nameof(iotHubHostName));
Preconditions.CheckNotNull(connectionProvider, nameof(connectionProvider));
var settings = new AmqpSettings
{
AllowAnonymousConnection = true,
RequireSecureTransport = true,
RuntimeProvider = new AmqpRuntimeProvider(linkHandlerProvider, true, identityFactory, authenticator, iotHubHostName, connectionProvider, credentialsCache)
};
// Add all transport providers we want to support.
AddSaslProvider();
AddAmqpProvider();
return(settings);
void AddSaslProvider()
{
var saslProvider = new SaslTransportProvider
{
MaxFrameSize = 65536,
};
saslProvider.Versions.Add(Constants.AmqpVersion100);
// TODO: Verify if this handler still needs to be added. It looks like at some point in the past
// SASL EXTERNAL was used to do CBS. Since then we have moved away from that and are using
// SASL ANONYMOUS to do CBS. So this may not be needed anymore depending on back-compat
// needs (i.e. old clients that are still using EXTERNAL for CBS).
// saslProvider.AddHandler(new SaslExternalHandler());
saslProvider.AddHandler(new SaslAnonymousHandler()); // CBS for other clients
// This handler implements SAS key based auth.
saslProvider.AddHandler(new SaslPlainHandler(new EdgeHubSaslPlainAuthenticator(authenticator, identityFactory, iotHubHostName)));
settings.TransportProviders.Add(saslProvider);
}
void AddAmqpProvider()
{
var amqpProvider = new AmqpTransportProvider();
amqpProvider.Versions.Add(Constants.AmqpVersion100);
settings.TransportProviders.Add(amqpProvider);
}
}
public EdgeTlsTransportSettings(
TransportSettings innerSettings,
bool isInitiator,
IAuthenticator authenticator,
IClientCredentialsFactory clientCredentialsProvider)
: base(innerSettings, isInitiator)
{
this.clientCredentialsProvider = Preconditions.CheckNotNull(clientCredentialsProvider, nameof(clientCredentialsProvider));
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
}
public AuthenticationMiddleware(
RequestDelegate next,
Task <IAuthenticator> authenticatorTask,
IClientCredentialsFactory identityFactory,
string iotHubName)
{
this.next = next;
this.authenticatorTask = Preconditions.CheckNotNull(authenticatorTask, nameof(authenticatorTask));
this.identityFactory = Preconditions.CheckNotNull(identityFactory, nameof(identityFactory));
this.iotHubName = Preconditions.CheckNonWhiteSpace(iotHubName, nameof(iotHubName));
}
public EdgeX509Principal(
X509CertificateIdentity identity,
IList <X509Certificate2> chainCertificates,
IAuthenticator authenticator,
IClientCredentialsFactory clientCredentialsProvider)
: base(identity)
{
this.chainCertificates = Preconditions.CheckNotNull(chainCertificates, nameof(chainCertificates));
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.clientCredentialsProvider = Preconditions.CheckNotNull(clientCredentialsProvider, nameof(clientCredentialsProvider));
}
public EdgeTlsTransport(
TransportBase innerTransport,
TlsTransportSettings tlsSettings,
IAuthenticator authenticator,
IClientCredentialsFactory clientCredentialsProvider)
: base(innerTransport, tlsSettings)
{
this.clientCredentialsProvider = Preconditions.CheckNotNull(clientCredentialsProvider, nameof(clientCredentialsProvider));
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.remoteCertificateChain = null;
}
public AmqpRuntimeProvider(ILinkHandlerProvider linkHandlerProvider, bool requireSecureTransport,
IClientCredentialsFactory clientCredentialsFactory, IAuthenticator authenticator,
string iotHubHostName, IConnectionProvider connectionProvider, ICredentialsCache credentialsCache)
{
this.linkHandlerProvider = Preconditions.CheckNotNull(linkHandlerProvider, nameof(linkHandlerProvider));
this.requireSecureTransport = Preconditions.CheckNotNull(requireSecureTransport, nameof(requireSecureTransport));
this.clientCredentialsFactory = Preconditions.CheckNotNull(clientCredentialsFactory, nameof(clientCredentialsFactory));
this.iotHubHostName = Preconditions.CheckNonWhiteSpace(iotHubHostName, nameof(iotHubHostName));
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.connectionProvider = Preconditions.CheckNotNull(connectionProvider, nameof(connectionProvider));
this.credentialsCache = Preconditions.CheckNotNull(credentialsCache, nameof(credentialsCache));
}
public HttpProxiedCertificateExtractor(
IAuthenticator authenticator,
IClientCredentialsFactory identityFactory,
string iotHubName,
string edgeDeviceId,
string proxyModuleId)
{
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.identityFactory = Preconditions.CheckNotNull(identityFactory, nameof(identityFactory));
this.iotHubName = Preconditions.CheckNonWhiteSpace(iotHubName, nameof(iotHubName));
this.edgeDeviceId = Preconditions.CheckNonWhiteSpace(edgeDeviceId, nameof(edgeDeviceId));
this.proxyModuleId = Preconditions.CheckNonWhiteSpace(proxyModuleId, nameof(proxyModuleId));
}
public DeviceIdentityProvider(
IAuthenticator authenticator,
IClientCredentialsFactory clientCredentialsFactory,
IMetadataStore metadataStore,
bool clientCertAuthAllowed)
{
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.clientCredentialsFactory = Preconditions.CheckNotNull(clientCredentialsFactory, nameof(clientCredentialsFactory));
this.metadataStore = Preconditions.CheckNotNull(metadataStore, nameof(metadataStore));
this.clientCertAuthAllowed = clientCertAuthAllowed;
this.remoteCertificate = Option.None <X509Certificate2>();
this.remoteCertificateChain = new List <X509Certificate2>();
}
public AuthAgentProtocolHead(
IAuthenticator authenticator,
IMetadataStore metadataStore,
IUsernameParser usernameParser,
IClientCredentialsFactory clientCredentialsFactory,
ISystemComponentIdProvider systemComponentIdProvider,
AuthAgentProtocolHeadConfig config)
{
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.metadataStore = Preconditions.CheckNotNull(metadataStore, nameof(metadataStore));
this.usernameParser = Preconditions.CheckNotNull(usernameParser, nameof(usernameParser));
this.clientCredentialsFactory = Preconditions.CheckNotNull(clientCredentialsFactory, nameof(clientCredentialsFactory));
this.systemComponentIdProvider = Preconditions.CheckNotNull(systemComponentIdProvider);
this.config = Preconditions.CheckNotNull(config);
}
public DefaultTransportSettings(
string scheme,
string hostName,
int port,
X509Certificate2 tlsCertificate,
bool clientCertAuthAllowed,
IAuthenticator authenticator,
IClientCredentialsFactory clientCredentialsProvider,
SslProtocols sslProtocols)
{
this.HostName = Preconditions.CheckNonWhiteSpace(hostName, nameof(hostName));
Preconditions.CheckNotNull(clientCredentialsProvider, nameof(clientCredentialsProvider));
Preconditions.CheckNotNull(authenticator, nameof(authenticator));
var address = new UriBuilder
{
Host = hostName,
Port = Preconditions.CheckRange(port, 0, ushort.MaxValue, nameof(port)),
Scheme = Preconditions.CheckNonWhiteSpace(scheme, nameof(scheme))
};
var tcpSettings = new TcpTransportSettings()
{
Host = address.Host,
Port = address.Port
};
var tlsSettings = new EdgeTlsTransportSettings(tcpSettings, false, authenticator, clientCredentialsProvider)
{
TargetHost = address.Host,
Certificate = Preconditions.CheckNotNull(tlsCertificate, nameof(tlsCertificate)),
// NOTE: The following property doesn't appear to be used by the AMQP library.
// Not sure that setting this to true/false makes any difference!
CheckCertificateRevocation = false,
Protocols = sslProtocols
};
if (clientCertAuthAllowed == true)
{
tlsSettings.CertificateValidationCallback = (sender, cert, chain, sslPolicyErrors) => true;
}
this.Settings = tlsSettings;
}
static IWebHost CreateWebHostBuilder(
IAuthenticator authenticator,
IUsernameParser usernameParser,
IClientCredentialsFactory clientCredentialsFactory,
ISystemComponentIdProvider systemComponentIdProvider,
AuthAgentProtocolHeadConfig config)
{
return(WebHost.CreateDefaultBuilder()
.UseStartup <AuthAgentStartup>()
.UseKestrel(serverOptions => serverOptions.Limits.MaxRequestBufferSize = 64 * 1024)
.UseUrls($"http://*:{config.Port}")
.ConfigureServices(s => s.TryAddSingleton(authenticator))
.ConfigureServices(s => s.TryAddSingleton(usernameParser))
.ConfigureServices(s => s.TryAddSingleton(clientCredentialsFactory))
.ConfigureServices(s => s.TryAddSingleton(systemComponentIdProvider))
.ConfigureServices(s => s.TryAddSingleton(config))
.ConfigureServices(s => s.AddControllers().AddNewtonsoftJson())
.ConfigureLogging(c => c.ClearProviders())
.Build());
}
public ServerWebSocketTransport(WebSocket webSocket,
string localEndpoint,
string remoteEndpoint,
string correlationId,
X509Certificate2 clientCert,
IList <X509Certificate2> clientCertChain,
IAuthenticator authenticator,
IClientCredentialsFactory clientCredentialsProvider)
: this(webSocket, localEndpoint, remoteEndpoint, correlationId)
{
Preconditions.CheckNotNull(authenticator, nameof(authenticator));
Preconditions.CheckNotNull(clientCredentialsProvider, nameof(clientCredentialsProvider));
Preconditions.CheckNotNull(clientCert, nameof(clientCert));
Preconditions.CheckNotNull(clientCertChain, nameof(clientCertChain));
// we mark this as authenticated but the real authentication will happen when the credentials are
// evaluated in EdgeX509Principal.AuthenticateAsyc
var x509CertIdentity = new X509CertificateIdentity(clientCert, true);
this.Principal = new EdgeX509Principal(x509CertIdentity, clientCertChain, authenticator, clientCredentialsProvider);
}
protected override void Load(ContainerBuilder builder)
{
// IByteBufferAllocator
builder.Register(
c =>
{
// TODO - We should probably also use some heuristics to make this determination, like how much memory does the system have.
return(this.optimizeForPerformance ? PooledByteBufferAllocator.Default : UnpooledByteBufferAllocator.Default as IByteBufferAllocator);
})
.As <IByteBufferAllocator>()
.SingleInstance();
builder.Register(c => new ByteBufferConverter(c.Resolve <IByteBufferAllocator>()))
.As <IByteBufferConverter>()
.SingleInstance();
// MessageAddressConverter
builder.Register(c => new MessageAddressConverter(this.conversionConfiguration))
.As <MessageAddressConverter>()
.SingleInstance();
// IMessageConverter<IProtocolGatewayMessage>
builder.Register(c => new ProtocolGatewayMessageConverter(c.Resolve <MessageAddressConverter>(), c.Resolve <IByteBufferConverter>()))
.As <IMessageConverter <IProtocolGatewayMessage> >()
.SingleInstance();
// ISettingsProvider
builder.Register(c => new MqttSettingsProvider(this.mqttSettingsConfiguration))
.As <ISettingsProvider>()
.SingleInstance();
// Task<IMqttConnectionProvider>
builder.Register(
async c =>
{
var pgMessageConverter = c.Resolve <IMessageConverter <IProtocolGatewayMessage> >();
var byteBufferConverter = c.Resolve <IByteBufferConverter>();
IConnectionProvider connectionProvider = await c.Resolve <Task <IConnectionProvider> >();
IMqttConnectionProvider mqtt = new MqttConnectionProvider(connectionProvider, pgMessageConverter, byteBufferConverter);
return(mqtt);
})
.As <Task <IMqttConnectionProvider> >()
.SingleInstance();
// Task<ISessionStatePersistenceProvider>
builder.Register(
async c =>
{
if (this.isStoreAndForwardEnabled)
{
IDbStoreProvider dbStoreProvider = await c.Resolve <Task <IDbStoreProvider> >();
IEntityStore <string, SessionState> entityStore = new StoreProvider(dbStoreProvider).GetEntityStore <string, SessionState>(Constants.SessionStorePartitionKey);
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
return(new SessionStateStoragePersistenceProvider(edgeHub, entityStore) as ISessionStatePersistenceProvider);
}
else
{
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
return(new SessionStatePersistenceProvider(edgeHub) as ISessionStatePersistenceProvider);
}
})
.As <Task <ISessionStatePersistenceProvider> >()
.SingleInstance();
// MqttProtocolHead
builder.Register(
async c =>
{
var productInfoStore = await c.Resolve <Task <IProductInfoStore> >();
var settingsProvider = c.Resolve <ISettingsProvider>();
var websocketListenerRegistry = c.Resolve <IWebSocketListenerRegistry>();
var byteBufferAllocator = c.Resolve <IByteBufferAllocator>();
var mqttConnectionProviderTask = c.Resolve <Task <IMqttConnectionProvider> >();
var sessionStatePersistenceProviderTask = c.Resolve <Task <ISessionStatePersistenceProvider> >();
var authenticatorProviderTask = c.Resolve <Task <IAuthenticator> >();
IClientCredentialsFactory clientCredentialsProvider = c.Resolve <IClientCredentialsFactory>();
IMqttConnectionProvider mqttConnectionProvider = await mqttConnectionProviderTask;
ISessionStatePersistenceProvider sessionStatePersistenceProvider = await sessionStatePersistenceProviderTask;
IAuthenticator authenticator = await authenticatorProviderTask;
return(new MqttProtocolHead(
settingsProvider,
this.tlsCertificate,
mqttConnectionProvider,
authenticator,
clientCredentialsProvider,
sessionStatePersistenceProvider,
websocketListenerRegistry,
byteBufferAllocator,
productInfoStore,
this.clientCertAuthAllowed,
this.sslProtocols));
})
.As <Task <MqttProtocolHead> >()
.SingleInstance();
base.Load(builder);
}
public EdgeSaslPlainAuthenticator(IAuthenticator authenticator, IClientCredentialsFactory clientCredentialsFactory, string iotHubHostName)
{
this.clientCredentialsFactory = Preconditions.CheckNotNull(clientCredentialsFactory, nameof(clientCredentialsFactory));
this.authenticator = Preconditions.CheckNotNull(authenticator, nameof(authenticator));
this.iotHubHostName = Preconditions.CheckNonWhiteSpace(iotHubHostName, nameof(iotHubHostName));
}
protected override void Load(ContainerBuilder builder)
{
// ITransportSettings
builder.Register(
async c =>
{
IClientCredentialsFactory clientCredentialsProvider = c.Resolve <IClientCredentialsFactory>();
IAuthenticator authenticator = await c.Resolve <Task <IAuthenticator> >();
ITransportSettings settings = new DefaultTransportSettings(this.scheme, HostName, this.port, this.tlsCertificate, this.clientCertAuthAllowed, authenticator, clientCredentialsProvider);
return(settings);
})
.As <Task <ITransportSettings> >()
.SingleInstance();
// ITransportListenerProvider
builder.Register(c => new AmqpTransportListenerProvider())
.As <ITransportListenerProvider>()
.SingleInstance();
// ILinkHandlerProvider
builder.Register(
c =>
{
IMessageConverter <AmqpMessage> messageConverter = new AmqpMessageConverter();
IMessageConverter <AmqpMessage> twinMessageConverter = new AmqpTwinMessageConverter();
IMessageConverter <AmqpMessage> directMethodMessageConverter = new AmqpDirectMethodMessageConverter();
var identityProvider = c.Resolve <IIdentityProvider>();
var productInfoStore = c.Resolve <IProductInfoStore>();
ILinkHandlerProvider linkHandlerProvider = new LinkHandlerProvider(messageConverter, twinMessageConverter, directMethodMessageConverter, identityProvider, productInfoStore);
return(linkHandlerProvider);
})
.As <ILinkHandlerProvider>()
.SingleInstance();
// Task<AmqpProtocolHead>
builder.Register(
async c =>
{
var identityFactory = c.Resolve <IClientCredentialsFactory>();
var transportSettingsTask = c.Resolve <Task <ITransportSettings> >();
var transportListenerProvider = c.Resolve <ITransportListenerProvider>();
var linkHandlerProvider = c.Resolve <ILinkHandlerProvider>();
var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >();
var authenticatorTask = c.Resolve <Task <IAuthenticator> >();
var connectionProviderTask = c.Resolve <Task <IConnectionProvider> >();
ICredentialsCache credentialsCache = await credentialsCacheTask;
IAuthenticator authenticator = await authenticatorTask;
IConnectionProvider connectionProvider = await connectionProviderTask;
ITransportSettings transportSettings = await transportSettingsTask;
var webSocketListenerRegistry = c.Resolve <IWebSocketListenerRegistry>();
AmqpSettings amqpSettings = AmqpSettingsProvider.GetDefaultAmqpSettings(
this.iotHubHostName,
authenticator,
identityFactory,
linkHandlerProvider,
connectionProvider,
credentialsCache);
return(new AmqpProtocolHead(
transportSettings,
amqpSettings,
transportListenerProvider,
webSocketListenerRegistry,
authenticator,
identityFactory));
})
.As <Task <AmqpProtocolHead> >()
.SingleInstance();
base.Load(builder);
}
protected override void Load(ContainerBuilder builder)
{
// IByteBufferAllocator
builder.Register(
c =>
{
var usePooledBuffers = this.mqttSettingsConfiguration.GetValue("UsePooledBuffers", false);
return(usePooledBuffers ? PooledByteBufferAllocator.Default : UnpooledByteBufferAllocator.Default as IByteBufferAllocator);
})
.As <IByteBufferAllocator>()
.SingleInstance();
builder.Register(c => new ByteBufferConverter(c.Resolve <IByteBufferAllocator>()))
.As <IByteBufferConverter>()
.SingleInstance();
// MessageAddressConverter
builder.Register(c => new MessageAddressConverter(this.conversionConfiguration))
.As <MessageAddressConverter>()
.SingleInstance();
// IMessageConverter<IProtocolGatewayMessage>
builder.Register(c => new ProtocolGatewayMessageConverter(c.Resolve <MessageAddressConverter>(), c.Resolve <IByteBufferConverter>()))
.As <IMessageConverter <IProtocolGatewayMessage> >()
.SingleInstance();
// ISettingsProvider
builder.Register(c => new MqttSettingsProvider(this.mqttSettingsConfiguration))
.As <ISettingsProvider>()
.SingleInstance();
// Task<IMqttConnectionProvider>
builder.Register(
async c =>
{
var pgMessageConverter = c.Resolve <IMessageConverter <IProtocolGatewayMessage> >();
var byteBufferConverter = c.Resolve <IByteBufferConverter>();
IConnectionProvider connectionProvider = await c.Resolve <Task <IConnectionProvider> >();
ISessionStatePersistenceProvider sessionStatePersistenceProvider = await c.Resolve <Task <ISessionStatePersistenceProvider> >();
IMqttConnectionProvider mqtt = new MqttConnectionProvider(connectionProvider, pgMessageConverter, byteBufferConverter, sessionStatePersistenceProvider);
return(mqtt);
})
.As <Task <IMqttConnectionProvider> >()
.SingleInstance();
// Task<ISessionStatePersistenceProvider>
builder.Register(
async c =>
{
if (this.isStoreAndForwardEnabled)
{
IDbStoreProvider dbStoreProvider = await c.Resolve <Task <IDbStoreProvider> >();
IEntityStore <string, SessionState> entityStore = new StoreProvider(dbStoreProvider).GetEntityStore <string, SessionState>(Constants.SessionStorePartitionKey);
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
return(new SessionStateStoragePersistenceProvider(edgeHub, entityStore) as ISessionStatePersistenceProvider);
}
else
{
IEdgeHub edgeHub = await c.Resolve <Task <IEdgeHub> >();
return(new SessionStatePersistenceProvider(edgeHub) as ISessionStatePersistenceProvider);
}
})
.As <Task <ISessionStatePersistenceProvider> >()
.SingleInstance();
// MqttProtocolHead
builder.Register(
async c =>
{
var metadataStore = await c.Resolve <Task <IMetadataStore> >();
var settingsProvider = c.Resolve <ISettingsProvider>();
var websocketListenerRegistry = c.Resolve <IWebSocketListenerRegistry>();
var byteBufferAllocator = c.Resolve <IByteBufferAllocator>();
var mqttConnectionProviderTask = c.Resolve <Task <IMqttConnectionProvider> >();
var sessionStatePersistenceProviderTask = c.Resolve <Task <ISessionStatePersistenceProvider> >();
var authenticatorProviderTask = c.Resolve <Task <IAuthenticator> >();
var usernameParser = c.Resolve <IUsernameParser>();
IClientCredentialsFactory clientCredentialsProvider = c.Resolve <IClientCredentialsFactory>();
IMqttConnectionProvider mqttConnectionProvider = await mqttConnectionProviderTask;
ISessionStatePersistenceProvider sessionStatePersistenceProvider = await sessionStatePersistenceProviderTask;
IAuthenticator authenticator = await authenticatorProviderTask;
return(new MqttProtocolHead(
settingsProvider,
this.tlsCertificate,
mqttConnectionProvider,
authenticator,
usernameParser,
clientCredentialsProvider,
sessionStatePersistenceProvider,
websocketListenerRegistry,
byteBufferAllocator,
metadataStore,
this.clientCertAuthAllowed,
this.sslProtocols));
})
.As <Task <MqttProtocolHead> >()
.SingleInstance();
base.Load(builder);
}
public DeviceIdentityProvider(IAuthenticator authenticator, IClientCredentialsFactory clientCredentialsFactory, bool clientCertAuthAllowed)
{
this.authenticator = authenticator;
this.clientCredentialsFactory = clientCredentialsFactory;
this.clientCertAuthAllowed = clientCertAuthAllowed;
}
