public PortfolioValuationSummaryXmlWriter(ILogger logger, IAppConfigurationManager appConfigurationManager, IHashingFilenameGenerator hashingFilenameGenerator)
{
_hashingFilenameGenerator = hashingFilenameGenerator;
_outputDirectory = appConfigurationManager.SimulationReportDirectory;
_logger = logger;
}
public LogMaintenance(IAppConfigurationManager config, ILogStore logStore)
{
this.config = config;
this.logStore = logStore;
}
public GlobalConfig(IAppConfigurationManager confManager)
{
this.confManager = confManager;
}
/// <summary>
/// Initializes a new instance of the <see cref="StarshipDataService" /> class.
/// </summary>
/// <param name="httpClientHandler">The HTTP client handler.</param>
/// <param name="appConfigurationManager">The application configuration manager.</param>
public StarshipDataService(IHttpClientHandler httpClientHandler, IAppConfigurationManager appConfigurationManager)
{
_appConfigurationManager = appConfigurationManager;
_httpClientHandler = httpClientHandler;
}
public ApplicationGridModule(GlobalConfig globals, IAppConfigurationManager appconf, ILogStore logStore)
{
if (globals.IsAuthenticationEnabled())
{
this.RequiresAuthentication();
}
Get["/", true] = async(x, ct) => {
ApplicationGridModel model = null;
if (DefaultCacheTimeInSeconds != 0)
{
model = cache["appstats"] as ApplicationGridModel;
}
if (model == null)
{
var applicationStatuses = await logStore.GetApplicationStatusesAsync(DateTime.UtcNow.AddMinutes(-15));
var allApplications = await appconf.GetAppsAsync();
var activeServers = new SortedSet <string>();
var activeApplications = new Dictionary <string, Application>();
var activeApplicationStatuses = new SortedDictionary <string, IDictionary <string, LastApplicationStatus> >();
foreach (var appStatus in applicationStatuses)
{
activeServers.Add(appStatus.Server);
var app = allApplications.FirstOrDefault(a => string.Equals(a.Path, appStatus.ApplicationPath,
StringComparison.InvariantCultureIgnoreCase));
if (app != null && !app.IsExcluded)
{
if (!activeApplications.ContainsKey(app.Path))
{
activeApplications.Add(app.Path, app);
}
IDictionary <string, LastApplicationStatus> applicationStatusPerServer;
if (!activeApplicationStatuses.TryGetValue(app.Path, out applicationStatusPerServer))
{
applicationStatusPerServer = new Dictionary <string, LastApplicationStatus>(StringComparer.OrdinalIgnoreCase);
activeApplicationStatuses.Add(app.Path, applicationStatusPerServer);
}
applicationStatusPerServer.Add(appStatus.Server, appStatus);
}
}
// for the rest of the applications
foreach (var app in allApplications)
{
if (!app.IsExcluded)
{
if (!activeApplications.ContainsKey(app.Path))
{
activeApplications.Add(app.Path, app);
}
if (!activeApplicationStatuses.ContainsKey(app.Path))
{
activeApplicationStatuses.Add(app.Path, new Dictionary <string, LastApplicationStatus>(StringComparer.OrdinalIgnoreCase));
}
}
}
model = new ApplicationGridModel {
LastUpdateTime = DateTime.Now,
Servers = activeServers.ToArray(),
Applications = activeApplications,
ApplicationStatuses = activeApplicationStatuses
};
if (DefaultCacheTimeInSeconds != 0)
{
cache.Set("appstats", model, new CacheItemPolicy()
{
AbsoluteExpiration = DateTimeOffset.UtcNow.AddSeconds(DefaultCacheTimeInSeconds)
});
}
}
return(View["ApplicationGrid.cshtml", model]);
};
Get["/apps", true] = async(x, ct) => {
// gets applications for which we have received the logs
return(View["Applications", (await appconf.GetAppsAsync()).Where(app => !app.IsHidden).Select(
app => {
app.DaysToKeepLogs = app.DaysToKeepLogs ?? AppSettings.DefaultNoOfDaysToKeepLogs;
return app;
})]);
};
}
public XmlModelFactory(ILogger logger, IAppConfigurationManager appConfigurationManager)
{
_appConfigurationManager = appConfigurationManager;
_logger = logger;
}
public CollectModule(IAppConfigurationManager config, IValidator <LogRecord> logRecordValidator, ILogStore logStore)
{
Post["/collect", true] = async(x, ct) => {
var logrec = this.Bind <LogRecord>(new BindingConfig {
BodyOnly = true
});
var validationResult = logRecordValidator.Validate(logrec);
if (!validationResult.IsValid)
{
return("VALIDATION ERROR");
}
logrec.ApplicationPath = logrec.ApplicationPath.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
var app = await config.FindAppAsync(logrec.ApplicationPath);
if (app == null)
{
app = new Application {
IsExcluded = true,
Path = logrec.ApplicationPath
};
await config.AddOrUpdateAppAsync(app);
}
if (!app.IsExcluded)
{
await logStore.AddLogRecordAsync(logrec);
await logStore.UpdateApplicationStatusAsync(
CreateApplicationStatus(logrec));
}
return("OK");
};
Post["/collectall", true] = async(x, ct) => {
var logrecs = this.Bind <LogRecord[]>(new BindingConfig {
BodyOnly = true
});
var logsToSave = new List <LogRecord>(logrecs.Length);
foreach (var logrec in logrecs)
{
var validationResult = logRecordValidator.Validate(logrec);
if (validationResult.IsValid)
{
logrec.ApplicationPath = logrec.ApplicationPath.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
// add new application to the configuration as excluded (it could be later renamed or unexcluded)
var app = await config.FindAppAsync(logrec.ApplicationPath);
if (app == null)
{
app = new Application {
IsExcluded = true,
Path = logrec.ApplicationPath
};
await config.AddOrUpdateAppAsync(app);
}
if (!app.IsExcluded)
{
logsToSave.Add(logrec);
}
else
{
logger.TraceEvent(TraceEventType.Verbose, 0, "Log record for the application '{0}' was not stored as the application is excluded.");
}
}
else
{
if (logger.Switch.ShouldTrace(TraceEventType.Warning))
{
logger.TraceEvent(TraceEventType.Warning, 0, "Validation error(s) occured when saving a logrecord: {0}, errors: {1}",
logrec, validationResult.Errors);
}
}
}
if (logsToSave.Count > 0)
{
await logStore.AddLogRecordsAsync(logsToSave);
await logStore.UpdateApplicationStatusesAsync(CreateApplicationStatusesList(logsToSave));
}
return("OK");
};
}
