private static void StopService(string serviceName) { if (!IsInstalled(serviceName)) { return; } using (var controller = new ServiceController(serviceName)) { try { WindowsEventLog.WriteInfoLog(string.Format(@"Trying to Stop the Service...")); if (controller.Status != ServiceControllerStatus.Stopped) { controller.Stop(); controller.WaitForStatus(ServiceControllerStatus.Stopped, TimeSpan.FromSeconds(10)); } } catch (Exception ex) { WindowsEventLog.WriteErrorLog(string.Format(@"\nError in stopping service method \n{0}", ex.Message)); } } }
private void btnFetchLogs_Click(object sender, EventArgs e) { IEnumerable <Log> logs = null; if (dtpFrom.Checked) { logs = WindowsEventLog.GetEntryCollection(dtpFrom.Value, dtpTo.Checked ? dtpTo.Value : DateTime.Now, chkErrors.Checked, chkWarnings.Checked, chkInformations.Checked, chkAuditSuccess.Checked, chkAuditFailure.Checked); } else if (dtpTo.Checked) { logs = WindowsEventLog.GetEntryCollection(dtpTo.Value.AddDays(-30), dtpTo.Value, chkErrors.Checked, chkWarnings.Checked, chkInformations.Checked, chkAuditSuccess.Checked, chkAuditFailure.Checked); } else { logs = WindowsEventLog.GetEntryCollection(chkErrors.Checked, chkWarnings.Checked, chkInformations.Checked, chkAuditSuccess.Checked, chkAuditFailure.Checked); } if (logs != null) { dgvLogs.DataSource = logs.ToDataTable(); } }
public static void WriteToEventLogTest() { WindowsEventLog evt = null; try { _msg.Length = 0; _msg.Append("WriteToEventLogTest started ...\r\n"); Program._messageLog.WriteLine(_msg.ToString()); evt = new WindowsEventLog(WindowsEventLog.EventLogName.Application, ".", "PFApps"); evt.WriteEntry("Test message from testprog ... yes indeed!", WindowsEventLog.WindowsEventLogEntryType.Information); } catch (System.Exception ex) { _msg.Length = 0; _msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex)); Program._messageLog.WriteLine(_msg.ToString()); AppMessages.DisplayErrorMessage(_msg.ToString(), _saveErrorMessagesToAppLog); } finally { _msg.Length = 0; _msg.Append("\r\n... WriteToEventLogTest finished."); Program._messageLog.WriteLine(_msg.ToString()); } }
protected override void OnShutdown() { base.OnShutdown(); WindowsEventLog.WriteInfoLog($"The {Environment.MachineName} server will be turned off."); ServiceLifeController.WillBeTurnOff(); }
private void AreEqual(WindowsEventLog exp, WindowsEventLog act) { if (exp != null) { AreEqual(exp.DataSources, act.DataSources); } }
protected void Application_Start(object sender, EventArgs e) { WindowsEventLog.AddEvent("WebDav Application_Start()", 9999); IoCSetup.ForceLoad(typeof(EC.Core.Common.ForceLoad)); BootstrapContainer(); SetupServices(); }
public static bool PauseService(string serviceName) { if (!IsInstalled(serviceName)) { return(false); } using (var controller = new ServiceController(serviceName)) { try { WindowsEventLog.WriteInfoLog(@"Trying to paused the Service..."); if (controller.Status != ServiceControllerStatus.Paused) { controller.Stop(); controller.WaitForStatus(ServiceControllerStatus.Paused, TimeSpan.FromSeconds(60)); } return(true); } catch (Exception ex) { WindowsEventLog.WriteErrorLog($@"\nError in stopping service method \n{ex.Message}"); } return(false); } }
/// <summary> /// If the condition is false, log an error in the Windows Event Log. In a /// DEBUG build, an assertion failure will also cause the server to shut /// down. /// </summary> /// <param name="condition">Boolean to check</param> /// <param name="message">Message for event log</param> /// <exception cref="AssertException">Throw exception if assert fails (condition == <c>false</c>)</exception> public static void Assert(bool condition, string message) { if (condition) { return; } string msg = String.Format("{0} - Assertion Failure: {1}", DebugUtils.GetLocationFromStack(2), message); WindowsEventLog.AddEvent(msg, WindowsEventLog.DBCAssertion); ShutdownIfNeededAndThrow(msg); }
/// <summary> /// Check if the parameter <c>obj</c> is <c>null</c>. If <c>obj</c> is <c>null</c>, /// write an error to the Windows Event Log. In a DEBUG build, an assertion failure /// will also cause the server to shut down. /// </summary> /// <param name="obj">Object to check.</param> /// <param name="message">Message for the log if the parameter <c>obj</c> is <c>null</c>.</param> /// <exception cref="AssertException">Throw exception if object is <c>null</c></exception> public static void NonNull <T>(T obj, string message) { if (obj != null) { return; } string msg = String.Format("{0} - Null check failure: {1}", DebugUtils.GetLocationFromStack(2), message); WindowsEventLog.AddEvent(msg, WindowsEventLog.DBCNonNull); ShutdownIfNeededAndThrow(msg); }
/// <summary> /// Initiates IOC /// </summary> /// <remarks> /// IoCSetupForceLoad() deals with the problem that the app is so loosely /// coupled that it won't bother loading some assemblies because it doesn't /// see direct references to this. /// </remarks> private void BootstrapContainer() { try { container = IoCSetup.Run("EC WebDav Application Starting", "EC-Web-Dav"); } catch (Exception ex) { var msg = String.Format("EC WebDav Application Startup (BootstrapContainer) - Unexpected Exception [{0}]", ex.Message.ToString()); WindowsEventLog.AddEvent(msg, WindowsEventLog.FatalError); } }
public static bool InstallService() { try { WindowsEventLog.WriteInfoLog(@"Installing Service"); ManagedInstallerClass.InstallHelper(new[] { ExePath }); } catch { return(false); } return(true); }
public static bool UninstallService() { try { WindowsEventLog.WriteInfoLog(string.Format(@"Uninstalling Service")); ManagedInstallerClass.InstallHelper(new string[] { "/u", ExePath }); } catch { return(false); } return(true); }
protected override void OnIncomingError(ExceptionContext exceptionContext, IHubIncomingInvokerContext invokerContext) { string message = string.Format("=> Exception {0}", exceptionContext.Error.Message); if (exceptionContext.Error.InnerException != null) { message += "\n\t=> Inner Exception " + exceptionContext.Error.InnerException.Message; } WindowsEventLog.WriteErrorLog(message); base.OnIncomingError(exceptionContext, invokerContext); }
/// <summary> /// The main entry point for the application. /// </summary> static void Main(string[] args) { WindowsEventLog.CreateEventLog(); ServiceBase[] ServicesToRun; ServicesToRun = new ServiceBase[] { new SignalRService() }; //ServiceBase.Run(ServicesToRun); ServicesToRun.SelectWhatDoing(args); }
/// <summary> /// The main entry point for the application. /// </summary> static void Main(string[] args) { WindowsEventLog.EventLogName = SharedLinks.EventLogName; WindowsEventLog.EventLogSourceName = SharedLinks.EventLogSource; WindowsEventLog.CreateEventLog(); var servicesToRun = new ServiceBase[] { new SLCService() }; //ServiceBase.Run(servicesToRun); servicesToRun.SelectWhatDoing(args); }
public static void NotifyStoppedCoveredServices() { lock (SyncObj) { var allServices = ServicesHelper.GetAllServices(); // all services try { foreach (var keepService in NewSetting.CoveredServices) { // find any new state of covered services var serviceNewStatus = allServices.FirstOrDefault(x => x.Name.Equals(keepService.Service.Name, StringComparison.CurrentCultureIgnoreCase))?.Status; // find any old state of covered services var serviceOldStatus = OldSetting.CoveredServices.FirstOrDefault(s => s.Service.Name.Equals(keepService.Service.Name, StringComparison.CurrentCultureIgnoreCase))?.Service.Status; // set new state to new setting service keepService.Service.Status = serviceNewStatus ?? ServiceControllerStatus.Stopped; // the service stopped just now!!! ServiceControllerStatusChanging newStatus; Enum.TryParse(serviceNewStatus.ToString(), true, out newStatus); // if status changed and identify status changing... if (serviceNewStatus != serviceOldStatus) { if (NewSetting.NotifyJustStatusChangingTo.HasFlag(newStatus)) { OnServiceStatusChanged(new ServiceNotifyEventArgs(keepService, serviceNewStatus ?? ServiceControllerStatus.Stopped)); } } } } catch (Exception exp) { WindowsEventLog.WriteErrorLog($"Exception in ServiceLifeControllerService: {exp.Message}"); } finally { if (allServices != null) { GC.SuppressFinalize(allServices); } OldSetting = NewSetting; } } }
public void WindowsEventLog_Constructor_CreatesWithExpectedInformation() { // Arrange var logName = "foo"; var machineName = "bar"; var sourceName = "blah"; // Act var windowsEventLog = new WindowsEventLog(logName, machineName, sourceName); // Assert Assert.NotNull(windowsEventLog.DiagnosticsEventLog); Assert.Equal(logName, windowsEventLog.DiagnosticsEventLog.Log); Assert.Equal(machineName, windowsEventLog.DiagnosticsEventLog.MachineName); Assert.Equal(sourceName, windowsEventLog.DiagnosticsEventLog.Source); }
public void GivenWindowsEventLogAndDefaultEntryTypeShouldWriteEntry() { const string source = "source"; const string message = "message"; EventType eventType = new EventType(); LogAuthorFake logAuthorFake = new LogAuthorFake(); WindowsEventLog windowsEventLog = new WindowsEventLog(logAuthorFake); windowsEventLog.WriteEntry(source, message, eventType); logAuthorFake.LogEntries().Count.Should().Be(1); logAuthorFake.LogEntries().First().Source().Should().Be(source); logAuthorFake.LogEntries().First().Message().Should().Be(message); logAuthorFake.LogEntries().First().EventType().Should().Be(eventType); }
public void DeleteEventSource(string eventSourceName) { try { if (WindowsEventLog.SourceExists(eventSourceName)) { WindowsEventLog.DeleteEventSource(eventSourceName); if (WindowsEventLog.SourceExists(eventSourceName) == false) { _msg.Length = 0; _msg.Append("Event Source "); _msg.Append(eventSourceName); _msg.Append(" delete succeeded."); WriteMessageToLog(_msg.ToString()); } else { _msg.Length = 0; _msg.Append("Event Source "); _msg.Append(eventSourceName); _msg.Append(" delete failed."); WriteMessageToLog(_msg.ToString()); } } else { _msg.Length = 0; _msg.Append("Event Source "); _msg.Append(eventSourceName); _msg.Append(" not found. No delete needed."); WriteMessageToLog(_msg.ToString()); } } catch (System.Exception ex) { _msg.Length = 0; _msg.Append(AppGlobals.AppMessages.FormatErrorMessage(ex)); _msg.Append(Environment.NewLine); _msg.Append("Caller must have elevated security permissions (e.g. use Run As Administrator) to create and delete event sources and event logs."); WriteMessageToLog(_msg.ToString()); AppMessages.DisplayErrorMessage(_msg.ToString(), true); } finally { ; } }
/// <summary> /// Shut down the application. This involves shutting down any background threads and then releasing the /// IoC container that was allocated in IoCSetup.Run(). /// </summary> public static void ShutdownThreadsAndReleaseContainer(string shutdownMsg) { if (ShuttingDown && Logger != null) { Logger.InfoFormat("IoCSetup::ShutdownThreadsAndReleaseContainer[{0}] - Re-entrant call. Stack = {1}", ContainerName, DebugUtils.GetStackTrace()); return; } ShuttingDown = true; if (Logger != null) { string msg = string.Format("IoCSetup::Shutdown[{0}] - {1}", ContainerName, shutdownMsg); Logger.Info(msg); } ShutdownBackgroundThreads(); MainContainer.Dispose(); WindowsEventLog.AddEvent(string.Format("IoCSetup::Shutdown[{0}] threads stopped and container disposed.", ContainerName), WindowsEventLog.Info); }
/// <summary> /// Initialize the Castle/Windsor IoC system. This includes setting up common facilities /// as well as registering components from all assemblies in the directory the application /// is executing from. /// </summary> /// <remarks> /// Originally this was called only once on application startup and a single container /// was used for the lifetime of the application. However, due to the way EF migration /// works, it became necessary to allocate new containers that would only be used in the /// context of EF migrations. These containers are assumed to be temporary in existence /// and it is also assumed that they should not have any background services /// associated with them. Thus, the suppressStartable parameter is interpreted to mean /// the caller is asking for a temporary-use container which has the effect /// both of suppressing the starting of IStartable components, but also of not storing /// the new container in the static member variable which is used to track the /// applications main container. /// </remarks> /// <remarks> /// RegisterCommonFacilities() must be called immediately on the newly created container /// because it sets up things like logging that we use every else. /// </remarks> /// <param name="startMsg">A startup message to place in the log</param> /// <returns>the initialized Windsor container</returns> public static IWindsorContainer Run(string startMsg, string containerName, bool suppressStartable = false) { WindowsEventLog.AddEvent(string.Format("IOCSetup.Run has been called for container name {0} (suppressStartable={1})", containerName, suppressStartable), WindowsEventLog.Info); ContainerName = containerName; var newContainer = new WindsorContainer(); newContainer.Kernel.ComponentCreated += Kernel_ComponentCreated; RegisterCommonFacilities(newContainer, suppressStartable); DBC.Assert(MainContainer == null, String.Format("IoCSetup::Run[{0}] - Duplicate main container", containerName)); MainContainer = newContainer; Logger = newContainer.Resolve <ILogger>(); Logger.Info(startMsg); DeactivatePropertyInjection(newContainer); SetupAssemblyLoadHook(); IList <Assembly> loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies(); loadedAssemblies.ForEach(a => LogAssemblyName(a, "initial")); RegisterAssembliesForIOC(newContainer, loadedAssemblies); return(newContainer); }
/// <summary> /// Shut down the IoC container and exit the application/process. This will also cause all /// component instances to be released and all startable components to be stopped. This call /// should never return because it causes the process to exit with <paramref name="exitCode"/> /// </summary> /// <remarks> /// <para> /// We call Environment.Exit() here because there are threads running which we don't have /// direct control over and which don't seem to get stopped when we dispose the container. /// For example, we have observed AsynAppender threads continuing to run after dispose on /// the container has returned. This probably shouldn't be the case, but it would be time /// consuming to track down why. If we don't exit here, then the process may not exit due /// to these running threads. /// </para> /// <para> /// We have to call Exit() in a separate thread because the SCM complains if you call /// Exit() on its thread (and when you stop a service via the SCM it is the SCM's thread /// that is calling into this code). /// </para> /// <para> /// There is an interesting deadlock scenario that ShutdownStoppables() needs to avoid. /// If the thread calling Shutdown() is the background thread for an object bearing the /// IBackgroundThread interface, and it tries to call Stop() on the instance for which it /// is a background thread, then a deadlock results (because it is trying to stop itself). /// So ShutdownStoppeables() needs to avoid this scenario. /// </para> /// <para> /// We should try to stop all incoming requests, and ensure that all in-process requests /// are complete prior to calling Dispose on the container. This is not implemented currently. /// </para> /// </remarks> /// <param name="shutdownMsg">The shutdown message to log before exiting.</param> /// <param name="exitCode">Exit code to stop the system (any code other than 0 for any error occurred).</param> public static void ShutdownAndExit(string shutdownMsg, int exitCode) { try { ShutdownThreadsAndReleaseContainer(shutdownMsg); if (exitCode != 0) { string msg = string.Format("IoCSetup::Shutdown[{0}] - {1} {2}", ContainerName, shutdownMsg, string.Format("Stack = {0}", DebugUtils.GetStackTrace())); WindowsEventLog.AddEvent(msg, WindowsEventLog.FatalError); } } catch (Exception ex) { var msg = String.Format("IoCSetup::Shutdown[{0}]: Unexpected exception Msg={1} Ex = {2}", ContainerName, shutdownMsg, ex); WindowsEventLog.AddEvent(msg, WindowsEventLog.FatalError); } Task.Factory.StartNew(() => Environment.Exit(exitCode)); }
private static bool LoggedIntoEventlog(Icon popupIcon, string infoMessage) { if (WindowsServiceHelper.IsRunningInServiceContext) { if (popupIcon == SystemIcons.Error) { WindowsEventLog.LogError(infoMessage); } else if (popupIcon == SystemIcons.Warning) { WindowsEventLog.LogWarning(infoMessage); } else { WindowsEventLog.LogInformation(infoMessage); } return(true); } return(false); }
public static void StartLifeCycleController() { try { WindowsEventLog.WriteInfoLog($"Services Life Cycle Controller Begin."); LoadSettingData(); ExertSetting(); CycleTimer.Elapsed += cycleTimer_Elapsed; CycleTimer.Start(); WindowsEventLog.WriteInfoLog($"Services Life Cycle Controller Started."); } catch (Exception exp) { WindowsEventLog.WriteErrorLog($"Exception in ServiceLifeController start: {exp.Message}"); } }
private static void LoadSettingData() { try { var path = FileManager.DefaultApplicationDataPath; var settingJson = FileManager.ReadFileSafely(path); if (settingJson == null) { return; } // exchange new by old setting NewSetting = JsonConvert.DeserializeObject <SettingModel>(settingJson); } catch (Exception exp) { WindowsEventLog.WriteErrorLog($"Exception in ServiceLifeController: {exp.Message}"); } }
protected void Application_Error(object sender, EventArgs e) { //Log the Error Exception ex = Server.GetLastError(); ILogger logger = null; try { if (ex != null) { string errMsg = string.Format("Unhandled top-level error: {0}", ex.ToString()); string innerErrMsg = ex.InnerException != null?string.Format("Unhandled top-level error (inner): {0}", ex.InnerException.Message) : "No inner exception"; // Event logs... WindowsEventLog.AddEvent(string.Format("WebDav Global.Application_Error(): {0}", errMsg), 9999); if (ex.InnerException != null) { WindowsEventLog.AddEvent(string.Format("WebDav Global.Application_Error(): {0}", innerErrMsg), 9999); } // File log... logger = container.Resolve <ILogger>(); logger.Error(errMsg); if (ex.InnerException != null) { logger.ErrorFormat("WebDav Global.Application_Error(): {0}", innerErrMsg); } } else { WindowsEventLog.AddEvent("WebDav Global.Application_Error(): No exception found", 9999); } } finally { if (logger != null) { container.Release(logger); } } }
private void btnClearLogs_Click(object sender, EventArgs e) { WindowsEventLog.DeleteCurrentSource(); btnFetchLogs.PerformClick(); }
static void Main(string[] args) { try { Logging.LogManager.Initialize("Deployment"); } catch (Exception ex) { Console.WriteLine($"Failed to initialize logger: {ex}"); #if DEBUG Console.ReadKey(); #endif ExitInstallation("Failed to intialize Logger", ExitCode.FailedToInitilizeLogger); } _logger.Info($"Initialized {Namespace} v{Version}"); // This has to happen quite early as it can take some time for the eventlog to be fully registered _logger.Trace("Ensuring WindowsEventLog ..."); WindowsEventLog.Ensure(); _logger.Trace("Trying to read settings..."); if (args.Length != 2) { ExitInstallation("Invalid command line arguments. Use: -i [XML] or -u [XML]", ExitCode.MissingRequiredParameter); } var settingsPath = Path.GetFullPath(args[1]); _logger.Trace($"Searching for settings file in {settingsPath}"); if (!File.Exists(settingsPath)) { ExitInstallation("settings.xml is missing!", ExitCode.SettingsFileMissing); } var arguments = args.ToList(); var isInstallation = arguments.Any(argument => argument.ToLower() == "--install" || argument.ToLower() == "-i"); var isUninstallation = arguments.Any(argument => argument.ToLower() == "--uninstall" || argument.ToLower() == "-u"); DeploymentEnvironmentVariables.RootDirectory = Path.GetDirectoryName(settingsPath); _logger.Info($"DeploymentRootDirectory: {DeploymentEnvironmentVariables.RootDirectory}"); EnvironmentVariables.Configuration = ReadXml <Configuration>(settingsPath); _logger.Trace("Successfully read settings"); _logger.Info("Verifying install dependencies ..."); _logger.Info($"IsAdministrator: {EnvironmentVariables.IsAdministrator}"); _logger.Info($"IsElevated: {EnvironmentVariables.IsElevated}"); if (!EnvironmentVariables.IsElevated) { ExitInstallation("Program has to be run as Administrator to function properly!", ExitCode.NotElevated); } try { _logger.Info($"DT-Installation Path: {EnvironmentVariables.DeploymentToolkitInstallPath}"); } catch (DeploymentToolkitInstallPathNotFoundException) { ExitInstallation($"Could not get installation path of the deployment toolkit", ExitCode.DeploymentToolkitInstallPathNotFound); } _logger.Trace("Reading deployment settings ..."); ApplyGlobalSettings(); _logger.Trace("Parsing command line arguments..."); if (isInstallation) { Install(); } else { if (isUninstallation) { Uninstall(); } else { ExitInstallation("Failed to install or uninstall. Neither install nor uninstall command line has been specified", ExitCode.MissingRequiredParameter); } } _logger.Info($"Ended {Namespace} v{Version}"); #if DEBUG Console.ReadKey(); #endif Environment.Exit(GlobalExitCode); }
private void ServiceLifeController_ServiceStatusChanged(ServiceNotifyEventArgs e) { #region Send Notify var emailMsg = $"<p>The <strong>{e.KeepService.Service.Name}</strong> process is <strong>{e.NewStatus}</strong>!</p>"; var emailSubject = string.IsNullOrEmpty(ServiceLifeController.NewSetting.NotifyMessageTitle) ? $"A Service is {e.NewStatus}!" : ServiceLifeController.NewSetting.NotifyMessageTitle; var smsMsg = $@"{ServiceLifeController.NewSetting.NotifyMessageContent}{Environment.NewLine}" + $"The <{e.KeepService.Service.Name}> process is [{e.NewStatus}]. {Environment.NewLine}"; SendNotify(e, emailSubject, emailMsg, smsMsg); #endregion #region Keep Service Stablity Status try { // Keep service status on a stable state which is selected by user if (e.KeepService.KeepStatusOn != ServiceStableStatus.None) { WindowsEventLog.WriteInfoLog($"Keep service status is ON for '{e.KeepService.Service.Name}'."); if ((int)e.KeepService.KeepStatusOn != (int)e.NewStatus) { WindowsEventLog.WriteInfoLog( $"Tying to keep '{e.KeepService.Service.Name}' status on {e.KeepService.KeepStatusOn} state..."); var result = false; switch (e.KeepService.KeepStatusOn) { case ServiceStableStatus.Running: result = ServiceInstallHelper.StartService(e.KeepService.Service.Name); break; case ServiceStableStatus.Stopped: result = ServiceInstallHelper.StopService(e.KeepService.Service.Name); break; case ServiceStableStatus.Paused: result = ServiceInstallHelper.PauseService(e.KeepService.Service.Name); break; } if (result) // success { WindowsEventLog.WriteInfoLog($"The '{e.KeepService.Service.Name}' status rollbacked on {e.KeepService.KeepStatusOn} stable state successfull"); #region Send Notify emailSubject = $"{e.KeepService.Service.Name} Rollbacked to {e.KeepService.KeepStatusOn} state Successfully"; emailMsg = $"<p style='color: #90EE90'>The <strong>{e.KeepService.Service.Name}</strong> process be rollbacked to <strong>{e.KeepService.KeepStatusOn}</strong> Successfully.</p>"; smsMsg = $@"Ok !{Environment.NewLine}" + $"The '{e.KeepService.Service.Name}' process be rollbacked to '{e.KeepService.KeepStatusOn}' Successfully.{Environment.NewLine}"; SendNotify(e, emailSubject, emailMsg, smsMsg); #endregion } else // fail { WindowsEventLog.WriteWarningLog($"The '{e.KeepService.Service.Name}' status can not rollbacked, and state is still on {e.NewStatus} !!!"); #region Send Notify emailSubject = $"{e.KeepService.Service.Name} Rollback to {e.KeepService.KeepStatusOn} state Failed!!"; emailMsg = $"<p style='color: #CD5C5C'>The <strong>{e.KeepService.Service.Name}</strong> process Rollbacking to <strong>{e.KeepService.KeepStatusOn}</strong> failed!!!</p>"; smsMsg = $@"Fail !!!{Environment.NewLine}" + $"The '{e.KeepService.Service.Name}' process can not rollbacked, and state is still on {e.NewStatus} !!!. {Environment.NewLine}"; SendNotify(e, emailSubject, emailMsg, smsMsg); #endregion } } else { WindowsEventLog.WriteInfoLog( $"The '{e.KeepService.Service.Name}' process status is stable state({e.KeepService.KeepStatusOn}), Now."); } } else { WindowsEventLog.WriteInfoLog($"Keep service status is OFF for '{e.KeepService.Service.Name}' !!!"); } } catch (Exception exp) { WindowsEventLog.WriteErrorLog($"Error in Keep service status on stable state by this Message: {exp.Message}"); } #endregion }
protected override void OnPause() { WindowsEventLog.WriteWarningLog($"{ServiceName} Paused."); }