Ticket #7762: shutdownSlaveEnhanced_v0.3.diff

playbacksock.h

@@ -42 +42 @@
     void setIP(QString &lip) { ip = lip; }
     QString getIP(void) { return ip; }
 
-    bool GoToSleep(void);
+    int GoToSleep(void);
     void GetDiskSpace(QStringList &o_strlist);
     int DeleteFile(const QString filename, const QString sgroup);
     int StopRecording(const ProgramInfo *pginfo);

scheduler.h

@@ -77 +77 @@
 
     bool WasStartedAutomatically();
 
+    static 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);
+    bool CheckDailyWakeUpPeriodSlaveAndEncoderStatus(QString slaveHostname, EncoderLink *enc);
+    QDateTime getDailyWakeupTime(QString sPeriod, QString slaveHostname);
 
     int FillRecordingDir(RecordingInfo *pginfo, RecList& reclist);
     void FillDirectoryInfoCache(bool force = false);

encoderlink.h

@@ -65 +65 @@
     TVRec *GetTVRec(void) { return tv; }
 
     /// \brief Tell a slave backend to go to sleep
-    bool GoToSleep(void);
+    int GoToSleep(void);
     int LockTuner(void);
     /// \brief Unlock the tuner.
     /// \sa LockTuner(), IsTunerLocked()

playbacksock.cpp

@@ -117 +117 @@
 
 /** \brief Tells a slave to go to sleep
  */
-bool PlaybackSock::GoToSleep(void)
+int PlaybackSock::GoToSleep(void)
 {
     QStringList strlist( QString("GO_TO_SLEEP") );
-
-    return SendReceiveStringList(strlist, 1) && (strlist[0] == "OK");
+    if (SendReceiveStringList(strlist, 1)) {
+        if (strlist[0] == "OK") 
+            return 1;
+        else if (strlist[0] == "BUSY")
+            return 0;
+    }
+    return -1;
 }
 
 /**

mainserver.cpp

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

scheduler.cpp

@@ -1706 +1706 @@
                 }
                 firstRun = false;
             }
-
-            PutInactiveSlavesToSleep();
-            lastSleepCheck = QDateTime::currentDateTime();
         }
       }
 
@@ -1718 +1715 @@
 
         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;
@@ -1971 +1961 @@
             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))
         {
@@ -2149 +2148 @@
         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) *
@@ -2199 +2199 @@
         }
     }
 
-    // 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");
 
@@ -2243 +2245 @@
             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.")
@@ -2259 +2261 @@
     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;
@@ -2276 +2278 @@
         {
             enc = (*m_tvList)[pginfo->cardid];
             if ((!enc->IsLocal()) &&
-                (!SlavesInUse.contains(enc->GetHostName())))
-            {
-                if (pginfo->recstatus == rsWillRecord)
+                (!slavesInUse.contains(enc->GetHostName())) &&
+                (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'")
-                            .arg(enc->GetHostName()).arg(pginfo->title));
-                SlavesInUse << enc->GetHostName();
+                    slavesInUse << enc->GetHostName();
             }
         }
     }
 
-    VERBOSE(VB_SCHEDULE+VB_EXTRA, "  Checking inuseprograms table:");
+    VERBOSE(VB_SCHEDULE+VB_EXTRA, "2  Checking inuseprograms table:");
     QDateTime oneHourAgo = QDateTime::currentDateTime().addSecs(-61 * 60);
     MSqlQuery query(MSqlQuery::InitCon());
     query.prepare("SELECT DISTINCT hostname, recusage FROM inuseprograms "
@@ -2300 +2297 @@
     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())
@@ -2308 +2305 @@
         }
     }
 
-    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)
     {
         enc = *enciter;
+        QString slaveHost = enc->GetHostName();
 
         if ((!enc->IsLocal()) &&
             (enc->IsAwake()) &&
-            (!SlavesInUse.contains(enc->GetHostName())) &&
-            (!enc->IsFallingAsleep()))
+            (!slavesInUse.contains(slaveHost)) &&
+            (!enc->IsFallingAsleep()) &&
+            (enc->GetSleepStatusTime().secsTo(curtime) > 300) &&
+            (!Scheduler::CheckDailyWakeUpPeriodSlave(slaveHost)))
         {
             QString sleepCommand = gContext->GetSettingOnHost("SleepCommand",
-                enc->GetHostName());
+                slaveHost);
             QString wakeUpCommand = gContext->GetSettingOnHost("WakeUpCommand",
-                enc->GetHostName());
+                slaveHost);
 
-            if (!sleepCommand.isEmpty() && !wakeUpCommand.isEmpty())
+            if (!sleepCommand.isEmpty() && !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));
-
-                if (enc->GoToSleep())
+                VERBOSE(VB_SCHEDULE+VB_EXTRA, QString("    Asking %1 to "
+                            "go to sleep.").arg(slaveHost));
+                int goToSleep = enc->GoToSleep();
+                if (goToSleep == 1)
                 {
                     QMap<int, EncoderLink *>::Iterator slviter =
                         m_tvList->begin();
                     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 "
@@ -2352 +2352 @@
                         }
                     }
                 }
-                else
+                else if (goToSleep == -1)
                 {
                     VERBOSE(VB_IMPORTANT, LOC_ERR + QString("Unable to "
                             "shutdown %1 slave backend, setting sleep "
-                            "status to undefined.").arg(thisHost));
+                            "status to undefined.").arg(slaveHost));
                     QMap<int, EncoderLink *>::Iterator slviter =
                         m_tvList->begin();
                     for (; slviter != m_tvList->end(); ++slviter)
                     {
                         EncoderLink *slv = *slviter;
-                        if (slv->GetHostName() == thisHost)
+                        if (slv->GetHostName() == slaveHost)
                             slv->SetSleepStatus(sStatus_Undefined);
                     }
                 }
@@ -2404 +2404 @@
     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
@@ -2421 +2426 @@
     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() || enc->IsWaking())
             continue;
 
         thisSlave = enc->GetHostName();
 
         if ((!gContext->GetSettingOnHost("WakeUpCommand", thisSlave)
-                .isEmpty()) &&
-            (!SlavesThatCanWake.contains(thisSlave)))
-            SlavesThatCanWake << thisSlave;
+                    .isEmpty()) && 
+                (!slavesThatCanWake.contains(thisSlave))) {
+            slavesThatCanWake << thisSlave;
+
+            if (forceWakeAll || (!forceWakeAll && Scheduler::CheckDailyWakeUpPeriodSlaveAndEncoderStatus(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 slaveHostname)
+{
+    QString sTime = gContext->GetSettingOnHost(sPeriod, slaveHostname, "00:00");
+    QTime tTime = QTime::fromString(sTime, "hh:mm");
+    QDateTime dtDateTime = QDateTime(QDate::currentDate(), tTime);
+
+    return dtDateTime;
+}
+
+bool Scheduler::CheckDailyWakeUpPeriodSlaveAndEncoderStatus(QString slaveHostname, EncoderLink *enc)
+{
+    
+    QDateTime dtCurrent = QDateTime::currentDateTime();
+    if (Scheduler::CheckDailyWakeUpPeriodSlave(slaveHostname))
     {
-        thisSlave = SlavesThatCanWake[slave];
-        VERBOSE(VB_SCHEDULE,
-                QString("Scheduler, Sending wakeup command to slave: %1")
-                        .arg(thisSlave));
-        WakeUpSlave(thisSlave, false);
+            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;
+
 }
+bool Scheduler::CheckDailyWakeUpPeriodSlave(QString slaveHostname)
+{
+    QDateTime dtPeriod1Start = getDailyWakeupTime("DailyWakeupStartPeriod1", slaveHostname);
+    QDateTime dtPeriod1End = getDailyWakeupTime("DailyWakeupEndPeriod1", slaveHostname);
+    QDateTime dtPeriod2Start = getDailyWakeupTime("DailyWakeupStartPeriod2", slaveHostname);
+    QDateTime dtPeriod2End = getDailyWakeupTime("DailyWakeupEndPeriod2", slaveHostname);
+    QDateTime dtCurrent = QDateTime::currentDateTime();
 
+    bool inPeriod = false;
+
+    // taken from mythshutdown
+    // Check for time periods that cross midnight
+    if (dtPeriod1End < dtPeriod1Start)
+    {
+        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;
+        }
+    }
+
+    return inPeriod;
+}
+
 void *Scheduler::SchedulerThread(void *param)
 {
     // Lower scheduling priority, to avoid problems with recordings.

encoderlink.cpp

@@ -358 +358 @@
 
 /** \brief Tell a slave to go to sleep
  */
-bool EncoderLink::GoToSleep(void)
+int EncoderLink::GoToSleep(void)
 {
     if (IsLocal() || !sock)
-        return false;
+        return -1;
 
     lastSleepTime = QDateTime::currentDateTime();