/// <summary>
/// Gets the service.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <returns>The complete service.</returns>
internal static Service GetService(Service service, FileLoggerConfiguration loggerConfiguration)
{
var svcTbl = new SC_StatusDbDt.Service();
string where = string.Empty;
if (string.IsNullOrEmpty(service.ServiceName))
{
where = string.Format("{0} = {1}", "ServiceId", service.ServiceId);
}
else
{
where = string.Format("{0} = '{1}'", "ServiceName", service.ServiceName);
}
var svc = svcTbl.Single(where : where);
return(new Service {
ServiceId = (int)svc.ServiceId,
ServiceName = svc.ServiceName,
ServiceDescription = svc.ServiceDescription,
ServiceStatus = (Service.ServiceStatusEnum)((int)svc.ServiceStatus),
ServiceDisplayName = svc.ServiceDisplayName,
LocationId = (int)svc.LocationId,
SystemId = (int)svc.SystemId,
ApplicationId = (int)svc.ApplicationId,
InstallPath = svc.InstallPath,
IsHub = svc.IsHub,
ServiceCommands = GetServiceCommands(service, loggerConfiguration)
});
}
/// <summary>
/// Gets the services.
/// </summary>
/// <param name="serviceStatusDatabasePath">The service status database path.</param>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <returns>
/// A generic list of services administered by the hub service.
/// </returns>
public static List <Service> GetServices(FileLoggerConfiguration loggerConfiguration)
{
List <Service> services = new List <Service>();
var svcTable = new SC_StatusDbDt.Service();
var svcs = svcTable.All();
foreach (var svc in svcs)
{
services.Add(new Service {
ServiceId = (int)svc.ServiceId,
ServiceName = svc.ServiceName,
ServiceDescription = svc.ServiceDescription,
ServiceStatus = (Service.ServiceStatusEnum)((int)svc.ServiceStatus),
ServiceDisplayName = svc.ServiceDisplayName,
LocationId = (int)svc.LocationId,
SystemId = (int)svc.SystemId,
ApplicationId = (int)svc.ApplicationId,
InstallPath = svc.InstallPath,
IsHub = svc.IsHub,
ServiceCommands = GetServiceCommands((int)svc.ServiceId, loggerConfiguration)
});
}
return(services);
}
private FileLogger(FileLoggerConfiguration settings)
{
Settings = settings;
log4net.GlobalContext.Properties["LogName"] = Settings.LogFileName;
logger = LogManager.GetLogger(typeof(FileLogger));
XmlConfigurator.Configure();
}
/// <summary>
/// Removes the service.
/// </summary>
public static void RemoveService(Service service, FileLoggerConfiguration loggerConfiguration)
{
Logging.Log(LogLevelEnum.Info, "Begin Service status removal", loggerConfiguration);
Logging.Log(LogLevelEnum.Debug, "Begin SQLite database connection initialization", loggerConfiguration);
using (SQLiteConnection sqliteConnection = SQLite.InitializeConnection(service.ServiceStatusDatabasePath, loggerConfiguration)) {
sqliteConnection.Open();
Logging.Log(LogLevelEnum.Debug, "SQLite Connection opened", loggerConfiguration);
Logging.Log(LogLevelEnum.Info, string.Format("Beginning service status removal:\t\tService name: {0}\t\tService ID: {1}", service.ServiceName, service.ServiceId), loggerConfiguration);
string sqlStatement = string.Format("DELETE FROM ServiceCommand where ServiceId = {0}", service.ServiceId);
try {
SQLite.ExecuteNonQuery(sqlStatement, sqliteConnection, loggerConfiguration);
sqlStatement = string.Format("DELETE FROM Service where ServiceId = {0}", service.ServiceId);
SQLite.ExecuteNonQuery(sqlStatement, sqliteConnection, loggerConfiguration);
}
catch (Exception ex) {
Logging.Log(LogLevelEnum.Fatal, FileLogger.GetInnerException(ex).Message, loggerConfiguration);
Logging.HandleException(ex);
throw;
}
sqliteConnection.Close();
Logging.Log(LogLevelEnum.Debug, "SQLite Connection closed", loggerConfiguration);
Logging.Log(LogLevelEnum.Info, string.Format("Service status removal finished:\t\tService name: {0}\t\tService ID: {1}", service.ServiceName, service.ServiceId), loggerConfiguration);
}
Logging.Log(LogLevelEnum.Info, "End Service status removal", loggerConfiguration);
}
public static ILoggerFactory AddFileLogger(this ILoggerFactory loggerFactory, Action <FileLoggerConfiguration> configure)
{
var config = new FileLoggerConfiguration();
configure(config);
return(loggerFactory.AddFileLogger(config));
}
/// <summary>
/// Add <seealso cref="FileLoggerProvider"/> with set path and the <seealso cref="FileLoggerConfiguration"/>.
/// </summary>
/// <param name="builder">The <seealso cref="ILoggingBuilder"/> that adds the <seealso cref="FileLoggerProvider"/>.</param>
/// <param name="path">The path of the log file.</param>
/// <param name="configuration">The configuration for the <seealso cref="FileLogger"/>.</param>
/// <returns></returns>
public static ILoggingBuilder AddFile(this ILoggingBuilder builder, string path,
FileLoggerConfiguration configuration = null)
{
configuration ??= new FileLoggerConfiguration();
builder.AddProvider(new FileLoggerProvider(path, configuration));
return(builder);
}
public void Test_FileLogger_Default()
{
var fileLoggerConfiguration = new FileLoggerConfiguration();
var fileLogger = LogSettings.RegisterDefaultLogger <FileLogger>(fileLoggerConfiguration);
Assert.Equal(fileLoggerConfiguration.FilenamePattern, fileLogger.FilenamePattern);
Assert.Equal(fileLogger, LogSettings.DefaultLogger);
}
/// <summary>
/// Is used to configure and register file logger
/// </summary>
/// <param name="fileLoggerConfiguration">file logger configuration</param>
/// <param name="loggerConfiguration">applications main (serilog) logger configuration</param>
private static void RegisterFileLogger(FileLoggerConfiguration fileLoggerConfiguration, LoggerConfiguration loggerConfiguration)
{
if (fileLoggerConfiguration.Enabled)
{
string path = fileLoggerConfiguration.IsGlobalPath ?
fileLoggerConfiguration.Path :
Path.Combine(ApplicationEnvironment.ApplicationBasePath, fileLoggerConfiguration.Path);
LogEventLevel fileLogLvl = (LogEventLevel)Enum.Parse(typeof(LogEventLevel), fileLoggerConfiguration.Level);
loggerConfiguration.WriteTo.RollingFile(path, fileLogLvl, fileSizeLimitBytes: fileLoggerConfiguration.FileSizeLimitBytes, retainedFileCountLimit: fileLoggerConfiguration.RetainedFileCountLimit);
}
}
public static FileLogger Instance(FileLoggerConfiguration settings)
{
if (string.IsNullOrEmpty(settings.LogFileName))
{
settings.LogFileName = FileLoggerConfiguration.DefaultLogFileName;
}
instance = new FileLogger(settings);
return(instance);
}
public static SQLiteConnection InitializeConnection(string databasePath, FileLoggerConfiguration loggerConfiguration)
{
SQLiteConnectionStringBuilder sqliteConnectionStringBuilder = new SQLiteConnectionStringBuilder {
DataSource = databasePath,
PageSize = 1024,
Pooling = true
};
Logging.Log(LogLevelEnum.Debug, "SQLite Connection string initialized", loggerConfiguration);
Logging.Log(LogLevelEnum.Debug, string.Format("Connection string: {0}", sqliteConnectionStringBuilder.ConnectionString), loggerConfiguration);
return(new SQLiteConnection(sqliteConnectionStringBuilder.ConnectionString));
}
public static void ExecuteNonQuery(SQLiteCommand sqliteCommand, FileLoggerConfiguration loggerConfiguration)
{
try {
using (sqliteCommand) {
sqliteCommand.CommandType = CommandType.Text;
Logging.Log(LogLevelEnum.Debug, string.Format("SQL statement:\n\n{0}\n\n", sqliteCommand.CommandText), loggerConfiguration);
sqliteCommand.ExecuteNonQuery();
}
}
catch (Exception ex) {
StackTrace stackTrace = new StackTrace();
Logging.Log(LogLevelEnum.Error, string.Format("{0}: {1}", stackTrace.GetFrame(1).GetMethod().Name, FileLogger.GetInnerException(ex).Message), loggerConfiguration);
Logging.HandleException(ex);
}
}
/// <summary>
/// Initializes the service.
/// </summary>
/// <param name="service">The service.</param>
/// <returns>The service ID</returns>
public static int InitializeService(Service service, FileLoggerConfiguration loggerConfiguration)
{
Logging.Log(LogLevelEnum.Info, "Begin Service status initialization", loggerConfiguration);
int serviceId = -1;
Logging.Log(LogLevelEnum.Debug, "Begin SQLite database connection initialization", loggerConfiguration);
using (SQLiteConnection sqliteConnection = SQLite.InitializeConnection(service.ServiceStatusDatabasePath, loggerConfiguration)) {
sqliteConnection.Open();
Logging.Log(LogLevelEnum.Debug, "SQLite Connection opened", loggerConfiguration);
serviceId = InitializeService(service, sqliteConnection, loggerConfiguration);
sqliteConnection.Close();
Logging.Log(LogLevelEnum.Debug, "SQLite Connection closed", loggerConfiguration);
}
return(serviceId);
}
/// <summary>
/// Gets the service status.
/// </summary>
/// <param name="service">The service.</param>
/// <returns>The service status.</returns>
public static Service.ServiceStatusEnum GetServiceStatus(Service service, FileLoggerConfiguration loggerConfiguration)
{
return(GetServiceStatus(service.ServiceId, loggerConfiguration));
}
/// <summary>
/// Gets the service status.
/// </summary>
/// <param name="serviceId"></param>
/// <returns>The service status.</returns>
public static Service.ServiceStatusEnum GetServiceStatus(int serviceId, FileLoggerConfiguration loggerConfiguration)
{
return(GetService(serviceId, loggerConfiguration).ServiceStatus);
}
/// <summary>
/// Sets the service status.
/// </summary>
/// <param name="serviceStatus"></param>
/// <param name="serviceId"></param>
public static void SetStatus(Service.ServiceStatusEnum serviceStatus, int serviceId, FileLoggerConfiguration loggerConfiguration)
{
var svcTable = new SC_StatusDbDt.Service();
svcTable.Update(new { ServiceStatus = (int)serviceStatus }, serviceId);
}
/// <summary>
/// Sets the service status.
/// </summary>
/// <param name="service">The service.</param>
public static void SetStatus(Service service, FileLoggerConfiguration loggerConfiguration)
{
SetStatus(service.ServiceStatus, service.ServiceId, loggerConfiguration);
}
public static SQLiteDataReader ExecuteReader(string sqlStatement, SQLiteConnection sqliteConnection, FileLoggerConfiguration loggerConfiguration)
{
SQLiteDataReader reader = null;
try {
using (SQLiteCommand cmd = new SQLiteCommand(sqlStatement, sqliteConnection)) {
cmd.CommandType = CommandType.Text;
Logging.Log(LogLevelEnum.Debug, string.Format("SQL statement:\n\n{0}\n\n", sqlStatement), loggerConfiguration);
reader = cmd.ExecuteReader();
}
}
catch (Exception ex) {
StackTrace stackTrace = new StackTrace();
Logging.Log(LogLevelEnum.Error, string.Format("{0}: {1}", stackTrace.GetFrame(1).GetMethod().Name, FileLogger.GetInnerException(ex).Message), loggerConfiguration);
Logging.HandleException(ex);
}
return(reader);
}
/// <summary>
/// Creates the database. This is the method used by the hub set up.
/// </summary>
/// <returns>The service ID for the hub.</returns>
public static int CreateDatabase(Service service, List <string> serviceStatusDbSetupSql, FileLoggerConfiguration loggerConfiguration)
{
int serviceId = -1;
if (!File.Exists(service.ServiceStatusDatabasePath))
{
Logging.Log(LogLevelEnum.Info, "Begin SQLite database initialization", loggerConfiguration);
var db = new SC_StatusDbDt.Service();
Logging.Log(LogLevelEnum.Debug, "Begin SQL statements", loggerConfiguration);
foreach (var sqlStatement in serviceStatusDbSetupSql)
{
try {
db.Execute(sqlStatement, new object[0]);
}
catch (Exception ex) {
Logging.Log(LogLevelEnum.Fatal, FileLogger.GetInnerException(ex).Message, loggerConfiguration);
Logging.HandleException(ex);
throw;
}
}
Logging.Log(LogLevelEnum.Debug, "End SQL statements", loggerConfiguration);
serviceId = DatabaseInstaller.InitializeService(service, null, loggerConfiguration);
Logging.Log(LogLevelEnum.Info, "End SQLite database initialization", loggerConfiguration);
}
return(serviceId);
}
private static List <LogRecord> Parse(LogLevelEnum logLevel, FileLoggerConfiguration configuration)
{
FileLogger fileLogger = FileLogger.Instance(configuration);
return(fileLogger.Parse(logLevel));
}
/// <summary>
/// Updates the service monitor.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="serviceStatusDatabasePath">The service status database path.</param>
public static void UpdateServiceMonitor(Service service, string serviceStatusDatabasePath, FileLoggerConfiguration loggerConfiguration)
{
var svcMon = new SC_StatusDbDt.ServiceMonitor();
if (svcMon.Count(string.Format("ServiceId = {0}", service.ServiceId)) > 0)
{
svcMon.Update(new { MonitorTime = DateTime.Now }, new { ServiceId = service.ServiceId });
}
else
{
svcMon.Insert(new { MonitorTime = DateTime.Now, ServiceId = service.ServiceId });
}
}
/// <summary>
/// Initializes the service.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="sqliteConnection">The sqlite connection.</param>
/// <returns>The service ID</returns>
internal static int InitializeService(Service service, SQLiteConnection sqliteConnection, FileLoggerConfiguration loggerConfiguration)
{
Logging.Log(LogLevelEnum.Info, string.Format("Beginning service status initialization:\n\t\tService name: {0}", service.ServiceName), loggerConfiguration);
var svcTbl = new SC_StatusDbDt.Service();
var newId = svcTbl.Insert(new {
ServiceName = service.ServiceName,
ServiceDescription = service.ServiceDescription,
ServiceDisplayName = service.ServiceDisplayName,
LocationId = service.LocationId,
ApplicationId = service.ApplicationId,
SystemId = service.SystemId,
InstallPath = service.InstallPath,
ServiceStatus = (int)Service.ServiceStatusEnum.Stopped,
IsHub = service.IsHub
});
service = DatabaseController.GetService(service, loggerConfiguration);
Logging.Log(LogLevelEnum.Info, string.Format("Service status initialization finished:\n\t\tService name: {0}\n\t\tService ID: {1}", service.ServiceName, service.ServiceId), loggerConfiguration);
return(service.ServiceId);
}
/// <summary>
/// Gets the service commands.
/// </summary>
/// <param name="serviceId">The service id.</param>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <returns></returns>
public static List <ServiceCommandStruct> GetServiceCommands(int serviceId, FileLoggerConfiguration loggerConfiguration)
{
return(GetServiceCommands(new Service {
ServiceId = serviceId
}, loggerConfiguration));
}
/// <summary>
/// Gets the service.
/// </summary>
/// <param name="serviceId">The service id.</param>
/// <param name="loggerConfiguration">The logger configuration.</param>
/// <returns></returns>
internal static Service GetService(int serviceId, FileLoggerConfiguration loggerConfiguration)
{
return(GetService(new Service {
ServiceId = serviceId
}, loggerConfiguration));
}
public static void ExecuteNonQuery(SQLiteCommand sqliteCommand, SQLiteConnection sqliteConnection, FileLoggerConfiguration loggerConfiguration)
{
try {
using (sqliteCommand) {
sqliteCommand.Connection = sqliteConnection;
ExecuteNonQuery(sqliteCommand, loggerConfiguration);
}
}
catch (Exception ex) {
StackTrace stackTrace = new StackTrace();
Logging.Log(LogLevelEnum.Error, string.Format("{0}: {1}", stackTrace.GetFrame(1).GetMethod().Name, FileLogger.GetInnerException(ex).Message), loggerConfiguration);
Logging.HandleException(ex);
}
}
public static void Log(LogLevelEnum logLevel, string message, FileLoggerConfiguration configuration)
{
FileLogger fileLogger = FileLogger.Instance(configuration);
fileLogger.WriteLog(logLevel, message);
}
/// <summary>
/// Gets the service monitor time.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="serviceStatusDatabasePath">The service status database path.</param>
/// <returns></returns>
public static DateTime GetServiceMonitorTime(Service service, string serviceStatusDatabasePath, FileLoggerConfiguration loggerConfiguration)
{
DateTime returnTime = new DateTime();
var svcMon = new SC_StatusDbDt.ServiceMonitor();
var monitorTime = svcMon.Single(new { ServiceId = service.ServiceId });
returnTime = monitorTime.MonitorTime;
return(returnTime);
}
private static List <LogRecord> Parse(FileLoggerConfiguration configuration)
{
FileLogger fileLogger = FileLogger.Instance(configuration);
return(fileLogger.Parse());
}
/// <summary>
/// Sets the extension success status.
/// </summary>
/// <param name="serviceId">The service id.</param>
/// <param name="success">if set to <c>true</c> [success].</param>
/// <param name="serviceStatusDatabasePath">The service status database path.</param>
public static void SetExtensionSuccessStatus(int serviceId, bool success, string serviceStatusDatabasePath, FileLoggerConfiguration loggerConfiguration)
{
var svcMon = new SC_StatusDbDt.ServiceMonitor();
dynamic data = new { };
if (svcMon.Count(string.Format("ServiceId = {0}", serviceId)) > 0)
{
if (success)
{
data = new { ServiceSuccessRunTime = DateTime.Now };
}
else
{
data = new { ServiceFailRunTime = DateTime.Now };
}
svcMon.Update(data, new { ServiceId = serviceId });
}
else
{
if (success)
{
data = new { ServiceSuccessRunTime = DateTime.Now, ServiceId = serviceId };
}
else
{
data = new { ServiceFailRunTime = DateTime.Now, ServiceId = serviceId };
}
svcMon.Insert(data);
}
}
/// <summary>
/// Gets the service commands.
/// </summary>
/// <param name="service">The service.</param>
/// <returns>A generic list of ServiceCommandStruct</returns>
public static List <ServiceCommandStruct> GetServiceCommands(Service service, FileLoggerConfiguration loggerConfiguration)
{
var svcTable = new SC_StatusDbDt.ServiceCommand();
var svcCommands = svcTable.All(where : string.Format("ServiceId = {0}", service.ServiceId));
List <ServiceCommandStruct> tempCommands = new List <ServiceCommandStruct>();
foreach (var command in svcCommands)
{
tempCommands.Add(new ServiceCommandStruct {
CommandId = command.CommandId,
CommandDescription = command.CommandDescription
});
}
return(tempCommands);
}
/// <summary>
/// Gets the extension execute status time.
/// </summary>
/// <param name="service">The service.</param>
/// <param name="success">if set to <c>true</c> [success].</param>
/// <param name="serviceStatusDatabasePath">The service status database path.</param>
/// <returns></returns>
public static DateTime GetExtensionExecuteStatusTime(Service service, bool success, string serviceStatusDatabasePath, FileLoggerConfiguration loggerConfiguration)
{
DateTime returnTime = DateTime.MinValue;
var svcMon = new SC_StatusDbDt.ServiceMonitor();
var monitorTime = svcMon.Single(new { ServiceId = service.ServiceId });
if (success)
{
returnTime = monitorTime.ServiceSuccessRunTime;
}
else
{
returnTime = monitorTime.ServiceFailRunTime;
}
return(returnTime);
}
