MojErr MojDbServiceHandler::handlePut(MojServiceMessage* msg, MojObject& payload, MojDbReq& req)
{
MojAssert(msg);
MojLogTrace(s_log);
// check space level
if( MojDbServiceHandlerInternal::spaceAlertLevel() == MojDbServiceHandlerInternal::AlertLevelHigh)
return MojErrDbQuotaExceeded;
MojObject obj;
MojErr err = payload.getRequired(MojDbServiceDefs::ObjectsKey, obj);
MojErrCheck(err);
MojObject::ArrayIterator begin;
err = obj.arrayBegin(begin);
MojErrCheck(err);
MojObject::ConstArrayIterator end = obj.arrayEnd();
err = m_db.put(begin, end, MojDb::FlagNone, req);
MojErrCheck(err);
err = formatPut(msg, begin, end);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbIndex::getKeys(const MojObject& obj, KeySet& keysOut) const
{
MojLogTrace(s_log);
// build the set of unique keys from object
MojDbKeyBuilder builder;
MojErr err = builder.push(m_idSet);
MojErrCheck(err);
MojSize idx = 0;
for (PropVec::ConstIterator i = m_props.begin();
i != m_props.end();
++i, ++idx) {
KeySet vals;
err = (*i)->vals(obj, vals);
MojErrCheck(err);
err = builder.push(vals);
MojErrCheck(err);
}
err = builder.keys(keysOut);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbServiceHandler::handlePutPermissions(MojServiceMessage* msg, MojObject& payload, MojDbReq& req)
{
MojAssert(msg);
MojLogTrace(s_log);
// check space level
if( MojDbServiceHandlerInternal::spaceAlertLevel() == MojDbServiceHandlerInternal::AlertLevelHigh)
return MojErrDbQuotaExceeded;
MojObject permissionsArr;
MojErr err = payload.getRequired(MojDbServiceDefs::PermissionsKey, permissionsArr);
MojErrCheck(err);
MojObject::ArrayIterator begin;
err = permissionsArr.arrayBegin(begin);
MojErrCheck(err);
MojObject::ConstArrayIterator end = permissionsArr.arrayEnd();
err = m_db.putPermissions(begin, end, req);
MojErrCheck(err);
err = msg->replySuccess();
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbKind::addSuper(MojDbKind* kind)
{
MojAssert(kind);
MojLogTrace(s_log);
// we may have temporary cycles, so ignore them
if (kind->extends(m_id))
return MojErrNone;
// if our current super is the root kind, remove it
if (!m_supers.empty() && m_supers.front()->id() == MojDbKindEngine::RootKindId) {
MojDbKind* root = m_supers.front();
MojErr err = root->removeKind(root->m_subs, this);
MojErrCheck(err);
m_supers.clear();
}
// update vecs
MojErr err = m_supers.push(kind);
MojErrCheck(err);
err = kind->m_subs.push(this);
MojErrCheck(err);
return MojErrNone;
}
void PowerdProxy::TriggerChargerStatus()
{
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Triggering status signals for \"charging\" and "
"\"docked\" requirements"));
MojObject params(MojObject::TypeObject);
#if 0
m_triggerChargerStatus = boost::make_shared<MojoWeakPtrCall<PowerdProxy> >(
boost::dynamic_pointer_cast<PowerdProxy, RequirementManager>(
shared_from_this()), &PowerdProxy::TriggerChargerStatusResponse,
m_service, "palm://com.palm.telephony/chargeSourceQuery", params);
m_triggerChargerStatus->Call();
#endif
m_triggerChargerStatus = boost::make_shared<MojoWeakPtrCall<PowerdProxy> >(
boost::dynamic_pointer_cast<PowerdProxy, RequirementManager>(
shared_from_this()), &PowerdProxy::TriggerChargerStatusResponse,
m_service, "palm://com.palm.power/com/palm/power/chargerStatusQuery",
params);
m_triggerChargerStatus->Call();
}
/*
* Change in buddy status
*/
bool IMServiceHandler::updateBuddyStatus(const char* accountId, const char* serviceName, const char* username, int availability,
const char* customMessage, const char* groupName, const char* buddyAvatarLoc)
{
MojLogTrace(IMServiceApp::s_log);
// log the parameters
MojLogInfo (IMServiceApp::s_log, _T("updateBuddyStatus - accountId: %s, serviceName: %s, username: %s, availability: %i, customMessage: %s, groupName: %s, buddyAvatarLoc: %s"),
accountId, serviceName, username, availability, customMessage, groupName, buddyAvatarLoc);
// handle the message
MojRefCountedPtr<BuddyStatusHandler> buddyStatusHandler(new BuddyStatusHandler(m_service, this));
MojErr err = buddyStatusHandler->updateBuddyStatus(accountId, serviceName, username, availability, customMessage, groupName, buddyAvatarLoc);
if (err) {
MojString error;
MojErrToString(err, error);
MojLogError(IMServiceApp::s_log, _T("updateBuddyStatus failed: %d - %s"), err, error.data());
return false;
}
return true;
}
void MojoExclusiveTrigger::ProcessResponse(const MojObject& response,
MojErr err)
{
MojLogTrace(s_log);
/* Subscription guarantees any errors received are from the subscribing
* Service. Transient bus errors are handled automatically.
*
* XXX have an option to disable auto-resubscribe */
if (err) {
MojLogInfo(s_log, _T("[Activity %llu] Trigger call \"%s\" failed"),
m_activity.lock()->GetId(),
m_subscription->GetURL().GetURL().data());
m_response = response;
Fire();
} else if (m_matcher->Match(response)) {
MojLogInfo(s_log, _T("[Activity %llu] Trigger call \"%s\" fired!"),
m_activity.lock()->GetId(),
m_subscription->GetURL().GetURL().data());
m_response = response;
Fire();
}
}
MojErr MojDbIndex::insertKeys(const KeySet& keys, MojDbStorageTxn* txn)
{
MojLogTrace(s_log);
int count = 0;
for (KeySet::ConstIterator i = keys.begin(); i != keys.end(); ++i) {
MojErr err = m_index->insert(*i, txn);
#if defined(MOJ_DEBUG_LOGGING)
char s[1024];
int size = (*i).size();
MojErr err2 = MojByteArrayToHex((*i).data(), size, s);
MojErrCheck(err2);
if (size > 16) // if the object-id is in key
strncat(s, (char *)((*i).data()) + (size - 17), 16);
MojLogInfo(s_log, _T("insertKey %d for: %s; key= %s ; err= %d\n"), count+1, this->m_name.data(), s, err);
#endif
MojErrCheck(err);
count ++;
}
return MojErrNone;
}
void MojoNewWhereMatcher::ValidateClauses(const MojObject& where) const
{
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Validating trigger clauses"));
if (where.type() == MojObject::TypeObject) {
ValidateClause(where);
} else if (where.type() == MojObject::TypeArray) {
for (MojObject::ConstArrayIterator iter = where.arrayBegin();
iter != where.arrayEnd(); ++iter) {
const MojObject& clause = *iter;
if (clause.type() != MojObject::TypeObject) {
throw std::runtime_error("where statement array must "
"consist of valid clauses");
} else {
ValidateClause(clause);
}
}
} else {
throw std::runtime_error("where statement should consist of a single "
"clause or array of valid clauses");
}
}
MojErr MojDbKindEngine::loadKinds(MojDbReq& req)
{
MojAssert(isOpen());
MojAssertWriteLocked(m_db->m_schemaLock);
MojLogTrace(s_log);
MojDbQuery query;
MojErr err = query.from(KindKindId);
MojErrCheck(err);
MojDbCursor cursor;
err = m_db->find(query, cursor, req);
MojErrCheck(err);
for (;;) {
MojObject obj;
bool found = false;
err = cursor.get(obj, found);
MojErrCheck(err);
if (!found)
break;
// load kind
MojErr loadErr = err = putKind(obj, req);
MojErrCatchAll(err) {
MojString id;
bool found = false;
MojErr err = obj.get(MojDbServiceDefs::IdKey, id, found);
MojErrCheck(err);
MojString errStr;
MojErrToString(loadErr, errStr);
MojLogError(s_log, _T("error loading kind '%s' - %s"), id.data(), errStr.data());
}
}
err = cursor.close();
MojErrCheck(err);
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 MojDbIndex::fromObject(const MojObject& obj, const MojString& locale)
{
MojLogTrace(s_log);
// check name
MojString name;
MojErr err = obj.getRequired(NameKey, name);
MojErrCheck(err);
err = validateName(name);
MojErrCheck(err);
m_name = name;
m_locale = locale;
if(m_locale == _T("en_CN"))
m_locale = locale;
// get deleted flag
bool includeDel = false;
if (obj.get(IncludeDeletedKey, includeDel)) {
incDel(includeDel);
}
// add props
MojObject props;
err = obj.getRequired(PropsKey, props);
MojErrCheck(err);
MojObject propObj;
MojSize j = 0;
while (props.at(j++, propObj)) {
err = addProp(propObj);
MojErrCheck(err);
}
if (m_props.empty()) {
MojErrThrowMsg(MojErrDbInvalidIndex, _T("db: no properties specified in index '%s'"), name.data());
}
m_obj = obj;
return MojErrNone;
}
void ActivityManager::CheckReadyQueue()
{
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Checking to see if more background Activities can "
"run"));
bool ranInteractive = false;
while (((GetRunningBackgroundActivitiesCount()
< m_backgroundInteractiveConcurrencyLevel) ||
(m_backgroundInteractiveConcurrencyLevel
== UnlimitedBackgroundConcurrency))
&& !m_runQueue[RunQueueReadyInteractive].empty()) {
RunReadyBackgroundInteractiveActivity(
m_runQueue[RunQueueReadyInteractive].front());
ranInteractive = true;
}
if (!m_runQueue[RunQueueReadyInteractive].empty()) {
if (ranInteractive) {
UpdateYieldTimeout();
} else if (!m_interactiveYieldTimeout) {
UpdateYieldTimeout();
}
} else {
if (m_interactiveYieldTimeout) {
CancelYieldTimeout();
}
}
while (((GetRunningBackgroundActivitiesCount()
< m_backgroundConcurrencyLevel) ||
(m_backgroundConcurrencyLevel == UnlimitedBackgroundConcurrency))
&& !m_runQueue[RunQueueReady].empty()) {
RunReadyBackgroundActivity(m_runQueue[RunQueueReady].front());
}
}
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;
}
MojErr MojDbServiceHandler::handleDel(MojServiceMessage* msg, MojObject& payload, MojDbReq& req)
{
MojAssert(msg);
MojLogTrace(s_log);
MojErr err = MojErrNone;
MojUInt32 count = 0;
MojUInt32 flags = MojDb::FlagNone;
bool purge = false;
if (payload.get(MojDbServiceDefs::PurgeKey, purge) && purge) {
flags |= MojDb::FlagPurge;
}
MojObject obj;
if (payload.get(MojDbServiceDefs::IdsKey, obj)) {
if (payload.contains(MojDbServiceDefs::QueryKey))
MojErrThrowMsg(MojErrInvalidArg, _T("db: cannot have both an objects argument and a query argument"));
MojObject deletedObjects;
err = m_db.del(obj.arrayBegin(), obj.arrayEnd(), count, deletedObjects, flags, req);
MojErrCheck(err);
err = formatPut(msg, deletedObjects.arrayBegin(), deletedObjects.arrayEnd());
MojErrCheck(err);
}
else if (payload.get(MojDbServiceDefs::QueryKey, obj)) {
MojDbQuery query;
err = query.fromObject(obj);
MojErrCheck(err);
MojUInt32 queryCount = 0;
err = m_db.del(query, queryCount, flags, req);
MojErrCheck(err);
count += queryCount;
err = formatCount(msg, count);
MojErrCheck(err);
}
return MojErrNone;
}
MojErr MojDbIndex::cancelWatch(MojDbWatcher* watcher)
{
MojAssert(isOpen());
MojAssert(watcher);
MojLogTrace(s_log);
MojLogInfo(s_log, _T("Index_cancelWatch: index name = %s; domain = %s\n"),
this->name().data(), watcher->domain().data());
MojThreadWriteGuard guard(m_lock);
MojSize idx;
MojSize size = m_watcherVec.size();
for (idx = 0; idx < size; ++idx) {
if (m_watcherVec.at(idx).get() == watcher) {
MojErr err = m_watcherVec.erase(idx);
MojErrCheck(err);
WatcherMap::Iterator iter;
err = m_watcherMap.find(watcher->domain(), iter);
MojErrCheck(err);
if (iter != m_watcherMap.end()) {
iter.value() -= 1;
if (iter.value() == 0) {
bool found = false;
m_watcherMap.del(iter.key(), found);
MojAssert(found);
MojLogInfo(s_log, _T("Index_cancelwatch: Domain Del found = %d; index name = %s; domain = %s\n"),
(int)found, this->name().data(), watcher->domain().data());
}
}
break;
}
}
if (idx == size)
MojErrThrow(MojErrDbWatcherNotRegistered);
return MojErrNone;
}
MojoNewWhereMatcher::MatchResult MojoNewWhereMatcher::CheckClauses(
const MojObject& clauses, const MojObject& response, MatchMode mode) const
{
MojLogTrace(s_log);
if (clauses.type() == MojObject::TypeObject) {
return CheckClause(clauses, response, mode);
} else if (clauses.type() != MojObject::TypeArray) {
throw std::runtime_error("Multiple clauses must be specified as an "
"array of clauses");
}
MojLogInfo(s_log, _T("Checking clauses '%s' against response '%s' (%s)"),
MojoObjectJson(clauses).c_str(), MojoObjectJson(response).c_str(),
(mode == AndMode) ? "and" : "or");
for (MojObject::ConstArrayIterator iter = clauses.arrayBegin();
iter != clauses.arrayEnd(); ++iter) {
MatchResult result = CheckClause(*iter, response, mode);
if (mode == AndMode) {
if (result != Matched) {
return NotMatched;
}
} else {
if (result == Matched) {
return Matched;
}
}
}
if (mode == AndMode) {
return Matched;
} else {
return NotMatched;
}
}
MojErr MojDb::close()
{
MojLogTrace(s_log);
MojThreadWriteGuard guard(m_schemaLock);
MojErr err = MojErrNone;
MojErr errClose = MojErrNone;
if (m_isOpen) {
MojLogInfo(s_log, _T("closing..."));
errClose = m_quotaEngine.close();
MojErrAccumulate(err, errClose);
errClose = m_permissionEngine.close();
MojErrAccumulate(err, errClose);
errClose = m_kindEngine.close();
MojErrAccumulate(err, errClose);
if (m_idSeq.get()) {
errClose = m_idSeq->close();
MojErrAccumulate(err, errClose);
m_idSeq.reset();
}
if (m_objDb.get()) {
errClose = m_objDb->close();
MojErrAccumulate(err, errClose);
m_objDb.reset();
}
if (m_storageEngine.get()) {
errClose = m_storageEngine->close();
MojErrAccumulate(err, errClose);
m_storageEngine.reset();
}
m_isOpen = false;
MojLogInfo(s_log, _T("close completed"));
}
return err;
}
MojErr MojDbIndex::delKeys(const KeySet& keys, MojDbStorageTxn* txn, bool forcedel)
{
MojLogTrace(s_log);
int count = 0;
for (KeySet::ConstIterator i = keys.begin(); i != keys.end(); ++i) {
MojErr err = m_index->del(*i, txn);
#if defined(MOJ_DEBUG_LOGGING)
char s[1024];
char *s2 = NULL;
if (m_kind)
s2 = (char *)(m_kind->id().data());
size_t size = (*i).size();
MojErr err2 = MojByteArrayToHex((*i).data(), size, s);
MojErrCheck(err2);
if (size > 16) // if the object-id is in key
strncat(s, (char *)((*i).data()) + (size - 17), 16);
MojLogInfo(s_log, _T("delKey %d for: %s - %s; key= %s ; err= %d\n"), count+1, s2, this->m_name.data(), s, err);
#endif
// This has some potential risk
if (err == MojErrInternalIndexOnDel) {
m_delMisses++;
#if defined(MOJ_DEBUG_LOGGING)
MojLogWarning(s_log, _T("delKey %d for: %s - %s; key= %s; err = %d \n"), count+1, s2, this->m_name.data(), s, err);
#endif
if (forcedel)
err = MojErrNone;
}
MojErrCheck(err);
count++;
}
return MojErrNone;
}
MojErr MojDbQuotaEngine::open(const MojObject& conf, MojDb* db, MojDbReq& req)
{
MojAssert(db);
MojLogTrace(s_log);
MojErr err = db->storageEngine()->openDatabase(_T("UsageDbName"), req.txn(), m_usageDb);
MojErrCheck(err);
err = MojDbPutHandler::open(conf, db, req);
MojErrCheck(err);
MojDbKindEngine::KindMap& kinds = db->kindEngine()->kindMap();
for (MojDbKindEngine::KindMap::ConstIterator i = kinds.begin();
i != kinds.end(); ++i) {
err = initUsage(i.value().get(), req);
MojErrCheck(err);
}
err = refreshImpl(req.txn());
MojErrCheck(err);
m_isOpen = true;
return MojErrNone;
}
MojErr MojDbQuotaEngine::commitQuota(const MojString& owner, MojInt64 size)
{
MojLogTrace(s_log);
MojAssertWriteLocked(m_db->schemaLock());
// get or create quota object
QuotaMap::Iterator iter;
MojErr err = m_quotas.find(owner, iter);
MojErrCheck(err);
if (iter == m_quotas.end()) {
MojRefCountedPtr<Quota> quota(new Quota(size));
MojAllocCheck(quota.get());
err = m_quotas.put(owner, quota);
MojErrCheck(err);
} else {
iter.value()->size(size);
}
if (m_isOpen) {
err = refresh();
MojErrCheck(err);
}
return MojErrNone;
}
// This updates the access time without needing to subscribe, it's
// like using touch on an existing file
bool
CFileCacheSet::Touch(const cachedObjectId_t objId) {
MojLogTrace(s_log);
bool retVal = false;
const std::string typeName(GetTypeForObjectId(objId));
if (!typeName.empty()) {
CFileCache* fileCache = GetFileCacheForType(typeName);
if (fileCache != NULL) {
retVal = fileCache->Touch(objId);
MojLogInfo(s_log, _T("Touch: Object '%llu' touched."), objId);
} else {
MojLogWarning(s_log,
_T("Touch: No cache of type '%s' found for id '%llu'."),
typeName.c_str(), objId);
}
} else {
MojLogWarning(s_log, _T("Touch: Cache type not found for id '%llu'."),
objId);
}
return retVal;
}
// Remove the client subscription of an object. This will remove
// the guarantee that the object will be kept in the cache.
void
CFileCacheSet::UnSubscribeCacheObject(const std::string& typeName,
const cachedObjectId_t objId) {
MojLogTrace(s_log);
if (!typeName.empty()) {
CFileCache* fileCache = GetFileCacheForType(typeName);
if (fileCache != NULL) {
fileCache->UnSubscribe(objId);
MojLogInfo(s_log,
_T("UnSubscribeCacheObject: Object '%llu' unsubscribed."),
objId);
} else {
MojLogWarning(s_log,
_T("UnSubscribeCacheObject: No cache of type '%s' found for id '%llu'."),
typeName.c_str(), objId);
}
} else {
MojLogWarning(s_log,
_T("UnSubscribeCacheObject: Cache type not found for id '%llu'."),
objId);
}
}
MojErr MojDbBerkeleyEngine::drop(const MojChar* path, MojDbStorageTxn* txn)
{
MojLogTrace(MojDbBerkeleyEngine::s_log);
MojAssert(m_isOpen);
MojThreadGuard guard(m_dbMutex);
// close sequences
for (SequenceVec::ConstIterator i = m_seqs.begin(); i != m_seqs.end(); ++i) {
MojErr err = (*i)->closeImpl();
MojErrCheck(err);
}
m_seqs.clear();
// drop databases
for (DatabaseVec::ConstIterator i = m_dbs.begin(); i != m_dbs.end(); ++i) {
MojErr err = (*i)->closeImpl();
MojErrCheck(err);
err = (*i)->drop(txn);
MojErrCheck(err);
}
m_dbs.clear();
return MojErrNone;
}
MojErr MojDbKindEngine::putKind(const MojObject& obj, MojDbReq& req, bool builtin)
{
MojAssert(isOpen());
MojAssertWriteLocked(m_db->m_schemaLock);
MojLogTrace(s_log);
// parse out id
MojString id;
MojErr err = obj.getRequired(MojDbServiceDefs::IdKey, id);
MojErrCheck(err);
KindMap::ConstIterator i = m_kinds.find(id);
if (i == m_kinds.end()) {
// new kind
err = createKind(id, obj, req, builtin);
MojErrCheck(err);
} else {
// existing kind
MojLogDebug(s_log, _T("UpdatingKind: %s \n"), id.data());
err = (*i)->configure(obj, m_kinds, m_locale, req);
MojErrCheck(err);
}
return MojErrNone;
}
void ActivityManager::RunReadyBackgroundActivity(
boost::shared_ptr<Activity> act)
{
MojLogTrace(s_log);
MojLogNotice(s_log, _T("Attepting to run ready [Activity %llu]"),
act->GetId());
ActivityRunQueue::iterator iter;
for (iter = m_runQueue[RunQueueReady].begin();
iter != m_runQueue[RunQueueReady].end(); ++iter) {
if (&(*iter) == &(*act)) {
break;
}
}
if (iter != m_runQueue[RunQueueReady].end()) {
RunReadyBackgroundActivity(*iter);
return;
}
for (iter = m_runQueue[RunQueueReadyInteractive].begin();
iter != m_runQueue[RunQueueReadyInteractive].end(); ++iter) {
if (&(*iter) == &(*act)) {
break;
}
}
if (iter != m_runQueue[RunQueueReadyInteractive].end()) {
RunReadyBackgroundInteractiveActivity(*iter);
return;
}
MojLogWarning(s_log, _T("[Activity %llu] Not found on ready "
"queue"), act->GetId());
throw std::runtime_error("Activity not on ready queue");
}
MojErr MojDbKind::drop(MojDbReq& req)
{
MojLogTrace(s_log);
MojErr err = checkPermission(OpKindUpdate, req);
MojErrCheck(err);
err = req.curKind(this);
MojErrCheck(err);
// drop indexes
MojErr errAcc = MojErrNone;
for (IndexVec::ConstIterator i = m_indexes.begin();
i != m_indexes.end(); ++i) {
errAcc = dropIndex(i->get(), req);
MojErrAccumulate(err, errAcc);
}
m_indexes.clear();
// remove self from super/sub kinds
errAcc = close();
MojErrAccumulate(err, errAcc);
return err;
}
MojErr MojDbKind::openIndex(MojDbIndex* index, MojDbReq& req)
{
MojAssert(index);
MojAssert(m_db);
MojLogTrace(s_log);
// construct storage index name
MojString name;
MojErr err = name.format(_T("%s-%d-%s"), m_name.data(), m_version, index->name().data());
MojErrCheck(err);
// get id
MojObject id;
bool created = false;
err = m_state->indexId(index->name(), req, id, created);
MojErrCheck(err);
// open
MojRefCountedPtr<MojDbStorageIndex> storageIndex;
err = m_db->openIndex(id, req.txn(), storageIndex);
MojErrCheck(err);
err = index->open(storageIndex.get(), id, req, created);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDb::configure(const MojObject& conf)
{
MojLogTrace(s_log);
MojThreadWriteGuard guard(m_schemaLock);
MojErr err = requireNotOpen();
MojErrCheck(err);
bool found = false;
MojObject dbConf;
if (conf.get(ConfKey, dbConf)) {
err = dbConf.get(_T("storageEngine"), m_engineName, found);
MojErrCheck(err);
found = dbConf.get(_T("purgeWindow"), m_purgeWindow);
if (!found) {
m_purgeWindow = PurgeNumDaysDefault;
}
found = dbConf.get(_T("loadStepSize"), m_loadStepSize);
if (!found) {
m_loadStepSize = LoadStepSizeDefault;
}
m_conf = dbConf;
}
return MojErrNone;
}
MojErr MojService::dispatchRequest(MojServiceMessage* msg)
{
MojAssert(msg);
MojAssertMutexUnlocked(m_mutex);
MojLogTrace(s_log);
// get payload
MojObject payload;
MojErr reqErr;
MojErr err = reqErr = msg->payload(payload);
MojErrCatchAll(err) {
return msg->replyError(reqErr);
}
// get callback
Category* category = msg->serviceCategory();
MojAssert(category);
MojAssert(category && category->m_service == this);
// invoke
err = reqErr = category->m_handler->invoke(msg->method(), msg, payload);
MojErrCatchAll(err) {
MojString payloadStr;
(void) payload.toJson(payloadStr);
MojString errStr;
(void) MojErrToString(reqErr, errStr);
MojLogError(s_log, _T("%s (%d) - sender='%s' method='%s' payload='%s'"),
errStr.data(), (int) reqErr, msg->senderName(), msg->method(), payloadStr.data());
if (msg->numReplies() == 0) {
return msg->replyError(reqErr);
}
}
if (msg->numReplies() == 0 && msg->hasData()) {
return msg->reply();
}
return MojErrNone;
}
