protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
switch (powerStatus)
{
case PowerBroadcastStatus.BatteryLow:
break;
case PowerBroadcastStatus.OemEvent:
break;
case PowerBroadcastStatus.PowerStatusChange:
break;
case PowerBroadcastStatus.QuerySuspend:
break;
case PowerBroadcastStatus.QuerySuspendFailed:
break;
case PowerBroadcastStatus.ResumeAutomatic:
break;
case PowerBroadcastStatus.ResumeCritical:
break;
case PowerBroadcastStatus.ResumeSuspend:
break;
case PowerBroadcastStatus.Suspend:
break;
}
return base.OnPowerEvent(powerStatus);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
try {
switch (powerStatus) {
case PowerBroadcastStatus.QuerySuspend:
TerminateAllCommThreads();
StopDevice();
break;
case PowerBroadcastStatus.ResumeSuspend:
TerminateAllCommThreads();
StartDevice();
InitializeAppManager();
break;
case PowerBroadcastStatus.Suspend:
TerminateAllCommThreads();
StopDevice();
break;
case PowerBroadcastStatus.ResumeAutomatic:
TerminateAllCommThreads();
StartDevice();
InitializeAppManager();
break;
}
}
catch {
return false;
}
return base.OnPowerEvent(powerStatus);
}
/// <summary>
/// Handles power events published by WsapmService.
/// </summary>
/// <param name="powerStatus">The power status to handle.</param>
public void OnPowerEvent(PowerBroadcastStatus powerStatus)
{
try
{
switch (powerStatus)
{
case PowerBroadcastStatus.ResumeAutomatic:
// System woken up (by wake timer, on user input, WoL, etc.).
// ResumeAutomatic will always appear when the computer wakes up from standby. When these is any user input (i.e. the user is present), a ResumeSuspend will appear afterwards.
// Reset windows idle timer, a ResumeSuspend should be raised afterwards.
// Start the WSAPM timers not generally when a ResumeAutomatic appears, just start them when WSAPM scheduled automatic wake!
WsapmLog.Log.WriteLine(Resources.Wsapm_Core.WsapmManager_ResumeAutomatic, LogMode.Normal);
this.lastWakeTime = DateTime.Now;
StartMonitoringTimer();
HandleResumeActions();
break;
case PowerBroadcastStatus.Suspend:
// System gets suspended.
this.lastWakeTime = null;
StopMonitoringTimer();
WsapmLog.Log.WriteLine(Resources.Wsapm_Core.WsapmManager_Suspend, LogMode.Normal);
break;
default:
break;
}
}
catch (Exception ex)
{
WriteErrorLog(ex);
}
}
/// <summary>
/// Allows Connection Monitor service to publish a ServicePowerEvent event to subscribers
/// </summary>
public void ServicePowerEvent(PowerBroadcastStatus status)
{
foreach (IConMonServiceEventsCallBack subscriber in _subscribers)
{
subscriber.OnServicePowerEvent(status);
}
}
protected override bool OnPowerEvent(PowerBroadcastStatus status)
{
try
{
if (ctx.EventLog)
{
if (status == PowerBroadcastStatus.Suspend)
{
EventLog.WriteEntry("Entering Standby");
}
if (status == PowerBroadcastStatus.ResumeSuspend)
{
if (this[typeof(PowerBroadcastFallback)] != null)
{
return(true);
}
EventLog.WriteEntry("Resuming Operation");
}
}
PowerChange?.Invoke(this, new PowerChangeEvent {
Status = status
});
}
catch (Exception e)
{
EventLog.WriteEntry(e.ToString(), EventLogEntryType.Error, 99);
}
return(true);
}
/// <summary>
/// Fires when a power event on the computer is happening
/// </summary>
/// <param name="powerStatus"></param>
/// <returns>Boolean indicating whether to continue the powerevent</returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
const string MemberName = "OnPowerEvent";
using (new Tracer(MemberName))
{
try
{
LogMessage("Power mode event fired" + powerStatus.ToString() + ". Determining action to take", TraceEventType.Information);
if (powerStatus == PowerBroadcastStatus.ResumeAutomatic ||
powerStatus == PowerBroadcastStatus.ResumeCritical ||
powerStatus == PowerBroadcastStatus.ResumeSuspend)
{
LogMessage("System is resuming from hibernation! Restarting ConMon Service Events", TraceEventType.Verbose);
this.StartupHost();
}
else if (powerStatus == PowerBroadcastStatus.Suspend)
{
LogMessage("System is hibernating! Stopping ConMon Service Events", TraceEventType.Verbose);
StopAndCleanupHost();
}
}
catch (Exception ex)
{
Logger.Write(ex);
}
}
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus == PowerBroadcastStatus.Suspend || powerStatus == PowerBroadcastStatus.ResumeSuspend || powerStatus == PowerBroadcastStatus.ResumeAutomatic)
{
SerialPort port = new SerialPort("COM3", 9600, Parity.None, 8, StopBits.One);
try
{
port.Open();
}
catch (Exception e)
{
return(true);
}
if (powerStatus == PowerBroadcastStatus.Suspend)
{
port.WriteLine("Sleep");
}
else
{
port.WriteLine("Wake");
}
try
{
port.Close();
}
catch
{
return(true);
}
}
return(true);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
switch (powerStatus)
{
case PowerBroadcastStatus.QuerySuspendFailed:
OnStart(null);
break;
case PowerBroadcastStatus.ResumeAutomatic:
case PowerBroadcastStatus.ResumeCritical:
case PowerBroadcastStatus.ResumeSuspend:
OnStart(null);
break;
case PowerBroadcastStatus.QuerySuspend:
case PowerBroadcastStatus.Suspend:
OnSuspend();
break;
default:
break;
}
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
switch (powerStatus)
{
case PowerBroadcastStatus.BatteryLow:
case PowerBroadcastStatus.OemEvent:
case PowerBroadcastStatus.PowerStatusChange:
case PowerBroadcastStatus.QuerySuspend:
this.Flush();
return(true);
case PowerBroadcastStatus.ResumeAutomatic:
case PowerBroadcastStatus.ResumeCritical:
case PowerBroadcastStatus.ResumeSuspend:
if (this.autoPaused)
{
Log.Notice("Resuming service.");
this.autoPaused = false;
this.OnContinue();
}
return(true);
case PowerBroadcastStatus.Suspend:
this.autoPaused = true;
Log.Notice("Suspending service.");
this.OnStop();
return(true);
case PowerBroadcastStatus.QuerySuspendFailed:
default:
return(true);
}
}
private int ServiceCommandCallbackEx(int command, int eventType, IntPtr eventData, IntPtr eventContext)
{
if (command != NativeMethods.CONTROL_POWEREVENT)
{
ServiceCommandCallback(command);
}
else
{
try {
PowerBroadcastStatus status = (PowerBroadcastStatus)eventType;
bool statusResult = OnPowerEvent(status);
WriteEventLogEntry(Res.GetString(Res.PowerEventOK));
if (!statusResult)
{
return(NativeMethods.BROADCAST_QUERY_DENY);
}
}
catch (Exception e) {
WriteEventLogEntry(Res.GetString(Res.PowerEventFailed, e.ToString()), EventLogEntryType.Error);
}
}
return(NativeMethods.NO_ERROR);
}
protected int PowerEventThreadWndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
{
if (msg == NativeMethods.WM_POWERBROADCAST)
{
PowerBroadcastStatus status = (PowerBroadcastStatus)wParam.ToInt32();
SafeLogD("PowerEventHandler received {0}", status);
switch (status)
{
case PowerBroadcastStatus.QuerySuspend:
var onQuerySuspend = OnQuerySuspend;
if (onQuerySuspend != null)
{
if (!onQuerySuspend())
{
return(NativeMethods.BROADCAST_QUERY_DENY);
}
}
break;
default:
var onPowerEvent = OnPowerEvent;
if (onPowerEvent != null)
{
onPowerEvent(status);
}
break;
}
}
return(NativeMethods.DefWindowProc(hWnd, msg, wParam, lParam));
}
/// <summary>
/// OnPowerEvent(): Useful for detecting power status changes,
/// such as going into Suspend mode or Low Battery for laptops.
/// </summary>
/// <param name="powerStatus">The Power Broadcase Status (BatteryLow, Suspend, etc.)</param>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
// Send the event to the core
m_alphaCore.OnPowerEvent(powerStatus);
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
Logger.Debug("Power Event: {0}", powerStatus);
switch (powerStatus)
{
case PowerBroadcastStatus.QuerySuspendFailed:
Logger.Warn("System failed to enter Suspend state!");
OnStart(null);
break;
case PowerBroadcastStatus.ResumeAutomatic:
OnStart(null);
break;
case PowerBroadcastStatus.ResumeCritical:
case PowerBroadcastStatus.ResumeSuspend:
break;
case PowerBroadcastStatus.QuerySuspend:
case PowerBroadcastStatus.Suspend:
OnSuspend();
break;
default:
break;
}
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
switch (powerStatus)
{
case PowerBroadcastStatus.BatteryLow:
break;
case PowerBroadcastStatus.OemEvent:
break;
case PowerBroadcastStatus.PowerStatusChange:
break;
case PowerBroadcastStatus.QuerySuspend:
break;
case PowerBroadcastStatus.QuerySuspendFailed:
break;
case PowerBroadcastStatus.ResumeAutomatic:
break;
case PowerBroadcastStatus.ResumeCritical:
break;
case PowerBroadcastStatus.ResumeSuspend:
break;
case PowerBroadcastStatus.Suspend:
break;
}
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
SystemEvents.PowerModeChanged += new PowerModeChangedEventHandler((s, e) =>
{
switch (e.Mode)
{
case PowerModes.Suspend:
break;
case PowerModes.Resume:
break;
}
});
switch (powerStatus)
{
case PowerBroadcastStatus.Suspend:
_numMonitors = 0;
Logging.LogEvents("Sleep");
_sleeping = true;
break;
case PowerBroadcastStatus.ResumeSuspend:
_numMonitors = SystemStats.GetNumMonitors();
Logging.LogEvents("Wake");
_sleeping = false;
break;
}
return(base.OnPowerEvent(powerStatus));
}
/// <summary>
/// Useful for detecting power status changes,
/// such as going into Suspend mode or Low Battery for laptops.
/// </summary>
/// <param name="powerStatus">The Power Broadcast Status
/// (BatteryLow, Suspend, etc.)</param>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
//
// handle power events here
//
return(base.OnPowerEvent(powerStatus));
}
/// <summary>
/// Handle power events, such as hibernation.
/// </summary>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (imapProxies != null)
{
foreach (ImapProxy imapProxy in imapProxies)
{
imapProxy.ProcessPowerEvent((int)powerStatus);
}
imapProxies.Clear();
}
if (pop3Proxies != null)
{
foreach (Pop3Proxy pop3Proxy in pop3Proxies)
{
pop3Proxy.ProcessPowerEvent((int)powerStatus);
}
pop3Proxies.Clear();
}
if (smtpProxies != null)
{
foreach (SmtpProxy smtpProxy in smtpProxies)
{
smtpProxy.ProcessPowerEvent((int)powerStatus);
}
smtpProxies.Clear();
}
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if ((activemodules & Modules.Power) == Modules.Power)
{
string details = "";
switch (powerStatus)
{
case PowerBroadcastStatus.BatteryLow:
details = String.Format("WARNING Baterry low, {0}% remaining.", PowerMonitor.BatteryCharge());
le = new LogEntry(Logfile.FullName, (uint)LogEntryIDs.BatteryLow, details, machine, username);
break;
case PowerBroadcastStatus.PowerStatusChange:
if (PowerMonitor.ACPowerPluggedIn())
{
details = String.Format("Power Status Changed: System runs on AC power.");
le = new LogEntry(Logfile.FullName, (uint)LogEntryIDs.PowerChangedOnAC, details, machine, username);
}
else
{
details = String.Format("Power Status Changed: System runs on battery.");
le = new LogEntry(Logfile.FullName, (uint)LogEntryIDs.PowerChangedOnBattery, details, machine, username);
}
break;
}
}
return(base.OnPowerEvent(powerStatus));
}
/// <summary>
/// Called when [power event].
/// </summary>
/// <param name="powerStatus">The power status.</param>
/// <returns>System.Boolean.</returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
string message = $" powerStatus:{powerStatus} tcpServerTaskStatus:{this.TcpServerTask.Status} this.pollingTimer{this.pollingTimer.Enabled} ";
this.OnLog(message);
return(true);
}
/// <summary>
/// Overrides the power event handler. Method is called when a PC power event is detected, e.g. suspend
/// </summary>
/// <param name="powerStatus">The broadcasted power status</param>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
#if DEBUG
WriteEventLogEntry("In OnPowerEvent");
#endif
return(base.OnPowerEvent(powerStatus));
}
/// <summary>
/// OnPowerEvent method of service. Gets called when a power event is raised.
/// </summary>
/// <param name="powerStatus"></param>
/// <returns></returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
base.OnPowerEvent(powerStatus);
this.WsapmManager.OnPowerEvent(powerStatus);
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus == PowerBroadcastStatus.Suspend)
{
fileConverter.Stop();
}
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
ChoApplication.WriteToEventLog("OnPowerEvent()...");
if (_host != null)
{
return(_host.OnPowerEventService(powerStatus));
}
return(true);
}
/// <summary>
/// OnPowerEvent(): Useful for detecting power status changes,
/// such as going into Suspend mode or Low Battery for laptops.
/// </summary>
/// <param name="powerStatus">The Power Broadcast Status
/// (BatteryLow, Suspend, etc.)</param>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
_log.Info("Service power event detected = {0}.", powerStatus.ToString());
_log.Flush();
if (powerStatus == PowerBroadcastStatus.Suspend)
{
OnStop();
}
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus == PowerBroadcastStatus.QuerySuspend)
{
// Deny suspend if required.
if (_suspendLevel > SuspendLevel.None)
return false;
}
return base.OnPowerEvent(powerStatus);
}
// For Laptop
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus.HasFlag(PowerBroadcastStatus.Suspend))
{
SendMailService.WriteErrorLog("System has been shutdown.");
SendMailService.SendEmail(ServiceProperty.Email, "Service Report", "Your system has been down on " + DateTime.Now.ToLongTimeString());
}
return(true);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus == PowerBroadcastStatus.ResumeSuspend ||
powerStatus == PowerBroadcastStatus.ResumeAutomatic ||
powerStatus == PowerBroadcastStatus.ResumeCritical)
{
this.service.ReInitializeFanControl();
}
return(true);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
switch (powerStatus)
{
case PowerBroadcastStatus.BatteryLow:
_log.Info(() => string.Format("Service {0} pausing in response to [BATTERY LOW]", ServiceName));
PauseService();
_log.Info(() => string.Format("Service {0} paused", ServiceName));
return(true);
//no clue as to what this OEM event is -- let's not do anything
case PowerBroadcastStatus.OemEvent:
//useless since we don't know if we've gone to battery, or A/C... could also be battery low
//which will result in a shutdown
case PowerBroadcastStatus.PowerStatusChange:
return(false);
//turn off our timer process
case PowerBroadcastStatus.QuerySuspend:
_log.Info(() => string.Format("Service {0} pausing in response to [SUSPEND REQUEST]", ServiceName));
PauseService();
_log.Info(() => string.Format("Service {0} paused", ServiceName));
return(true);
case PowerBroadcastStatus.QuerySuspendFailed:
_log.Info(() => string.Format("Service {0} starting in response to [SUSPEND REQUEST FAIL]", ServiceName));
return(true);
//don't do anything yet as we will get a ResumeSuspend
//of course that might not make sense as a server
case PowerBroadcastStatus.ResumeAutomatic:
return(true);
case PowerBroadcastStatus.ResumeCritical:
//recreate our resources
_log.Info(() => string.Format("Service {0} starting in response to [RESUME FROM CRITICAL]", ServiceName));
StartService();
_log.Info(() => string.Format("Service {0} started", ServiceName));
return(true);
//resuming our service, so start synchronizing again
case PowerBroadcastStatus.ResumeSuspend:
_log.Info(() => string.Format("Service {0} starting in response to [RESUME FROM SUSPEND]", ServiceName));
StartService();
_log.Info(() => string.Format("Service {0} started", ServiceName));
return(true);
//we already paused our service in QuerySuspend
case PowerBroadcastStatus.Suspend:
return(true);
}
return(false);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus == PowerBroadcastStatus.ResumeSuspend
|| powerStatus == PowerBroadcastStatus.ResumeAutomatic
|| powerStatus == PowerBroadcastStatus.ResumeCritical)
{
this.service.ReInitializeFanControl();
}
return true;
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus == PowerBroadcastStatus.ResumeAutomatic) // || powerStatus == PowerBroadcastStatus.ResumeSuspend)
{
Log($"Service powerEvent {powerStatus} at {DateTime.Now}");
ApplyConfiguraton();
}
return(base.OnPowerEvent(powerStatus));
}
/// <summary>
/// Executes when the computer's power status has changed. This applies to
/// laptop computers when they go into suspended mode, which is not the same
/// as a system shutdown.
/// </summary>
/// <param name="powerStatus">
/// A System.ServiceProcess.PowerBroadcastStatus that indicates a notification
/// from the system about its power status.
/// </param>
/// <returns>
/// When implemented in a derived class, the needs of your application determine
/// what value to return.
/// For example, if a QuerySuspend broadcast status is passed, you could cause
/// your application to reject the query by returning false.
/// </returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
try
{
LogMsg("OnPowerEvent(): {0}", powerStatus);
}
catch (Exception e)
{
LogMsg(e.ToString());
}
return base.OnPowerEvent(powerStatus);
}
/// <summary>
/// Power Management strikes again
/// </summary>
/// <param name="powerStatus"> power status information</param>
/// <returns>true on power on</returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus == PowerBroadcastStatus.Suspend)
{
logger.WarnMethod("MFC detected that the system is about to go into suspend power mode.");
}
else if (powerStatus == PowerBroadcastStatus.ResumeSuspend)
{
logger.WarnMethod("MFC detected that the system has been resumed.");
}
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
switch (powerStatus)
{
case PowerBroadcastStatus.BatteryLow:
_log.Info(() => string.Format("Service {0} pausing in response to [BATTERY LOW]", ServiceName));
PauseService();
_log.Info(() => string.Format("Service {0} paused", ServiceName));
return true;
//no clue as to what this OEM event is -- let's not do anything
case PowerBroadcastStatus.OemEvent:
//useless since we don't know if we've gone to battery, or A/C... could also be battery low
//which will result in a shutdown
case PowerBroadcastStatus.PowerStatusChange:
return false;
//turn off our timer process
case PowerBroadcastStatus.QuerySuspend:
_log.Info(() => string.Format("Service {0} pausing in response to [SUSPEND REQUEST]", ServiceName));
PauseService();
_log.Info(() => string.Format("Service {0} paused", ServiceName));
return true;
case PowerBroadcastStatus.QuerySuspendFailed:
_log.Info(() => string.Format("Service {0} starting in response to [SUSPEND REQUEST FAIL]", ServiceName));
return true;
//don't do anything yet as we will get a ResumeSuspend
//of course that might not make sense as a server
case PowerBroadcastStatus.ResumeAutomatic:
return true;
case PowerBroadcastStatus.ResumeCritical:
//recreate our resources
_log.Info(() => string.Format("Service {0} starting in response to [RESUME FROM CRITICAL]", ServiceName));
StartService();
_log.Info(() => string.Format("Service {0} started", ServiceName));
return true;
//resuming our service, so start synchronizing again
case PowerBroadcastStatus.ResumeSuspend:
_log.Info(() => string.Format("Service {0} starting in response to [RESUME FROM SUSPEND]", ServiceName));
StartService();
_log.Info(() => string.Format("Service {0} started", ServiceName));
return true;
//we already paused our service in QuerySuspend
case PowerBroadcastStatus.Suspend:
return true;
}
return false;
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus == PowerBroadcastStatus.QuerySuspend)
{
// Deny suspend if required.
if (_suspendLevel > SuspendLevel.None)
{
return(false);
}
}
return(base.OnPowerEvent(powerStatus));
}
/// <summary>
/// Executes when the computer's power status has changed. This applies to
/// laptop computers when they go into suspended mode, which is not the same
/// as a system shutdown.
/// </summary>
/// <param name="powerStatus">
/// A System.ServiceProcess.PowerBroadcastStatus that indicates a notification
/// from the system about its power status.
/// </param>
/// <returns>
/// When implemented in a derived class, the needs of your application determine
/// what value to return.
/// For example, if a QuerySuspend broadcast status is passed, you could cause
/// your application to reject the query by returning false.
/// </returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
try
{
LogMsg("OnPowerEvent(): {0}", powerStatus);
}
catch (Exception e)
{
LogMsg(e.ToString());
}
return(base.OnPowerEvent(powerStatus));
}
protected override bool OnPowerEvent(
PowerBroadcastStatus powerStatus)
{
log.Debug(m => m("Handling power event '{0}' on service '{1}'...", powerStatus, ServiceName));
bool returnValue = false;
if (serviceInstance.CanHandlePowerEvent)
{
returnValue = serviceInstance.OnPowerEvent(powerStatus);
}
log.Debug(m => m("Done handling power event '{0}' on service '{1}'.", powerStatus, ServiceName));
return(returnValue);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
switch(powerStatus)
{
case PowerBroadcastStatus.Suspend:
logger.Trace("OnPowerEvent: Computer suspend");
logSend("Suspend");
break;
case PowerBroadcastStatus.ResumeSuspend:
logger.Trace("OnPowerEvent: Computer resume");
logSend("Resume");
break;
}
return base.OnPowerEvent(powerStatus);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (powerStatus == PowerBroadcastStatus.Suspend || powerStatus == PowerBroadcastStatus.QuerySuspend)
{
if (node != null)
node.Stop();
node = null;
}
else if (powerStatus == PowerBroadcastStatus.ResumeSuspend ||
powerStatus == PowerBroadcastStatus.ResumeCritical ||
powerStatus == PowerBroadcastStatus.ResumeAutomatic ||
powerStatus == PowerBroadcastStatus.QuerySuspendFailed)
{
if (node == null)
node = new ComputerNode();
node.Start();
}
return true;
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
debuglog.Info("OnPowerEvent:" + powerStatus.ToString());
switch (powerStatus)
{
case PowerBroadcastStatus.ResumeAutomatic:
case PowerBroadcastStatus.ResumeCritical:
case PowerBroadcastStatus.ResumeSuspend:
debuglog.Info("RELOGIN ");
runningFlag = 1;
thr.Join();
OnStart(new string[] { });
return true;
}
return base.OnPowerEvent(powerStatus);
}
/// <summary>
/// When implemented in a derived class, executes when the computer's power status has changed. This applies to laptop computers when they go into suspended mode, which is not the same as a system shutdown.
/// </summary>
/// <param name="powerStatus">A <see cref="T:System.ServiceProcess.PowerBroadcastStatus"/> that indicates a notification from the system about its power status.</param>
/// <returns>
/// When implemented in a derived class, the needs of your application determine what value to return. For example, if a QuerySuspend broadcast status is passed, you could cause your application to reject the query by returning false.
/// </returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
return true;
}
/// <summary>
/// Handle power events, such as hibernation.
/// </summary>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if (imapProxies != null)
{
foreach (ImapProxy imapProxy in imapProxies)
imapProxy.ProcessPowerEvent((int)powerStatus);
imapProxies.Clear();
}
if (pop3Proxies != null)
{
foreach (Pop3Proxy pop3Proxy in pop3Proxies)
pop3Proxy.ProcessPowerEvent((int)powerStatus);
pop3Proxies.Clear();
}
if (smtpProxies != null)
{
foreach (SmtpProxy smtpProxy in smtpProxies)
smtpProxy.ProcessPowerEvent((int)powerStatus);
smtpProxies.Clear();
}
return base.OnPowerEvent(powerStatus);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
_logger.WriteEntry("OnPowerEvent", EventLogEntryType.Information);
return base.OnPowerEvent(powerStatus);
}
public WindowsPowerEventArguments(PowerBroadcastStatus powerStatus)
{
_eventCode = (PowerEventCode) Enum.ToObject(typeof(PowerEventCode), (int)powerStatus);
}
protected void SendSystemStatePowerMessage(PowerBroadcastStatus status)
{
switch (status)
{
case PowerBroadcastStatus.ResumeAutomatic:
case PowerBroadcastStatus.ResumeCritical:
case PowerBroadcastStatus.ResumeSuspend:
SystemMessaging.SendSystemStateChangeMessage(SystemState.Resuming);
break;
case PowerBroadcastStatus.Suspend:
SystemMessaging.SendSystemStateChangeMessage(SystemState.Suspending);
break;
}
}
/// <summary>
/// When implemented in a derived class, executes when the computer's power status has changed. This applies to laptop computers when they go into suspended mode, which is not the same as a system shutdown.
/// </summary>
/// <param name="powerStatus">A <see cref="T:System.ServiceProcess.PowerBroadcastStatus"/> that indicates a notification from the system about its power status.</param>
/// <returns>
/// When implemented in a derived class, the needs of your application determine what value to return. For example, if a QuerySuspend broadcast status is passed, you could cause your application to reject the query by returning false.
/// </returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
bool status = false;
try
{
switch (powerStatus)
{
case PowerBroadcastStatus.QuerySuspend:
status = base.OnPowerEvent(powerStatus);
break;
case PowerBroadcastStatus.ResumeSuspend:
this.OnStart(null);
status = base.OnPowerEvent(powerStatus);
break;
case PowerBroadcastStatus.Suspend:
this.OnStop();
status = base.OnPowerEvent(powerStatus);
break;
}
}
catch (Exception e)
{
Log.Error(e);
status = false;
}
Log.Info(string.Format("Responding {0} to {1} request", status, powerStatus));
return status;
}
/// <summary>
/// Override of the Power Event
/// </summary>
/// <param name="powerStatus"></param>
/// <returns></returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
if ((powerStatus == PowerBroadcastStatus.BatteryLow) |
(powerStatus == PowerBroadcastStatus.Suspend))
{
// stop the background processing
StopProcesses();
}
if ((powerStatus == PowerBroadcastStatus.ResumeAutomatic) |
(powerStatus == PowerBroadcastStatus.ResumeCritical) |
(powerStatus == PowerBroadcastStatus.ResumeSuspend))
{
// start the background processing
StartProcesses();
}
return base.OnPowerEvent(powerStatus);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
try
{
LogMessage("Received power event: " + powerStatus, LogEntryType.StatusChange);
switch (powerStatus)
{
case PowerBroadcastStatus.QuerySuspend:
ExecutionManager.StopService(false);
break;
case PowerBroadcastStatus.Suspend:
ExecutionManager.StopService(false);
break;
case PowerBroadcastStatus.ResumeAutomatic:
if (ExecutionManager.ExecutionState != ExecutionState.Running)
ExecutionManager.StartService(this);
break;
case PowerBroadcastStatus.ResumeSuspend:
case PowerBroadcastStatus.ResumeCritical:
case PowerBroadcastStatus.QuerySuspendFailed:
if (ExecutionManager.ExecutionState != ExecutionState.Running)
ExecutionManager.StartService(this);
break;
};
return true;
}
catch (Exception e)
{
LogMessage("OnPowerEvent - Exception: " + e.Message, LogEntryType.ErrorMessage);
throw e;
}
}
/// <summary>
/// OnPowerEvent(): Useful for detecting power status changes,
/// such as going into Suspend mode or Low Battery for laptops.
/// </summary>
/// <param name="power_status">The Power Broadcast Status
/// (BatteryLow, Suspend, etc.)</param>
protected override bool OnPowerEvent(PowerBroadcastStatus power_status)
{
_log.Info("Service power event detected = {0}.", power_status.ToString());
_log.Flush();
if (power_status == PowerBroadcastStatus.Suspend)
{
_collector.Stop();
}
return base.OnPowerEvent(power_status);
}
/// <summary>
/// This occurs when a power event was triggered.
/// </summary>
/// <param name="powerStatus">Indicates the system's power status</param>
/// <returns>True if we are going to accept the query, otherwise false</returns>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
try
{
Trace.WriteLine("On Power Event");
Trace.WriteLine(powerStatus.ToString());
}
catch (Exception ex)
{
Trace.WriteLine(ex);
}
//When implemented in a derived class, the needs of your application determine what value to return.
//For example, if a QuerySuspend broadcast status is passed, you could cause your application to
//reject the query by returning false.
return base.OnPowerEvent(powerStatus);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
return ((IServiceEvents)this).OnPowerEvent(powerStatus);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
using (var eventLog = new TaskManagementEventLog())
{
try
{
Trace.WriteLineIf(Tracing.Is.TraceVerbose, "powerStatus={0}".FormatWith(powerStatus.ToString("G")));
switch (powerStatus)
{
case PowerBroadcastStatus.QuerySuspend:
OnPause();
break;
case PowerBroadcastStatus.Suspend:
OnStop();
break;
case PowerBroadcastStatus.QuerySuspendFailed:
case PowerBroadcastStatus.ResumeAutomatic:
case PowerBroadcastStatus.ResumeCritical:
case PowerBroadcastStatus.ResumeSuspend:
if (null == Manager)
{
OnStart(Args);
}
else
{
OnContinue();
}
break;
}
}
catch (Exception exception)
{
eventLog.FailureOnPowerEvent(powerStatus);
Trace.TraceError("{0}", exception);
}
}
return false;
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
// Save all session/other data?
return base.OnPowerEvent(powerStatus);
}
bool IServiceEvents.OnPowerEvent(PowerBroadcastStatus powerStatus)
{
return base.OnPowerEvent(powerStatus);
}
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
Log.Info("Power status updated.");
Log.DebugFormat("Status: {0}", powerStatus);
return base.OnPowerEvent(powerStatus) && ProviderLoader.Provider.PowerEvent(powerStatus);
}
public void FailureOnPowerEvent(PowerBroadcastStatus powerStatus)
{
WriteEvent(new EventInstance(0xC00003F9, 2, EventLogEntryType.Error), powerStatus.ToString("G"));
}
public void SuccessOnPowerEvent(PowerBroadcastStatus powerStatus)
{
WriteEvent(new EventInstance(0x000003EF, 2), powerStatus.ToString("G"));
}
/// <summary>
///
/// </summary>
/// <param name="status"></param>
public PowerBroardCastEventArgs(PowerBroadcastStatus status)
{
Status = status;
}
/// <summary>
/// OnPowerEvent(): Useful for detecting power status changes,
/// such as going into Suspend mode or Low Battery for laptops.
/// </summary>
/// <param name="powerStatus">The Power Broadcase Status (BatteryLow, Suspend, etc.)</param>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
return base.OnPowerEvent(powerStatus);
}
protected virtual bool OnPowerEvent(PowerBroadcastStatus powerStatus)
{
return true;
}
/// <summary>
/// OnPowerEvent(): Useful for detecting power status changes,
/// such as going into Suspend mode or Low Battery for laptops.
/// </summary>
/// <param name="powerStatus">The Power Broadcast Status
/// (BatteryLow, Suspend, etc.)</param>
protected override bool OnPowerEvent(PowerBroadcastStatus powerStatus) {
Log("Power Status Changed", true);
return base.OnPowerEvent(powerStatus);
}
