private static IBusControl AmazonMQConfigureBus(IRegistration registration,
IEnumerable <ReceiveEndpointRegistration> receiveEndpoints,
bool isConsumer,
EventBusSettings settings)
{
string hostName = settings.AmazonMQ?.HostName;
string username = settings.AmazonMQ?.UserName;
string password = settings.AmazonMQ?.Password;
return(Bus.Factory.CreateUsingActiveMq(cfg =>
{
var host = cfg.Host(hostName, h =>
{
h.Username(username);
h.Password(password);
//h.UseSsl();
});
if (isConsumer)
{
cfg.AddReceiveEndpoints(registration, receiveEndpoints);
}
}));
}
private void ConfigureEventBus(IServiceCollection services, EventBusSettings settings)
{
if (settings.AzureServiceBusEnabled)
{
services.AddSingleton <IServiceBusPersisterConnection>(sp =>
{
var logger = sp.GetRequiredService <ILogger <DefaultServiceBusPersisterConnection> >();
var serviceBusConnection = new ServiceBusConnectionStringBuilder(settings.EventBusConnection);
return(new DefaultServiceBusPersisterConnection(serviceBusConnection, logger));
});
}
else
{
services.AddSingleton <IRabbitMQPersistentConnection>(sp =>
{
var logger = sp.GetRequiredService <ILogger <DefaultRabbitMQPersistentConnection> >();
var factory = new ConnectionFactory()
{
HostName = settings.EventBusConnection
};
factory.UserName = settings.EventBusUserName;
factory.Password = settings.EventBusPassword;
var retryCount = settings.EventBusRetryCount;
return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
});
}
}
private static IBusControl CloudAMQPConfigureBus(IRegistration registration,
IEnumerable <ReceiveEndpointRegistration> receiveEndpoints,
bool isConsumer,
EventBusSettings settings)
{
string hostName = settings.CloudAMQP?.HostName;
string vhost = settings.CloudAMQP?.VirtualHost;
string port = settings.CloudAMQP?.Port;
string username = settings.CloudAMQP?.UserName;
string password = settings.CloudAMQP?.Password;
return(Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(new Uri($@"rabbitmq://{hostName}:{port}/{vhost}/"), h =>
{
h.Username(username);
h.Password(password);
//h.UseSsl(s =>
//{
// s.Protocol = SslProtocols.Tls12;
//});
});
if (isConsumer)
{
cfg.AddReceiveEndpoints(registration, receiveEndpoints);
}
}));
}
private static void AddRabbitMQBus(ContainerBuilder builder, EventBusSettings settings)
{
builder.Register <IRabbitMQPersistentConnection>(ctx =>
{
var logger = ctx.Resolve <ILogger <DefaultRabbitMQPersistentConnection> >();
var factory = new ConnectionFactory()
{
VirtualHost = settings.VirtualHost,
HostName = settings.EventBusConnection,
UserName = settings.EventBusUserName,
Password = settings.EventBusPassword,
AutomaticRecoveryEnabled = true,
NetworkRecoveryInterval = TimeSpan.FromSeconds(5)
};
var retryCount = settings.EventBusRetryCount > 0 ? settings.EventBusRetryCount : 5;
return(new DefaultRabbitMQPersistentConnection(factory, logger, retryCount));
}).SingleInstance();
builder.Register <IBusClient>(ctx =>
{
var logger = ctx.Resolve <ILogger <RabbitMQClient> >();
var lifeTimeScope = ctx.Resolve <ILifetimeScope>();
var subscriptionManager = ctx.Resolve <ISubscriptionManager>();
var persistentConnection = ctx.Resolve <IRabbitMQPersistentConnection>();
var retryCount = settings.EventBusRetryCount > 0 ? settings.EventBusRetryCount : 5;
return(new RabbitMQClient(lifeTimeScope, persistentConnection, retryCount,
settings.SubscriptionClientName, subscriptionManager, logger, settings.ExchangeName, settings.LogMessages));
});
}
private void RegisterEventBus(IServiceCollection services, EventBusSettings settings)
{
var subscriptionClientName = settings.SubscriptionClientName;
if (settings.AzureServiceBusEnabled)
{
services.AddSingleton <IEventBus, EventBusServiceBus>(sp =>
{
var serviceBusPersisterConnection = sp.GetRequiredService <IServiceBusPersisterConnection>();
var iLifetimeScope = sp.GetRequiredService <ILifetimeScope>();
var logger = sp.GetRequiredService <ILogger <EventBusServiceBus> >();
var eventBusSubcriptionsManager = sp.GetRequiredService <IEventBusSubscriptionsManager>();
return(new EventBusServiceBus(serviceBusPersisterConnection, logger,
eventBusSubcriptionsManager, subscriptionClientName, iLifetimeScope));
});
}
else
{
services.AddSingleton <IEventBus, EventBusRabbitMQ>(sp =>
{
var rabbitMQPersistentConnection = sp.GetRequiredService <IRabbitMQPersistentConnection>();
var iLifetimeScope = sp.GetRequiredService <ILifetimeScope>();
var logger = sp.GetRequiredService <ILogger <EventBusRabbitMQ> >();
var eventBusSubcriptionsManager = sp.GetRequiredService <IEventBusSubscriptionsManager>();
var retryCount = settings.EventBusRetryCount;
return(new EventBusRabbitMQ(rabbitMQPersistentConnection, logger, iLifetimeScope,
eventBusSubcriptionsManager, subscriptionClientName, retryCount));
});
}
services.AddSingleton <IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();
}
public ItemService(IItemRepository itemRepository, IItemMapper itemMapper, ILogger <IItemService> logger, ConnectionFactory eventBusConnectionFactory, EventBusSettings settings)
{
_itemRepository = itemRepository;
_itemMapper = itemMapper;
_logger = logger;
_eventBusConnectionFactory = eventBusConnectionFactory;
_settings = settings;
}
private static IServiceCollection RegisterBrokerDependencies(this IServiceCollection services,
EventBusSettings settings,
IEnumerable <ReceiveEndpointRegistration> receiveEndpoints = null)
{
// CHANGE THE BROKER HERE. SEE ALSO ALL OVERLOADED EXTENDED METHODS
services.RegisterDependencies(settings, Configure <IServiceCollectionConfigurator, IServiceProvider>, receiveEndpoints, AmazonMQConfigureBus);
return(services);
}
private static Container RegisterBrokerDependencies(this Container container,
EventBusSettings settings,
IEnumerable <ReceiveEndpointRegistration> receiveEndpoints = null)
{
// CHANGE THE BROKER HERE. SEE ALSO ALL OVERLOADED EXTENDED METHODS
container.RegisterDependencies(settings, Configure <ISimpleInjectorConfigurator, Container>, receiveEndpoints, AmazonMQConfigureBus);
return(container);
}
public BookService(IBookRepository bookRepository, IBookMapper bookMapper, ConnectionFactory eventBusConnectionFactory,
ILogger <BookService> logger, EventBusSettings settings, IEventBus eventBus)
{
_bookRepository = bookRepository;
_bookMapper = bookMapper;
_eventBusConnectionFactory = eventBusConnectionFactory;
_logger = logger;
_settings = settings;
_eventBus = eventBus ?? throw new ArgumentNullException(nameof(eventBus));
}
private static IServiceCollection RegisterDependencies(this IServiceCollection services,
EventBusSettings settings,
Action <IServiceCollectionConfigurator,
EventBusSettings,
IEnumerable <ReceiveEndpointRegistration>,
Func <IRegistration, IEnumerable <ReceiveEndpointRegistration>, bool, EventBusSettings, IBusControl> > configure,
IEnumerable <ReceiveEndpointRegistration> receiveEndpoints,
Func <IRegistration, IEnumerable <ReceiveEndpointRegistration>, bool, EventBusSettings, IBusControl> configureBus)
{
services.TryAddSingleton(KebabCaseEndpointNameFormatter.Instance);
services.AddMassTransit(x => configure(x, settings, receiveEndpoints, configureBus));
return(services);
}
private static Container RegisterDependencies(this Container container,
EventBusSettings settings,
Action <ISimpleInjectorConfigurator,
EventBusSettings,
IEnumerable <ReceiveEndpointRegistration>,
Func <IRegistration, IEnumerable <ReceiveEndpointRegistration>, bool, EventBusSettings, IBusControl> > configure,
IEnumerable <ReceiveEndpointRegistration> receiveEndpoints,
Func <IRegistration, IEnumerable <ReceiveEndpointRegistration>, bool, EventBusSettings, IBusControl> configureBus)
{
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
container.Register <IEndpointNameFormatter>(() => KebabCaseEndpointNameFormatter.Instance, Lifestyle.Singleton);
container.AddMassTransit(x => configure(x, settings, receiveEndpoints, configureBus));
return(container);
}
public static IServiceCollection AddEventBus(this IServiceCollection services, IConfiguration configuration)
{
var config = new EventBusSettings();
configuration.Bind("EventBus", config);
services.AddSingleton(config);
var factory = new ConnectionFactory
{
HostName = config.HostName,
UserName = config.User,
Password = config.Password,
};
services.AddSingleton(factory);
return(services);
}
public ItemSoldOutBackgroundService(IMediator mediator,
EventBusSettings settings, ConnectionFactory factory, ILogger <ItemSoldOutBackgroundService> logger)
{
_settings = settings;
_logger = logger;
_mediator = mediator;
try
{
var connection = factory.CreateConnection();
_channel = connection.CreateModel();
}
catch (Exception e)
{
_logger.LogWarning("Unable to initialize the event bus: {message}", e.Message);
}
}
private static void AddAzureBus(ContainerBuilder builder, EventBusSettings settings)
{
builder.Register <IAzureServiceBusPersistentConnection>(ctx =>
{
var logger = ctx.Resolve <ILogger <DefaultAzureServiceBusPersistentConnection> >();
var serviceBusConnection = new ServiceBusConnectionStringBuilder(settings.EventBusConnection);
return(new DefaultAzureServiceBusPersistentConnection(serviceBusConnection, logger));
}).SingleInstance();
builder.Register <IBusClient>(ctx =>
{
var persisterConnection = ctx.Resolve <IAzureServiceBusPersistentConnection>();
var lifeTimeScope = ctx.Resolve <ILifetimeScope>();
var logger = ctx.Resolve <ILogger <AzureClient> >();
var subscriptionManager = ctx.Resolve <ISubscriptionManager>();
return(new AzureClient(persisterConnection, lifeTimeScope, subscriptionManager, logger,
settings.SubscriptionClientName, settings.ExchangeName));
}).SingleInstance();
}
public static void AddBus(this ContainerBuilder builder, EventBusSettings settings)
{
builder.RegisterType <InMemorySubscriptionManager>()
.As <ISubscriptionManager>().SingleInstance();
if (settings.AzureServiceBusEnabled)
{
AddAzureBus(builder, settings);
}
else
{
AddRabbitMQBus(builder, settings);
}
builder.RegisterType <BusPublisher>()
.As <IBusPublisher>().SingleInstance();
builder.RegisterType <BusSubscriber>()
.As <IBusSubscriber>().SingleInstance();
}
private static void Configure <TConfigurator, TContainerContext>(TConfigurator configurator,
EventBusSettings settings,
IEnumerable <ReceiveEndpointRegistration> receiveEndpoints,
Func <IRegistration, IEnumerable <ReceiveEndpointRegistration>, bool, EventBusSettings, IBusControl> configureBus)
where TConfigurator : class, IRegistrationConfigurator <TContainerContext>, IRegistrationConfigurator
where TContainerContext : class
{
bool isConsumer = receiveEndpoints?.Any() ?? false;
if (isConsumer)
{
configurator.AddConsumers(GetConsumers(receiveEndpoints));
}
if (settings.UseInMemory)
{
configurator.AddBus(p => InMemoryConfigureBus(p));
}
else
{
configurator.AddBus(p => configureBus(p, receiveEndpoints, isConsumer, settings));
}
}
public static Container RegisterTestSomeActionExecutedConsumerDependencies(this Container container, EventBusSettings settings)
{
var receiveEndpoints = new List <ReceiveEndpointRegistration>
{
new ReceiveEndpointRegistration(
queueName: QueueHelper.GetQueueName <TestSomeActionExecutedConsumer>(),
consumers: new List <Type> {
typeof(TestSomeActionExecutedConsumer)
}
)
};
container.RegisterBrokerDependencies(settings, receiveEndpoints);
return(container);
}
public EventBus(EventBusSettings settings, CacheManager cacheManager, ILogger<IEventBus> logger)
{
_settings = settings;
_CacheManager = cacheManager;
_logger = logger;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
StartLoggly();
services.AddWebSocketManager();
IFileRepository fileRepository;
IGroupRepository groupRepository;
IKeysRepository keysRepository;
ITagRepository tagRepository;
IUserRepository userRepository;
ISanctionRepository sanctionRepository;
IEventRepository eventRepository;
if (bool.Parse(Configuration.GetValue <string>("UseDB")))
{
var dbContext = Configuration.GetValue <string>("MysqlConnectionString");
using (var context = new EduhubContext(dbContext))
{
if (bool.Parse(Configuration.GetValue <string>("DeleteDB")))
{
context.Database.EnsureDeleted();
}
if (context.Database.EnsureCreated())
{
var dbName = dbContext.Split("database=")[1].Split(";")[0];
context.Database.ExecuteSqlCommand(
"ALTER DATABASE " + dbName + " CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;");
var modelNames = context.Model.GetEntityTypes();
foreach (var modelname in modelNames)
{
var mapping = context.Model.FindEntityType(modelname.Name).Relational();
var tableName = mapping.TableName;
context.Database.ExecuteSqlCommand(
"alter table " + tableName.ToLower()
+ " convert to character set utf8mb4 collate utf8mb4_bin;");
}
}
context.Database.Migrate();
}
fileRepository = new InMysqlFileRepository(dbContext);
groupRepository = new InMysqlGroupRepository(dbContext);
keysRepository = new InMysqlKeyRepository(dbContext);
tagRepository = new InMysqlTagRepository(dbContext);
userRepository = new InMysqlUserRepository(dbContext);
sanctionRepository = new InMysqlSanctionRepository(dbContext);
eventRepository = new InMemoryEventRepository();
}
else
{
fileRepository = new InMemoryFileRepository();
groupRepository = new InMemoryGroupRepository();
keysRepository = new InMemoryKeysRepository();
tagRepository = new InMemoryTagRepository();
sanctionRepository = new InMemorySanctionRepository();
userRepository = new InMemoryUserRepository();
eventRepository = new InMemoryEventRepository();
}
var emailSettings = new EmailSettings(Configuration.GetValue <string>("EmailLogin"),
Configuration.GetValue <string>("Email"),
Configuration.GetValue <string>("EmailPassword"),
Configuration.GetValue <string>("SmtpAddress"),
Configuration.GetValue <string>("ConfirmAddress"),
int.Parse(Configuration.GetValue <string>("SmtpPort")));
var defaultAvatarFilename = Configuration.GetValue <string>("DefaultAvatarFilename");
var defaultAvatarContentType = Configuration.GetValue <string>("DefaultAvatarContentType");
var userSettings = new UserSettings(defaultAvatarFilename);
if (!fileRepository.DoesFileExists(defaultAvatarFilename))
{
fileRepository.AddFile(new UserFile(defaultAvatarFilename, defaultAvatarContentType));
}
var tagFacade = new TagFacade(tagRepository);
var emailSender = new EmailSender(emailSettings);
var notificationsDistributor = new NotificationsDistributor(groupRepository, userRepository, emailSender);
var groupSettings = new GroupSettings(Configuration.GetValue <int>("MinGroupSize"),
Configuration.GetValue <int>("MaxGroupSize"),
Configuration.GetValue <double>("MinGroupValue"),
Configuration.GetValue <double>("MaxGroupValue"));
var eventBusSettings = new EventBusSettings(Configuration.GetValue <string>("RabbitMqServerHostName"),
Configuration.GetValue <string>("RabbitMqServerVirtualHost"),
Configuration.GetValue <string>("RabbitMqAdminUserName"),
Configuration.GetValue <string>("RabbitMqAdminPassword"));
var eventBus = new EventBus(eventBusSettings);
eventBus.StartListening();
var adminsEventConsumer = new AdminsEventConsumer(notificationsDistributor, eventRepository);
var courseEventConsumer = new CourseEventConsumer(notificationsDistributor, eventRepository);
var curriculumEventConsumer = new CurriculumEventConsumer(notificationsDistributor, eventRepository);
var groupEventsConsumer = new GroupEventsConsumer(notificationsDistributor, eventRepository);
var invitationConsumer = new InvitationConsumer(notificationsDistributor, eventRepository);
var memberActionsConsumer = new MemberActionsConsumer(notificationsDistributor, eventRepository);
eventBus.RegisterConsumer(new TagPopularityConsumer(tagFacade));
eventBus.RegisterConsumer <ReportMessageEvent>(adminsEventConsumer);
eventBus.RegisterConsumer <SanctionsAppliedEvent>(adminsEventConsumer);
eventBus.RegisterConsumer <SanctionCancelledEvent>(adminsEventConsumer);
eventBus.RegisterConsumer <TeacherFoundEvent>(courseEventConsumer);
eventBus.RegisterConsumer <CourseFinishedEvent>(courseEventConsumer);
eventBus.RegisterConsumer <ReviewReceivedEvent>(courseEventConsumer);
eventBus.RegisterConsumer <CurriculumAcceptedEvent>(curriculumEventConsumer);
eventBus.RegisterConsumer <CurriculumDeclinedEvent>(curriculumEventConsumer);
eventBus.RegisterConsumer <CurriculumSuggestedEvent>(curriculumEventConsumer);
eventBus.RegisterConsumer <NewCreatorEvent>(groupEventsConsumer);
eventBus.RegisterConsumer <GroupIsFormedEvent>(groupEventsConsumer);
eventBus.RegisterConsumer <InvitationAcceptedEvent>(invitationConsumer);
eventBus.RegisterConsumer <InvitationDeclinedEvent>(invitationConsumer);
eventBus.RegisterConsumer <InvitationReceivedEvent>(invitationConsumer);
eventBus.RegisterConsumer <NewMemberEvent>(memberActionsConsumer);
eventBus.RegisterConsumer <MemberLeftEvent>(memberActionsConsumer);
var publisher = eventBus.GetEventPublisher();
var userFacade = new UserFacade(userRepository, groupRepository, eventRepository, publisher);
var groupEditFacade = new GroupEditFacade(groupRepository, groupSettings, publisher);
var userEditFacade = new UserEditFacade(userRepository, fileRepository, sanctionRepository);
var groupFacade = new GroupFacade(groupRepository, userRepository, sanctionRepository, groupSettings,
publisher);
var fileFacade = new FileFacade(fileRepository);
var chatFacade = new ChatFacade(groupRepository, userRepository);
var sanctionsFacade = new SanctionFacade(sanctionRepository, userRepository, publisher);
var userAccountFacade = new AccountFacade(keysRepository, userRepository, emailSender, userSettings);
var reportFacade = new ReportFacade(userRepository, eventRepository, publisher);
services.AddSingleton <IUserFacade>(userFacade);
services.AddSingleton <IGroupFacade>(groupFacade);
services.AddSingleton <IFileFacade>(fileFacade);
services.AddSingleton <IChatFacade>(chatFacade);
services.AddSingleton <IGroupEditFacade>(groupEditFacade);
services.AddSingleton <IUserEditFacade>(userEditFacade);
services.AddSingleton <ITagFacade>(tagFacade);
services.AddSingleton <ISanctionFacade>(sanctionsFacade);
services.AddSingleton <IAccountFacade>(userAccountFacade);
services.AddSingleton <IReportFacade>(reportFacade);
services.AddSingleton(Env);
userAccountFacade.CheckAdminExistence(Configuration.GetValue <string>("AdminEmail"));
services.AddSwaggerGen(current =>
{
current.SwaggerDoc("v1", new Info
{
Title = "EduHub API",
Version = "v1"
});
current.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description =
"JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
current.OperationFilter <ExamplesOperationFilter>();
current.DescribeAllEnumsAsStrings();
var a = string.Format(@"{0}\EduHub.xml", AppDomain.CurrentDomain.BaseDirectory);
current.IncludeXmlComments(string.Format(@"{0}/EduHub.xml", AppDomain.CurrentDomain.BaseDirectory));
});
ConfigureSecurity(services);
if (Configuration.GetValue <bool>("Authorization"))
{
services.AddMvc(o =>
{
o.Filters.Add(new ExceptionFilter());
o.Filters.Add(new ActionFilter());
});
}
else
{
services.AddMvc(o =>
{
o.Filters.Add(new AllowAnonymousFilter());
o.Filters.Add(new ExceptionFilter());
o.Filters.Add(new ActionFilter());
});
}
services.AddCors(options =>
{
options.AddPolicy("AllowAnyOrigin",
builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});
}
public RabbitMQPublisher(IOptions <EventBusSettings> appConfig)
{
_appConfig = appConfig.Value;
}
public static Container RegisterEventBusProducerDependencies(this Container container, EventBusSettings settings)
{
container.RegisterBrokerDependencies(settings)
.Register <IEventBusProducerService, EventBusProducerService>(Lifestyle.Scoped);
return(container);
}
public static Container RegisterSendMailConsumerDependencies(this Container container, EventBusSettings settings)
{
var receiveEndpoints = new List <ReceiveEndpointRegistration>
{
new ReceiveEndpointRegistration(
queueName: QueueHelper.GetQueueName <SendMailConsumer>(),
consumers: new List <Type> {
typeof(SendMailConsumer)
},
faultConsumers: new List <Type> {
typeof(FaultSendMailConsumer)
},
canUsePriority: true
)
};
container.RegisterBrokerDependencies(settings, receiveEndpoints);
return(container);
}
public static IServiceCollection RegisterEventBusProducerDependencies(this IServiceCollection services, EventBusSettings settings)
{
services.RegisterBrokerDependencies(settings)
.AddScoped <IEventBusProducerService, EventBusProducerService>();
return(services);
}
