Ticket #7762: SWpatch_shutdownEnhanced09Feb.diff

programs/mythbackend/scheduler.h

@@ -77 +77 @@
 
     bool WasStartedAutomatically();
 
+    bool CheckShutdownServer(int prerollseconds, QDateTime &idleSince,
+                             bool &blockShutdown);
     int GetError(void) const { return error; }
 
   protected:
@@ -126 +128 @@
     bool ChangeRecordingEnd(RecordingInfo *oldp, RecordingInfo *newp);
 
     void findAllScheduledPrograms(RecList &proglist);
-    bool CheckShutdownServer(int prerollseconds, QDateTime &idleSince,
-                             bool &blockShutdown);
     void ShutdownServer(int prerollseconds, QDateTime &idleSince);
     void PutInactiveSlavesToSleep(void);
     bool WakeUpSlave(QString slaveHostname, bool setWakingStatus = true);
-    void WakeUpSlaves(void);
+    bool WakeUpSlaves(bool forceWakeAll = true);
+    bool CheckDailyWakeUpPeriodSlave(QString slaveHostname, EncoderLink *enc);
+    QDateTime getDailyWakeupTime(QString sPeriod);
 
     int FillRecordingDir(RecordingInfo *pginfo, RecList& reclist);
     void FillDirectoryInfoCache(bool force = false);

programs/mythbackend/main.cpp

@@ -1080 +1080 @@
 
         if (nosched)
             sched->DisableScheduling();
+    } else {
+        // just initialise the scheduler but do not start it
+        sched = new Scheduler(false, &tvList);
+        int err = sched->GetError();
+        if (err)
+        {
+            return err;
+        }
+        sched->DisableScheduling();
     }
 
     // Get any initial housekeeping done before we fire up anything else

programs/mythbackend/mainserver.cpp

@@ -2514 +2514 @@
 void MainServer::HandleGoToSleep(PlaybackSock *pbs)
 {
     QStringList strlist;
+    QDateTime idleSince;
+    bool blockShutdown = gContext->GetNumSetting("blockSDWUwithoutClient", 1);
+    bool status = m_sched->CheckShutdownServer(0, idleSince,  blockShutdown);
 
-    QString sleepCmd = gContext->GetSetting("SleepCommand");
-    if (!sleepCmd.isEmpty())
+
+    if (status) 
     {
         strlist << "OK";
-        SendResponse(pbs->getSocket(), strlist);
-        VERBOSE(VB_IMPORTANT, "Received GO_TO_SLEEP command from master, "
-                "running SleepCommand.");
-        myth_system(sleepCmd);
+        VERBOSE(VB_IMPORTANT, "Received a request to shut down this machine.... response is OK.");
     }
     else
     {
-        strlist << "ERROR: SleepCommand is empty";
-        VERBOSE(VB_IMPORTANT,
-                "ERROR: in HandleGoToSleep(), but no SleepCommand found!");
-        SendResponse(pbs->getSocket(), strlist);
+        // not allowed to sleep
+        strlist << "BUSY";
+        VERBOSE(VB_IMPORTANT, "Received a request to shut down this machine.... response is BUSY.");
     }
+
+    SendResponse(pbs->getSocket(), strlist);
+
+    if (status)
+    {
+        // shutdown
+        QString SleepCmd = gContext->GetSetting("SleepCommand", "");
+
+        if (!SleepCmd.isEmpty())
+        {   
+            VERBOSE(VB_GENERAL, QString("Running SleepCommand."));
+
+            // and now shutdown myself
+            if (!myth_system(SleepCmd))
+                return;
+            else
+                VERBOSE(VB_IMPORTANT, "SleepCommand failed, shutdown aborted.");
+        }
+        else
+        {
+            strlist << "ERROR: SleepCommand is empty"; 
+            VERBOSE(VB_IMPORTANT, 
+                "ERROR: in HandleGoToSleep(), but no SleepCommand found!"); 
+            SendResponse(pbs->getSocket(), strlist);
+        }
+    }
 }
 
 /**

programs/mythbackend/scheduler.cpp

@@ -1700 +1700 @@
                 }
                 firstRun = false;
             }
-
-            PutInactiveSlavesToSleep();
-            lastSleepCheck = QDateTime::currentDateTime();
         }
       }
 
@@ -1712 +1709 @@
 
         curtime = QDateTime::currentDateTime();
 
-        // About every 5 minutes check for slaves that can be put to sleep
-        if (lastSleepCheck.secsTo(curtime) > 300)
-        {
-            PutInactiveSlavesToSleep();
-            lastSleepCheck = QDateTime::currentDateTime();
-        }
-
         // Go through the list of recordings starting in the next few minutes
         // and wakeup any slaves that are asleep
         RecIter recIter = startIter;
@@ -1965 +1955 @@
             idleSince = QDateTime();
         }
 
+        // About every minute check for slaves that can be waken up or put to sleep
+        if (lastSleepCheck.secsTo(curtime) >= 60)
+        {
+            bool slaveWaken = WakeUpSlaves(false);
+            if (!slaveWaken)
+                PutInactiveSlavesToSleep();
+            lastSleepCheck = QDateTime::currentDateTime();
+        }
+
         // if idletimeout is 0, the user disabled the auto-shutdown feature
         if ((idleTimeoutSecs > 0) && (m_mainServer != NULL))
         {
@@ -2093 +2092 @@
     int state = 0;
     if (!preSDWUCheckCommand.isEmpty())
     {
+        VERBOSE(VB_GENERAL, QString("Running preSDWUCheckCommand which is: ") + preSDWUCheckCommand);
         state = myth_system(preSDWUCheckCommand);
 
         if (GENERIC_EXIT_NOT_OK != state)
@@ -2143 +2143 @@
         if ((*recIter)->recstatus == rsWillRecord)
             break;
 
-    // set the wakeuptime if needed
-    if (recIter != reclist.end())
+    // set the wakeuptime if needed and if we are the master
+    // otherwise, the master will wake up us
+    if (recIter != reclist.end() && gContext->IsMasterBackend())
     {
         RecordingInfo *nextRecording = (*recIter);
         QDateTime restarttime = nextRecording->recstartts.addSecs((-1) *
@@ -2193 +2194 @@
         }
     }
 
-    // tell anyone who is listening the master server is going down now
-    MythEvent me(QString("SHUTDOWN_NOW"));
-    gContext->dispatch(me);
-
+    if (gContext->IsMasterBackend())
+    {  
+        // tell anyone who is listening the master server is going down now
+        MythEvent me(QString("SHUTDOWN_NOW"));
+        gContext->dispatch(me);
+    }
     QString halt_cmd = gContext->GetSetting("ServerHaltCommand",
                                             "sudo /sbin/halt -p");
 
@@ -2237 +2240 @@
             someSlavesCanSleep = true;
     }
 
-    if (!someSlavesCanSleep)
+    if (!someSlavesCanSleep) 
         return;
 
     VERBOSE(VB_SCHEDULE,
             "Scheduler, Checking for slaves that can be shut down");
 
     int sleepThreshold =
-        gContext->GetNumSetting( "SleepThreshold", 60 * 45);
+        gContext->GetNumSetting( "idleWaitForRecordingTime", 15) * 60;
 
     VERBOSE(VB_SCHEDULE+VB_EXTRA, QString("  Getting list of slaves that "
             "will be active in the next %1 minutes.")
@@ -2253 +2256 @@
     VERBOSE(VB_SCHEDULE+VB_EXTRA, "Checking scheduler's reclist");
     RecIter recIter = reclist.begin();
     QDateTime curtime = QDateTime::currentDateTime();
-    QStringList SlavesInUse;
+    QStringList slavesInUse;
     for ( ; recIter != reclist.end(); recIter++)
     {
         RecordingInfo *pginfo = *recIter;
@@ -2270 +2273 @@
         {
             enc = (*m_tvList)[pginfo->cardid];
             if ((!enc->IsLocal()) &&
-                (!SlavesInUse.contains(enc->GetHostName())))
+                (!slavesInUse.contains(enc->GetHostName())))
             {
-                if (pginfo->recstatus == rsWillRecord)
+                if (pginfo->recstatus == rsWillRecord) {
                     VERBOSE(VB_SCHEDULE+VB_EXTRA, QString("    Slave %1 will "
                             "be in use in %2 minutes").arg(enc->GetHostName())
                             .arg(secsleft / 60));
-                else
-                    VERBOSE(VB_SCHEDULE+VB_EXTRA, QString("    Slave %1 is "
-                            "in use currently recording '%1'")
+                    slavesInUse << enc->GetHostName();
+                } /* else if (enc->GetState() == kState_None) {
+                    VERBOSE(VB_IMPORTANT, QString("    Slave %1 is "
+                            "idling")
+                            .arg(enc->GetHostName()));
+                } else {
+                    VERBOSE(VB_IMPORTANT, QString("    Slave %1 is "
+                            "in use currently recording '%2'")
                             .arg(enc->GetHostName()).arg(pginfo->title));
-                SlavesInUse << enc->GetHostName();
+                    slavesInUse << enc->GetHostName();
+                } */
             }
         }
     }
@@ -2294 +2303 @@
     if (query.exec() && query.size() > 0)
     {
         while(query.next()) {
-            SlavesInUse << query.value(0).toString();
+            slavesInUse << query.value(0).toString();
             VERBOSE(VB_SCHEDULE+VB_EXTRA, QString("    Slave %1 is marked as "
                     "in use by a %2")
                     .arg(query.value(0).toString())
                     .arg(query.value(1).toString()));
         }
     }
+    else
+    {
+        VERBOSE(VB_SCHEDULE+VB_EXTRA, "    No entries.");
+    }
 
-    VERBOSE(VB_SCHEDULE+VB_EXTRA, QString("  Shutting down slaves which will "
-            "be inactive for the next %1 minutes and can be put to sleep.")
-            .arg(sleepThreshold / 60));
+    QStringList slavesThatCanWake;
 
     enciter = m_tvList->begin();
     for (; enciter != m_tvList->end(); ++enciter)
@@ -2313 +2324 @@
 
         if ((!enc->IsLocal()) &&
             (enc->IsAwake()) &&
-            (!SlavesInUse.contains(enc->GetHostName())) &&
-            (!enc->IsFallingAsleep()))
+            (!slavesInUse.contains(enc->GetHostName())) &&
+            (!enc->IsFallingAsleep()) &&
+            (enc->GetSleepStatusTime().secsTo(curtime) > 300))
         {
-            QString sleepCommand = gContext->GetSettingOnHost("SleepCommand",
-                enc->GetHostName());
+            QString slaveHost = enc->GetHostName();
+            bool allowSlaveToSleep = gContext->GetNumSettingOnHost("AllowSlaveToSleep", slaveHost, 0);
             QString wakeUpCommand = gContext->GetSettingOnHost("WakeUpCommand",
-                enc->GetHostName());
+                slaveHost);
 
-            if (!sleepCommand.isEmpty() && !wakeUpCommand.isEmpty())
+            if (allowSlaveToSleep && !wakeUpCommand.isEmpty() && !slavesThatCanWake.contains(slaveHost)) 
             {
-                QString thisHost = enc->GetHostName();
+                // avoid asking the same slave to go to sleep
+                slavesThatCanWake << slaveHost;
 
-                VERBOSE(VB_SCHEDULE+VB_EXTRA, QString("    Commanding %1 to "
-                        "go to sleep.").arg(thisHost));
+                VERBOSE(VB_IMPORTANT, QString("    Asking %1 to "
+                            "go to sleep.").arg(slaveHost));
 
                 if (enc->GoToSleep())
                 {
@@ -2335 +2348 @@
                     for (; slviter != m_tvList->end(); ++slviter)
                     {
                         EncoderLink *slv = *slviter;
-                        if (slv->GetHostName() == thisHost)
+                        if (slv->GetHostName() == slaveHost)
                         {
                             VERBOSE(VB_SCHEDULE+VB_EXTRA,
-                                    QString("    Marking card %1 on slave %2 "
+                                    QString("      Marking card %1 on slave %2 "
                                             "as falling asleep.")
                                             .arg(slv->GetCardID())
                                             .arg(slv->GetHostName()));
@@ -2348 +2361 @@
                 }
                 else
                 {
-                    VERBOSE(VB_IMPORTANT, LOC_ERR + QString("Unable to "
-                            "shutdown %1 slave backend, setting sleep "
-                            "status to undefined.").arg(thisHost));
-                    QMap<int, EncoderLink *>::Iterator slviter =
-                        m_tvList->begin();
-                    for (; slviter != m_tvList->end(); ++slviter)
-                    {
-                        EncoderLink *slv = *slviter;
-                        if (slv->GetHostName() == thisHost)
-                            slv->SetSleepStatus(sStatus_Undefined);
-                    }
+                VERBOSE(VB_IMPORTANT, QString("      Slave %1 responded "
+                            "that it will not go to sleep.").arg(slaveHost));
                 }
             }
         }
@@ -2398 +2402 @@
     for (; enciter != m_tvList->end(); ++enciter)
     {
         EncoderLink *enc = *enciter;
-        if (setWakingStatus && (enc->GetHostName() == slaveHostname))
+        if (setWakingStatus && (enc->GetHostName() == slaveHostname)) 
             enc->SetSleepStatus(sStatus_Waking);
+
         enc->SetLastWakeTime(curtime);
     }
 
+    VERBOSE(VB_SCHEDULE, QString("Trying to Wake Up %1.").arg(slaveHostname));
+
     if (!IsMACAddress(wakeUpCommand))
     {
+        wakeUpCommand = wakeUpCommand.replace(QRegExp("%SLAVE%"), QString("%1")
+            .arg(slaveHostname));
         VERBOSE(VB_SCHEDULE, QString("Executing '%1' to wake up slave.")
-                .arg(wakeUpCommand));
+            .arg(wakeUpCommand));
         myth_system(wakeUpCommand);
     }
     else
@@ -2415 +2424 @@
     return true;
 }
 
-void Scheduler::WakeUpSlaves(void)
+bool Scheduler::WakeUpSlaves(bool forceWakeAll)
 {
-    QStringList SlavesThatCanWake;
+    VERBOSE(VB_SCHEDULE, "Scheduler, Checking for slaves that can be wake up");
+    QStringList slavesThatCanWake;
     QString thisSlave;
+    bool slaveWaken = false;
     QMap<int, EncoderLink *>::Iterator enciter = m_tvList->begin();
     for (; enciter != m_tvList->end(); ++enciter)
     {
         EncoderLink *enc = *enciter;
 
-        if (enc->IsLocal())
+        if ((!forceWakeAll && !enc->CanSleep()) || enc->IsAwake() || enc->IsLocal())
             continue;
 
         thisSlave = enc->GetHostName();
 
         if ((!gContext->GetSettingOnHost("WakeUpCommand", thisSlave)
-                .isEmpty()) &&
-            (!SlavesThatCanWake.contains(thisSlave)))
-            SlavesThatCanWake << thisSlave;
+                    .isEmpty()) && 
+                (!slavesThatCanWake.contains(thisSlave))) {
+            slavesThatCanWake << thisSlave;
+
+            if (forceWakeAll || (!forceWakeAll && CheckDailyWakeUpPeriodSlave(thisSlave, enc)))
+            {
+                VERBOSE(VB_SCHEDULE,
+                    QString("Scheduler, Sending wakeup command to slave: %1")
+                    .arg(thisSlave));
+                WakeUpSlave(thisSlave);
+                slaveWaken = true;
+            }
+        }
     }
+    return slaveWaken;
+}
 
-    int slave = 0;
-    for (; slave < SlavesThatCanWake.count(); slave++)
+QDateTime Scheduler::getDailyWakeupTime(QString sPeriod)
+{
+    QString sTime = gContext->GetSetting(sPeriod, "00:00");
+    QTime tTime = QTime::fromString(sTime, "hh:mm");
+    QDateTime dtDateTime = QDateTime(QDate::currentDate(), tTime);
+
+    return dtDateTime;
+}
+
+bool Scheduler::CheckDailyWakeUpPeriodSlave(QString slaveHostname, EncoderLink *enc)
+{
+    QDateTime dtPeriod1Start = getDailyWakeupTime("DailyWakeupStartPeriod1");
+    QDateTime dtPeriod1End = getDailyWakeupTime("DailyWakeupEndPeriod1");
+    QDateTime dtPeriod2Start = getDailyWakeupTime("DailyWakeupStartPeriod2");
+    QDateTime dtPeriod2End = getDailyWakeupTime("DailyWakeupEndPeriod2");
+    QDateTime dtCurrent = QDateTime::currentDateTime();
+
+    bool inPeriod = false;
+
+    // taken from mythshutdown
+    // Check for time periods that cross midnight
+    if (dtPeriod1End < dtPeriod1Start)
     {
-        thisSlave = SlavesThatCanWake[slave];
-        VERBOSE(VB_SCHEDULE,
-                QString("Scheduler, Sending wakeup command to slave: %1")
-                        .arg(thisSlave));
-        WakeUpSlave(thisSlave, false);
+        if (dtCurrent > dtPeriod1End)
+            dtPeriod1End = dtPeriod1End.addDays(1);
+        else
+            dtPeriod1Start = dtPeriod1Start.addDays(-1);
     }
+
+    if (dtPeriod2End < dtPeriod2Start)
+    {
+        if (dtCurrent > dtPeriod2End)
+            dtPeriod2End = dtPeriod2End.addDays(1);
+        else
+            dtPeriod2Start = dtPeriod2Start.addDays(-1);
+    }
+
+    // Check for one of the daily wakeup periods
+    if (dtPeriod1Start != dtPeriod1End)
+    {
+        if (dtCurrent >= dtPeriod1Start && dtCurrent <= dtPeriod1End)
+        {
+            VERBOSE(VB_SCHEDULE+VB_EXTRA, "In a daily wakeup period (1).");
+            inPeriod = true;
+        }
+    }
+
+    if (dtPeriod2Start != dtPeriod2End)
+    {
+        if (dtCurrent >= dtPeriod2Start && dtCurrent <= dtPeriod2End)
+        {
+            VERBOSE(VB_SCHEDULE+VB_EXTRA, "In a daily wakeup period (2).");
+            inPeriod = true;
+        }
+    }
+
+
+    if (inPeriod)
+    {
+            if (enc->IsAsleep() && !enc->IsWaking())
+            {
+                VERBOSE(VB_SCHEDULE, QString("DailyWakupPeriod starts for "
+                            "slave backend %1, waking it up").arg(slaveHostname));
+                return true;
+            }
+            else if ((enc->IsWaking()) && (enc->GetSleepStatusTime()
+                        .secsTo(dtCurrent) < 370) &&
+                    (enc->GetLastWakeTime().secsTo(dtCurrent) > 60))
+            {
+                VERBOSE(VB_SCHEDULE, QString("DailyWakupPeriod already "
+                            "started for slave backend %1 but not yet "
+                            "available, trying to wake it up again.")
+                        .arg(slaveHostname));
+                return true;
+            }
+    }
+
+    return false;
 }
 
 void *Scheduler::SchedulerThread(void *param)

programs/mythbackend/httpstatus.cpp

@@ -715 +715 @@
                         (SleepStatus) e.attribute("sleepstatus",
                             QString((int)sStatus_Undefined)).toInt();
 
-                    if (sleepStatus == sStatus_Asleep)
+                    switch( sleepStatus )
+                    {
+                        case  sStatus_Asleep:
                         os << " (currently asleep).<br />";
-                    else
+                        break;
+
+                        case sStatus_FallingAsleep:
+                        os << " (currently falling asleep).<br />";
+                        break;
+
+                        case sStatus_Waking:
+                        os << " (currently waking up).<br />";
+                        break;
+
+                        case sStatus_Undefined:
+                        os << " (currently undefined).<br />";
+                        break;
+
+                        default:
                         os << " (currently not connected).<br />";
+                        break;
+                    }
 
                     node = node.nextSibling();
                     continue;