MojErr MojDbServiceHandler::handleDelKind(MojServiceMessage* msg, MojObject& payload, MojDbReq& req) { MojAssert(msg); MojLogTrace(s_log); MojObject id; MojErr err = payload.getRequired(MojDbServiceDefs::IdKey, id); MojErrCheck(err); bool found = false; err = m_db.delKind(id, found, MojDb::FlagNone, req); MojErrCheck(err); if (!found) MojErrThrow(MojErrDbKindNotRegistered); err = msg->replySuccess(); MojErrCheck(err); return MojErrNone; }
MojErr MojDbMultiExtractor::vals(const MojObject& obj, KeySet& valsOut) const { LOG_TRACE("Entering function %s", __FUNCTION__); // extract property values for (ExtractorVec::ConstIterator i = m_extractors.begin(); i != m_extractors.end(); ++i) { MojErr err = (*i)->vals(obj, valsOut); MojErrCheck(err); } return MojErrNone; }
MojErr MojDbPropExtractor::updateLocale(const MojChar* locale) { LOG_TRACE("Entering function %s", __FUNCTION__); if (m_collation != MojDbCollationInvalid) { if(m_tokenizer.get()) { m_tokenizer.reset(new MojDbTextTokenizer()); MojAllocCheck(m_tokenizer.get()); MojErr err = m_tokenizer->init(locale); MojErrCheck(err); } m_collator.reset(new MojDbTextCollator()); MojAllocCheck(m_collator.get()); MojErr err = m_collator->init(locale, m_collation); MojErrCheck(err); } return MojErrNone; }
MojErr MojService::addRequest(MojServiceRequest* req) { MojAssert(req); MojAssertMutexLocked(m_mutex); MojLogTrace(s_log); MojErr err = m_requests.put(req->token(), req); MojErrCheck(err); return MojErrNone; }
MojErr MojService::removeSubscription(MojServiceMessage* msg) { MojAssert(msg); MojAssertMutexUnlocked(m_mutex); MojLogTrace(s_log); SubscriptionKey key; MojErr err = key.init(msg); MojErrCheck(err); MojThreadGuard guard(m_mutex); bool found = false; err = m_subscriptions.del(key, found); MojErrCheck(err); MojAssert(found); err = removeSubscriptionImpl(msg); MojErrCheck(err); return MojErrNone; }
MojErr MojDbKindState::indexId(const MojChar* indexName, MojDbReq& req, MojObject& idOut, bool& createdOut) { MojAssert(indexName); MojThreadGuard guard(m_lock); MojErr err = id(indexName, IndexIdsKey, req, idOut, createdOut); MojErrCheck(err); return MojErrNone; }
MojErr MojDbKindState::addToken(const MojChar* propName, MojUInt8& tokenOut, TokenVec& vecOut, MojObject& tokenObjOut) { MojAssert(propName); MojThreadGuard guard(m_lock); MojErr err = addPropImpl(propName, true, tokenOut, vecOut, tokenObjOut); MojErrCheck(err); return MojErrNone; }
MojErr MojDbKind::updateIndexes(const MojObject* newObj, const MojObject* oldObj, const MojDbReq& req, MojDbOp op, MojVector<MojDbKind*>& kindVec, MojInt32& idxcount) { MojErr err = kindVec.push(this); MojErrCheck(err); // update supers for (KindVec::ConstIterator i = m_supers.begin(); i != m_supers.end(); ++i) { if (kindVec.find((*i), 0) == MojInvalidIndex) { err = (*i)->updateIndexes(newObj, oldObj, req, op, kindVec, idxcount); MojErrCheck(err); } else { return MojErrNone; } } err = updateOwnIndexes(newObj, oldObj, req, idxcount); MojErrCheck(err); return MojErrNone; }
MojErr MojDbKind::clearSupers() { MojLogTrace(s_log); // remove old supers MojErr err = MojErrNone; for (KindVec::ConstIterator i = m_supers.begin(); i != m_supers.end(); ++i) { err = (*i)->removeKind((*i)->m_subs, this); MojErrCheck(err); } m_supers.clear(); // remove old subs for (KindVec::ConstIterator i = m_subs.begin(); i != m_subs.end(); ++i) { err = (*i)->removeKind((*i)->m_supers, this); MojErrCheck(err); } m_subs.clear(); return MojErrNone; }
MojErr MojDbKind::checkPermission(MojDbOp op, MojDbReq& req) { // if this request has admin privileges, skip the permissions check if (hasOwnerPermission(req)) return MojErrNone; if (op == OpKindUpdate) { MojErr err = deny(req); MojErrCheck(err); } else { // check if permissions are set on this kind const MojChar* opStr = stringFromOperation(op); MojDbPermissionEngine::Value val = objectPermission(opStr, req); if (val != MojDbPermissionEngine::ValueAllow) { MojErr err = deny(req); MojErrCheck(err); } } return MojErrNone; }
MojErr MojServiceMessage::handleCancel() { MojAssert(m_service); if (m_subscribed) { MojErr err = m_service->removeSubscription(this); MojErrCheck(err); m_subscribed = false; } return MojErrNone; }
MojErr MojServiceMessage::replyError(MojErr code, const MojChar* text) { MojAssert(code != MojErrNone && text); MojObject payload; MojErr err = payload.putBool(ReturnValueKey, false); MojErrCheck(err); err = payload.putInt(ErrorCodeKey, (MojInt64) code); MojErrCheck(err); err = payload.putString(ErrorTextKey, text); MojErrCheck(err); // reset the writer first, then reply with this payload err = writer().reset(); MojErrCheck(err); err = reply(payload); MojErrCheck(err); return MojErrNone; }
MojErr MojDb::drop(const MojChar* path) { MojAssert(path); MojLogTrace(s_log); MojErr err = requireOpen(); MojErrCheck(err); MojDbReq req; err = req.begin(this, true); MojErrCheck(err); err = m_storageEngine->drop(path, req.txn()); MojErrCheck(err); err = req.end(); MojErrCheck(err); err = close(); MojErrCheck(err); return MojErrNone; }
MojErr MojDb::checkDbVersion(const MojChar* path) { MojAssert(path); MojLogTrace(s_log); MojString version; MojString versionFileName; MojErr err = versionFileName.format(_T("%s/%s"), path, VersionFileName); MojErrCheck(err); err = MojFileToString(versionFileName, version); MojErrCatch(err, MojErrNotFound) { // if the version file is not found, create it // make sure the directory exists err = MojCreateDirIfNotPresent(path); MojErrCheck(err); err = version.format(_T("%lld"), DatabaseVersion); MojErrCheck(err); err = MojFileFromString(versionFileName, version); MojErrCheck(err); } else {
MojErr MojDbSearchCursor::count(MojUInt32& countOut) { LOG_TRACE("Entering function %s", __FUNCTION__); countOut = 0; MojErr err = begin(); MojErrCheck(err); countOut = m_count; return MojErrNone; }
MojErr MojObjectFilter::intValue(MojInt64 val) { MojAssert(m_visitor); if (m_state.m_includeCount) { m_state.m_includeCount--; MojErr err = m_visitor->intValue(val); MojErrCheck(err); } return MojErrNone; }
MojErr MojDbTestStorageDatabase::openIndex(const MojObject& id, MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageIndex>& indexOut) { MojErr err = m_testEngine->checkErrMap(_T("db.openIndex")); MojErrCheck(err); MojAssert(m_db.get()); MojAssert(!indexOut.get()); //open the actual storage index MojRefCountedPtr<MojDbStorageIndex> realIdx; err = m_db->openIndex(id, MojTestTxn(txn), realIdx); MojErrCheck(err); //create the test storage index as a wrapper MojRefCountedPtr<MojDbTestStorageIndex> index(new MojDbTestStorageIndex(realIdx.get(), m_testEngine)); MojAllocCheck(index.get()); indexOut = index; return MojErrNone; }
MojErr MojObjectFilter::nullValue() { MojAssert(m_visitor); if (m_state.m_includeCount) { m_state.m_includeCount--; MojErr err = m_visitor->nullValue(); MojErrCheck(err); } return MojErrNone; }
MojErr MojDbLevelQuery::seekImpl(const ByteVec& key, bool desc, bool& foundOut) { if (key.empty()) { // if key is empty, seek to beginning (or end if desc) MojErr err = getKey(foundOut, SeekEmptyFlags[desc]); MojErrCheck(err); } else { // otherwise seek to the key MojErr err = m_key.fromBytes(key.begin(), key.size()); MojErrCheck(err); err = getKey(foundOut, SeekFlags); MojErrCheck(err); // if descending, skip the first result (which is outside the range) if (desc) { err = next(foundOut); MojErrCheck(err); } } return MojErrNone; }
MojErr MojDbTestStorageDatabase::beginTxn(MojRefCountedPtr<MojDbStorageTxn>& txnOut) { MojErr err = m_testEngine->checkErrMap(_T("db.beginTxn")); MojErrCheck(err); MojAssert(m_db.get()); MojAssert(!txnOut.get()); //create the real transaction MojRefCountedPtr<MojDbStorageTxn> realTxn; err = m_db->beginTxn(realTxn); MojErrCheck(err); //create a test txn wrapper around the real txn MojRefCountedPtr<MojDbTestStorageTxn> txn(new MojDbTestStorageTxn(realTxn.get(), m_testEngine)); MojAllocCheck(txn.get()); txnOut = txn; return MojErrNone; }
MojErr MojDb::delImpl(const MojObject& id, bool& foundOut, MojObject& foundObjOut, MojDbReq& req, MojUInt32 flags) { MojLogTrace(s_log); foundObjOut.clear(); // get object, so we can find the type MojRefCountedPtr<MojDbStorageItem> item; MojErr err = m_objDb->get(id, req.txn(), true, item); MojErrCheck(err); if (item.get()) { // and delete it MojObject obj; err = item->toObject(obj, m_kindEngine); MojErrCheck(err); err = delObj(id, obj, item.get(), foundObjOut, req, flags); MojErrCheck(err); foundOut = true; } return MojErrNone; }
MojErr MojDb::get(const MojObject* idsBegin, const MojObject* idsEnd, MojObjectVisitor& visitor, MojDbReqRef req) { MojAssert(idsBegin || idsBegin == idsEnd); MojAssert(idsEnd >= idsBegin); MojLogTrace(s_log); MojErr err = beginReq(req); MojErrCheck(err); // do the gets for (const MojObject* i = idsBegin; i != idsEnd; ++i) { err = getImpl(*i, visitor, OpRead, req); MojErrCheck(err); } // commit txn err = req->end(); MojErrCheck(err); return MojErrNone; }
MojErr MojDb::merge(const MojDbQuery& query, const MojObject& props, MojUInt32& countOut, MojUInt32 flags, MojDbReqRef req) { MojLogTrace(s_log); countOut = 0; MojErr err = beginReq(req); MojErrCheck(err); MojDbCursor cursor; err = findImpl(query, cursor, NULL, req, OpUpdate); MojErrCheck(err); MojAssert(cursor.txn()); MojUInt32 count = 0; MojUInt32 warns = 0; bool found = false; MojObject prev; for (;;) { // get prev rev from cursor MojDbStorageItem* prevItem = NULL; err = cursor.get(prevItem, found); if (err == MojErrInternalIndexOnFind) { warns++; continue; } MojErrCheck(err); if (!found) break; err = prevItem->toObject(prev, m_kindEngine); MojErrCheck(err); // merge obj into prev MojObject merged; err = mergeInto(merged, props, prev); MojErrCheck(err); // and update the db const MojObject& id = prevItem->id(); err = putObj(id, merged, &prev, prevItem, req, OpUpdate); MojErrCheck(err); ++count; } if (warns > 0) MojLogWarning(s_log, _T("Merge index_warnings: %s; count: %d\n"), query.from().data(), warns); err = cursor.close(); MojErrCheck(err); err = req->end(); MojErrCheck(err); countOut = count; return MojErrNone; }
/*********************************************************************** * setPagePosition * * Move cursor position to page id provided in query. * 1. Find item "_id" which is equal to page id iteratively. * 2. If found, set begin/last position and next page. ***********************************************************************/ MojErr MojDbSearchCursor::setPagePosition() { LOG_TRACE("Entering function %s", __FUNCTION__); MojErr err; MojDbStorageItem* item; m_pos = m_items.begin(); ItemVec::ConstIterator last = m_items.end(); m_limitPos = last; // retrieve page id from query MojObject pageKey; err = m_page.toObject(pageKey); MojErrCheck(err); while (m_pos != last) { // retrieve id from query item = m_pos->get(); const MojObject id = item->id(); // If match, set begin/last position and next page if(pageKey.compare(id) == 0) { if (m_limit >= (last-m_pos)) { m_limitPos = m_items.end(); m_page.clear(); } else { m_limitPos = m_pos + m_limit; // set next page MojDbStorageItem* nextItem = m_limitPos->get(); const MojObject nextId = nextItem->id(); m_page.fromObject(nextId); // print log for nextId MojString strOut; err = nextId.toJson(strOut); MojErrCheck(err); LOG_DEBUG("[db_mojodb] nextId : %s \n", strOut.data()); } break; } ++m_pos; } return MojErrNone; }
MojErr MojDbTextUtils::strToUnicode(const MojString& src, UnicodeVec& destOut) { MojErr err = destOut.resize(src.length() * 2); MojErrCheck(err); MojInt32 destCapacity = 0; MojInt32 destLength = 0; do { UChar* dest = NULL; err = destOut.begin(dest); MojErrCheck(err); destCapacity = (MojInt32) destOut.size(); UErrorCode status = U_ZERO_ERROR; u_strFromUTF8(dest, destCapacity, &destLength, src.data(), (MojInt32) src.length(), &status); if (status != U_BUFFER_OVERFLOW_ERROR) MojUnicodeErrCheck(status); err = destOut.resize(destLength); MojErrCheck(err); } while (destLength > destCapacity); return MojErrNone; }
MojErr MojBuffer::release(MojAutoPtr<Chunk>& chunkOut) { MojErr err = consolidate(); MojErrCheck(err); MojAssert(m_chunks.size() <= 1); if (m_chunks.empty()) { chunkOut.reset(); } else { chunkOut.reset(m_chunks.popFront()); } return MojErrNone; }
MojErr MojObjectFilter::end(VisitorMethod method) { MojAssert(m_visitor); MojAssert(!m_stack.empty()); if (m_state.m_included) { MojErr err = (m_visitor->*method)(); MojErrCheck(err); } // save node so we can re-enter it in the next array element m_nextNode = m_state.m_node; // pop state m_state = m_stack.back(); MojErr err = m_stack.pop(); MojErrCheck(err); // decrement include count if (m_state.m_includeCount) m_state.m_includeCount--; return MojErrNone; }
MojErr MojSocketMessageEncoder::writeToBuffer(MojDataWriter& writer) { // initialize header MojSocketMessageHeader header(m_msg); if (header.messageLen() > MojSocketMessageHeader::s_maxMsgSize) { MojErrThrow(MojErrInvalidMsg); } // reserve buffer space MojSize reserve = header.messageLen() + sizeof(header); MojErr err = writer.reserve(reserve); MojErrCheck(err); // write header and message to buffer err = header.write(writer); MojErrCheck(err); err = m_msg.serialize(writer); MojErrCheck(err); return MojErrNone; }
MojErr ActivityManagerApp::ready() { LOG_AM_DEBUG("%s ready to accept incoming requests", name().data()); /* All stored Activities have been deserialized from the database. All * previously persisted Activity IDs are marked as used. It's safe to * accept requests. Bring up the Service side interface! */ MojErr err = online(); MojErrCheck(err); /* Activity Manager prepared to accept requests at this point, but not * to allow Activities to move into the scheduled state where their * outcalls are made. */ #ifndef WEBOS_TARGET_MACHINE_IMPL_SIMULATOR /* Engage the Luna Bus Proxy, start mapping services */ m_busProxy->Enable(); #endif /* Start up the various requirement management proxy connections now, * so they don't start a storm of requests once the UI is up. */ m_requirementManager->Enable(); /* Subscribe to timezone notifications. */ m_scheduler->Enable(); #if !defined(WEBOS_TARGET_MACHINE_IMPL_SIMULATOR) char *upstart_job = getenv("UPSTART_JOB"); if (upstart_job) { char *upstart_event = g_strdup_printf("/sbin/initctl emit %s-ready", upstart_job); if (upstart_event) { int retVal = ::system(upstart_event); if (retVal == -1) { LOG_AM_ERROR(MSGID_UPSTART_EMIT_FAIL,0, "ServiceApp: Failed to emit upstart event"); } g_free(upstart_event); } else { LOG_AM_ERROR(MSGID_UPSTART_EMIT_ALLOC_FAIL,0, "ServiceApp: Failed to allocate memory for upstart emit"); } } #endif #if defined(WEBOS_TARGET_MACHINE_IMPL_SIMULATOR) /* SystemManagerProxy not instantiated, so mark the UI as enabled */ m_am->Enable(ActivityManager::UI_ENABLE); #endif return MojErrNone; }
MojErr MojPrintF(const MojChar* format, ...) { MojAssert(format); va_list args; va_start (args, format); MojErr err = MojVPrintF(format, args); va_end(args); MojErrCheck(err); return MojErrNone; }