/// <summary>
        /// Initializes the supplied HTTP server <paramref name="configuration"/> based on the
        /// properties of the provided <paramref name="configSection"/>
        /// </summary>
        /// <param name="configuration">The configuration to initialize</param>
        /// <param name="configSection">The configuration section whose properties are to be used
        /// to initialize the <paramref name="configuration"/></param>
        /// <returns>Returns a task that completes when the configuration has been initialized</returns>
        public async Task Initialize(RabbitMQHostConfiguration configuration,
                                     RabbitMQHostConfigurationSection configSection)
        {
            await base.Initialize(configuration, configSection);

            configuration.BaseUri = configSection.BaseUri ?? new Uri(RabbitMQDefaults.BaseUri);

            configuration.Encoding = string.IsNullOrWhiteSpace(configSection.Encoding)
                ? Encoding.UTF8
                : Encoding.GetEncoding(configSection.Encoding);

            configuration.AutoAcknowledge  = configSection.AutoAcknowledge;
            configuration.ConcurrencyLimit = configSection.ConcurrencyLimit;
            configuration.MaxAttempts      = configSection.MaxAttempts;
            configuration.RetryDelay       = configSection.RetryDelay;
            configuration.IsDurable        = configSection.IsDurable;

            var securityTokenServiceFactory = new SecurityTokenServiceFactory(configuration.DiagnosticService);
            var securityTokenConfig         = configSection.SecurityTokens;

            configuration.SecurityTokenService = await securityTokenServiceFactory.InitSecurityTokenService(securityTokenConfig);
        }
Exemple #2
0
        /// <inheritdoc />
        public async Task <IMessageQueueingService> CreateMessageQueueingService(QueueingElement configuration)
        {
            var connectionName = configuration.GetString("connectionName");

            if (string.IsNullOrWhiteSpace(connectionName))
            {
                throw new ConfigurationErrorsException(
                          "Attribute 'connectionName' is required for SQL message queueing service");
            }

            var connectionStringSettings = ConfigurationManager.ConnectionStrings[connectionName];

            if (connectionStringSettings == null)
            {
                throw new ConfigurationErrorsException($"Connection string settings \"{connectionName}\" not found");
            }

            var securityTokenServiceFactory = new SecurityTokenServiceFactory();
            var securityTokenConfig         = configuration.SecurityTokens;
            var securityTokenService        = await securityTokenServiceFactory.InitSecurityTokenService(securityTokenConfig);

            var messageEncryptionServiceFactory = new MessageEncryptionServiceFactory();
            var messageEncryptionConfig         = configuration.Encryption;
            var messageEncryptionService        = await messageEncryptionServiceFactory.InitMessageEncryptionService(messageEncryptionConfig);

            var connectionProvider             = new DefaultConnectionProvider(connectionStringSettings);
            var commandBuildersFactory         = new CommandBuildersFactory(connectionStringSettings);
            var messageQueueingCommandBuilders = commandBuildersFactory.InitMessageQueueingCommandBuilders();
            var messageQueueingOptions         = new SQLMessageQueueingOptions(connectionProvider, messageQueueingCommandBuilders)
            {
                SecurityTokenService     = securityTokenService,
                MessageEncryptionService = messageEncryptionService
            };
            var sqlMessageQueueingService = new SQLMessageQueueingService(messageQueueingOptions);

            sqlMessageQueueingService.Init();
            return(sqlMessageQueueingService);
        }
        /// <inheritdoc />
        /// <summary>
        /// Creates an initializes a <see cref="T:Platibus.IMessageQueueingService" />
        /// based on the provided <paramref name="configuration" />
        /// </summary>
        /// <param name="configuration">The journaling configuration
        /// element</param>
        /// <returns>Returns a task whose result is an initialized
        /// <see cref="T:Platibus.IMessageQueueingService" /></returns>
        public async Task <IMessageQueueingService> CreateMessageQueueingService(QueueingElement configuration)
        {
            var path = configuration.GetString("path");

            var securityTokenServiceFactory = new SecurityTokenServiceFactory();
            var securityTokenConfig         = configuration.SecurityTokens;
            var securityTokenService        = await securityTokenServiceFactory.InitSecurityTokenService(securityTokenConfig);

            var messageEncryptionServiceFactory = new MessageEncryptionServiceFactory();
            var messageEncryptionConfig         = configuration.Encryption;
            var messageEncryptionService        = await messageEncryptionServiceFactory.InitMessageEncryptionService(messageEncryptionConfig);

            var fsQueueingOptions = new FilesystemMessageQueueingOptions
            {
                BaseDirectory            = GetRootedDirectory(path),
                SecurityTokenService     = securityTokenService,
                MessageEncryptionService = messageEncryptionService
            };
            var fsQueueingService = new FilesystemMessageQueueingService(fsQueueingOptions);

            fsQueueingService.Init();
            return(fsQueueingService);
        }
        /// <inheritdoc />
        /// <summary>
        /// Creates an initializes a <see cref="T:Platibus.IMessageQueueingService" />
        /// based on the provided <paramref name="configuration" />
        /// </summary>
        /// <param name="configuration">The journaling configuration
        ///     element</param>
        /// <returns>Returns a task whose result is an initialized
        /// <see cref="T:Platibus.IMessageQueueingService" /></returns>
        public async Task <IMessageQueueingService> CreateMessageQueueingService(IConfiguration configuration)
        {
            var path = configuration?["path"];

            var securityTokenServiceFactory = new SecurityTokenServiceFactory();
            var securityTokenConfig         = configuration?.GetSection("securityTokens");
            var securityTokenService        = await securityTokenServiceFactory.InitSecurityTokenService(securityTokenConfig);

            var messageEncryptionServiceFactory = new MessageEncryptionServiceFactory();
            var messageEncryptionConfig         = configuration?.GetSection("encryption");
            var messageEncryptionService        = await messageEncryptionServiceFactory.InitMessageEncryptionService(messageEncryptionConfig);

            var fsQueueingOptions = new FilesystemMessageQueueingOptions()
            {
                BaseDirectory            = GetRootedDirectory(path),
                SecurityTokenService     = securityTokenService,
                MessageEncryptionService = messageEncryptionService
            };

            var fsQueueingService = new FilesystemMessageQueueingService(fsQueueingOptions);

            fsQueueingService.Init();
            return(fsQueueingService);
        }
        public static Task <ISecurityTokenService> InitSecurityTokenService(SecurityTokensElement config)
        {
            var factory = new SecurityTokenServiceFactory();

            return(factory.InitSecurityTokenService(config));
        }