ScriptPromise Cache::put(ScriptState* scriptState, const String& requestString, Response* response, ExceptionState& exceptionState)
{
Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
if (exceptionState.hadException())
return ScriptPromise();
return putImpl(scriptState, request, response);
}
MessageBuffer& MessageBuffer::put(const void* data, uint32_t len)
{
MX_ASSERT(NULL != data && len > 0);
MX_ASSERT(len <= writable());
return putImpl(data, len);
}
MessageBuffer& MessageBuffer::put(uint64_t value)
{
MX_ASSERT(writable() >= sizeof(value));
uint64_t orderValue = ByteOrder::NATIVE_ORDER.toOrder(value, byteOrder_);
return putImpl(&orderValue, sizeof(orderValue));
}
// buildTrie() - The Trie node structure is needed. Create it from the data that was
// saved at the time the ZoneStringFormatter was created. The Trie is only
// needed for parsing operations, which are less common than formatting,
// and the Trie is big, which is why its creation is deferred until first use.
void TextTrieMap::buildTrie(UErrorCode &status) {
umtx_lock(&TextTrieMutex);
if (fLazyContents != NULL) {
for (int32_t i=0; i<fLazyContents->size(); i+=2) {
const UChar *key = (UChar *)fLazyContents->elementAt(i);
void *val = fLazyContents->elementAt(i+1);
UnicodeString keyString(TRUE, key, -1); // Aliasing UnicodeString constructor.
putImpl(keyString, val, status);
}
delete fLazyContents;
fLazyContents = NULL;
}
umtx_unlock(&TextTrieMutex);
}
MojErr MojDb::updateState(const MojChar* key, const MojObject& val, MojDbReq& req)
{
MojLogTrace(s_log);
MojObject obj;
MojErr err = obj.putString(IdKey, DbStateObjId);
MojErrCheck(err);
err = obj.putString(KindKey, MojDbKindEngine::DbStateId);
MojErrCheck(err);
err = obj.put(key, val);
MojErrCheck(err);
err = putImpl(obj, FlagMerge, req);
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDb::put(MojObject* begin, const MojObject* end, MojUInt32 flags, MojDbReqRef req)
{
MojAssert(begin || begin == end);
MojAssert(end >= begin);
MojLogTrace(s_log);
MojErr err = beginReq(req);
MojErrCheck(err);
for (MojObject* i = begin; i != end; ++i) {
err = putImpl(*i, flags, req);
MojErrCheck(err);
}
err = req->end();
MojErrCheck(err);
return MojErrNone;
}
MojErr MojDb::loadImpl(MojObject& obj, MojUInt32 flags, MojDbReq& req)
{
bool found = false;
MojString kindName;
MojErr err = obj.get(MojDb::KindKey, kindName, found);
MojErrCheck(err);
if (!found)
MojErrThrow(MojErrDbKindNotSpecified);
bool deleted = false;
obj.get(MojDb::DelKey, deleted);
// when loading objects, if the object is deleted, call delKind/del
// otherwise, call putKind, putPermissions or put depending on the kind
if (deleted) {
MojObject id;
if (obj.get(MojDbServiceDefs::IdKey, id)) {
if (kindName.startsWith(MojDbKindEngine::KindKindIdPrefix)) {
err = delKind(id, found, flags, req);
MojErrCheck(err);
} else {
err = del(id, found, flags, req);
MojErrCheck(err);
}
}
} else {
if (kindName.startsWith(MojDbKindEngine::KindKindIdPrefix)) {
err = putKind(obj, flags, req);
MojErrCheck(err);
} else if (kindName.startsWith(MojDbKindEngine::PermissionIdPrefix)) {
err = putPermissions(&obj, &obj + 1, req);
MojErrCatch(err, MojErrDbKindNotRegistered); // kind may not have been backed up
MojErrCheck(err);
} else {
err = putImpl(obj, flags, req, false /*checkSchema*/);
MojErrCatch(err, MojErrDbKindNotRegistered); // kind may not have been backed up
MojErrCheck(err);
}
}
return MojErrNone;
}
MojErr MojDb::putKind(MojObject& obj, MojUInt32 flags, MojDbReqRef req)
{
MojErr err = beginReq(req, true);
MojErrCheck(err);
// get id
MojString id;
err = obj.getRequired(MojDbServiceDefs::IdKey, id);
MojErrCheck(err);
MojLogInfo(s_log, _T("putKind: %s \n"), id.data());
MojLogWarning(s_log, _T("putKind: %s \n"), id.data());
// set _kind and _id
err = obj.putString(KindKey, MojDbKindEngine::KindKindId);
MojErrCheck(err);
MojString dbId;
err = formatKindId(id, dbId);
MojErrCheck(err);
err = obj.putString(IdKey, dbId);
MojErrCheck(err);
// put the object
MojDbAdminGuard guard(req);
err = putImpl(obj, flags | FlagForce, req);
MojErrCheck(err);
guard.unset();
// attempt the putKind
MojErr errAcc = m_kindEngine.putKind(obj, req);
MojErrAccumulate(err, errAcc);
err = commitKind(id, req, err);
MojErrCheck(err);
return MojErrNone;
}
ScriptPromise Cache::put(ScriptState* scriptState, Request* request, Response* response)
{
return putImpl(scriptState, request, response);
}
std::ostream& DerivedClassification::put(std::ostream& os) const
{
putImpl("Security Extensions", securityExtensions, os);
os << "DES Version: " << desVersion << "\n";
putImpl("Create Date", &createDate, os);
putImpl("Complies With", compliesWith, os);
os << "Level: " << classification << "\n";
putImpl("Owner/producer", ownerProducer, os);
putImpl("SCI Controls", sciControls, os);
putImpl("SAR Identifier", sarIdentifier, os);
putImpl("Dissemination Controls", disseminationControls, os);
putImpl("FGI Source Open", fgiSourceOpen, os);
putImpl("FGI Source Protected", fgiSourceProtected, os);
putImpl("Releasable To", releasableTo, os);
putImpl("Non IC Markings", nonICMarkings, os);
os << "Classified By: " << classifiedBy
<< "\nCompilation Reason: " << compilationReason
<< "\nDerivatively Classified By: " << derivativelyClassifiedBy
<< "\nClassification Reason: " << classificationReason << "\n";
putImpl("Non US Controls", nonUSControls, os);
os << "Derived From: " << derivedFrom << "\n";
putImpl("Declass Date", declassDate.get(), os);
os << "Declass Event: " << declassEvent
<< "\nDeclass Exception: " << declassException
<< "\nExempted Source Type: " << exemptedSourceType << "\n";
putImpl("Exempted Source Date", exemptedSourceDate.get(), os);
return os;
}
MojErr MojDb::purge(MojUInt32& countOut, MojInt64 numDays, MojDbReqRef req)
{
MojLogTrace(s_log);
countOut = 0;
if (numDays <= -1) {
numDays = m_purgeWindow;
}
MojErr err = beginReq(req);
MojErrCheck(err);
MojLogDebug(s_log, _T("purging objects deleted more than %lld days ago..."), numDays);
MojTime time;
err = MojGetCurrentTime(time);
MojErrCheck(err);
// store the revision number to current timestamp mapping
MojObject revTimeMapping;
MojInt64 rev;
err = nextId(rev);
MojErrCheck(err);
err = revTimeMapping.put(RevNumKey, rev);
MojErrCheck(err);
err = revTimeMapping.put(TimestampKey, time.microsecs());
MojErrCheck(err);
err = revTimeMapping.putString(KindKey, MojDbKindEngine::RevTimestampId);
MojErrCheck(err);
err = putImpl(revTimeMapping, MojDb::FlagNone, req);
MojErrCheck(err);
// find the revision number for numDays prior to now
MojInt64 purgeTime = time.microsecs() - (MojTime::UnitsPerDay * numDays);
MojDbQuery query;
err = query.from(MojDbKindEngine::RevTimestampId);
MojErrCheck(err);
query.limit(1);
err = query.where(TimestampKey, MojDbQuery::OpLessThanEq, purgeTime);
MojErrCheck(err);
err = query.order(TimestampKey);
MojErrCheck(err);
query.desc(true);
MojDbCursor cursor;
err = findImpl(query, cursor, NULL, req, OpDelete);
MojErrCheck(err);
bool found = false;
MojObject obj;
err = cursor.get(obj, found);
MojErrCheck(err);
err = cursor.close();
MojErrCheck(err);
MojUInt32 batchCount = 0;
MojUInt32 totalCount = 0;
while ((found))
{
// Do it in AutoBatchSize batches
batchCount = 0;
req->fixmode(true); // purge even if index mis-matches
err = purgeImpl(obj, batchCount, req);
MojLogDebug(s_log, _T("purge batch processed: batch: %d; total: %d; err = %d\n"),
batchCount, (totalCount + batchCount), err);
MojErrCheck(err);
totalCount += batchCount;
countOut = totalCount;
if (batchCount < AutoBatchSize) // last batch
break;
err = commitBatch(req);
MojErrCheck(err);
continue;
}
// end request
err = req->end();
MojErrCheck(err);
MojLogDebug(s_log, _T("purged %d objects"), countOut);
return MojErrNone;
}
