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;
}
