Added ServiceName to Settings (#42)

samples/TransactionalBox.Sample.WebApi/Program.cs

@@ -40,14 +40,16 @@
 
 builder.Services.AddDbContextPool<SampleDbContext>(x => x.UseNpgsql(connectionString));
 
-builder.Services.AddTransactionalBox(x =>
+builder.Services.AddTransactionalBox(
+x =>
 {
     x.AddOutbox(storage => storage.UseEntityFramework<SampleDbContext>())
      .WithWorker(storage => storage.UseEntityFramework(), transport => transport.UseKafka(settings => settings.BootstrapServers = bootstrapServers));
 
     x.AddInbox(storage => storage.UseEntityFramework<SampleDbContext>())
-     .WithWorker(storage => storage.UseEntityFramework(), transport => transport.UseKafka(bootstrapServers));
-});
+     .WithWorker(storage => storage.UseEntityFramework(), transport => transport.UseKafka(settings => settings.BootstrapServers = bootstrapServers));
+},
+settings => settings.ServiceName = "Registrations");
 
 var app = builder.Build();
 
@@ -68,7 +70,7 @@
 {
     await outbox.Add(message, m =>
     {
-        m.Receiver = "ModuleName";
+        m.Receiver = "Registrations";
         m.OccurredUtc = DateTime.UtcNow;
     });
 

source/TransactionalBox.InboxWorker.Kafka/Extensions.cs

@@ -3,27 +3,26 @@
 using TransactionalBox.InboxWorker.Configurators;
 using TransactionalBox.InboxWorker.Internals;
 using TransactionalBox.InboxWorker.Kafka.Internals;
+using TransactionalBox.InboxWorker.Kafka.Settings;
 
 namespace TransactionalBox.InboxWorker.Kafka
 {
     public static class Extensions
     {
         public static void UseKafka(
             this IInboxWorkerTransportConfigurator inboxWorkerTransportConfigurator,
-            string bootstrapServers)
+            Action<InboxWorkerKafkaSettings> settingsConfiguration = null)
         {
             var services = inboxWorkerTransportConfigurator.Services;
+            var settings = new InboxWorkerKafkaSettings();
 
-            var config = new ConsumerConfig()
+            if (settingsConfiguration is not null) 
             {
-                GroupId = "ModuleName", //TODO ServiceNameProvider #28
-                BootstrapServers = bootstrapServers,
-                AutoOffsetReset = AutoOffsetReset.Earliest,
-                EnableAutoCommit = false,
-            };
-
-            services.AddSingleton(config);
+                settingsConfiguration(settings);
+            }
 
+            services.AddSingleton<IInboxWorkerKafkaSettings>(settings);
+            services.AddSingleton<KafkaConfigFactory>();
             services.AddSingleton<IInboxWorkerTransport, KafkaInboxWorkerTransport>();
         }
     }

source/TransactionalBox.InboxWorker.Kafka/Internals/IInboxWorkerKafkaSettings.cs

@@ -0,0 +1,7 @@
+namespace TransactionalBox.InboxWorker.Kafka.Internals
+{
+    internal interface IInboxWorkerKafkaSettings
+    {
+        string BootstrapServers { get; }
+    }
+}

source/TransactionalBox.InboxWorker.Kafka/Internals/KafkaConfigFactory.cs

@@ -0,0 +1,40 @@
+using Confluent.Kafka;
+using TransactionalBox.Internals;
+
+namespace TransactionalBox.InboxWorker.Kafka.Internals
+{
+    internal sealed class KafkaConfigFactory
+    {
+        private readonly ITransactionalBoxSettings _transactionalBoxSettings;
+
+        private readonly IInboxWorkerKafkaSettings _inboxWorkerKafkaSettings;
+
+        private ConsumerConfig? _config = null;
+
+        public KafkaConfigFactory(
+            ITransactionalBoxSettings transactionalBoxSettings,
+            IInboxWorkerKafkaSettings inboxWorkerKafkaSettings) 
+        {
+            _transactionalBoxSettings = transactionalBoxSettings;
+            _inboxWorkerKafkaSettings = inboxWorkerKafkaSettings;
+        }
+
+        internal ConsumerConfig Create()
+        {
+            if (_config is not null) 
+            {
+                return _config;
+            }
+
+            _config = new ConsumerConfig()
+            {
+                GroupId = _transactionalBoxSettings.ServiceName,
+                BootstrapServers = _inboxWorkerKafkaSettings.BootstrapServers,
+                AutoOffsetReset = AutoOffsetReset.Earliest,
+                EnableAutoCommit = false,
+            };
+
+            return _config;
+        }
+    }
+}

source/TransactionalBox.InboxWorker.Kafka/Internals/KafkaInboxWorkerTransport.cs

@@ -3,24 +3,32 @@
 using System.Text.Json;
 using TransactionalBox.InboxBase.StorageModel;
 using TransactionalBox.InboxWorker.Internals;
+using TransactionalBox.Internals;
 
 namespace TransactionalBox.InboxWorker.Kafka.Internals
 {
     internal sealed class KafkaInboxWorkerTransport : IInboxWorkerTransport
     {
-        private readonly ConsumerConfig _config;
+        private readonly ITransactionalBoxSettings _transactionalBoxSettings;
 
-        public KafkaInboxWorkerTransport(ConsumerConfig config) 
+        private readonly KafkaConfigFactory _configFactory;
+
+        public KafkaInboxWorkerTransport(
+            ITransactionalBoxSettings transactionalBoxSettings,
+            KafkaConfigFactory configFactory) 
         {
-            _config = config;
+            _transactionalBoxSettings = transactionalBoxSettings;
+            _configFactory = configFactory;
         }
 
         public async IAsyncEnumerable<InboxMessage> GetMessage([EnumeratorCancellation] CancellationToken cancellationToken)
         {
-            using (var consumer = new ConsumerBuilder<Ignore, string>(_config).Build())
+            var config = _configFactory.Create();
+
+            using (var consumer = new ConsumerBuilder<Ignore, string>(config).Build())
             {
-                //TODO #28
-                consumer.Subscribe("ModuleName-ExampleMessage");
+                //TODO #41
+                consumer.Subscribe($"{_transactionalBoxSettings.ServiceName}-ExampleMessage");
 
                 do
                 {

source/TransactionalBox.InboxWorker.Kafka/Settings/InboxWorkerKafkaSettings.cs

@@ -0,0 +1,11 @@
+using TransactionalBox.InboxWorker.Kafka.Internals;
+
+namespace TransactionalBox.InboxWorker.Kafka.Settings
+{
+    public sealed class InboxWorkerKafkaSettings : IInboxWorkerKafkaSettings
+    {
+        public string BootstrapServers { get; set; }
+
+        internal InboxWorkerKafkaSettings() { }
+    }
+}

source/TransactionalBox.Outbox/Internals/InternalOutbox.cs

@@ -1,19 +1,24 @@
 using System.Text.Json;
+using TransactionalBox.Internals;
 using TransactionalBox.Outbox.Internals.Exceptions;
 using TransactionalBox.OutboxBase.StorageModel;
 
 namespace TransactionalBox.Outbox.Internals
 {
     internal sealed class InternalOutbox : IOutbox
     {
+        private readonly ITransactionalBoxSettings _transactionalBoxSettings;
+
         private readonly IOutboxStorage _outboxStorage;
 
         private readonly TopicFactory _topicFactory;
 
         public InternalOutbox(
+            ITransactionalBoxSettings transactionalBoxSettings,
             IOutboxStorage outbox,
             TopicFactory topicFactory) 
         {
+            _transactionalBoxSettings = transactionalBoxSettings;
             _outboxStorage = outbox;
             _topicFactory = topicFactory;
         }
@@ -32,7 +37,7 @@ public async Task Add<TOutboxMessage>(TOutboxMessage message, Action<OutboxMessa
 
             if (receiver is null)
             {
-                receiver = "ModuleName"; //TODO ServiceNameProvider
+                receiver = _transactionalBoxSettings.ServiceName;
             }
 
             var outboxMessage = new OutboxMessage

source/TransactionalBox.OutboxWorker.Kafka/Extensions.cs

@@ -25,8 +25,8 @@ public static void UseKafka(
                 ClientId = Dns.GetHostName(), // TODO (HostNameService) #25
             };
 
-            services.AddSingleton(config);
-
+            services.AddSingleton<IOutboxWorkerKafkaSettings>(settings);
+            services.AddSingleton<KafkaConfigFactory>();
             services.AddScoped<ITransport, KafkaTransport>();
         }
     }

source/TransactionalBox.OutboxWorker.Kafka/Internals/IOutboxWorkerKafkaSettings.cs

@@ -0,0 +1,7 @@
+namespace TransactionalBox.OutboxWorker.Kafka.Internals
+{
+    internal interface IOutboxWorkerKafkaSettings
+    {
+        string BootstrapServers { get; }
+    }
+}

source/TransactionalBox.OutboxWorker.Kafka/Internals/KafkaConfigFactory.cs

@@ -0,0 +1,38 @@
+using Confluent.Kafka;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TransactionalBox.OutboxWorker.Kafka.Internals
+{
+    internal sealed class KafkaConfigFactory
+    {
+        private readonly IOutboxWorkerKafkaSettings _outboxWorkerKafkaSettings;
+
+        private ProducerConfig? _config = null;
+
+        public KafkaConfigFactory(IOutboxWorkerKafkaSettings outboxWorkerKafkaSettings) 
+        {
+            _outboxWorkerKafkaSettings = outboxWorkerKafkaSettings;
+        }
+
+        internal ProducerConfig Create()
+        {
+            if (_config is not null) 
+            {
+                return _config;
+            }
+
+            _config = new ProducerConfig()
+            {
+                BootstrapServers = _outboxWorkerKafkaSettings.BootstrapServers,
+                ClientId = Dns.GetHostName(), // TODO (HostNameService) #25
+            };
+
+            return _config;
+        }
+    }
+}

source/TransactionalBox.OutboxWorker.Kafka/Internals/KafkaTransport.cs

@@ -7,16 +7,18 @@ namespace TransactionalBox.OutboxWorker.Kafka.Internals
 {
     internal sealed class KafkaTransport : ITransport
     {
-        private readonly ProducerConfig _config;
+        private readonly KafkaConfigFactory _configFactory;
 
-        public KafkaTransport(ProducerConfig config) 
+        public KafkaTransport(KafkaConfigFactory configFactory) 
         {
-            _config = config;
+            _configFactory = configFactory;
         }
 
         public async Task Add(OutboxMessage message)
         {
-            using (var producer = new ProducerBuilder<Null, String>(_config).Build())
+            var config = _configFactory.Create();
+
+            using (var producer = new ProducerBuilder<Null, String>(config).Build())
             {
                 //TODO #27
                 var value = JsonSerializer.Serialize(message);

source/TransactionalBox.OutboxWorker.Kafka/Settings/OutboxWorkerKafkaSettings.cs

@@ -1,6 +1,8 @@
-namespace TransactionalBox.OutboxWorker.Kafka.Settings
+using TransactionalBox.OutboxWorker.Kafka.Internals;
+
+namespace TransactionalBox.OutboxWorker.Kafka.Settings
 {
-    public sealed class OutboxWorkerKafkaSettings
+    public sealed class OutboxWorkerKafkaSettings : IOutboxWorkerKafkaSettings
     {
         public string BootstrapServers { get; set; }
 

source/TransactionalBox/Extensions.cs

@@ -1,18 +1,26 @@
 using Microsoft.Extensions.DependencyInjection;
 using TransactionalBox.Configurators;
 using TransactionalBox.Internals;
+using TransactionalBox.Settings;
 
 namespace TransactionalBox
 {
     public static class Extensions
     {
         public static IServiceCollection AddTransactionalBox(
             this IServiceCollection services,
-            Action<ITransactionalBoxConfigurator> configure)
+            Action<ITransactionalBoxConfigurator> configuration,
+            Action<TransactionalBoxSettings> settingsConfiguration)
         {
             var configuratior = new TransactionalBoxConfigurator(services);
 
-            configure(configuratior);
+            var settings = new TransactionalBoxSettings();
+
+            configuration(configuratior);
+
+            settingsConfiguration(settings);
+
+            services.AddSingleton<ITransactionalBoxSettings>(settings);
 
             return services;
         }

source/TransactionalBox/Internals/ITransactionalBoxSettings.cs

@@ -0,0 +1,7 @@
+namespace TransactionalBox.Internals
+{
+    public interface ITransactionalBoxSettings
+    {
+        string ServiceName { get; }
+    }
+}

source/TransactionalBox/Settings/TransactionalBoxSettings.cs

@@ -0,0 +1,11 @@
+using TransactionalBox.Internals;
+
+namespace TransactionalBox.Settings
+{
+    public sealed class TransactionalBoxSettings : ITransactionalBoxSettings
+    {
+        public string ServiceName { get; set; }
+
+        internal TransactionalBoxSettings() { }
+    }
+}