public MqttAdapter(
            Settings settings,
            ISessionStatePersistenceProvider sessionStateManager,
            IDeviceIdentityProvider authProvider,
            IQos2StatePersistenceProvider qos2StateProvider,
            MessagingBridgeFactoryFunc messagingBridgeFactory)
        {
            Contract.Requires(settings != null);
            Contract.Requires(sessionStateManager != null);
            Contract.Requires(authProvider != null);
            Contract.Requires(messagingBridgeFactory != null);

            this.lifetimeCancellation = new CancellationTokenSource();

            if (qos2StateProvider != null)
            {
                this.maxSupportedQosToClient = QualityOfService.ExactlyOnce;
                this.qos2StateProvider       = qos2StateProvider;
            }
            else
            {
                this.maxSupportedQosToClient = QualityOfService.AtLeastOnce;
            }

            this.settings               = settings;
            this.sessionStateManager    = sessionStateManager;
            this.authProvider           = authProvider;
            this.messagingBridgeFactory = messagingBridgeFactory;
        }
Exemple #2
0
        /// <summary>
        /// Configures the Tcp IoTHub Gateway
        /// </summary>
        /// <param name="settingsProvider">Configuration settings</param>
        /// <param name="deviceCredentialProvider">Provides the credentials map for the Tcp device using DeviceId</param>
        public Bootstrapper(ISettingsProvider settingsProvider, IDeviceCredentialProvider deviceCredentialProvider)
        {
            Contract.Requires(settingsProvider != null);
            Contract.Requires(deviceCredentialProvider != null);

            this.closeCompletionSource = new TaskCompletionSource();

            this.settingsProvider   = settingsProvider;
            this.settings           = new Settings(this.settingsProvider);
            this.authProvider       = new SasTokenDeviceIdentityProvider();
            this.credentialProvider = deviceCredentialProvider;
        }
        public Bootstrapper(ISettingsProvider settingsProvider, ISessionStatePersistenceProvider sessionStateManager, IQos2StatePersistenceProvider qos2StateProvider)
        {
            Contract.Requires(settingsProvider != null);
            Contract.Requires(sessionStateManager != null);

            this.closeCompletionSource = new TaskCompletionSource();

            this.settingsProvider    = settingsProvider;
            this.settings            = new Settings(this.settingsProvider);
            this.sessionStateManager = sessionStateManager;
            this.qos2StateProvider   = qos2StateProvider;
            this.authProvider        = new SasTokenDeviceIdentityProvider();
            this.iotHubMessageRouter = new ConfigurableMessageRouter();
        }
        Bootstrapper(ISettingsProvider settingsProvider, ISessionStatePersistenceProvider sessionStateManager, IQos2StatePersistenceProvider qos2StateProvider, IMessageAddressConverter addressConverter)
        {
            Contract.Requires(settingsProvider != null);
            Contract.Requires(sessionStateManager != null);

            this.closeCompletionSource = new TaskCompletionSource();

            this.settingsProvider     = settingsProvider;
            this.settings             = new Settings(this.settingsProvider);
            this.iotHubClientSettings = new IotHubClientSettings(this.settingsProvider);
            this.sessionStateManager  = sessionStateManager;
            this.qos2StateProvider    = qos2StateProvider;
            this.authProvider         = new SasTokenDeviceIdentityProvider();
            this.topicNameConverter   = addressConverter;
        }
        Bootstrapper(ISettingsProvider settingsProvider, ISessionStatePersistenceProvider sessionStateManager, IQos2StatePersistenceProvider qos2StateProvider, IMessageAddressConverter addressConverter)
        {
            Contract.Requires(settingsProvider != null);
            Contract.Requires(sessionStateManager != null);

            this.closeCompletionSource = new TaskCompletionSource();

            this.settingsProvider = settingsProvider;
            this.settings = new Settings(this.settingsProvider);
            this.iotHubClientSettings = new IotHubClientSettings(this.settingsProvider);
            this.sessionStateManager = sessionStateManager;
            this.qos2StateProvider = qos2StateProvider;
            this.authProvider = new SasTokenDeviceIdentityProvider();
            this.topicNameConverter = addressConverter;
        }
Exemple #6
0
        public SocketIoTHubAdapter
        (
            Settings settings,
            IDeviceCredentialProvider credentialProvider,
            IDeviceIdentityProvider authProvider
        )
        {
            Contract.Requires(settings != null);
            Contract.Requires(authProvider != null);
            Contract.Requires(credentialProvider != null);

            this.settings     = settings;
            this.authProvider = authProvider;
            this.messages     = new List <string>();
        }
Exemple #7
0
 public MqttWebSocketListener(
     Settings settings,
     MessagingBridgeFactoryFunc messagingBridgeFactoryFunc,
     IDeviceIdentityProvider identityProvider,
     Func <ISessionStatePersistenceProvider> sessionProviderFactory,
     IEventLoopGroup workerGroup,
     IByteBufferAllocator byteBufferAllocator,
     bool autoRead,
     int mqttDecoderMaxMessageSize
     )
 {
     this.settings = Preconditions.CheckNotNull(settings, nameof(settings));
     this.messagingBridgeFactoryFunc = Preconditions.CheckNotNull(messagingBridgeFactoryFunc, nameof(messagingBridgeFactoryFunc));
     this.identityProvider           = Preconditions.CheckNotNull(identityProvider, nameof(identityProvider));
     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;
 }
        public MqttIotHubAdapter(
            Settings settings,
            ISessionStatePersistenceProvider sessionStateManager,
            IDeviceIdentityProvider authProvider,
            IQos2StatePersistenceProvider qos2StateProvider,
            IMessagingFactory messagingFactory,
            IMessageRouter messageRouter)
        {
            Contract.Requires(settings != null);
            Contract.Requires(sessionStateManager != null);
            Contract.Requires(authProvider != null);
            Contract.Requires(messageRouter != null);

            if (qos2StateProvider != null)
            {
                this.maxSupportedQosToClient = QualityOfService.ExactlyOnce;
                this.qos2StateProvider       = qos2StateProvider;
            }
            else
            {
                this.maxSupportedQosToClient = QualityOfService.AtLeastOnce;
            }

            this.settings            = settings;
            this.sessionStateManager = sessionStateManager;
            this.authProvider        = authProvider;
            this.messagingFactory    = messagingFactory;
            this.messageRouter       = messageRouter;

            this.publishProcessor = new MessageAsyncProcessor <PublishPacket>(this.PublishToServerAsync);
            this.publishProcessor.Completion.OnFault(ShutdownOnPublishToServerFaultAction);

            TimeSpan?ackTimeout = this.settings.DeviceReceiveAckCanTimeout ? this.settings.DeviceReceiveAckTimeout : (TimeSpan?)null;

            this.publishPubAckProcessor = new RequestAckPairProcessor <AckPendingMessageState, PublishPacket>(this.AcknowledgePublishAsync, this.RetransmitNextPublish, ackTimeout);
            this.publishPubAckProcessor.Completion.OnFault(ShutdownOnPubAckFaultAction);
            this.publishPubRecProcessor = new RequestAckPairProcessor <AckPendingMessageState, PublishPacket>(this.AcknowledgePublishReceiveAsync, this.RetransmitNextPublish, ackTimeout);
            this.publishPubRecProcessor.Completion.OnFault(ShutdownOnPubRecFaultAction);
            this.pubRelPubCompProcessor = new RequestAckPairProcessor <CompletionPendingMessageState, PubRelPacket>(this.AcknowledgePublishCompleteAsync, this.RetransmitNextPublishRelease, ackTimeout);
            this.pubRelPubCompProcessor.Completion.OnFault(ShutdownOnPubCompFaultAction);
        }
        public MqttIotHubAdapter(
            Settings settings,
            ISessionStatePersistenceProvider sessionStateManager,
            IDeviceIdentityProvider authProvider,
            IQos2StatePersistenceProvider qos2StateProvider,
            IMessagingFactory messagingFactory,
            IMessageRouter messageRouter)
        {
            Contract.Requires(settings != null);
            Contract.Requires(sessionStateManager != null);
            Contract.Requires(authProvider != null);
            Contract.Requires(messageRouter != null);

            if (qos2StateProvider != null)
            {
                this.maxSupportedQosToClient = QualityOfService.ExactlyOnce;
                this.qos2StateProvider = qos2StateProvider;
            }
            else
            {
                this.maxSupportedQosToClient = QualityOfService.AtLeastOnce;
            }

            this.settings = settings;
            this.sessionStateManager = sessionStateManager;
            this.authProvider = authProvider;
            this.messagingFactory = messagingFactory;
            this.messageRouter = messageRouter;

            this.publishProcessor = new MessageAsyncProcessor<PublishPacket>(this.PublishToServerAsync);
            this.publishProcessor.Completion.OnFault(ShutdownOnPublishToServerFaultAction);

            TimeSpan? ackTimeout = this.settings.DeviceReceiveAckCanTimeout ? this.settings.DeviceReceiveAckTimeout : (TimeSpan?)null;
            this.publishPubAckProcessor = new RequestAckPairProcessor<AckPendingMessageState, PublishPacket>(this.AcknowledgePublishAsync, this.RetransmitNextPublish, ackTimeout);
            this.publishPubAckProcessor.Completion.OnFault(ShutdownOnPubAckFaultAction);
            this.publishPubRecProcessor = new RequestAckPairProcessor<AckPendingMessageState, PublishPacket>(this.AcknowledgePublishReceiveAsync, this.RetransmitNextPublish, ackTimeout);
            this.publishPubRecProcessor.Completion.OnFault(ShutdownOnPubRecFaultAction);
            this.pubRelPubCompProcessor = new RequestAckPairProcessor<CompletionPendingMessageState, PubRelPacket>(this.AcknowledgePublishCompleteAsync, this.RetransmitNextPublishRelease, ackTimeout);
            this.pubRelPubCompProcessor.Completion.OnFault(ShutdownOnPubCompFaultAction);
        }
Exemple #10
0
 public MqttProtocolHead(ISettingsProvider settingsProvider,
                         X509Certificate tlsCertificate,
                         IMqttConnectionProvider mqttConnectionProvider,
                         IDeviceIdentityProvider identityProvider,
                         ISessionStatePersistenceProvider sessionProvider,
                         IWebSocketListenerRegistry webSocketListenerRegistry,
                         IByteBufferAllocator byteBufferAllocator,
                         bool clientCertAuthAllowed,
                         string caChainPath)
 {
     this.settingsProvider          = Preconditions.CheckNotNull(settingsProvider, nameof(settingsProvider));
     this.tlsCertificate            = Preconditions.CheckNotNull(tlsCertificate, nameof(tlsCertificate));
     this.mqttConnectionProvider    = Preconditions.CheckNotNull(mqttConnectionProvider, nameof(mqttConnectionProvider));
     this.identityProvider          = Preconditions.CheckNotNull(identityProvider, nameof(identityProvider));
     this.sessionProvider           = Preconditions.CheckNotNull(sessionProvider, nameof(sessionProvider));
     this.webSocketListenerRegistry = Preconditions.CheckNotNull(webSocketListenerRegistry, nameof(webSocketListenerRegistry));
     this.byteBufferAllocator       = Preconditions.CheckNotNull(byteBufferAllocator);
     this.clientCertAuthAllowed     = clientCertAuthAllowed;
     this.caCertChain = clientCertAuthAllowed
         ? this.GetCaChainCerts(Preconditions.CheckNonWhiteSpace(caChainPath, nameof(this.caCertChain)))
         : Option.None <IList <X509Certificate2> >();
 }
Exemple #11
0
        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();

            // IIdentityProvider
            builder.Register(async c =>
            {
                IAuthenticator authenticator = await c.Resolve <Task <IAuthenticator> >();
                return(new DeviceIdentityProvider(authenticator, c.Resolve <IClientCredentialsFactory>(), this.clientCertAuthAllowed) as IDeviceIdentityProvider);
            })
            .As <Task <IDeviceIdentityProvider> >()
            .SingleInstance();

            // Task<ISessionStatePersistenceProvider>
            builder.Register(
                async c =>
            {
                if (this.isStoreAndForwardEnabled)
                {
                    IEntityStore <string, SessionState> entityStore = new StoreProvider(c.Resolve <IDbStoreProvider>()).GetEntityStore <string, SessionState>(Core.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 settingsProvider                           = c.Resolve <ISettingsProvider>();
                var websocketListenerRegistry                  = c.Resolve <IWebSocketListenerRegistry>();
                var byteBufferAllocator                        = c.Resolve <IByteBufferAllocator>();
                var mqttConnectionProviderTask                 = c.Resolve <Task <IMqttConnectionProvider> >();
                var deviceIdentityProviderTask                 = c.Resolve <Task <IDeviceIdentityProvider> >();
                var sessionStatePersistenceProviderTask        = c.Resolve <Task <ISessionStatePersistenceProvider> >();
                IMqttConnectionProvider mqttConnectionProvider = await mqttConnectionProviderTask;
                IDeviceIdentityProvider deviceIdentityProvider = await deviceIdentityProviderTask;
                ISessionStatePersistenceProvider sessionStatePersistenceProvider = await sessionStatePersistenceProviderTask;
                return(new MqttProtocolHead(
                           settingsProvider,
                           this.tlsCertificate,
                           mqttConnectionProvider,
                           deviceIdentityProvider,
                           sessionStatePersistenceProvider,
                           websocketListenerRegistry,
                           byteBufferAllocator,
                           this.clientCertAuthAllowed,
                           this.caChainPath));
            })
            .As <Task <MqttProtocolHead> >()
            .SingleInstance();

            base.Load(builder);
        }