void Start(MockBusClient& busClient, MojRefCountedPtr<ActivitySet>& actSet)
{
MockDoneSlot startSlot;
actSet->StartActivities(startSlot.GetSlot());
busClient.ProcessRequests();
ASSERT_TRUE( startSlot.Called() );
}
MojErr MojDbQuotaEngine::initUsage(MojDbKind* kind, MojDbReq& req)
{
MojAssert(kind);
MojRefCountedPtr<MojDbStorageItem> item;
MojErr err = m_usageDb->get(kind->id(), req.txn(), false, item);
MojErrCheck(err);
if (!item.get()) {
MojObject stats;
MojSize usage = 0;
err = kind->stats(stats, usage, req, false);
MojErrCheck(err);
err = insertUsage(kind->id(), (MojInt64) usage, req.txn());
MojErrCheck(err);
}
return MojErrNone;
}
MojErr sendEcho(const MojChar* json, const MojObject& expectedResponse, const MojChar* method)
{
MojRefCountedPtr<EchoResponseHdlr> handler(new EchoResponseHdlr(expectedResponse, ++m_pendingResponseCount));
MojAllocCheck(handler.get());
MojRefCountedPtr<MojServiceRequest> req;
MojErr err = m_service.createRequest(req);
MojTestErrCheck(err);
MojObject payload;
err = payload.fromJson(json);
MojTestErrCheck(err);
err = req->send(handler->m_slot, ServiceName, method, payload);
MojTestErrCheck(err);
return MojErrNone;
}
void End(MockBusClient& busClient, MojRefCountedPtr<ActivitySet>& actSet)
{
MockDoneSlot endSlot;
actSet->EndActivities(endSlot.GetSlot());
busClient.ProcessRequests();
ASSERT_TRUE( endSlot.Called() );
}
MojErr MojDbKindState::writeTokens(const MojObject& tokensObj)
{
MojAssert(m_kindEngine);
MojAssertMutexLocked(m_lock);
MojDbStorageDatabase* db = m_kindEngine->kindDb();
MojRefCountedPtr<MojDbStorageTxn> txn;
MojErr err = db->beginTxn(txn);
MojErrCheck(err);
MojAssert(txn.get());
err = writeObj(TokensKey, tokensObj, db, txn.get(), m_oldTokensItem);
MojErrCheck(err);
err = txn->commit();
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbKindState::readObj(const MojChar* key, MojObject& val, MojDbStorageDatabase* db,
MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageItem>& oldItem)
{
MojAssert(key && db);
MojErr err = db->get(m_kindId, txn, false, oldItem);
MojErrCheck(err);
if (oldItem.get()) {
// get objects
MojObject obj;
// TODO: this bugging ( on calling getObj)
err = oldItem->toObject(obj, *m_kindEngine, false);
MojErrCheck(err);
obj.get(key, val);
}
return MojErrNone;
}
MojErr MojDb::getImpl(const MojObject& id, MojObjectVisitor& visitor, MojDbOp op, MojDbReq& req)
{
MojRefCountedPtr<MojDbStorageItem> item;
MojErr err = m_objDb->get(id, req.txn(), false, item);
MojErrCheck(err);
if (item.get()) {
MojString kindId;
err = item->kindId(kindId, m_kindEngine);
MojErrCheck(err);
err = m_kindEngine.checkPermission(kindId, op, req);
MojErrCheck(err);
err = item->visit(visitor, m_kindEngine);
MojErrCheck(err);
err = item->close();
MojErrCheck(err);
}
return MojErrNone;
}
MojErr MojDbTestStorageEngine::openSequence(const MojChar* name, MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageSeq>& seqOut)
{
MojErr err = checkErrMap(_T("engine.openSequence"));
MojErrCheck(err);
MojAssert(name && !seqOut.get());
//open the actual storage sequence
MojAssert(m_engine.get());
MojRefCountedPtr<MojDbStorageSeq> realSeq;
err = m_engine->openSequence(name, MojTestTxn(txn), realSeq);
MojErrCheck(err);
//create the test storage seq as a wrapper
MojRefCountedPtr<MojDbTestStorageSeq> seq(new MojDbTestStorageSeq(realSeq.get(), this));
MojAllocCheck(seq.get());
seqOut = seq;
return MojErrNone;
}
MojErr MojDbSandwichEngine::beginTxn(MojRefCountedPtr<MojDbStorageTxn>& txnOut)
{
MojAssert(!txnOut.get());
MojRefCountedPtr<MojDbSandwichEnvTxn> txn(new MojDbSandwichEnvTxn(m_db));
MojAllocCheck(txn.get());
txnOut = txn;
return MojErrNone;
}
MojErr MojDbTestStorageIndex::find(MojAutoPtr<MojDbQueryPlan> plan, MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageQuery>& queryOut)
{
MojErr err = m_testEngine->checkErrMap(_T("index.find"));
MojErrCheck(err);
MojAssert(m_idx.get());
MojAssert(plan.get());
//create the real query
MojRefCountedPtr<MojDbStorageQuery> realQuery;
err = m_idx->find(plan, MojTestTxn(txn), realQuery);
MojErrCheck(err);
MojRefCountedPtr<MojDbTestStorageQuery> storageQuery(new MojDbTestStorageQuery(realQuery.get(), m_testEngine));
MojAllocCheck(storageQuery.get());
queryOut = storageQuery;
return MojErrNone;
}
MojErr MojDbTestStorageIndex::beginTxn(MojRefCountedPtr<MojDbStorageTxn>& txnOut)
{
MojErr err = m_testEngine->checkErrMap(_T("index.beginTxn"));
MojErrCheck(err);
MojAssert(m_idx.get());
//create the real transaction
MojRefCountedPtr<MojDbStorageTxn> realTxn;
err = m_idx->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 MojDbTestStorageEngine::openDatabase(const MojChar* name, MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageDatabase>& dbOut)
{
MojErr err = checkErrMap(_T("engine.openDatabase"));
MojErrCheck(err);
MojAssert(name && !dbOut.get());
//open the actual storage database
MojAssert(m_engine.get());
MojRefCountedPtr<MojDbStorageDatabase> realDb;
err = m_engine->openDatabase(name, MojTestTxn(txn), realDb);
MojErrCheck(err);
//create the test storage db as a wrapper
MojRefCountedPtr<MojDbTestStorageDatabase> db(new MojDbTestStorageDatabase(realDb.get(), this));
MojAllocCheck(db.get());
dbOut = db;
return MojErrNone;
}
void ImapSession::Connected(const MojRefCountedPtr<SocketConnection>& connection)
{
m_connection = connection;
if(connection.get()) {
m_inputStream = connection->GetInputStream();
m_outputStream = connection->GetOutputStream();
m_closedSlot.cancel(); // make sure it's not connected to a slot
m_connection->WatchClosed(m_closedSlot);
if(NeedLoginCapabilities()) {
CheckLoginCapabilities();
} else {
LoginCapabilityComplete();
}
} else {
CheckQueue();
}
}
MojErr MojDbSandwichEngine::beginTxn(MojRefCountedPtr<MojDbStorageTxn>& txnOut)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(!txnOut.get());
MojRefCountedPtr<MojDbSandwichEnvTxn> txn(new MojDbSandwichEnvTxn(m_db));
MojAllocCheck(txn.get());
txnOut = txn;
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 MojDbTestStorageEngine::beginTxn(MojRefCountedPtr<MojDbStorageTxn>& txnOut)
{
MojErr err = checkErrMap(_T("engine.beginTxn"));
MojErrCheck(err);
MojAssert(m_engine.get());
MojAssert(!txnOut.get());
//create the real transaction
MojRefCountedPtr<MojDbStorageTxn> realTxn;
err = m_engine->beginTxn(realTxn);
MojErrCheck(err);
//create a test txn wrapper around the real txn
MojRefCountedPtr<MojDbTestStorageTxn> txn(new MojDbTestStorageTxn(realTxn.get(), this));
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;
}
void ImapSession::DownloadPart(const MojObject& folderId, const MojObject& emailId, const MojObject& partId, const MojRefCountedPtr<DownloadListener>& listener, Command::Priority priority)
{
MojRefCountedPtr<FetchPartCommand> command(new FetchPartCommand(*this, folderId, emailId, partId, priority));
// Look for an active command
MojRefCountedPtr<ImapCommand> activeCommand = FindActiveCommand(command);
if(activeCommand.get()) {
MojLogDebug(m_log, "attaching download request to existing active command");
if(listener.get())
static_cast<FetchPartCommand*>(activeCommand.get())->AddDownloadListener(listener);
return;
}
// Look for a pending command with equal or higher priority
// TODO: requeue if a higher priority is needed
MojRefCountedPtr<ImapCommand> pendingCommand = FindPendingCommand(command);
if(pendingCommand.get() && pendingCommand->GetPriority() >= priority) {
MojLogDebug(m_log, "attaching download request to existing pending command");
if(listener.get())
static_cast<FetchPartCommand*>(pendingCommand.get())->AddDownloadListener(listener);
// Poke the queue in case it's not already running
CheckQueue();
return;
}
// Otherwise, use the new command
if(listener.get())
command->AddDownloadListener(listener);
// If this is a high priority request, set m_recentUserInteraction to true
if (priority >= Command::HighPriority) {
m_recentUserInteraction = true;
}
m_commandManager->QueueCommand(command, false);
CheckQueue();
}
MojErr MojDbLunaServiceDb::openDb(MojDbEnv* env, const MojChar* dir, const MojObject& conf)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(env && dir);
MojErr err;
// MojRefCountedPtr<MojDbBerkeleyEngine> engine(new MojDbBerkeleyEngine);
MojRefCountedPtr<MojDbStorageEngine> engine;
MojDbStorageEngine::engineFactory()->create(engine);
MojAllocCheck(engine.get());
err = engine->configure(conf);
MojErrCheck(err);
err = engine->open(dir, env);
MojErrCheck(err);
// open db
err = m_db.open(dir, engine.get());
MojErrCheck(err);
return MojErrNone;
}
MojErr DbPermissionsConfigurator::ProcessConfig(const string& filePath, MojObject& permissions)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
std::string owner;
MojObject perms;
owner = ParentId(filePath);
MojErr err = perms.put("permissions", permissions);
MojErrCheck(err);
// for third-party packages, we set the appid on the service request
// so that mojodb does things correctly. root config files aren't split up
// in a per-service/app directory way (though they should be like activitymanager)
MojRefCountedPtr<MojServiceRequest> request;
if (!owner.empty())
request = m_busClient.CreateRequest(owner.c_str());
else
request = m_busClient.CreateRequest();
return request->send(CreateCallback(filePath)->m_slot, ServiceName(), MOJODB_PUTPERMISSIONS_METHOD, perms);
}
// Cleanup sync sessions and activities
// Part of State_Cleanup
void ImapSession::CleanupAfterDisconnect()
{
if(m_client.get() && !m_client->DisableAccountInProgress()) {
MojRefCountedPtr<SyncSession> syncSession = m_client->GetSyncSession(m_folderId);
if(syncSession.get()) {
MojLogInfo(m_log, "stopping sync session after disconnect");
// Indicate that the sync session may need to schedule a retry.
// This will probably get ignored if the sync session is already ending (successful or not).
syncSession->SetQueueStopped();
// Stop the sync session
syncSession->RequestStop(m_syncSessionDoneSlot);
} else {
// Schedule push, if necessary
SchedulePush();
}
} else {
EndActivities();
}
}
MojErr MojDbBerkeleyEngine::beginTxn(MojRefCountedPtr<MojDbStorageTxn>& txnOut)
{
MojAssert(!txnOut.get());
MojLogTrace(MojDbBerkeleyEngine::s_log);
MojRefCountedPtr<MojDbBerkeleyTxn> txn(new MojDbBerkeleyTxn());
MojAllocCheck(txn.get());
MojErr err = txn->begin(this);
MojErrCheck(err);
txnOut = txn;
return MojErrNone;
}
MojErr MojDbIndex::createExtractor(const MojObject& propObj, MojRefCountedPtr<MojDbExtractor>& extractorOut)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(!isOpen());
// type
MojString type;
bool found = false;
MojErr err = propObj.get(TypeKey, type, found);
MojErrCheck(err);
if (found && type == MultiKey) {
extractorOut.reset(new MojDbMultiExtractor);
MojAllocCheck(extractorOut.get());
} else {
extractorOut.reset(new MojDbPropExtractor);
MojAllocCheck(extractorOut.get());
}
err = extractorOut->fromObject(propObj, m_locale);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDbTestStorageEnv::openStorage(MojRefCountedPtr< MojDbStorageEngine >& storage)
{
MojErr err;
MojRefCountedPtr<MojDbStorageEngine> parentEngine;
err = m_env->openStorage(parentEngine);
MojErrCheck(err);
MojRefCountedPtr<MojDbTestStorageEnv> thiz(this);
storage.reset(new MojDbTestStorageEngine(thiz, parentEngine));
return MojErrNone;
}
/*
* 1. get account details from accountservices or db?
*/
MojErr OnEnabledHandler::start(const MojObject& payload)
{
IMServiceHandler::logMojObjectJsonString(_T("OnEnabledHandler payload: %s"), payload);
MojString accountId;
MojErr err = payload.getRequired(_T("accountId"), accountId);
if (err != MojErrNone) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler accountId missing so bailing. error %d"), err);
return err;
}
err = payload.getRequired(_T("enabled"), m_enable);
if (err != MojErrNone) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler enabled missing, assuming 'false'"));
m_enable = false;
}
err = payload.getRequired(_T("capabilityProviderId"), m_capabilityProviderId);
if (err != MojErrNone) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler capabilityProviderId missing so bailing. error %d"), err);
return err;
}
MojRefCountedPtr<MojServiceRequest> req;
err = m_service->createRequest(req);
if (err != MojErrNone) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::start createRequest failed. error %d"), err);
} else {
MojObject params;
params.put(_T("accountId"), accountId);
err = req->send(m_getAccountInfoSlot, "com.palm.service.accounts", "getAccountInfo", params, 1);
if (err) {
MojLogError(IMServiceApp::s_log, _T("OnEnabledHandler::start: getAccountInfo id %s failed. error %d"), accountId.data(), err);
}
}
return MojErrNone;
}
MojErr MojDbLevelDatabase::openIndex(const MojObject& id, MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageIndex>& indexOut)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
MojAssert(!indexOut.get());
MojRefCountedPtr<MojDbLevelIndex> index(new MojDbLevelIndex());
MojAllocCheck(index.get());
MojErr err = index->open(id, this, txn);
MojErrCheck(err);
indexOut = index;
return MojErrNone;
}
MojErr MojDbBerkeleyEngine::openSequence(const MojChar* name, MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageSeq>& seqOut)
{
MojAssert(name && !seqOut.get());
MojLogTrace(MojDbBerkeleyEngine::s_log);
MojRefCountedPtr<MojDbBerkeleySeq> seq(new MojDbBerkeleySeq());
MojAllocCheck(seq.get());
MojErr err = seq->open(name, m_seqDb.get());
MojErrCheck(err);
seqOut = seq;
return MojErrNone;
}
ConnectionState::ConnectionStateHandler::ConnectionStateHandler(MojService* service, ConnectionState* connState)
: m_connMgrSubscriptionSlot(this, &ConnectionState::ConnectionStateHandler::connectionManagerResult),
m_service(service),
m_connState(connState),
m_receivedResponse(false)
{
MojLogInfo(IMServiceApp::s_log, "ConnectionStateHandler constructor");
MojRefCountedPtr<MojServiceRequest> req;
MojErr err = m_service->createRequest(req);
if (err)
{
MojLogError(IMServiceApp::s_log, _T("ConnectionStateHandler: create request failed"));
}
else
{
MojObject params;
params.put("subscribe", true);
params.put("start", true);
params.put("detailedEvents", true); // This tells activitymanager to send us updates whenever the trigger changes
const char* activityJson =
"{\"name\":\"Libpurple connection watch\","
"\"description\":\"Libpurple connection watch\","
// Need immediate:true to prevent blocking other low priority activities from running
"\"type\": {\"immediate\": true, \"priority\": \"low\"},"
"\"requirements\":{\"internet\":true}"
"}";
MojObject activity;
activity.fromJson(activityJson);
params.put("activity", activity);
err = req->send(m_connMgrSubscriptionSlot, "com.palm.activitymanager","create", params, MojServiceRequest::Unlimited);
if (err)
{
MojLogError(IMServiceApp::s_log, _T("ConnectionStateHandler send request failed"));
}
}
}
MojErr MojDbBerkeleyEngine::openDatabase(const MojChar* name, MojDbStorageTxn* txn, MojRefCountedPtr<MojDbStorageDatabase>& dbOut)
{
MojAssert(name && !dbOut.get());
MojLogTrace(MojDbBerkeleyEngine::s_log);
MojRefCountedPtr<MojDbBerkeleyDatabase> db(new MojDbBerkeleyDatabase());
MojAllocCheck(db.get());
bool created = false;
MojErr err = db->open(name, this, created, txn);
MojErrCheck(err);
dbOut = db;
return MojErrNone;
}
void SmtpSyncOutboxCommand::AttachAdoptedActivity(MojRefCountedPtr<Activity> activity, const MojString& activityId, const MojString& activityName)
{
MojLogInfo(m_log, "Attaching adopted activity, incoming activityId=%s, name=%s. WatchActivityName=%s"
, activityId.data(), activityName.data(), m_outboxWatchActivityName.data());
if (activityName == m_outboxWatchActivityName) {
if(m_outboxWatchActivity.get() && activity.get()) {
MojLogWarning(m_log, "%s: outbox activity already attached; replacing activity %s with %s", __PRETTY_FUNCTION__, AsJsonString(m_outboxWatchActivity->GetActivityId()).c_str(), AsJsonString(activity->GetActivityId()).c_str());
}
m_outboxWatchActivity = activity;
} else if (activityName == m_accountWatchActivityName) {
if(m_accountWatchActivity.get() && activity.get()) {
MojLogWarning(m_log, "%s: account watch activity already attached; replacing activity %s with %s", __PRETTY_FUNCTION__, AsJsonString(m_accountWatchActivity->GetActivityId()).c_str(), AsJsonString(activity->GetActivityId()).c_str());
}
m_accountWatchActivity = activity;
} else {
m_manualActivities.push_back( activity );
}
m_networkStatus->ParseActivity(activity);
}
