private static void Start(string[] args)
{
_container = new Container(x =>
{
x.For <IMongoRepository>().Singleton().Use <MongoRepository>()
.Ctor <string>("mongoConnectionString").Is(System.Configuration.ConfigurationManager.AppSettings["MongoDBConnectionString"])
.Ctor <string>("mongoUsername").Is(System.Configuration.ConfigurationManager.AppSettings["MongoDBUsername"])
.Ctor <string>("mongoPassword").Is(System.Configuration.ConfigurationManager.AppSettings["MongoDBPassword"])
.Ctor <string>("certBase64").Is(System.Configuration.ConfigurationManager.AppSettings["MongoCertBase64"])
.Ctor <string>("databaseName").Is(System.Configuration.ConfigurationManager.AppSettings["PersistanceDatabaseName"]);
x.For <IAuditRepository>().Use <AuditRepository>()
.Ctor <string>("auditCollecitonName").Is(System.Configuration.ConfigurationManager.AppSettings["PersistanceCollectionNameAudit"])
.Ctor <string>("serviceMessagesCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["ServiceMessagesCollectionName"]);
x.For <IErrorRepository>().Use <ErrorRepository>()
.Ctor <string>("errorCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["PersistanceCollectionNameError"]);
x.For <IHeartbeatRepository>().Use <HeartbeatRepository>()
.Ctor <string>("heartbeatCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["PersistanceCollectionNameHeartbeat"])
.Ctor <string>("servicesCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["ServiceDetailsCollectionName"]);
x.For <IServiceRepository>().Use <ServiceRepository>()
.Ctor <string>("servicesCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["ServiceDetailsCollectionName"]);
x.For <IServiceMessageRepository>().Use <ServiceMessageRepository>()
.Ctor <string>("serviceMessagesCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["ServiceMessagesCollectionName"]);
x.For <IHeartbeatRepository>().Use <HeartbeatRepository>()
.Ctor <string>("heartbeatCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["PersistanceCollectionNameHeartbeat"])
.Ctor <string>("serviceCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["ServiceDetailsCollectionName"]);
x.For <ITagRepository>().Use <TagRepository>()
.Ctor <string>("tagCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["TagsCollectionName"]);
x.For <ISettingsRepository>().Use <SettingsRepository>()
.Ctor <string>("settingsCollectionName").Is(System.Configuration.ConfigurationManager.AppSettings["SettingsCollectionName"]);
x.Scan(scan =>
{
scan.TheCallingAssembly();
scan.WithDefaultConventions();
});
});
var webAppConfig = new AuditConfig(_container);
_webApp = WebApp.Start("https://*:" + System.Configuration.ConfigurationManager.AppSettings["Port"], app => webAppConfig.Configuration(app));
var auditHub = GlobalHost.ConnectionManager.GetHubContext <AuditHub>();
var errorHub = GlobalHost.ConnectionManager.GetHubContext <ErrorHub>();
var heartbeatHub = GlobalHost.ConnectionManager.GetHubContext <HeartbeatHub>();
var settingsRepository = _container.GetInstance <ISettingsRepository>();
var settings = settingsRepository.Get().GetAwaiter().GetResult();
if (settings == null)
{
settings = new Settings
{
Id = Guid.NewGuid(),
Environments = new List <Models.Environment>(),
KeepAuditsFor = "7",
KeepErrorsFor = "150",
KeepHeartbeatsFor = "7"
};
settingsRepository.Update(settings);
}
Globals.Settings = settings;
foreach (var environment in settings.Environments)
{
// Two distinct connections one for receiving and one for sending that way publishing isn't delayed if the socket is busy pulling messages
var receivingConnection = new Connection(environment);
var sendingConnection = new Connection(environment);
var consumerEnvironment = new ConsumerEnvironment
{
Server = environment.Server,
AuditMessageHandler = new AuditMessageHandler(_container.GetInstance <IAuditRepository>(), auditHub),
ErrorMessageHandler = new ErrorMessageHandler(_container.GetInstance <IErrorRepository>(), errorHub),
HeartbeatMessageHandler = new HearbeatMessageHandler(_container.GetInstance <IHeartbeatRepository>(), heartbeatHub),
ReceivingConnection = receivingConnection,
SendingConnection = sendingConnection,
AuditConsumer = new ConsumerPool(receivingConnection),
ErrorConsumer = new ConsumerPool(receivingConnection),
HeartbeatConsumer = new ConsumerPool(receivingConnection),
Producer = new Producer(sendingConnection)
};
string forwardErrorQueue = null;
string forwardAuditQueue = null;
string forwardHeartbeatQueue = null;
if (settings.ForwardAudit)
{
forwardAuditQueue = settings.ForwardAuditQueue;
}
if (settings.ForwardErrors)
{
forwardErrorQueue = settings.ForwardErrorQueue;
}
if (settings.ForwardHeartbeats)
{
forwardHeartbeatQueue = settings.ForwardHeartbeatQueue;
}
consumerEnvironment.AuditConsumer.StartConsuming(consumerEnvironment.AuditMessageHandler.Execute, environment.AuditQueue, forwardAuditQueue);
consumerEnvironment.ErrorConsumer.StartConsuming(consumerEnvironment.ErrorMessageHandler.Execute, environment.ErrorQueue, forwardErrorQueue);
consumerEnvironment.HeartbeatConsumer.StartConsuming(consumerEnvironment.HeartbeatMessageHandler.Execute, environment.HeartbeatQueue, forwardHeartbeatQueue);
Globals.Environments.Add(consumerEnvironment);
}
Globals.AuditExpiry = settings.KeepAuditsFor;
var timer = new Timer(AuditCallback, settings, 0, 3600000);
Globals.Timers["Audit"] = timer;
Globals.ErrorExpiry = settings.KeepErrorsFor;
timer = new Timer(ErrorCallback, settings, 0, 3600000);
Globals.Timers["Error"] = timer;
Globals.HeartbeatExpiry = settings.KeepHeartbeatsFor;
timer = new Timer(HeartbeatCallback, settings, 0, 3600000);
Globals.Timers["Heartbeat"] = timer;
_container.GetInstance <IAuditRepository>().EnsureIndex();
_container.GetInstance <IErrorRepository>().EnsureIndex();
_container.GetInstance <IHeartbeatRepository>().EnsureIndex();
_container.GetInstance <IServiceMessageRepository>().EnsureIndex();
_container.GetInstance <IServiceRepository>().EnsureIndex();
}
public async Task <Settings> UpdateSettings(Settings model)
{
if (string.IsNullOrEmpty(model.KeepAuditsFor))
{
model.KeepAuditsFor = "Forever";
}
if (string.IsNullOrEmpty(model.KeepErrorsFor))
{
model.KeepErrorsFor = "Forever";
}
if (string.IsNullOrEmpty(model.KeepHeartbeatsFor))
{
model.KeepHeartbeatsFor = "Forever";
}
await _settingsRepository.Update(model);
if (model.ForwardAudit == false)
{
foreach (var consumerEnvironment in Globals.Environments)
{
consumerEnvironment.AuditConsumer.SetForwardQueue(null);
}
}
if (Globals.Settings.ForwardAuditQueue != model.ForwardAuditQueue)
{
foreach (var consumerEnvironment in Globals.Environments)
{
consumerEnvironment.AuditConsumer.SetForwardQueue(model.ForwardAuditQueue);
}
}
if (model.ForwardErrors == false)
{
foreach (var consumerEnvironment in Globals.Environments)
{
consumerEnvironment.ErrorConsumer.SetForwardQueue(null);
}
}
if (Globals.Settings.ForwardErrorQueue != model.ForwardErrorQueue)
{
foreach (var consumerEnvironment in Globals.Environments)
{
consumerEnvironment.ErrorConsumer.SetForwardQueue(model.ForwardErrorQueue);
}
}
if (model.ForwardHeartbeats == false)
{
foreach (var consumerEnvironment in Globals.Environments)
{
consumerEnvironment.HeartbeatConsumer.SetForwardQueue(null);
}
}
if (Globals.Settings.ForwardHeartbeatQueue != model.ForwardHeartbeatQueue)
{
foreach (var consumerEnvironment in Globals.Environments)
{
consumerEnvironment.HeartbeatConsumer.SetForwardQueue(model.ForwardHeartbeatQueue);
}
}
Globals.Settings = model;
var auditHub = GlobalHost.ConnectionManager.GetHubContext <AuditHub>();
var errorHub = GlobalHost.ConnectionManager.GetHubContext <ErrorHub>();
var heartbeatHub = GlobalHost.ConnectionManager.GetHubContext <HeartbeatHub>();
var environments = Globals.Environments;
foreach (var environment in model.Environments)
{
var consumerEnvironment = environments.FirstOrDefault(x => x.Server == environment.Server &&
x.Username == environment.Username &&
x.Password == environment.Password &&
x.SslEnabled == environment.SslEnabled &&
x.CertBase64 == environment.CertBase64 &&
x.CertPassword == environment.CertPassword &&
x.AuditQueue == environment.AuditQueue &&
x.ErrorQueue == environment.ErrorQueue &&
x.HeartbeatQueue == environment.HeartbeatQueue);
if (consumerEnvironment == null)
{
var receivingConnection = new Connection(environment);
var sendingConnection = new Connection(environment);
consumerEnvironment = new ConsumerEnvironment
{
Server = environment.Server,
AuditMessageHandler = new AuditMessageHandler(_auditRepository, auditHub),
ErrorMessageHandler = new ErrorMessageHandler(_errorRepository, errorHub),
HeartbeatMessageHandler = new HearbeatMessageHandler(_heartbeatRepository, heartbeatHub),
ReceivingConnection = receivingConnection,
SendingConnection = sendingConnection,
AuditConsumer = new ConsumerPool(receivingConnection),
ErrorConsumer = new ConsumerPool(receivingConnection),
HeartbeatConsumer = new ConsumerPool(receivingConnection),
Producer = new Producer(sendingConnection)
};
string forwardErrorQueue = null;
string forwardAuditQueue = null;
string forwardHeartbeatQueue = null;
if (Globals.Settings.ForwardAudit)
{
forwardAuditQueue = Globals.Settings.ForwardAuditQueue;
}
if (Globals.Settings.ForwardErrors)
{
forwardErrorQueue = Globals.Settings.ForwardErrorQueue;
}
if (Globals.Settings.ForwardHeartbeats)
{
forwardHeartbeatQueue = Globals.Settings.ForwardHeartbeatQueue;
}
consumerEnvironment.AuditConsumer.StartConsuming(consumerEnvironment.AuditMessageHandler.Execute, environment.AuditQueue, forwardAuditQueue);
consumerEnvironment.ErrorConsumer.StartConsuming(consumerEnvironment.ErrorMessageHandler.Execute, environment.ErrorQueue, forwardErrorQueue);
consumerEnvironment.HeartbeatConsumer.StartConsuming(consumerEnvironment.HeartbeatMessageHandler.Execute, environment.HeartbeatQueue, forwardHeartbeatQueue);
}
}
var environmentsToRemove = new List <ConsumerEnvironment>();
foreach (var consumerEnvironment in environments)
{
var environment = model.Environments.FirstOrDefault(x => x.Server == consumerEnvironment.Server &&
x.Username == consumerEnvironment.Username &&
x.Password == consumerEnvironment.Password &&
x.SslEnabled == consumerEnvironment.SslEnabled &&
x.CertBase64 == consumerEnvironment.CertBase64 &&
x.CertPassword == consumerEnvironment.CertPassword &&
x.AuditQueue == consumerEnvironment.AuditQueue &&
x.ErrorQueue == consumerEnvironment.ErrorQueue &&
x.HeartbeatQueue == consumerEnvironment.HeartbeatQueue);
if (environment == null)
{
environmentsToRemove.Add(consumerEnvironment);
}
}
foreach (var consumerEnvironment in environmentsToRemove)
{
consumerEnvironment.AuditMessageHandler.Dispose();
consumerEnvironment.ErrorMessageHandler.Dispose();
consumerEnvironment.HeartbeatMessageHandler.Dispose();
consumerEnvironment.AuditConsumer.Dispose();
consumerEnvironment.ErrorConsumer.Dispose();
consumerEnvironment.HeartbeatConsumer.Dispose();
consumerEnvironment.Producer.Dispose();
consumerEnvironment.ReceivingConnection.Dispose();
consumerEnvironment.SendingConnection.Dispose();
environments.Remove(consumerEnvironment);
}
return(model);
}
