MojErr
DevelCategoryHandler::PriorityControl(MojServiceMessage *msg, MojObject& payload)
{
ACTIVITY_SERVICEMETHOD_BEGIN();
MojLogTrace(s_log);
MojLogInfo(s_log, _T("PriorityControl: %s"),
MojoObjectJson(payload).c_str());
MojErr err;
bool enabled = false;
bool found = payload.get(_T("enabled"), enabled);
if (!found) {
err = msg->replyError(MojErrInvalidArg, _T("Must specify "
"\"enabled\":true or \"enabled\":false"));
MojErrCheck(err);
return MojErrNone;
}
if (enabled) {
m_resourceManager->Enable();
} else {
m_resourceManager->Disable();
}
err = msg->replySuccess();
MojErrCheck(err);
ACTIVITY_SERVICEMETHOD_END(msg);
return MojErrNone;
}
MojErr
TestCategoryHandler::WhereMatchTest(MojServiceMessage *msg, MojObject &payload)
{
ACTIVITY_SERVICEMETHOD_BEGIN();
MojObject response;
bool found = payload.get(_T("response"), response);
if (!found) {
throw std::runtime_error("Please provide a \"response\" and a "
"\"where\" clause to test against it");
}
MojObject where;
found = payload.get(_T("where"), where);
if (!found) {
throw std::runtime_error("Please provide a \"where\" clause to test "
"the response against");
}
MojoNewWhereMatcher matcher(where);
bool matched = matcher.Match(response);
MojObject reply;
MojErr err = reply.putBool(_T("matched"), matched);
MojErrCheck(err);
err = msg->reply(reply);
MojErrCheck(err);
ACTIVITY_SERVICEMETHOD_END(msg);
return MojErrNone;
}
MojErr
DevelCategoryHandler::Evict(MojServiceMessage *msg, MojObject &payload)
{
ACTIVITY_SERVICEMETHOD_BEGIN();
LOG_AM_TRACE("Entering function %s", __FUNCTION__);
LOG_AM_DEBUG("Evict: %s", MojoObjectJson(payload).c_str());
MojErr err = MojErrNone;
bool evictAll = false;
payload.get(_T("evictAll"), evictAll);
if (evictAll) {
LOG_AM_DEBUG("EVICTING ALL ACTIVITIES FROM BACKGROUND QUEUE");
m_am->EvictAllBackgroundActivities();
} else {
boost::shared_ptr<Activity> act;
err = LookupActivity(msg, payload, act);
MojErrCheck(err);
LOG_AM_DEBUG(" EVICTING [Activity %llu] FROM BACKGROUND QUEUE",act->GetId());
m_am->EvictBackgroundActivity(act);
}
err = msg->replySuccess();
MojErrCheck(err);
ACTIVITY_SERVICEMETHOD_END(msg);
return MojErrNone;
}
MojErr
CallbackCategoryHandler::ScheduledWakeup(MojServiceMessage *msg, MojObject &payload)
{
ACTIVITY_SERVICEMETHOD_BEGIN();
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Callback: ScheduledWakeup"));
boost::dynamic_pointer_cast<PowerdScheduler,Scheduler>(m_scheduler)->ScheduledWakeup();
ACTIVITY_SERVICEMETHOD_END(msg);
return MojErrNone;
}
MojErr
CallbackCategoryHandler::SchedulerTest(MojServiceMessage *msg, MojObject& payload)
{
ACTIVITY_SERVICEMETHOD_BEGIN();
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Callback: Scheduler Test Start: %s"),
MojoObjectJson(payload).c_str());
m_testDriver->Start(payload);
MojErr err = msg->replySuccess();
MojErrCheck(err);
ACTIVITY_SERVICEMETHOD_END(msg);
return MojErrNone;
}
MojErr
TestCategoryHandler::Leak(MojServiceMessage *msg, MojObject &payload)
{
ACTIVITY_SERVICEMETHOD_BEGIN();
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Leak: %s"), MojoObjectJson(payload).c_str());
MojErr err = MojErrNone;
bool freeAll = false;
payload.get(_T("freeAll"), freeAll);
if (freeAll) {
MojLogCritical(s_log, _T("RELEASING REFERENCES TO ALL INTENTIONALLY "
"LEAKED ACTIVITIES"));
while (!m_leakedActivities.empty()) {
boost::shared_ptr<Activity> act = m_leakedActivities.front();
m_leakedActivities.pop_front();
MojLogCritical(s_log, _T("RELEASING REFERENCE TO [Activity %llu]"),
act->GetId());
}
} else {
boost::shared_ptr<Activity> act;
err = LookupActivity(msg, payload, act);
MojErrCheck(err);
MojLogCritical(s_log, _T("INTENTIONALLY LEAKING [Activity %llu]!!"),
act->GetId());
m_leakedActivities.push_back(act);
}
err = msg->replySuccess();
MojErrCheck(err);
ACTIVITY_SERVICEMETHOD_END(msg);
return MojErrNone;
}
MojErr
DevelCategoryHandler::SetConcurrency(MojServiceMessage *msg, MojObject &payload)
{
ACTIVITY_SERVICEMETHOD_BEGIN();
MojLogTrace(s_log);
MojLogInfo(s_log, _T("SetConcurrency: %s"),
MojoObjectJson(payload).c_str());
bool unlimited = false;
payload.get(_T("unlimited"), unlimited);
MojUInt32 level;
bool found = false;
MojErr err = payload.get(_T("level"), level, found);
MojErrCheck(err);
if (unlimited || found) {
m_am->SetBackgroundConcurrencyLevel(unlimited ?
ActivityManager::UnlimitedBackgroundConcurrency :
(unsigned int)level);
err = msg->replySuccess();
MojErrCheck(err);
} else {
MojLogWarning(s_log, _T("Attempt to set background concurrency did "
"not specify \"unlimited\":true or a \"level\""));
err = msg->replyError(MojErrInvalidArg, "Either \"unlimited\":true, "
"or \"level\":<number concurrent Activities> must be specified");
MojErrCheck(err);
}
ACTIVITY_SERVICEMETHOD_END(msg);
return MojErrNone;
}
MojErr
DevelCategoryHandler::Run(MojServiceMessage *msg, MojObject &payload)
{
ACTIVITY_SERVICEMETHOD_BEGIN();
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Run: %s"), MojoObjectJson(payload).c_str());
MojErr err = MojErrNone;
bool runAll = false;
payload.get(_T("runAll"), runAll);
if (runAll) {
MojLogCritical(s_log, _T("EVICTING ALL ACTIVITIES FROM BACKGROUND "
"QUEUE"));
m_am->RunAllReadyActivities();
} else {
boost::shared_ptr<Activity> act;
err = LookupActivity(msg, payload, act);
MojErrCheck(err);
MojLogCritical(s_log, _T("EVICTING [Activity %llu] FROM BACKGROUND "
"QUEUE"), act->GetId());
m_am->RunReadyBackgroundActivity(act);
}
err = msg->replySuccess();
MojErrCheck(err);
ACTIVITY_SERVICEMETHOD_END(msg);
return MojErrNone;
}
