Diff: scheduler.cpp

Revision:

9:ee21cd055a97

Parent:

7:98c8b2eabea3

Child:

10:8cff30b5b90d

--- a/scheduler.cpp	Tue Jul 11 23:12:54 2017 +0000
+++ b/scheduler.cpp	Thu Jul 13 20:01:07 2017 +0000
@@ -1,5 +1,8 @@
 #include "scheduler.h"
 
+#include "mbed-trace/mbed_trace.h"
+#define TRACE_GROUP  "schd"
+
 Timeout WakeOnce;
 
 void update(void *target) {
@@ -14,7 +17,7 @@
     bool descendingTimeline(Appointment *a1, Appointment *a2)
     {
         bool rv = a1->GetTime() <= a2->GetTime();
-        //printf("(%d %d:%d)", *d1, *d2, rv);
+        //tr_debug("(%d %d:%d)", *d1, *d2, rv);
         return rv;
     };
     
@@ -61,7 +64,7 @@
     Response<JobID> Scheduler::JobAdd(JobTypeID jobTID, ISchedule *schedule, IJobData *data) {
         Appointment *apt = new Appointment(jobTID, schedule, data, time_t(0));
         if (NULL == apt) {
-            printf("[Scheduler::JobAdd] failed to allocate appointment\n");
+            tr_debug("[JobAdd] failed to allocate appointment\n");
             return Response<JobID>(1, 0);
         }
         return this->reschedule(apt);
@@ -75,26 +78,26 @@
         apt->SetTime(apt->GetJob()->GetSchedule()->NextRunTime(now));
         if (apt->GetTime() == 0) {
             // there is no next run time; delete appointment
-            printf("[Scheduler::reschedule] NO next appointment\n");
+            tr_debug("[reschedule] NO next appointment\n");
             delete apt;
             req.response.error = 2;
             return req.response;
         }
         
-        printf("[Scheduler::reschedule] put\n");
+        tr_debug("[reschedule] put\n");
         _updates.put(&req);
-        printf("[Scheduler::reschedule] get\n");
+        tr_debug("[reschedule] get\n");
         // default is wait forever
         osEvent evt = req.resQueue.get();
         if (evt.status == osEventMessage) {
             if (evt.value.p != NULL) {
-                printf("[Scheduler::reschedule] completed ok\n");
+                tr_debug("[reschedule] completed ok\n");
             } else {
-                printf("[Scheduler::reschedule] NOT added (C1)\n");
+                tr_debug("[reschedule] NOT added (C1)\n");
             }
         } else {
             // not sure what condition is
-            printf("[Scheduler::reschedule] NOT added (C2)\n");
+            tr_debug("[reschedule] NOT added (C2)\n");
             delete apt;
             apt = NULL;
         }
@@ -113,14 +116,14 @@
     
     void Scheduler::updateHandler() {
         while (!_quitUpdater) {
-            printf("[Scheduler::updateHandler] waiting for action\n");
+            tr_debug("[updateHandler] waiting for action\n");
             // wait forever ...
             osEvent evt = _updates.get();
             if (evt.status == osEventMessage) {
-                printf("[Scheduler::updateHandler] process action\n");
+                tr_debug("[updateHandler] process action\n");
                 this->process((Action*)evt.value.p);
             } else {
-                printf("[Scheduler::updateHandler] NOT osEventMessage\n");
+                tr_debug("[updateHandler] NOT osEventMessage\n");
             }
         }
     }
@@ -130,7 +133,7 @@
         time_t now = time(NULL); // now in seconds
         switch(action->type) {
             case JobAddAT: {
-                printf("[Scheduler::process] JobAddAT\n");
+                tr_debug("[process] JobAddAT\n");
                 JobAddReq *req = static_cast<JobAddReq*>(action);
                 Job *job = req->apt->GetJob();
                 if (job->GetID() == 0) {
@@ -139,30 +142,30 @@
                 }
                 node<Appointment> *tmp = _timeline.insertOrdered(req->apt, descendingTimeline);
                 if (NULL == tmp) {
-                    printf("[Scheduler::process] timeline insert failed\n");
+                    tr_debug("[process] timeline insert failed\n");
                     action->resQueue.put(NULL);
                     // internal state has not changed
                     return;
                 }
                 req->response.data = job->GetID();
-                //printf("[Scheduler::process] simulate error\n");
+                //tr_debug("[process] simulate error\n");
                 //action->resQueue.put(NULL);
                 action->resQueue.put(&req->response);
                 break;
             }
             case JobRunAT: {
-                printf("[Scheduler::process] JobRunAT\n");
+                tr_debug("[process] JobRunAT\n");
                 // execute job run logic after switch
                 break;
             }
             case JobQuitAT: {
-                printf("[Scheduler::process] JobQuitAT\n");
+                tr_debug("[process] JobQuitAT\n");
                 action->resQueue.put(NULL);
                 _quitUpdater = true;
                 return;
             }
             default:
-                printf("[Scheduler::process] unknown action type\n");
+                tr_debug("[process] unknown action type\n");
                 action->resQueue.put(NULL);
         }
         node<Appointment> *wakeNode = _timeline.pop(1);
@@ -171,11 +174,11 @@
         if (now < wakeApt->GetTime()) {
             // request wake up
             time_t sleepTime = wakeApt->GetTime() - now;
-            printf("[Scheduler::process] job %d wake up in %d seconds\n", wakeJob->GetID(), sleepTime);
+            tr_debug("[process] job %d wake up in %d seconds\n", wakeJob->GetID(), sleepTime);
             WakeOnce.attach(callback(this, &Scheduler::onWakeOnce), sleepTime);
         } else {
             // process job
-            printf("[Scheduler::process] job ID %d ready to run\n", wakeJob->GetID());
+            tr_debug("[process] job ID %d ready to run\n", wakeJob->GetID());
             _timeline.remove(1);
             _runs.put(wakeApt);
         }
@@ -183,31 +186,31 @@
     
     void Scheduler::runHandler() {
         while (!_quitRunner) {
-            printf("[Scheduler::runHandler] waiting for action\n");
+            tr_debug("[runHandler] waiting for action\n");
             // wait forever ...
             osEvent evt = _runs.get();
             if (evt.status == osEventMessage) {
-                printf("[Scheduler::runHandler] run action\n");
+                tr_debug("[runHandler] run action\n");
                 Appointment *apt = (Appointment*)evt.value.p;
                 if (NULL == apt) {
-                    printf("[Scheduler::runHandler] quit requested\n");
+                    tr_debug("[runHandler] quit requested\n");
                     _quitRunner = true;
                     break;
                 }
                 Job *job = apt->GetJob();
-                jobFunc *f = _jobService->GetJob(job->GetTypeID());
+                JobType *f = _jobService->GetJob(job->GetTypeID());
                 if (f == NULL) {
-                    printf("[Scheduler::runHandler] NO FUNC for job type id %d\n", job->GetTypeID());
+                    tr_debug("[runHandler] NO FUNC for job type id %d\n", job->GetTypeID());
                     // NO reschedule
                     delete apt;
                     continue;
                 }
-                printf("Job Started\n");
-                f();
-                printf("Job Finished\n");
+                tr_debug("Job Started\n");
+                f->RunJob();
+                tr_debug("Job Finished\n");
                 this->reschedule(apt);
             } else {
-                printf("[Scheduler::runHandler] NOT osEventMessage\n");
+                tr_debug("[runHandler] NOT osEventMessage\n");
             }
         }
     }