/* ****************************************************************************
*
* mongoNofityContextAvailability -
*/
HttpStatusCode mongoNotifyContextAvailability(NotifyContextAvailabilityRequest* requestP, NotifyContextAvailabilityResponse* responseP, const std::string& tenant) {
reqSemTake(__FUNCTION__, "mongo ngsi9 notification");
/* We ignore "subscriptionId" and "originator" in the request, as we don't have anything interesting
* to do with them */
/* Process each ContextRegistrationElement to create a "fake" RegisterContextRequest */
RegisterContextRequest rcr;
for (unsigned int ix= 0; ix < requestP->contextRegistrationResponseVector.size(); ++ix) {
ContextRegistration* crP = &requestP->contextRegistrationResponseVector.get(ix)->contextRegistration;
rcr.contextRegistrationVector.push_back(crP);
}
/* notifyContextAvailability doesn't include duration information, so we will use the defaulf */
rcr.duration.set(DEFAULT_DURATION);
/* We use processRegisterContext() function. Note that in this case the response is not needed, so we will
* only use it to conform to function signature. In addition, take into account that from a registerContext
* point of view, notifyContextAvailability is considered as a new registration (as no registratinId is
* received in the notification message) */
RegisterContextResponse rcres;
processRegisterContext(&rcr, &rcres, NULL, tenant);
responseP->responseCode.fill(SccOk);
reqSemGive(__FUNCTION__, "mongo ngsi9 notification");
return SccOk;
}
/* ****************************************************************************
*
* semToString -
*
* The real test here would be to create a few threads and play with the semaphores ...
*
* Here I only exercise the code (which is also valid and important)
*
* This is only a wrapper function for the real semaphore function and as we're only testing
* the wrapper functions, there is no reason to do any more ...
*/
TEST(commonSem, unique)
{
int s;
s = semInit();
EXPECT_EQ(0, s);
s = reqSemGive(__FUNCTION__, "test");
EXPECT_EQ(0, s);
bool taken;
s = reqSemTake(__FUNCTION__, "test", SemReadWriteOp, &taken);
EXPECT_EQ(0, s);
EXPECT_TRUE(taken);
}
/* ****************************************************************************
*
* mongoUpdateContext -
*/
HttpStatusCode mongoUpdateContext
(
UpdateContextRequest* requestP,
UpdateContextResponse* responseP,
const std::string& tenant,
const std::vector<std::string>& servicePathV,
std::map<std::string, std::string>& uriParams, // FIXME P7: we need this to implement "restriction-based" filters
const std::string& xauthToken,
const std::string& apiVersion,
bool checkEntityExistance
)
{
bool reqSemTaken;
reqSemTake(__FUNCTION__, "ngsi10 update request", SemWriteOp, &reqSemTaken);
/* Check that the service path vector has only one element, returning error otherwise */
if (servicePathV.size() > 1)
{
LM_W(("Bad Input (service path length %d is greater than the one in update)", servicePathV.size()));
responseP->errorCode.fill(SccBadRequest, "service path length greater than one in update");
}
else
{
/* Process each ContextElement */
for (unsigned int ix = 0; ix < requestP->contextElementVector.size(); ++ix)
{
processContextElement(requestP->contextElementVector.get(ix),
responseP,
requestP->updateActionType.get(),
tenant,
servicePathV,
uriParams,
xauthToken,
apiVersion,
checkEntityExistance);
}
/* Note that although individual processContextElements() invocations return ConnectionError, this
error gets "encapsulated" in the StatusCode of the corresponding ContextElementResponse and we
consider the overall mongoUpdateContext() as OK. */
responseP->errorCode.fill(SccOk);
}
reqSemGive(__FUNCTION__, "ngsi10 update request", reqSemTaken);
return SccOk;
}
/* ****************************************************************************
*
* mongoNotifyContext -
*/
HttpStatusCode mongoNotifyContext(NotifyContextRequest* requestP, NotifyContextResponse* responseP, const std::string& tenant) {
reqSemTake(__FUNCTION__, "ngsi10 notification");
/* We ignore "subscriptionId" and "originator" in the request, as we don't have anything interesting
* to do with them */
/* Process each ContextElement */
for (unsigned int ix = 0; ix < requestP->contextElementResponseVector.size(); ++ix) {
/* We use 'ucr' to conform processContextElement signature but we are not doing anything with that */
UpdateContextResponse ucr;
// FIXME P10: we need to pass an empty service path vector in order to fulfill the processContextElement signature(). To review,
// once we implement service path also for subscriptions/notifications
std::vector<std::string> servicePathV;
processContextElement(&requestP->contextElementResponseVector.get(ix)->contextElement, &ucr, "append", tenant, servicePathV);
}
reqSemGive(__FUNCTION__, "ngsi10 notification");
responseP->responseCode.fill(SccOk);
return SccOk;
}
/* ****************************************************************************
*
* mongoEntityTypes -
*/
HttpStatusCode mongoEntityTypes
(
EntityTypesResponse* responseP,
const std::string& tenant,
const std::vector<std::string>& servicePathV,
std::map<std::string, std::string>& uriParams
)
{
unsigned int offset = atoi(uriParams[URI_PARAM_PAGINATION_OFFSET].c_str());
unsigned int limit = atoi(uriParams[URI_PARAM_PAGINATION_LIMIT].c_str());
std::string detailsString = uriParams[URI_PARAM_PAGINATION_DETAILS];
bool details = (strcasecmp("on", detailsString.c_str()) == 0)? true : false;
LM_T(LmtMongo, ("Query Entity Types"));
LM_T(LmtPagination, ("Offset: %d, Limit: %d, Details: %s", offset, limit, (details == true)? "true" : "false"));
reqSemTake(__FUNCTION__, "query types request");
DBClientBase* connection = getMongoConnection();
/* Compose query based on this aggregation command:
*
* FIXME P9: taking into account that type is no longer used as part of the attribute "key", not sure if the
* aggregation query below is fully correct
*
* db.runCommand({aggregate: "entities",
* pipeline: [ {$match: { "_id.servicePath": /.../ } },
* {$project: {_id: 1, "attrs.name": 1, "attrs.type": 1} },
* {$project: { "attrs"
* {$cond: [ {$eq: [ "$attrs", [ ] ] }, [null], "$attrs"] }
* }
* },
* {$unwind: "$attrs"},
* {$group: {_id: "$_id.type", attrs: {$addToSet: "$attrs"}} },
* {$sort: {_id: 1} }
* ]
* })
*
* The $cond part is hard... more information at http://stackoverflow.com/questions/27510143/empty-array-prevents-document-to-appear-in-query
* As a consequence, some "null" values may appear in the resulting attrs vector, which are prunned by the result processing logic.
*
* FIXME P6: in the future, we can interpret the collapse parameter at this layer. If collapse=true so we don't need attributes, the
* following command can be used:
*
* db.runCommand({aggregate: "entities", pipeline: [ {$group: {_id: "$_id.type"} }]})
*
*/
BSONObj result;
// Building the projection part of the query that includes types that have no attributes
// See bug: https://github.com/telefonicaid/fiware-orion/issues/686
BSONArrayBuilder emptyArrayBuilder;
BSONArrayBuilder nulledArrayBuilder;
nulledArrayBuilder.appendNull();
// We are using the $cond: [ .. ] and not the $cond: { .. } one, as the former is the only one valid in MongoDB 2.4
BSONObj projection = BSON(
"$project" << BSON(
"attrs" << BSON(
"$cond" << BSON_ARRAY(
BSON("$eq" << BSON_ARRAY(S_ATTRS << emptyArrayBuilder.arr()) ) <<
nulledArrayBuilder.arr() <<
S_ATTRS
)
)
)
);
BSONObj cmd = BSON("aggregate" << COL_ENTITIES <<
"pipeline" << BSON_ARRAY(
BSON("$match" << BSON(C_ID_SERVICEPATH << fillQueryServicePath(servicePathV))) <<
BSON("$project" << BSON("_id" << 1 << C_ATTR_NAME << 1 << C_ATTR_TYPE << 1)) <<
projection <<
BSON("$unwind" << S_ATTRS) <<
BSON("$group" << BSON("_id" << CS_ID_ENTITY << "attrs" << BSON("$addToSet" << S_ATTRS))) <<
BSON("$sort" << BSON("_id" << 1))
)
);
LM_T(LmtMongo, ("runCommand() in '%s' database: '%s'", composeDatabaseName(tenant).c_str(), cmd.toString().c_str()));
mongoSemTake(__FUNCTION__, "aggregation command");
try
{
connection->runCommand(composeDatabaseName(tenant).c_str(), cmd, result);
mongoSemGive(__FUNCTION__, "aggregation command");
LM_I(("Database Operation Successful (%s)", cmd.toString().c_str()));
}
catch (const DBException& e)
{
mongoSemGive(__FUNCTION__, "aggregation command");
std::string err = std::string("database: ") + composeDatabaseName(tenant).c_str() +
" - command: " + cmd.toString() +
" - exception: " + e.what();
LM_E(("Database Error (%s)", err.c_str()));
responseP->statusCode.fill(SccReceiverInternalError, err);
reqSemGive(__FUNCTION__, "query types request");
return SccOk;
}
catch (...)
{
mongoSemGive(__FUNCTION__, "aggregation command");
std::string err = std::string("database: ") + composeDatabaseName(tenant).c_str() +
" - command: " + cmd.toString() +
" - exception: " + "generic";
LM_E(("Database Error (%s)", err.c_str()));
responseP->statusCode.fill(SccReceiverInternalError, err);
reqSemGive(__FUNCTION__, "query types request");
return SccOk;
}
/* Processing result to build response */
LM_T(LmtMongo, ("aggregation result: %s", result.toString().c_str()));
std::vector<BSONElement> resultsArray = result.getField("result").Array();
/* Another strategy to implement pagination is to use the $skip and $limit operators in the
* aggregation framework. However, doing so, we don't know the total number of results, which can
* be needed in the case of details=on (using that approach, we need to do two queries: one to get
* the count and other to get the actual results with $skip and $limit, in the same "transaction" to
* avoid incoherence between both if some entity type is created or deleted in the process).
*
* However, considering that the number of types will be small compared with the number of entities,
* the current approach seems to be ok
*/
for (unsigned int ix = offset; ix < MIN(resultsArray.size(), offset + limit); ++ix)
{
BSONObj resultItem = resultsArray[ix].embeddedObject();
TypeEntity* type = new TypeEntity(resultItem.getStringField("_id"));
std::vector<BSONElement> attrsArray = resultItem.getField("attrs").Array();
if (!attrsArray[0].isNull())
{
for (unsigned int jx = 0; jx < attrsArray.size(); ++jx)
{
/* This is the place in which null elements in the resulting attrs vector are prunned */
if (attrsArray[jx].isNull())
{
continue;
}
BSONObj jAttr = attrsArray[jx].embeddedObject();
ContextAttribute* ca = new ContextAttribute(jAttr.getStringField(ENT_ATTRS_NAME), jAttr.getStringField(ENT_ATTRS_TYPE));
type->contextAttributeVector.push_back(ca);
}
}
responseP->typeEntityVector.push_back(type);
}
char detailsMsg[256];
if (responseP->typeEntityVector.size() > 0)
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Count: %d", (int) resultsArray.size());
responseP->statusCode.fill(SccOk, detailsMsg);
}
else
{
responseP->statusCode.fill(SccOk);
}
}
else
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Number of types: %d. Offset is %d", (int) resultsArray.size(), offset);
responseP->statusCode.fill(SccContextElementNotFound, detailsMsg);
}
else
{
responseP->statusCode.fill(SccContextElementNotFound);
}
}
reqSemGive(__FUNCTION__, "query types request");
return SccOk;
}
/* ****************************************************************************
*
* mongoAttributesForEntityType -
*/
HttpStatusCode mongoAttributesForEntityType
(
std::string entityType,
EntityTypeAttributesResponse* responseP,
const std::string& tenant,
const std::vector<std::string>& servicePathV,
std::map<std::string, std::string>& uriParams
)
{
unsigned int offset = atoi(uriParams[URI_PARAM_PAGINATION_OFFSET].c_str());
unsigned int limit = atoi(uriParams[URI_PARAM_PAGINATION_LIMIT].c_str());
std::string detailsString = uriParams[URI_PARAM_PAGINATION_DETAILS];
bool details = (strcasecmp("on", detailsString.c_str()) == 0)? true : false;
// Setting the name of the entity type for the response
responseP->entityType.type = entityType;
LM_T(LmtMongo, ("Query Types Attribute for <%s>", entityType.c_str()));
LM_T(LmtPagination, ("Offset: %d, Limit: %d, Details: %s", offset, limit, (details == true)? "true" : "false"));
reqSemTake(__FUNCTION__, "query types attributes request");
DBClientBase* connection = getMongoConnection();
/* Compose query based on this aggregation command:
*
* FIXME P9: taking into account that type is no longer used as part of the attribute "key", not sure if the
* aggregation query below is fully correct
*
* db.runCommand({aggregate: "entities",
* pipeline: [ {$match: { "_id.type": "TYPE" , "_id.servicePath": /.../ } },
* {$project: {_id: 1, "attrs.name": 1, "attrs.type": 1} },
* {$unwind: "$attrs"},
* {$group: {_id: "$_id.type", attrs: {$addToSet: "$attrs"}} },
* {$unwind: "$attrs"},
* {$group: {_id: "$attrs" }},
* {$sort: {_id.name: 1, _id.type: 1} }
* ]
* })
*
*/
BSONObj result;
BSONObj cmd = BSON("aggregate" << COL_ENTITIES <<
"pipeline" << BSON_ARRAY(
BSON("$match" << BSON(C_ID_ENTITY << entityType << C_ID_SERVICEPATH << fillQueryServicePath(servicePathV))) <<
BSON("$project" << BSON("_id" << 1 << C_ATTR_NAME << 1 << C_ATTR_TYPE << 1)) <<
BSON("$unwind" << S_ATTRS) <<
BSON("$group" << BSON("_id" << CS_ID_ENTITY << "attrs" << BSON("$addToSet" << S_ATTRS))) <<
BSON("$unwind" << S_ATTRS) <<
BSON("$group" << BSON("_id" << S_ATTRS)) <<
BSON("$sort" << BSON(C_ID_NAME << 1 << C_ID_TYPE << 1))
)
);
LM_T(LmtMongo, ("runCommand() in '%s' database: '%s'", composeDatabaseName(tenant).c_str(), cmd.toString().c_str()));
mongoSemTake(__FUNCTION__, "aggregation command");
try
{
connection->runCommand(composeDatabaseName(tenant).c_str(), cmd, result);
mongoSemGive(__FUNCTION__, "aggregation command");
LM_I(("Database Operation Successful (%s)", cmd.toString().c_str()));
}
catch (const DBException& e)
{
mongoSemGive(__FUNCTION__, "aggregation command");
std::string err = std::string("database: ") + composeDatabaseName(tenant).c_str() +
" - command: " + cmd.toString() +
" - exception: " + e.what();
LM_E(("Database Error (%s)", err.c_str()));
responseP->statusCode.fill(SccReceiverInternalError, err);
reqSemGive(__FUNCTION__, "query types request");
return SccOk;
}
catch (...)
{
mongoSemGive(__FUNCTION__, "aggregation command");
std::string err = std::string("database: ") + composeDatabaseName(tenant).c_str() +
" - command: " + cmd.toString() +
" - exception: " + "generic";
LM_E(("Database Error (%s)", err.c_str()));
responseP->statusCode.fill(SccReceiverInternalError, err);
reqSemGive(__FUNCTION__, "query types request");
return SccOk;
}
/* Processing result to build response*/
LM_T(LmtMongo, ("aggregation result: %s", result.toString().c_str()));
std::vector<BSONElement> resultsArray = result.getField("result").Array();
/* See comment above in the other method regarding this strategy to implement pagination */
for (unsigned int ix = offset; ix < MIN(resultsArray.size(), offset + limit); ++ix)
{
BSONElement idField = resultsArray[ix].embeddedObject().getField("_id");
//
// BSONElement::eoo returns true if 'not found', i.e. the field "_id" doesn't exist in 'sub'
//
// Now, if 'resultsArray[ix].embeddedObject().getField("_id")' is not found, if we continue,
// calling embeddedObject() on it, then we get an exception and the broker crashes.
//
if (idField.eoo() == true)
{
LM_E(("Database Error (error retrieving _id field in doc: %s)", resultsArray[ix].embeddedObject().toString().c_str()));
continue;
}
BSONObj resultItem = idField.embeddedObject();
ContextAttribute* ca = new ContextAttribute(resultItem.getStringField(ENT_ATTRS_NAME), resultItem.getStringField(ENT_ATTRS_TYPE));
responseP->entityType.contextAttributeVector.push_back(ca);
}
char detailsMsg[256];
if (responseP->entityType.contextAttributeVector.size() > 0)
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Count: %d", (int) resultsArray.size());
responseP->statusCode.fill(SccOk, detailsMsg);
}
else
{
responseP->statusCode.fill(SccOk);
}
}
else
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Number of attributes: %d. Offset is %d", (int) resultsArray.size(), offset);
responseP->statusCode.fill(SccContextElementNotFound, detailsMsg);
}
else
{
responseP->statusCode.fill(SccContextElementNotFound);
}
}
reqSemGive(__FUNCTION__, "query types request");
return SccOk;
}
/* ****************************************************************************
*
* mongoUpdateContextSubscription -
*/
HttpStatusCode mongoUpdateContextSubscription(UpdateContextSubscriptionRequest* requestP, UpdateContextSubscriptionResponse* responseP, Format inFormat, const std::string& tenant)
{
reqSemTake(__FUNCTION__, "ngsi10 update subscription request");
LM_T(LmtMongo, ("Update Context Subscription"));
DBClientBase* connection = getMongoConnection();
/* Look for document */
BSONObj sub;
try
{
OID id = OID(requestP->subscriptionId.get());
mongoSemTake(__FUNCTION__, "findOne in SubscribeContextCollection");
sub = connection->findOne(getSubscribeContextCollectionName(tenant).c_str(), BSON("_id" << id));
mongoSemGive(__FUNCTION__, "findOne in SubscribeContextCollection");
LM_I(("Database Operation Successful (findOne _id: %s)", id.toString().c_str()));
}
catch (const AssertionException &e)
{
/* This happens when OID format is wrong */
// FIXME P4: this checking should be done at the parsing stage, without progressing to
// mongoBackend. For the moment we can leave this here, but we should remove it in the future
// (old issue #95)
mongoSemGive(__FUNCTION__, "findOne in SubscribeContextCollection (mongo assertion exception)");
reqSemGive(__FUNCTION__, "ngsi10 update subscription request (mongo assertion exception)");
responseP->subscribeError.errorCode.fill(SccContextElementNotFound);
LM_W(("Bad Input (invalid OID format)"));
return SccOk;
}
catch (const DBException &e)
{
mongoSemGive(__FUNCTION__, "findOne in SubscribeContextCollection (mongo db exception)");
reqSemGive(__FUNCTION__, "ngsi10 update subscription request (mongo db exception)");
responseP->subscribeError.errorCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextCollectionName(tenant).c_str() +
" - findOne() _id: " + requestP->subscriptionId.get() +
" - exception: " + e.what());
LM_E(("Database Error (%s)", responseP->subscribeError.errorCode.details.c_str()));
return SccOk;
}
catch (...)
{
mongoSemGive(__FUNCTION__, "findOne in SubscribeContextCollection (mongo generic exception)");
reqSemGive(__FUNCTION__, "ngsi10 update subscription request (mongo generic exception)");
responseP->subscribeError.errorCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextCollectionName(tenant).c_str() +
" - findOne() _id: " + requestP->subscriptionId.get() +
" - exception: " + "generic");
LM_E(("Database Error (%s)", responseP->subscribeError.errorCode.details.c_str()));
return SccOk;
}
if (sub.isEmpty()) {
responseP->subscribeError.errorCode.fill(SccContextElementNotFound);
reqSemGive(__FUNCTION__, "ngsi10 update subscription request (no subscriptions found)");
return SccOk;
}
/* We start with an empty BSONObjBuilder and process requestP for all the fields that can
* be updated. I don't like too much this strategy (I would have preferred to start with
* a copy of the original document, then modify as neded, but this doesn't seem to be easy
* using the API provide by the Mongo C++ driver)
*
* FIXME: a better implementation strategy could be doing an findAndModify() query to do the
* update, so detecting if the document was not found, instead of using findOne() + update()
* with $set operation. One operations to MongoDb. vs two operations.
*/
BSONObjBuilder newSub;
/* Entities, attribute list and reference are not updatable, so they are appended directly */
newSub.appendArray(CSUB_ENTITIES, sub.getField(CSUB_ENTITIES).Obj());
newSub.appendArray(CSUB_ATTRS, sub.getField(CSUB_ATTRS).Obj());
newSub.append(CSUB_REFERENCE, STR_FIELD(sub, CSUB_REFERENCE));
/* Duration update */
if (requestP->duration.isEmpty()) {
newSub.append(CSUB_EXPIRATION, sub.getField(CSUB_EXPIRATION).numberLong());
}
else {
long long expiration = getCurrentTime() + requestP->duration.parse();
newSub.append(CSUB_EXPIRATION, expiration);
LM_T(LmtMongo, ("New subscription expiration: %l", expiration));
}
/* Restriction update */
// FIXME: Restrictions not implemented yet
/* Throttling update */
if (!requestP->throttling.isEmpty()) {
/* Throttling equal to 0 removes throttling */
long long throttling = requestP->throttling.parse();
if (throttling != 0) {
newSub.append(CSUB_THROTTLING, throttling);
}
}
else {
/* The hasField check is needed due to Throttling could not be present in the original doc */
if (sub.hasField(CSUB_THROTTLING)) {
newSub.append(CSUB_THROTTLING, sub.getField(CSUB_THROTTLING).numberLong());
}
}
/* Notify conditions */
bool notificationDone = false;
if (requestP->notifyConditionVector.size() == 0) {
newSub.appendArray(CSUB_CONDITIONS, sub.getField(CSUB_CONDITIONS).embeddedObject());
}
else {
/* Destroy any previous ONTIMEINTERVAL thread */
getNotifier()->destroyOntimeIntervalThreads(requestP->subscriptionId.get());
/* Build conditions array (including side-effect notifications and threads creation)
* In order to do so, we have to create and EntityIdVector and AttributeList from sub
* document, given the processConditionVector() signature */
EntityIdVector enV = subToEntityIdVector(sub);
AttributeList attrL = subToAttributeList(sub);
BSONArray conds = processConditionVector(&requestP->notifyConditionVector,
enV,
attrL,
requestP->subscriptionId.get(),
C_STR_FIELD(sub, CSUB_REFERENCE),
¬ificationDone,
inFormat,
tenant);
newSub.appendArray(CSUB_CONDITIONS, conds);
/* Remove EntityIdVector and AttributeList dynamic memory */
enV.release();
attrL.release();
}
int count = sub.hasField(CSUB_COUNT) ? sub.getIntField(CSUB_COUNT) : 0;
/* Last notification */
if (notificationDone) {
newSub.append(CSUB_LASTNOTIFICATION, getCurrentTime());
newSub.append(CSUB_COUNT, count + 1);
}
else {
/* The hasField check is needed due to lastNotification/count could not be present in the original doc */
if (sub.hasField(CSUB_LASTNOTIFICATION)) {
newSub.append(CSUB_LASTNOTIFICATION, sub.getIntField(CSUB_LASTNOTIFICATION));
}
if (sub.hasField(CSUB_COUNT)) {
newSub.append(CSUB_COUNT, count);
}
}
/* Adding format to use in notifications */
newSub.append(CSUB_FORMAT, std::string(formatToString(inFormat)));
/* Update document in MongoDB */
BSONObj update = newSub.obj();
try
{
LM_T(LmtMongo, ("update() in '%s' collection _id '%s': %s}", getSubscribeContextCollectionName(tenant).c_str(),
requestP->subscriptionId.get().c_str(),
update.toString().c_str()));
mongoSemTake(__FUNCTION__, "update in SubscribeContextCollection");
connection->update(getSubscribeContextCollectionName(tenant).c_str(), BSON("_id" << OID(requestP->subscriptionId.get())), update);
mongoSemGive(__FUNCTION__, "update in SubscribeContextCollection");
LM_I(("Database Operation Successful (update _id: %s, %s)", requestP->subscriptionId.get().c_str(), update.toString().c_str()));
}
catch (const DBException &e)
{
mongoSemGive(__FUNCTION__, "update in SubscribeContextCollection (mongo db exception)");
reqSemGive(__FUNCTION__, "ngsi10 update subscription request (mongo db exception)");
responseP->subscribeError.errorCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextCollectionName(tenant).c_str() +
" - update() _id: " + requestP->subscriptionId.get().c_str() +
" - update() doc: " + update.toString() +
" - exception: " + e.what());
LM_E(("Database Error (%s)", responseP->subscribeError.errorCode.details.c_str()));
return SccOk;
}
catch (...)
{
mongoSemGive(__FUNCTION__, "update in SubscribeContextCollection (mongo generic exception)");
reqSemGive(__FUNCTION__, "ngsi10 update subscription request (mongo generic exception)");
responseP->subscribeError.errorCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextCollectionName(tenant).c_str() +
" - update() _id: " + requestP->subscriptionId.get().c_str() +
" - update() doc: " + update.toString() +
" - exception: " + "generic");
LM_E(("Database Error (%s)", responseP->subscribeError.errorCode.details.c_str()));
return SccOk;
}
/* Duration and throttling are optional parameters, they are only added in the case they
* was used for update */
if (!requestP->duration.isEmpty()) {
responseP->subscribeResponse.duration = requestP->duration;
}
if (!requestP->throttling.isEmpty()) {
responseP->subscribeResponse.throttling = requestP->throttling;
}
responseP->subscribeResponse.subscriptionId = requestP->subscriptionId;
reqSemGive(__FUNCTION__, "ngsi10 update subscription request");
return SccOk;
}
/* ****************************************************************************
*
* mongoUpdateContextAvailabilitySubscription -
*/
HttpStatusCode mongoUpdateContextAvailabilitySubscription(UpdateContextAvailabilitySubscriptionRequest* requestP, UpdateContextAvailabilitySubscriptionResponse* responseP, Format inFormat, const std::string& tenant)
{
LM_T(LmtMongo, ("Update Context Subscription"));
reqSemTake(__FUNCTION__, "ngsi9 update subscription request");
DBClientConnection* connection = getMongoConnection();
/* Look for document */
BSONObj sub;
try {
OID id = OID(requestP->subscriptionId.get());
mongoSemTake(__FUNCTION__, "findOne from SubscribeContextAvailabilityCollection");
sub = connection->findOne(getSubscribeContextAvailabilityCollectionName(tenant).c_str(), BSON("_id" << id));
mongoSemGive(__FUNCTION__, "findOne from SubscribeContextAvailabilityCollection");
}
catch( const AssertionException &e ) {
/* This happens when OID format is wrong */
// FIXME: this checking should be done at parsing stage, without progressing to
// mongoBackend. By the moment we can live this here, but we should remove in the future
// (old issue #95)
mongoSemGive(__FUNCTION__, "findOne from SubscribeContextAvailabilityCollection (mongo assertion exception)");
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (mongo assertion exception)");
responseP->errorCode.fill(SccContextElementNotFound);
return SccOk;
}
catch( const DBException &e ) {
mongoSemGive(__FUNCTION__, "findOne from SubscribeContextAvailabilityCollection (mongo db exception)");
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (mongo db exception)");
responseP->errorCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextAvailabilityCollectionName(tenant).c_str() +
" - findOne() _id: " + requestP->subscriptionId.get() +
" - exception: " + e.what());
return SccOk;
}
catch(...) {
mongoSemGive(__FUNCTION__, "findOne from SubscribeContextAvailabilityCollection (mongo generic exception)");
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (mongo generic exception)");
responseP->errorCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextAvailabilityCollectionName(tenant).c_str() +
" - findOne() _id: " + requestP->subscriptionId.get() +
" - exception: " + "generic");
return SccOk;
}
if (sub.isEmpty()) {
responseP->errorCode.fill(SccContextElementNotFound);
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (no subscriptions found)");
return SccOk;
}
/* We start with an empty BSONObjBuilder and process requestP for all the fields that can
* be updated. I don't like too much this strategy (I would have preferred to start with
* a copy of the original document, then modify as neded, but this doesn't seem to be easy
* using the API provide by the Mongo C++ driver)
*
* FIXME: a better implementation strategy could be doing an findAndModify() query to do the
* update, so detecting if the document was not found, instead of using findOne() + update()
* with $set operation. One operations to MongoDb. vs two operations.
*/
BSONObjBuilder newSub;
/* Entities (mandatory) */
BSONArrayBuilder entities;
for (unsigned int ix = 0; ix < requestP->entityIdVector.size(); ++ix) {
EntityId* en = requestP->entityIdVector.get(ix);
if (en->type == "") {
entities.append(BSON(CASUB_ENTITY_ID << en->id <<
CASUB_ENTITY_ISPATTERN << en->isPattern));
}
else {
entities.append(BSON(CASUB_ENTITY_ID << en->id <<
CASUB_ENTITY_TYPE << en->type <<
CASUB_ENTITY_ISPATTERN << en->isPattern));
}
}
newSub.append(CASUB_ENTITIES, entities.arr());
/* Attributes (always taken into account) */
BSONArrayBuilder attrs;
for (unsigned int ix = 0; ix < requestP->attributeList.size(); ++ix) {
attrs.append(requestP->attributeList.get(ix));
}
newSub.append(CASUB_ATTRS, attrs.arr());
/* Duration (optional) */
if (requestP->duration.isEmpty()) {
newSub.append(CASUB_EXPIRATION, sub.getField(CASUB_EXPIRATION).numberLong());
}
else {
long long expiration = getCurrentTime() + requestP->duration.parse();
newSub.append(CASUB_EXPIRATION, expiration);
LM_T(LmtMongo, ("New subscription expiration: %l", expiration));
}
/* Reference is not updatable, so it is appended directly */
newSub.append(CASUB_REFERENCE, STR_FIELD(sub, CASUB_REFERENCE));
int count = sub.hasField(CASUB_COUNT) ? sub.getIntField(CASUB_COUNT) : 0;
/* The hasField check is needed due to lastNotification/count could not be present in the original doc */
if (sub.hasField(CASUB_LASTNOTIFICATION)) {
newSub.append(CASUB_LASTNOTIFICATION, sub.getIntField(CASUB_LASTNOTIFICATION));
}
if (sub.hasField(CASUB_COUNT)) {
newSub.append(CASUB_COUNT, count);
}
/* Adding format to use in notifications */
newSub.append(CASUB_FORMAT, std::string(formatToString(inFormat)));
/* Update document in MongoDB */
BSONObj update = newSub.obj();
LM_T(LmtMongo, ("update() in '%s' collection _id '%s': %s}", getSubscribeContextAvailabilityCollectionName(tenant).c_str(),
requestP->subscriptionId.get().c_str(),
update.toString().c_str()));
try {
mongoSemTake(__FUNCTION__, "update in SubscribeContextAvailabilityCollection");
connection->update(getSubscribeContextAvailabilityCollectionName(tenant).c_str(), BSON("_id" << OID(requestP->subscriptionId.get())), update);
mongoSemGive(__FUNCTION__, "update in SubscribeContextAvailabilityCollection");
}
catch( const DBException &e ) {
mongoSemGive(__FUNCTION__, "update in SubscribeContextAvailabilityCollection (mongo db exception)");
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (mongo db exception)");
responseP->errorCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextAvailabilityCollectionName(tenant).c_str() +
" - update() _id: " + requestP->subscriptionId.get().c_str() +
" - update() doc: " + update.toString() +
" - exception: " + e.what());
return SccOk;
}
catch(...) {
mongoSemGive(__FUNCTION__, "update in SubscribeContextAvailabilityCollection (mongo generic exception)");
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (mongo generic exception)");
responseP->errorCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextAvailabilityCollectionName(tenant).c_str() +
" - update() _id: " + requestP->subscriptionId.get().c_str() +
" - update() doc: " + update.toString() +
" - exception: " + "generic");
return SccOk;
}
/* Send notifications for matching context registrations */
processAvailabilitySubscription(requestP->entityIdVector, requestP->attributeList, requestP->subscriptionId.get(), STR_FIELD(sub, CASUB_REFERENCE), inFormat, tenant);
/* Duration is an optional parameter, it is only added in the case they
* was used for update */
if (!requestP->duration.isEmpty()) {
responseP->duration = requestP->duration;
}
responseP->subscriptionId = requestP->subscriptionId;
reqSemGive(__FUNCTION__, "ngsi9 update subscription request");
return SccOk;
}
/* ****************************************************************************
*
* mongoUnsubscribeContextAvailability -
*/
HttpStatusCode mongoUnsubscribeContextAvailability(UnsubscribeContextAvailabilityRequest* requestP, UnsubscribeContextAvailabilityResponse* responseP)
{
reqSemTake(__FUNCTION__, "ngsi9 unsubscribe request");
LM_T(LmtMongo, ("Unsubscribe Context Availability"));
DBClientConnection* connection = getMongoConnection();
/* No matter if success or failure, the subscriptionId in the response is always the one
* in the request */
responseP->subscriptionId = requestP->subscriptionId;
/* Look for document */
BSONObj sub;
try {
OID id = OID(requestP->subscriptionId.get());
LM_T(LmtMongo, ("findOne() in '%s' collection _id '%s'}", getSubscribeContextAvailabilityCollectionName(),
requestP->subscriptionId.get().c_str()));
mongoSemTake(__FUNCTION__, "findOne in SubscribeContextAvailabilityCollection");
sub = connection->findOne(getSubscribeContextAvailabilityCollectionName(), BSON("_id" << id));
mongoSemGive(__FUNCTION__, "findOne in SubscribeContextAvailabilityCollection");
if (sub.isEmpty()) {
responseP->statusCode.fill(SccContextElementNotFound);
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (no subscriptions)");
return SccOk;
}
}
catch( const AssertionException &e ) {
/* This happens when OID format is wrong */
// FIXME: this checking should be done at parsing stage, without progressing to
// mongoBackend. By the moment we can live this here, but we should remove in the future
// (odl issues #95)
mongoSemGive(__FUNCTION__, "findOne in SubscribeContextAvailabilityCollection (mongo assertion exception)");
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (mongo assertion exception)");
responseP->statusCode.fill(SccContextElementNotFound);
return SccOk;
}
catch( const DBException &e ) {
mongoSemGive(__FUNCTION__, "findOne in SubscribeContextAvailabilityCollection (mongo db exception)");
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (mongo db exception)");
responseP->statusCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextAvailabilityCollectionName() +
" - findOne() _id: " + requestP->subscriptionId.get() +
" - exception: " + e.what());
return SccOk;
}
catch(...) {
mongoSemGive(__FUNCTION__, "findOne in SubscribeContextAvailabilityCollection (mongo generic exception)");
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (mongo generic exception)");
responseP->statusCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextAvailabilityCollectionName() +
" - findOne() _id: " + requestP->subscriptionId.get() +
" - exception: " + "generic");
return SccOk;
}
/* Remove document in MongoDB */
// FIXME: I would prefer to do the find and remove in a single operation. Is the some similar
// to findAndModify for this?
try {
LM_T(LmtMongo, ("remove() in '%s' collection _id '%s'}", getSubscribeContextAvailabilityCollectionName(),
requestP->subscriptionId.get().c_str()));
mongoSemTake(__FUNCTION__, "remove in SubscribeContextAvailabilityCollection");
connection->remove(getSubscribeContextAvailabilityCollectionName(), BSON("_id" << OID(requestP->subscriptionId.get())));
mongoSemGive(__FUNCTION__, "remove in SubscribeContextAvailabilityCollection");
}
catch( const DBException &e ) {
mongoSemGive(__FUNCTION__, "remove in SubscribeContextAvailabilityCollection (mongo db exception)");
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (mongo db exception)");
responseP->statusCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextAvailabilityCollectionName() +
" - remove() _id: " + requestP->subscriptionId.get().c_str() +
" - exception: " + e.what());
return SccOk;
}
catch(...) {
mongoSemGive(__FUNCTION__, "remove in SubscribeContextAvailabilityCollection (mongo generic exception)");
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (mongo generic exception)");
responseP->statusCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextAvailabilityCollectionName() +
" - remove() _id: " + requestP->subscriptionId.get().c_str() +
" - exception: " + "generic");
return SccOk;
}
responseP->statusCode.fill(SccOk);
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request");
return SccOk;
}
/* ****************************************************************************
*
* mongoUpdateContextAvailabilitySubscription -
*/
HttpStatusCode mongoUpdateContextAvailabilitySubscription
(
UpdateContextAvailabilitySubscriptionRequest* requestP,
UpdateContextAvailabilitySubscriptionResponse* responseP,
Format notifyFormat,
const std::string& tenant
)
{
bool reqSemTaken;
LM_T(LmtMongo, ("Update Context Subscription, notifyFormat: '%s'", formatToString(notifyFormat)));
reqSemTake(__FUNCTION__, "ngsi9 update subscription request", SemWriteOp, &reqSemTaken);
/* Look for document */
BSONObj sub;
std::string err;
OID id;
if (!safeGetSubId(requestP->subscriptionId, &id, &(responseP->errorCode)))
{
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (mongo assertion exception)", reqSemTaken);
if (responseP->errorCode.code == SccContextElementNotFound)
{
std::string details = std::string("invalid OID format: '") + requestP->subscriptionId.get() + "'";
alarmMgr.badInput(clientIp, details);
}
else // SccReceiverInternalError
{
LM_E(("Runtime Error (exception getting OID: %s)", responseP->errorCode.details.c_str()));
}
return SccOk;
}
if (!collectionFindOne(getSubscribeContextAvailabilityCollectionName(tenant), BSON("_id" << id), &sub, &err))
{
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (mongo db exception)", reqSemTaken);
responseP->errorCode.fill(SccReceiverInternalError, err);
return SccOk;
}
if (sub.isEmpty())
{
responseP->errorCode.fill(SccContextElementNotFound);
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (no subscriptions found)", reqSemTaken);
return SccOk;
}
/* We start with an empty BSONObjBuilder and process requestP for all the fields that can
* be updated. I don't like too much this strategy (I would have preferred to start with
* a copy of the original document, then modify as neded, but this doesn't seem to be easy
* using the API provide by the Mongo C++ driver)
*
* FIXME: a better implementation strategy could be doing an findAndModify() query to do the
* update, so detecting if the document was not found, instead of using findOne() + update()
* with $set operation. One operations to MongoDb. vs two operations.
*/
BSONObjBuilder newSub;
/* Entities (mandatory) */
BSONArrayBuilder entities;
for (unsigned int ix = 0; ix < requestP->entityIdVector.size(); ++ix) {
EntityId* en = requestP->entityIdVector[ix];
if (en->type == "") {
entities.append(BSON(CASUB_ENTITY_ID << en->id <<
CASUB_ENTITY_ISPATTERN << en->isPattern));
}
else {
entities.append(BSON(CASUB_ENTITY_ID << en->id <<
CASUB_ENTITY_TYPE << en->type <<
CASUB_ENTITY_ISPATTERN << en->isPattern));
}
}
newSub.append(CASUB_ENTITIES, entities.arr());
/* Attributes (always taken into account) */
BSONArrayBuilder attrs;
for (unsigned int ix = 0; ix < requestP->attributeList.size(); ++ix) {
attrs.append(requestP->attributeList[ix]);
}
newSub.append(CASUB_ATTRS, attrs.arr());
/* Duration (optional) */
if (requestP->duration.isEmpty())
{
newSub.append(CASUB_EXPIRATION, getField(sub, CASUB_EXPIRATION).numberLong());
}
else {
long long expiration = getCurrentTime() + requestP->duration.parse();
newSub.append(CASUB_EXPIRATION, expiration);
LM_T(LmtMongo, ("New subscription expiration: %l", expiration));
}
/* Reference is not updatable, so it is appended directly */
newSub.append(CASUB_REFERENCE, getStringField(sub, CASUB_REFERENCE));
int count = sub.hasField(CASUB_COUNT) ? getIntField(sub, CASUB_COUNT) : 0;
/* The hasField check is needed due to lastNotification/count could not be present in the original doc */
if (sub.hasField(CASUB_LASTNOTIFICATION)) {
newSub.append(CASUB_LASTNOTIFICATION, getIntField(sub, CASUB_LASTNOTIFICATION));
}
if (sub.hasField(CASUB_COUNT)) {
newSub.append(CASUB_COUNT, count);
}
/* Adding format to use in notifications */
newSub.append(CASUB_FORMAT, std::string(formatToString(notifyFormat)));
/* Update document in MongoDB */
if (!collectionUpdate(getSubscribeContextAvailabilityCollectionName(tenant), BSON("_id" << OID(requestP->subscriptionId.get())), newSub.obj(), false, &err))
{
reqSemGive(__FUNCTION__, "ngsi9 update subscription request (mongo db exception)", reqSemTaken);
responseP->errorCode.fill(SccReceiverInternalError, err);
return SccOk;
}
/* Send notifications for matching context registrations */
processAvailabilitySubscription(requestP->entityIdVector, requestP->attributeList, requestP->subscriptionId.get(), getStringField(sub, CASUB_REFERENCE), notifyFormat, tenant);
/* Duration is an optional parameter, it is only added in the case they
* was used for update */
if (!requestP->duration.isEmpty())
{
responseP->duration = requestP->duration;
}
responseP->subscriptionId = requestP->subscriptionId;
reqSemGive(__FUNCTION__, "ngsi9 update subscription request", reqSemTaken);
return SccOk;
}
/* ****************************************************************************
*
* mongoSubscribeContext -
*/
HttpStatusCode mongoSubscribeContext
(
SubscribeContextRequest* requestP,
SubscribeContextResponse* responseP,
const std::string& tenant,
std::map<std::string, std::string>& uriParam,
const std::string& xauthToken,
const std::vector<std::string>& servicePathV
)
{
const std::string notifyFormatAsString = uriParam[URI_PARAM_NOTIFY_FORMAT];
Format notifyFormat = stringToFormat(notifyFormatAsString);
std::string servicePath = (servicePathV.size() == 0)? "" : servicePathV[0];
bool reqSemTaken = false;
LM_T(LmtMongo, ("Subscribe Context Request: notifications sent in '%s' format", notifyFormatAsString.c_str()));
reqSemTake(__FUNCTION__, "ngsi10 subscribe request", SemWriteOp, &reqSemTaken);
//
// Calculate expiration (using the current time and the duration field in the request).
// If expiration is not present, use a default value
//
long long expiration = -1;
if (requestP->expires > 0)
{
expiration = requestP->expires;
}
else
{
if (requestP->duration.isEmpty())
{
requestP->duration.set(DEFAULT_DURATION);
}
expiration = getCurrentTime() + requestP->duration.parse();
}
LM_T(LmtMongo, ("Subscription expiration: %lu", expiration));
/* Create the mongoDB subscription document */
BSONObjBuilder sub;
OID oid;
oid.init();
sub.append("_id", oid);
sub.append(CSUB_EXPIRATION, expiration);
sub.append(CSUB_REFERENCE, requestP->reference.get());
/* Throttling */
long long throttling = 0;
if (requestP->throttling.seconds != -1)
{
throttling = (long long) requestP->throttling.seconds;
sub.append(CSUB_THROTTLING, throttling);
}
else if (!requestP->throttling.isEmpty())
{
throttling = (long long) requestP->throttling.parse();
sub.append(CSUB_THROTTLING, throttling);
}
if (servicePath != "")
{
sub.append(CSUB_SERVICE_PATH, servicePath);
}
/* Build entities array */
BSONArrayBuilder entities;
for (unsigned int ix = 0; ix < requestP->entityIdVector.size(); ++ix)
{
EntityId* en = requestP->entityIdVector[ix];
if (en->type == "")
{
entities.append(BSON(CSUB_ENTITY_ID << en->id <<
CSUB_ENTITY_ISPATTERN << en->isPattern));
}
else
{
entities.append(BSON(CSUB_ENTITY_ID << en->id <<
CSUB_ENTITY_TYPE << en->type <<
CSUB_ENTITY_ISPATTERN << en->isPattern));
}
}
sub.append(CSUB_ENTITIES, entities.arr());
/* Build attributes array */
BSONArrayBuilder attrs;
for (unsigned int ix = 0; ix < requestP->attributeList.size(); ++ix) {
attrs.append(requestP->attributeList[ix]);
}
sub.append(CSUB_ATTRS, attrs.arr());
/* Build conditions array (including side-effect notifications and threads creation) */
bool notificationDone = false;
BSONArray conds = processConditionVector(&requestP->notifyConditionVector,
requestP->entityIdVector,
requestP->attributeList, oid.toString(),
requestP->reference.get(),
¬ificationDone,
notifyFormat,
tenant,
xauthToken,
servicePathV,
requestP->expression.q);
sub.append(CSUB_CONDITIONS, conds);
/* Build expression */
BSONObjBuilder expression;
expression << CSUB_EXPR_Q << requestP->expression.q
<< CSUB_EXPR_GEOM << requestP->expression.geometry
<< CSUB_EXPR_COORDS << requestP->expression.coords
<< CSUB_EXPR_GEOREL << requestP->expression.georel;
sub.append(CSUB_EXPR, expression.obj());
/* Last notification */
long long lastNotificationTime = 0;
if (notificationDone)
{
lastNotificationTime = (long long) getCurrentTime();
sub.append(CSUB_LASTNOTIFICATION, lastNotificationTime);
sub.append(CSUB_COUNT, 1);
}
/* Adding format to use in notifications */
sub.append(CSUB_FORMAT, notifyFormatAsString);
/* Insert document in database */
std::string err;
if (!collectionInsert(getSubscribeContextCollectionName(tenant), sub.obj(), &err))
{
reqSemGive(__FUNCTION__, "ngsi10 subscribe request (mongo db exception)", reqSemTaken);
responseP->subscribeError.errorCode.fill(SccReceiverInternalError, err);
return SccOk;
}
//
// 3. Create Subscription for the cache
//
std::string oidString = oid.toString();
LM_T(LmtSubCache, ("inserting a new sub in cache (%s)", oidString.c_str()));
cacheSemTake(__FUNCTION__, "Inserting subscription in cache");
subCacheItemInsert(tenant.c_str(),
servicePath.c_str(),
requestP,
oidString.c_str(),
expiration,
throttling,
notifyFormat,
notificationDone,
lastNotificationTime,
requestP->expression.q,
requestP->expression.geometry,
requestP->expression.coords,
requestP->expression.georel);
cacheSemGive(__FUNCTION__, "Inserting subscription in cache");
reqSemGive(__FUNCTION__, "ngsi10 subscribe request", reqSemTaken);
/* Fill int the response element */
responseP->subscribeResponse.duration = requestP->duration;
responseP->subscribeResponse.subscriptionId.set(oid.toString());
responseP->subscribeResponse.throttling = requestP->throttling;
return SccOk;
}
/* ****************************************************************************
*
* mongoAttributesForEntityType -
*/
HttpStatusCode mongoAttributesForEntityType
(
std::string entityType,
EntityTypeResponse* responseP,
const std::string& tenant,
const std::vector<std::string>& servicePathV,
std::map<std::string, std::string>& uriParams
)
{
unsigned int offset = atoi(uriParams[URI_PARAM_PAGINATION_OFFSET].c_str());
unsigned int limit = atoi(uriParams[URI_PARAM_PAGINATION_LIMIT].c_str());
std::string detailsString = uriParams[URI_PARAM_PAGINATION_DETAILS];
bool details = (strcasecmp("on", detailsString.c_str()) == 0)? true : false;
bool reqSemTaken = false;
// Setting the name of the entity type for the response
responseP->entityType.type = entityType;
LM_T(LmtMongo, ("Query Types Attribute for <%s>", entityType.c_str()));
LM_T(LmtPagination, ("Offset: %d, Limit: %d, Details: %s", offset, limit, (details == true)? "true" : "false"));
reqSemTake(__FUNCTION__, "query types attributes request", SemReadOp, &reqSemTaken);
/* Compose query based on this aggregation command:
*
* db.runCommand({aggregate: "entities",
* pipeline: [ {$match: { "_id.type": "TYPE" , "_id.servicePath": /.../ } },
* {$project: {_id: 1, "attrNames": 1} },
* {$unwind: "$attrNames"},
* {$group: {_id: "$_id.type", attrs: {$addToSet: "$attrNames"}} },
* {$unwind: "$attrs"},
* {$group: {_id: "$attrs" }},
* {$sort: {_id: 1}}
* ]
* })
*
*/
BSONObj result;
BSONObj cmd = BSON("aggregate" << COL_ENTITIES <<
"pipeline" << BSON_ARRAY(
BSON("$match" << BSON(C_ID_ENTITY << entityType << C_ID_SERVICEPATH << fillQueryServicePath(servicePathV))) <<
BSON("$project" << BSON("_id" << 1 << ENT_ATTRNAMES << 1)) <<
BSON("$unwind" << S_ATTRNAMES) <<
BSON("$group" << BSON("_id" << CS_ID_ENTITY << "attrs" << BSON("$addToSet" << S_ATTRNAMES))) <<
BSON("$unwind" << "$attrs") <<
BSON("$group" << BSON("_id" << "$attrs")) <<
BSON("$sort" << BSON("_id" << 1))
)
);
std::string err;
if (!runCollectionCommand(composeDatabaseName(tenant), cmd, &result, &err))
{
responseP->statusCode.fill(SccReceiverInternalError, err);
reqSemGive(__FUNCTION__, "query types request", reqSemTaken);
return SccOk;
}
/* Processing result to build response */
LM_T(LmtMongo, ("aggregation result: %s", result.toString().c_str()));
std::vector<BSONElement> resultsArray = getField(result, "result").Array();
responseP->entityType.count = countEntities(tenant, servicePathV, entityType);
if (resultsArray.size() == 0)
{
responseP->statusCode.fill(SccContextElementNotFound);
reqSemGive(__FUNCTION__, "query types request", reqSemTaken);
return SccOk;
}
/* See comment above in the other method regarding this strategy to implement pagination */
for (unsigned int ix = offset; ix < MIN(resultsArray.size(), offset + limit); ++ix)
{
BSONElement idField = resultsArray[ix].embeddedObject().getField("_id");
//
// BSONElement::eoo returns true if 'not found', i.e. the field "_id" doesn't exist in 'sub'
//
// Now, if 'resultsArray[ix].embeddedObject().getField("_id")' is not found, if we continue,
// calling embeddedObject() on it, then we get an exception and the broker crashes.
//
if (idField.eoo() == true)
{
LM_E(("Database Error (error retrieving _id field in doc: %s)", resultsArray[ix].embeddedObject().toString().c_str()));
continue;
}
/* Note that we need and extra query() to the database (inside attributeType() function) to get each attribute type.
* This could be unefficient, specially if the number of attributes is large */
std::string attrType = attributeType(tenant, servicePathV, entityType , idField.str());
ContextAttribute* ca = new ContextAttribute(idField.str(), attrType, "");
responseP->entityType.contextAttributeVector.push_back(ca);
}
char detailsMsg[256];
if (responseP->entityType.contextAttributeVector.size() > 0)
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Count: %d", (int) resultsArray.size());
responseP->statusCode.fill(SccOk, detailsMsg);
}
else
{
responseP->statusCode.fill(SccOk);
}
}
else
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Number of attributes: %d. Offset is %d", (int) resultsArray.size(), offset);
responseP->statusCode.fill(SccContextElementNotFound, detailsMsg);
}
else
{
responseP->statusCode.fill(SccContextElementNotFound);
}
}
reqSemGive(__FUNCTION__, "query types request", reqSemTaken);
return SccOk;
}
/* ****************************************************************************
*
* mongoUnsubscribeContext -
*/
HttpStatusCode mongoUnsubscribeContext(UnsubscribeContextRequest* requestP, UnsubscribeContextResponse* responseP, const std::string& tenant)
{
bool reqSemTaken;
std::string err;
reqSemTake(__FUNCTION__, "ngsi10 unsubscribe request", SemWriteOp, &reqSemTaken);
LM_T(LmtMongo, ("Unsubscribe Context"));
/* No matter if success or failure, the subscriptionId in the response is always the one
* in the request */
responseP->subscriptionId = requestP->subscriptionId;
if (responseP->subscriptionId.get() == "")
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (no subscriptions found)", reqSemTaken);
responseP->statusCode.fill(SccContextElementNotFound);
alarmMgr.badInput(clientIp, "no subscriptionId");
return SccOk;
}
/* Look for document */
BSONObj sub;
OID id;
if (!safeGetSubId(requestP->subscriptionId, &id, &(responseP->statusCode)))
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (safeGetSubId fail)", reqSemTaken);
if (responseP->statusCode.code == SccContextElementNotFound)
{
// FIXME: Doubt - invalid OID format? Or, just a subscription that was not found?
std::string details = std::string("invalid OID format: '") + requestP->subscriptionId.get() + "'";
alarmMgr.badInput(clientIp, details);
}
else // SccReceiverInternalError
{
LM_E(("Runtime Error (exception getting OID: %s)", responseP->statusCode.details.c_str()));
}
return SccOk;
}
if (!collectionFindOne(getSubscribeContextCollectionName(tenant), BSON("_id" << id), &sub, &err))
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo db exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError, err);
return SccOk;
}
if (sub.isEmpty())
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (no subscriptions found)", reqSemTaken);
responseP->statusCode.fill(SccContextElementNotFound, std::string("subscriptionId: /") + requestP->subscriptionId.get() + "/");
return SccOk;
}
/* Remove document in MongoDB */
// FIXME: I would prefer to do the find and remove in a single operation. Is there something similar
// to findAndModify for this?
if (!collectionRemove(getSubscribeContextCollectionName(tenant), BSON("_id" << OID(requestP->subscriptionId.get())), &err))
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo db exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError, err);
return SccOk;
}
/* Destroy any previous ONTIMEINTERVAL thread */
getNotifier()->destroyOntimeIntervalThreads(requestP->subscriptionId.get());
//
// Removing subscription from mongo subscription cache
//
LM_T(LmtSubCache, ("removing subscription '%s' (tenant '%s') from mongo subscription cache", requestP->subscriptionId.get().c_str(), tenant.c_str()));
cacheSemTake(__FUNCTION__, "Removing subscription from cache");
CachedSubscription* cSubP = subCacheItemLookup(tenant.c_str(), requestP->subscriptionId.get().c_str());
if (cSubP != NULL)
{
subCacheItemRemove(cSubP);
}
cacheSemGive(__FUNCTION__, "Removing subscription from cache");
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request", reqSemTaken);
responseP->statusCode.fill(SccOk);
return SccOk;
}
/* ****************************************************************************
*
* mongoQueryContext -
*
* NOTE
* If the in/out-parameter countP is non-NULL then the number of matching entities
* must be returned in *countP.
*
* This replaces the 'uriParams[URI_PARAM_PAGINATION_DETAILS]' way of passing this information.
* The old method was one-way, using the new method
*/
HttpStatusCode mongoQueryContext
(
QueryContextRequest* requestP,
QueryContextResponse* responseP,
const std::string& tenant,
const std::vector<std::string>& servicePathV,
std::map<std::string, std::string>& uriParams,
long long* countP
)
{
int offset = atoi(uriParams[URI_PARAM_PAGINATION_OFFSET].c_str());
int limit = atoi(uriParams[URI_PARAM_PAGINATION_LIMIT].c_str());
std::string detailsString = uriParams[URI_PARAM_PAGINATION_DETAILS];
bool details = (strcasecmp("on", detailsString.c_str()) == 0)? true : false;
LM_T(LmtMongo, ("QueryContext Request"));
LM_T(LmtPagination, ("Offset: %d, Limit: %d, Details: %s", offset, limit, (details == true)? "true" : "false"));
/* FIXME: restriction not supported for the moment */
if (!requestP->restriction.attributeExpression.isEmpty())
{
LM_W(("Bad Input (restriction found, but restrictions are not supported by mongo backend)"));
}
std::string err;
bool ok;
bool limitReached = false;
bool reqSemTaken;
ContextElementResponseVector rawCerV;
reqSemTake(__FUNCTION__, "ngsi10 query request", SemReadOp, &reqSemTaken);
ok = entitiesQuery(requestP->entityIdVector,
requestP->attributeList,
requestP->restriction,
&rawCerV,
&err,
true,
tenant,
servicePathV,
offset,
limit,
&limitReached,
countP);
if (!ok)
{
responseP->errorCode.fill(SccReceiverInternalError, err);
rawCerV.release();
reqSemGive(__FUNCTION__, "ngsi10 query request", reqSemTaken);
return SccOk;
}
ContextRegistrationResponseVector crrV;
/* In the case of empty response, if only generic processing is needed */
if (rawCerV.size() == 0)
{
if (registrationsQuery(requestP->entityIdVector, requestP->attributeList, &crrV, &err, tenant, servicePathV, 0, 0, false))
{
if (crrV.size() > 0)
{
processGenericEntities(requestP->entityIdVector, rawCerV, crrV, limitReached);
}
}
else
{
/* Different from errors in DB at entitiesQuery(), DB fails at registrationsQuery() are not considered "critical" */
LM_E(("Database Error (%s)", err.c_str()));
}
crrV.release();
}
/* First CPr lookup (in the case some CER is not found): looking in E-A registrations */
if (someContextElementNotFound(rawCerV))
{
if (registrationsQuery(requestP->entityIdVector, requestP->attributeList, &crrV, &err, tenant, servicePathV, 0, 0, false))
{
if (crrV.size() > 0)
{
fillContextProviders(rawCerV, crrV);
processGenericEntities(requestP->entityIdVector, rawCerV, crrV, limitReached);
}
}
else
{
/* Different from errors in DB at entitiesQuery(), DB fails at registrationsQuery() are not considered "critical" */
LM_E(("Database Error (%s)", err.c_str()));
}
crrV.release();
}
/* Second CPr lookup (in the case some element stills not being found): looking in E-<null> registrations */
AttributeList attrNullList;
if (someContextElementNotFound(rawCerV))
{
if (registrationsQuery(requestP->entityIdVector, attrNullList, &crrV, &err, tenant, servicePathV, 0, 0, false))
{
if (crrV.size() > 0)
{
fillContextProviders(rawCerV, crrV);
}
}
else
{
/* Different from errors in DB at entitiesQuery(), DB fails at registrationsQuery() are not considered "critical" */
LM_E(("Database Error (%s)", err.c_str()));
}
crrV.release();
}
/* Special case: request with <null> attributes. In that case, entitiesQuery() may have captured some local attribute, but
* the list need to be completed. Note that in the case of having this request someContextElementNotFound() is always false
* so we efficient not invoking registrationQuery() too much times */
if (requestP->attributeList.size() == 0)
{
if (registrationsQuery(requestP->entityIdVector, requestP->attributeList, &crrV, &err, tenant, servicePathV, 0, 0, false))
{
if (crrV.size() > 0)
{
addContextProviders(rawCerV, crrV, limitReached);
}
}
else
{
/* Different from fails in DB at entitiesQuery(), DB fails at registrationsQuery() are not considered "critical" */
LM_E(("Database Error (%s)", err.c_str()));
}
crrV.release();
}
/* Prune "not found" CERs */
pruneContextElements(rawCerV, &responseP->contextElementResponseVector);
/* Pagination stuff */
if (responseP->contextElementResponseVector.size() == 0)
{
// If the query has an empty response, we have to fill in the status code part in the response.
//
// However, if the response was empty due to a too high pagination offset,
// and if the user has asked for 'details' (as URI parameter, then the response should include information about
// the number of hits without pagination.
//
if ((countP != NULL) && (*countP > 0) && (offset >= *countP))
{
char details[256];
snprintf(details, sizeof(details), "Number of matching entities: %lld. Offset is %d", *countP, offset);
responseP->errorCode.fill(SccContextElementNotFound, details);
}
else
{
responseP->errorCode.fill(SccContextElementNotFound);
}
}
else if (countP != NULL)
{
//
// If all was OK, but the details URI param was set to 'on', then the responses error code details
// 'must' contain the total count of hits.
//
char details[64];
snprintf(details, sizeof(details), "Count: %lld", *countP);
responseP->errorCode.fill(SccOk, details);
}
rawCerV.release();
reqSemGive(__FUNCTION__, "ngsi10 query request", reqSemTaken);
return SccOk;
}
/* ****************************************************************************
*
* mongoUnsubscribeContextAvailability -
*/
HttpStatusCode mongoUnsubscribeContextAvailability
(
UnsubscribeContextAvailabilityRequest* requestP,
UnsubscribeContextAvailabilityResponse* responseP,
const std::string& tenant
)
{
bool reqSemTaken;
std::string err;
reqSemTake(__FUNCTION__, "ngsi9 unsubscribe request", SemWriteOp, &reqSemTaken);
LM_T(LmtMongo, ("Unsubscribe Context Availability"));
/* No matter if success or failure, the subscriptionId in the response is always the one
* in the request */
responseP->subscriptionId = requestP->subscriptionId;
/* Look for document */
BSONObj sub;
OID id;
if (!safeGetSubId(requestP->subscriptionId, &id, &(responseP->statusCode)))
{
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (safeGetSubId fail)", reqSemTaken);
if (responseP->statusCode.code == SccContextElementNotFound)
{
// FIXME: doubt: invalid OID format? Or, subscription not found?
std::string details = std::string("invalid OID format: '") + requestP->subscriptionId.get() + "'";
alarmMgr.badInput(clientIp, details);
}
else // SccReceiverInternalError
{
LM_E(("Runtime Error (exception getting OID: %s)", responseP->statusCode.details.c_str()));
}
return SccOk;
}
if (!collectionFindOne(getSubscribeContextAvailabilityCollectionName(tenant), BSON("_id" << id), &sub, &err))
{
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (mongo db exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError, err);
return SccOk;
}
alarmMgr.dbErrorReset();
if (sub.isEmpty())
{
responseP->statusCode.fill(SccContextElementNotFound);
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (no subscriptions)", reqSemTaken);
return SccOk;
}
/* Remove document in MongoDB */
// FIXME: I would prefer to do the find and remove in a single operation. Is the some similar
// to findAndModify for this?
if (!collectionRemove(getSubscribeContextAvailabilityCollectionName(tenant), BSON("_id" << OID(requestP->subscriptionId.get())), &err))
{
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request (mongo db exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError, err);
return SccOk;
}
reqSemGive(__FUNCTION__, "ngsi9 unsubscribe request", reqSemTaken);
responseP->statusCode.fill(SccOk);
return SccOk;
}
/* ****************************************************************************
*
* mongoEntityTypes -
*/
HttpStatusCode mongoEntityTypes
(
EntityTypesResponse* responseP,
const std::string& tenant,
const std::vector<std::string>& servicePathV,
std::map<std::string, std::string>& uriParams
)
{
unsigned int offset = atoi(uriParams[URI_PARAM_PAGINATION_OFFSET].c_str());
unsigned int limit = atoi(uriParams[URI_PARAM_PAGINATION_LIMIT].c_str());
std::string detailsString = uriParams[URI_PARAM_PAGINATION_DETAILS];
bool details = (strcasecmp("on", detailsString.c_str()) == 0)? true : false;
LM_T(LmtMongo, ("Query Entity Types"));
LM_T(LmtPagination, ("Offset: %d, Limit: %d, Details: %s", offset, limit, (details == true)? "true" : "false"));
reqSemTake(__FUNCTION__, "query types request");
DBClientBase* connection = getMongoConnection();
/* Compose query based on this aggregation command:
*
* FIXME P9: taking into account that type is no longer used as part of the attribute "key", not sure if the
* aggregation query below is fully correct
*
* db.runCommand({aggregate: "entities",
* pipeline: [ {$project: {_id: 1, "attrs.name": 1, "attrs.type": 1} },
* {$unwind: "$attrs"},
* {$group: {_id: "$_id.type", attrs: {$addToSet: "$attrs"}} },
* {$sort: {_id: 1} }
* ]
* })
*
* FIXME P6: in the future, we can interpret the collapse parameter at this layer. If collapse=true so we don't need attributes, the
* following command can be used:
*
* db.runCommand({aggregate: "entities", pipeline: [ {$group: {_id: "$_id.type"} }]})
*
*/
BSONObj result;
BSONObj cmd = BSON("aggregate" << COL_ENTITIES <<
"pipeline" << BSON_ARRAY(
BSON("$project" << BSON("_id" << 1 << C_ATTR_NAME << 1 << C_ATTR_TYPE << 1)) <<
BSON("$unwind" << S_ATTRS) <<
BSON("$group" << BSON("_id" << CS_ID_ENTITY << "attrs" << BSON("$addToSet" << S_ATTRS))) <<
BSON("$sort" << BSON("_id" << 1))
)
);
LM_T(LmtMongo, ("runCommand() in '%s' database: '%s'", composeDatabaseName(tenant).c_str(), cmd.toString().c_str()));
mongoSemTake(__FUNCTION__, "aggregation command");
try
{
connection->runCommand(composeDatabaseName(tenant).c_str(), cmd, result);
mongoSemGive(__FUNCTION__, "aggregation command");
LM_I(("Database Operation Successful (%s)", cmd.toString().c_str()));
}
catch (const DBException& e)
{
mongoSemGive(__FUNCTION__, "aggregation command");
std::string err = std::string("database: ") + composeDatabaseName(tenant).c_str() +
" - command: " + cmd.toString() +
" - exception: " + e.what();
LM_E(("Database Error (%s)", err.c_str()));
responseP->statusCode.fill(SccReceiverInternalError, err);
reqSemGive(__FUNCTION__, "query types request");
return SccOk;
}
catch (...)
{
mongoSemGive(__FUNCTION__, "aggregation command");
std::string err = std::string("database: ") + composeDatabaseName(tenant).c_str() +
" - command: " + cmd.toString() +
" - exception: " + "generic";
LM_E(("Database Error (%s)", err.c_str()));
responseP->statusCode.fill(SccReceiverInternalError, err);
reqSemGive(__FUNCTION__, "query types request");
return SccOk;
}
/* Processing result to build response*/
LM_T(LmtMongo, ("aggregation result: %s", result.toString().c_str()));
std::vector<BSONElement> resultsArray = result.getField("result").Array();
/* Another strategy to implement pagination is to use the $skip and $limit operators in the
* aggregation framework. However, doing so, we don't know the total number of results, which can
* be needed in the case of details=on (using that approach, we need to do two queries: one to get
* the count and other to get the actual results with $skip and $limit, in the same "transaction" to
* avoid incoherence between both if some entity type is created or deleted in the process).
*
* However, considering that the number of types will be small compared with the number of entities,
* the current approach seems to be ok
*/
for (unsigned int ix = offset; ix < MIN(resultsArray.size(), offset + limit); ++ix)
{
BSONObj resultItem = resultsArray[ix].embeddedObject();
TypeEntity* type = new TypeEntity(resultItem.getStringField("_id"));
std::vector<BSONElement> attrsArray = resultItem.getField("attrs").Array();
for (unsigned int jx = 0; jx < attrsArray.size(); ++jx)
{
BSONObj jAttr = attrsArray[jx].embeddedObject();
ContextAttribute* ca = new ContextAttribute(jAttr.getStringField(ENT_ATTRS_NAME), jAttr.getStringField(ENT_ATTRS_TYPE));
type->contextAttributeVector.push_back(ca);
}
responseP->typeEntityVector.push_back(type);
}
char detailsMsg[256];
if (responseP->typeEntityVector.size() > 0)
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Count: %d", (int) resultsArray.size());
responseP->statusCode.fill(SccOk, detailsMsg);
}
else
{
responseP->statusCode.fill(SccOk);
}
}
else
{
if (details)
{
snprintf(detailsMsg, sizeof(detailsMsg), "Number of types: %d. Offset is %d", (int) resultsArray.size(), offset);
responseP->statusCode.fill(SccContextElementNotFound, detailsMsg);
}
else
{
responseP->statusCode.fill(SccContextElementNotFound);
}
}
reqSemGive(__FUNCTION__, "query types request");
return SccOk;
}
/* ****************************************************************************
*
* mongoUnsubscribeContext -
*/
HttpStatusCode mongoUnsubscribeContext(UnsubscribeContextRequest* requestP, UnsubscribeContextResponse* responseP, const std::string& tenant)
{
bool reqSemTaken;
BSONObj sub;
DBClientBase* connection = NULL;
reqSemTake(__FUNCTION__, "ngsi10 unsubscribe request", SemWriteOp, &reqSemTaken);
LM_T(LmtMongo, ("Unsubscribe Context"));
/* No matter if success or failure, the subscriptionId in the response is always the one
* in the request */
responseP->subscriptionId = requestP->subscriptionId;
if (responseP->subscriptionId.get() == "")
{
responseP->statusCode.fill(SccContextElementNotFound);
LM_W(("Bad Input (no subscriptionId)"));
return SccOk;
}
LM_T(LmtMongo, ("findOne() in '%s' collection _id '%s'}", getSubscribeContextCollectionName(tenant).c_str(),
requestP->subscriptionId.get().c_str()));
/* Look for document */
connection = getMongoConnection();
try
{
OID id = OID(requestP->subscriptionId.get());
sub = connection->findOne(getSubscribeContextCollectionName(tenant).c_str(), BSON("_id" << id));
releaseMongoConnection(connection);
LM_I(("Database Operation Successful (findOne _id: %s)", id.toString().c_str()));
}
catch (const AssertionException &e)
{
releaseMongoConnection(connection);
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo assertion exception)", reqSemTaken);
//
// This happens when OID format is wrong
// FIXME: this checking should be done at parsing stage, without progressing to
// mongoBackend. By the moment we can live this here, but we should remove in the future
// (old issue #95)
//
responseP->statusCode.fill(SccContextElementNotFound);
LM_W(("Bad Input (invalid OID format)"));
return SccOk;
}
catch (const DBException &e)
{
releaseMongoConnection(connection);
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo db exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextCollectionName(tenant).c_str() +
" - findOne() _id: " + requestP->subscriptionId.get() +
" - exception: " + e.what());
LM_E(("Database Error (%s)", responseP->statusCode.details.c_str()));
return SccOk;
}
catch (...)
{
releaseMongoConnection(connection);
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo generic exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextCollectionName(tenant).c_str() +
" - findOne() _id: " + requestP->subscriptionId.get() +
" - exception: " + "generic");
LM_E(("Database Error (%s)", responseP->statusCode.details.c_str()));
return SccOk;
}
if (sub.isEmpty())
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (no subscriptions found)", reqSemTaken);
responseP->statusCode.fill(SccContextElementNotFound, std::string("subscriptionId: /") + requestP->subscriptionId.get() + "/");
return SccOk;
}
/* Remove document in MongoDB */
// FIXME: I will prefer to do the find and remove in a single operation. Is the some similar
// to findAndModify for this?
LM_T(LmtMongo, ("remove() in '%s' collection _id '%s'}", getSubscribeContextCollectionName(tenant).c_str(),
requestP->subscriptionId.get().c_str()));
connection = getMongoConnection();
try
{
connection->remove(getSubscribeContextCollectionName(tenant).c_str(), BSON("_id" << OID(requestP->subscriptionId.get())));
releaseMongoConnection(connection);
LM_I(("Database Operation Successful (remove _id: %s)", requestP->subscriptionId.get().c_str()));
}
catch (const DBException &e)
{
releaseMongoConnection(connection);
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo db exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextCollectionName(tenant).c_str() +
" - remove() _id: " + requestP->subscriptionId.get().c_str() +
" - exception: " + e.what());
LM_E(("Database Error (%s)", responseP->statusCode.details.c_str()));
return SccOk;
}
catch (...)
{
releaseMongoConnection(connection);
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo generic exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError,
std::string("collection: ") + getSubscribeContextCollectionName(tenant).c_str() +
" - remove() _id: " + requestP->subscriptionId.get().c_str() +
" - exception: " + "generic");
LM_E(("Database Error (%s)", responseP->statusCode.details.c_str()));
return SccOk;
}
/* Destroy any previous ONTIMEINTERVAL thread */
getNotifier()->destroyOntimeIntervalThreads(requestP->subscriptionId.get());
responseP->statusCode.fill(SccOk);
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request", reqSemTaken);
//
// Removing subscription from cache
//
subCache->remove(tenant, "", requestP->subscriptionId.get());
return SccOk;
}
/* ****************************************************************************
*
* mongoUnsubscribeContext -
*/
HttpStatusCode mongoUnsubscribeContext(UnsubscribeContextRequest* requestP, UnsubscribeContextResponse* responseP, const std::string& tenant)
{
bool reqSemTaken;
std::string err;
reqSemTake(__FUNCTION__, "ngsi10 unsubscribe request", SemWriteOp, &reqSemTaken);
LM_T(LmtMongo, ("Unsubscribe Context"));
/* No matter if success or failure, the subscriptionId in the response is always the one
* in the request */
responseP->subscriptionId = requestP->subscriptionId;
if (responseP->subscriptionId.get() == "")
{
responseP->statusCode.fill(SccContextElementNotFound);
LM_W(("Bad Input (no subscriptionId)"));
return SccOk;
}
/* Look for document */
BSONObj sub;
OID id;
try
{
id = OID(requestP->subscriptionId.get());
}
catch (const AssertionException &e)
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo assertion exception)", reqSemTaken);
//
// This happens when OID format is wrong
// FIXME: this checking should be done at parsing stage, without progressing to
// mongoBackend. For the moment we can live this here, but we should remove in the future
// (old issue #95)
//
responseP->statusCode.fill(SccContextElementNotFound);
LM_W(("Bad Input (invalid OID format)"));
return SccOk;
}
if (!collectionFindOne(getSubscribeContextCollectionName(tenant), BSON("_id" << id), &sub, &err))
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo db exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError, err);
return SccOk;
}
if (sub.isEmpty())
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (no subscriptions found)", reqSemTaken);
responseP->statusCode.fill(SccContextElementNotFound, std::string("subscriptionId: /") + requestP->subscriptionId.get() + "/");
return SccOk;
}
/* Remove document in MongoDB */
// FIXME: I would prefer to do the find and remove in a single operation. Is there something similar
// to findAndModify for this?
if (!collectionRemove(getSubscribeContextCollectionName(tenant), BSON("_id" << OID(requestP->subscriptionId.get())), &err))
{
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request (mongo db exception)", reqSemTaken);
responseP->statusCode.fill(SccReceiverInternalError, err);
return SccOk;
}
/* Destroy any previous ONTIMEINTERVAL thread */
getNotifier()->destroyOntimeIntervalThreads(requestP->subscriptionId.get());
// FIXME P7: mongoSubCache stuff could be avoided if subscription is not patterned
//
// Removing subscription from mongo subscription cache
//
LM_T(LmtMongoSubCache, ("removing subscription '%s' (tenant '%s') from mongo subscription cache", requestP->subscriptionId.get().c_str(), tenant.c_str()));
cacheSemTake(__FUNCTION__, "Removing subscription from cache");
CachedSubscription* cSubP = mongoSubCacheItemLookup(tenant.c_str(), requestP->subscriptionId.get().c_str());
if (cSubP != NULL) // Will only enter here if wildcard subscription
{
mongoSubCacheItemRemove(cSubP);
}
cacheSemGive(__FUNCTION__, "Removing subscription from cache");
reqSemGive(__FUNCTION__, "ngsi10 unsubscribe request", reqSemTaken);
responseP->statusCode.fill(SccOk);
return SccOk;
}
