public EventSubscriber(IMessageQueueClient messageQueueClient,
IHandlerProvider handlerProvider,
ICommandBus commandBus,
IMessagePublisher messagePublisher,
string subscriptionName,
TopicSubscription[] topicSubscriptions,
string consumerId,
ConsumerConfig consumerConfig = null)
{
ConsumerConfig = consumerConfig ?? ConsumerConfig.DefaultConfig;
MessageQueueClient = messageQueueClient;
HandlerProvider = handlerProvider;
_topicSubscriptions = topicSubscriptions ?? new TopicSubscription[0];
_topicSubscriptions.Where(ts => ts.TagFilter != null)
.ForEach(ts => { TagFilters.Add(ts.Topic, ts.TagFilter); });
ConsumerId = consumerId;
SubscriptionName = subscriptionName;
MessagePublisher = messagePublisher;
CommandBus = commandBus;
var loggerFactory = ObjectProviderFactory.GetService <ILoggerFactory>();
MessageProcessor = new MailboxProcessor(new DefaultProcessingMessageScheduler(),
new OptionsWrapper <MailboxOption>(new MailboxOption
{
BatchCount = ConsumerConfig.MailboxProcessBatchCount
}),
loggerFactory.CreateLogger <MailboxProcessor>());
Logger = loggerFactory.CreateLogger(GetType().Name);
}
protected MessageSender(IMessageQueueClient messageQueueClient, string defaultTopic = null)
{
MessageQueueClient = messageQueueClient;
DefaultTopic = defaultTopic;
MessageStateQueue = new BlockingCollection <MessageState>();
Logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
}
public async Task GetUsersTest()
{
using (var scope = ObjectProviderFactory.CreateScope())
{
var serviceProvider = scope.GetService <IServiceProvider>();
if (serviceProvider == null)
{
var logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
logger.LogError((scope as ObjectProvider)?.UnityContainer.Registrations.ToJson());
Assert.NotNull(serviceProvider);
}
var dbContext = scope.GetService <DemoDbContext>();
var users = await dbContext.Users
//.Include(u => u.Cards)
.FindAll(u => !string.IsNullOrWhiteSpace(u.Name))
.Take(10)
.ToArrayAsync();
foreach (var u in users)
{
await u.LoadCollectionAsync(u1 => u1.Cards);
Assert.Equal(u.GetDbContext <DemoDbContext>().GetHashCode(), dbContext.GetHashCode());
}
}
}
public void TestLog()
{
var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
Configuration.Instance
.UseAutofacContainer(new ContainerBuilder())
.UseConfiguration(builder.Build())
.UseJsonNet()
.UseLog4Net();
ObjectProviderFactory.Instance.Build();
var loggerFactory = ObjectProviderFactory.GetService <ILoggerFactory>();
var logger = loggerFactory.CreateLogger(GetType());
try
{
throw new NotImplementedException("test exception");
}
catch (Exception e)
{
LogTest(logger, e);
}
}
static MessageSender()
{
NeedMessageStore = Configuration.Instance.NeedMessageStore;
if (NeedMessageStore)
{
ObjectProviderFactory.GetService <IMessageStoreDaemon>().Start();
}
}
public MessageQueueClient(IMessageQueueClientProvider clientProvider)
{
_clientProvider = clientProvider;
QueueClients = new ConcurrentDictionary <string, IMessageProducer>();
TopicClients = new ConcurrentDictionary <string, IMessageProducer>();
Subscribers = new List <IMessageConsumer>();
QueueConsumers = new List <IMessageConsumer>();
Logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType().Name);
}
public object GetHandler(Type messageType)
{
object handler = null;
var handlerType = GetHandlerType(messageType);
if (handlerType != null)
{
handler = ObjectProviderFactory.GetService(handlerType.Type);
}
return(handler);
}
protected MessageConsumer(string[] topics,
string groupId,
string consumerId,
ConsumerConfig consumerConfig = null)
{
Logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
ConsumerConfig = consumerConfig ?? ConsumerConfig.DefaultConfig;
Topics = topics;
GroupId = groupId;
ConsumerId = consumerId ?? string.Empty;
SlidingDoors = new ConcurrentDictionary <string, SlidingDoor>();
}
public SlidingDoor(Action <MessageOffset> commitOffset,
string topic,
int partition,
bool commitPerMessage = false)
{
CommitOffset = commitOffset;
Topic = topic;
Partition = partition;
Offsets = new SortedSet <long>();
RemovedMessageOffsets = new SortedList <long, MessageOffset>();
CommitPerMessage = commitPerMessage;
_logger = ObjectProviderFactory.GetService <ILoggerFactory>()
.CreateLogger(GetType());
}
public static Configuration UseMessagePublisher(this Configuration configuration, string defaultTopic)
{
var builder = ObjectProviderFactory.Instance.ObjectProviderBuilder;
builder.Register <IMessagePublisher>(provider =>
{
var messageQueueClient = ObjectProviderFactory.GetService <IMessageQueueClient>();
configuration.SetDefaultTopic(defaultTopic);
defaultTopic = configuration.FormatAppName(defaultTopic);
var messagePublisher = new MessagePublisher(messageQueueClient, defaultTopic);
return(messagePublisher);
}, ServiceLifetime.Singleton);
return(configuration);
}
public static void Bootstrap()
{
try
{
var kafkaBrokerList = new[]
{
new IPEndPoint(Utility.GetLocalIpv4(), 9092).ToString()
//"10.100.7.46:9092"
};
Configuration.Instance
.UseAutofacContainer(Assembly.GetExecutingAssembly().FullName,
"Sample.CommandHandler",
"Sample.DomainEventSubscriber",
"Sample.AsyncDomainEventSubscriber",
"Sample.ApplicationEventSubscriber")
.UseConfiguration(new ConfigurationBuilder().AddJsonFile("appsettings.json")
.Build())
.UseCommonComponents()
.UseJsonNet()
.UseLog4Net()
.UseEntityFrameworkComponents <SampleModelContext>()
.UseMessageStore <SampleModelContext>()
.UseInMemoryMessageQueue()
//.UseConfluentKafka(string.Join(",", kafkaBrokerList))
//.UseEQueue()
.UseCommandBus(Environment.MachineName, linerCommandManager: new LinearCommandManager())
.UseMessagePublisher("eventTopic")
.UseDbContextPool <SampleModelContext>(options => options.UseInMemoryDatabase(nameof(SampleModelContext)))
//.UseDbContextPool<SampleModelContext>(options => options.UseSqlServer(Configuration.GetConnectionString(nameof(SampleModelContext))))
;
ObjectProviderFactory.Instance
.RegisterComponents(RegisterComponents, ServiceLifetime.Scoped)
.Build();
StartMessageQueueComponents();
_Logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(typeof(WebApiApplication).Name);
_Logger.LogDebug($"App Started");
}
catch (Exception ex)
{
_Logger.LogError(ex.GetBaseException().Message, ex);
}
}
public async Task AddUserTest()
{
using (var serviceScope = ObjectProviderFactory.CreateScope())
using (var scope = new TransactionScope(TransactionScopeOption.Required,
new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
},
TransactionScopeAsyncFlowOption.Enabled))
{
var serviceProvider = serviceScope.GetService <IServiceProvider>();
if (serviceProvider == null)
{
Assert.NotNull(serviceProvider);
}
try
{
var dbContext = serviceScope.GetService <DemoDbContext>();
if (dbContext == null)
{
var logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
logger.LogError((serviceScope as ObjectProvider)?.UnityContainer.Registrations.ToJson());
Assert.NotNull(dbContext);
}
var user = new User("ivan", "male");
user.AddCard("ICBC");
user.AddCard("CCB");
user.AddCard("ABC");
dbContext.Users.Add(user);
await dbContext.SaveChangesAsync();
scope.Complete();
var client = dbContext.GetMongoDbClient();
var database = dbContext.GetMongoDbDatabase();
var conn = dbContext.GetMongoDbConnection();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public static IMessageProcessor CreateCommandConsumer(string commandQueue,
string consumerId,
string[] handlerProvierNames,
ConsumerConfig consumerConfig = null)
{
var container = ObjectProviderFactory.Instance.ObjectProvider;
var messagePublisher = container.GetService <IMessagePublisher>();
var handlerProvider = new CommandHandlerProvider(handlerProvierNames);
var messageQueueClient = ObjectProviderFactory.GetService <IMessageQueueClient>();
var commandConsumer = new CommandProcessor(messageQueueClient,
messagePublisher,
handlerProvider,
commandQueue,
consumerId,
consumerConfig);
return(commandConsumer);
}
public async Task GetUsersTest()
{
using (var scope = ObjectProviderFactory.CreateScope())
{
var serviceProvider = scope.GetService <IServiceProvider>();
if (serviceProvider == null)
{
var logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
logger.LogError((scope as ObjectProvider)?.UnityContainer.Registrations.ToJson());
Assert.NotNull(serviceProvider);
}
//var options = new DbContextOptionsBuilder<DemoDbContext>();
//options.UseMongoDb(Configuration.Instance.GetConnectionString(DemoDbContextFactory.MongoDbConnectionStringName));
var dbContext = scope.GetService <DemoDbContext>();
try
{
var user = await dbContext.Users.FindAsync("5BEE29960CCE411C20215A17").ConfigureAwait(false);
// var connection = dbContext.GetMongoDbDatabase();
var users = await dbContext.Users
//.Include(u => u.Cards)
//.FindAll(u => !string.IsNullOrWhiteSpace(u.Name))
.Take(10)
.ToListAsync()
.ConfigureAwait(false);
//foreach (var u in users)
//{
// await u.LoadCollectionAsync(u1 => u1.Cards);
// Assert.True(u.Cards.Count > 0);
// //Assert.Equal(u.GetDbContext<DemoDbContext>().GetHashCode(), dbContext.GetHashCode());
//}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
}
public CommandBus(IMessageQueueClient messageQueueClient,
ILinearCommandManager linearCommandManager,
string consumerId,
string replyTopicName,
string replySubscriptionName,
ConsumerConfig consumerConfig = null)
: base(messageQueueClient)
{
_consumerConfig = consumerConfig ?? ConsumerConfig.DefaultConfig;
_consumerId = consumerId;
_commandStateQueues = new ConcurrentDictionary <string, MessageState>();
_linearCommandManager = linearCommandManager;
_replyTopicName = Configuration.Instance.FormatAppName(replyTopicName);
_replySubscriptionName = Configuration.Instance.FormatAppName(replySubscriptionName);
// _commandQueueNames = commandQueueNames;
_messageProcessor = new MailboxProcessor(new DefaultProcessingMessageScheduler(),
new OptionsWrapper <MailboxOption>(new MailboxOption
{
BatchCount = _consumerConfig.MailboxProcessBatchCount
}),
ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger <MailboxProcessor>());
}
public CommandBusTests()
{
_logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(typeof(CommandBusTests));
_commandBus = ObjectProviderFactory.GetService <ICommandBus>();
_createProducts = new List <CreateProduct>();
var tasks = new List <Task>();
for (var i = 0; i < productCount; i++)
{
var createProduct = new CreateProduct
{
ProductId = Guid.NewGuid(),
Name = string.Format("{0}-{1}", DateTime.Now, i),
Count = 20000
};
_createProducts.Add(createProduct);
tasks.Add(_commandBus.SendAsync(createProduct, true).Result.Reply);
}
Task.WaitAll(tasks.ToArray());
}
public static IMessageProcessor CreateEventSubscriber(TopicSubscription[] topicSubscriptions,
string subscription,
string consumerId,
string[] handlerProviderNames,
ConsumerConfig consumerConfig = null)
{
subscription = Configuration.Instance.FormatAppName(subscription);
var handlerProvider = new EventSubscriberProvider(handlerProviderNames);
var commandBus = GetCommandBus();
var messagePublisher = GetMessagePublisher();
var messageQueueClient = ObjectProviderFactory.GetService <IMessageQueueClient>();
var eventSubscriber = new EventSubscriber(messageQueueClient,
handlerProvider,
commandBus,
messagePublisher,
subscription,
topicSubscriptions,
consumerId,
consumerConfig);
return(eventSubscriber);
}
public async Task ConcurrentTest()
{
var logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
try
{
//await AddUserTest();
var tasks = new List <Task>();
for (int i = 0; i < 5; i++)
{
tasks.Add(GetUsersTest());
}
await Task.WhenAll(tasks);
logger.LogDebug($"incremented : {DemoDbContext.Total}");
}
catch (Exception e)
{
logger.LogError(e, $"incremented : {DemoDbContext.Total}");
throw;
}
}
public CommandProcessor(IMessageQueueClient messageQueueClient,
IMessagePublisher messagePublisher,
IHandlerProvider handlerProvider,
string commandQueueName,
string consumerId,
ConsumerConfig consumerConfig = null)
{
ConsumerConfig = consumerConfig ?? ConsumerConfig.DefaultConfig;
CommandQueueName = commandQueueName;
HandlerProvider = handlerProvider;
MessagePublisher = messagePublisher;
ConsumerId = consumerId;
CancellationTokenSource = new CancellationTokenSource();
MessageQueueClient = messageQueueClient;
var loggerFactory = ObjectProviderFactory.GetService <ILoggerFactory>();
MessageProcessor = new MailboxProcessor(new DefaultProcessingMessageScheduler(),
new OptionsWrapper <MailboxOption>(new MailboxOption
{
BatchCount = ConsumerConfig.MailboxProcessBatchCount
}),
loggerFactory.CreateLogger <MailboxProcessor>());
Logger = loggerFactory.CreateLogger(GetType().Name);
}
/// <summary>
/// GetMessagePublisher returns a singleton instance of message publisher
/// you can call it everywhere to get a message publisher to publish messages
/// </summary>
/// <returns></returns>
public static IMessagePublisher GetMessagePublisher()
{
return(ObjectProviderFactory.GetService <IMessagePublisher>());
}
public TaskWorker(string id = null)
{
Id = id;
_logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
}
public static ICommandBus GetCommandBus()
{
return(ObjectProviderFactory.GetService <ICommandBus>());
}
protected MessageStore(DbContextOptions options)
: base(options)
{
Logger = ObjectProviderFactory.GetService <ILoggerFactory>().CreateLogger(GetType());
InMemoryStore = options.FindExtension <InMemoryOptionsExtension>() != null;
}
