ErrorPtr P44JsonApiRequest::sendResult(ApiValuePtr aResult)
{
LOG(LOG_DEBUG, "cfg <- vdcd (JSON) result sent: result=%s", aResult ? aResult->description().c_str() : "<none>");
JsonApiValuePtr result = boost::dynamic_pointer_cast<JsonApiValue>(aResult);
if (result) {
P44VdcHost::sendCfgApiResponse(jsonComm, result->jsonObject(), ErrorPtr());
}
else {
// always return SOMETHING
P44VdcHost::sendCfgApiResponse(jsonComm, JsonObject::newNull(), ErrorPtr());
}
return ErrorPtr();
}
ErrorPtr PropertyContainer::accessProperty(PropertyAccessMode aMode, ApiValuePtr aQueryObject, ApiValuePtr aResultObject, int aDomain, PropertyDescriptorPtr aParentDescriptor)
{
ErrorPtr err;
#if DEBUGFOCUSLOGGING
FOCUSLOG("\naccessProperty: entered with query = %s\n", aQueryObject->description().c_str());
if (aParentDescriptor) {
FOCUSLOG("- parentDescriptor '%s' (%s), fieldKey=%u, objectKey=%u\n", aParentDescriptor->name(), aParentDescriptor->isStructured() ? "structured" : "scalar", aParentDescriptor->fieldKey(), aParentDescriptor->objectKey());
}
#endif
// for reading, NULL query is like query { "":NULL }
if (aQueryObject->isNull() && aMode==access_read) {
aQueryObject->setType(apivalue_object);
aQueryObject->add("", aQueryObject->newValue(apivalue_null));
}
// aApiObject must be of type apivalue_object
if (!aQueryObject->isType(apivalue_object))
return ErrorPtr(new VdcApiError(415, "Query or Value written must be object"));
if (aMode==access_read) {
if (!aResultObject)
return ErrorPtr(new VdcApiError(415, "accessing property for read must provide result object"));
aResultObject->setType(apivalue_object); // must be object
}
// Iterate trough elements of query object
aQueryObject->resetKeyIteration();
string queryName;
ApiValuePtr queryValue;
string errorMsg;
while (aQueryObject->nextKeyValue(queryName, queryValue)) {
FOCUSLOG("- starting to process query element named '%s' : %s\n", queryName.c_str(), queryValue->description().c_str());
if (aMode==access_read && queryName=="#") {
// asking for number of elements at this level -> generate and return int value
queryValue = queryValue->newValue(apivalue_int64); // integer
queryValue->setInt32Value(numProps(aDomain, aParentDescriptor));
aResultObject->add(queryName, queryValue);
}
else {
// accessing an element or series of elements at this level
bool wildcard = isMatchAll(queryName);
// - find all descriptor(s) for this queryName
PropertyDescriptorPtr propDesc;
int propIndex = 0;
bool foundone = false;
do {
propDesc = getDescriptorByName(queryName, propIndex, aDomain, aParentDescriptor);
if (propDesc) {
foundone = true; // found at least one descriptor for this query element
FOCUSLOG(" - processing descriptor '%s' (%s), fieldKey=%u, objectKey=%u\n", propDesc->name(), propDesc->isStructured() ? "structured" : "scalar", propDesc->fieldKey(), propDesc->objectKey());
// actually access by descriptor
if (propDesc->isStructured()) {
ApiValuePtr subQuery;
// property is a container. Now check the value
if (queryValue->isType(apivalue_object)) {
subQuery = queryValue; // query specifies next level, just use it
}
else if (queryName!="*" && (!wildcard || propDesc->isWildcardAddressable())) {
// don't recurse deeper when query name is "*" or property is not wildcard-adressable
// special case is "*" as leaf in query - only recurse if it is not present
// - autocreate subquery
subQuery = queryValue->newValue(apivalue_object);
subQuery->add("", queryValue->newValue(apivalue_null));
}
if (subQuery) {
// addressed property is a container by itself -> recurse
// - get the PropertyContainer
int containerDomain = aDomain; // default to same, but getContainer may modify it
PropertyDescriptorPtr containerPropDesc = propDesc;
PropertyContainerPtr container = getContainer(containerPropDesc, containerDomain);
if (container) {
FOCUSLOG(" - container for '%s' is 0x%p\n", propDesc->name(), container.get());
FOCUSLOG(" >>>> RECURSING into accessProperty()\n");
if (aMode==access_read) {
// read needs a result object
ApiValuePtr resultValue = queryValue->newValue(apivalue_object);
err = container->accessProperty(aMode, subQuery, resultValue, containerDomain, containerPropDesc);
if (Error::isOK(err)) {
// add to result with actual name (from descriptor)
FOCUSLOG("\n <<<< RETURNED from accessProperty() recursion\n");
FOCUSLOG(" - accessProperty of container for '%s' returns %s\n", propDesc->name(), resultValue->description().c_str());
aResultObject->add(propDesc->name(), resultValue);
}
}
else {
// for write, just pass the query value
err = container->accessProperty(aMode, subQuery, ApiValuePtr(), containerDomain, containerPropDesc);
FOCUSLOG(" <<<< RETURNED from accessProperty() recursion\n", propDesc->name(), container.get());
}
if ((aMode!=access_read) && Error::isOK(err)) {
// give this container a chance to post-process write access
err = writtenProperty(aMode, propDesc, aDomain, container);
}
// 404 errors are collected, but dont abort the query
if (Error::isError(err, VdcApiError::domain(), 404)) {
if (!errorMsg.empty()) errorMsg += "; ";
errorMsg += string_format("Error(s) accessing subproperties of '%s' : { %s }", queryName.c_str(), err->description().c_str());
err.reset(); // forget the error on this level
}
}
}
}
else {
// addressed (and known by descriptor!) property is a simple value field -> access it
if (aMode==access_read) {
// read access: create a new apiValue and have it filled
ApiValuePtr fieldValue = queryValue->newValue(propDesc->type()); // create a value of correct type to get filled
bool accessOk = accessField(aMode, fieldValue, propDesc); // read
// for read, not getting an OK from accessField means: property does not exist (even if known per descriptor),
// so it will not be added to the result
if (accessOk) {
// add to result with actual name (from descriptor)
aResultObject->add(propDesc->name(), fieldValue);
}
FOCUSLOG(" - accessField for '%s' returns %s\n", propDesc->name(), fieldValue->description().c_str());
}
else {
// write access: just pass the value
if (!accessField(aMode, queryValue, propDesc)) { // write
err = ErrorPtr(new VdcApiError(403,string_format("Write access to '%s' denied", propDesc->name())));
}
}
}
}
else {
// no descriptor found for this query element
// Note: this means that property is not KNOWN, which IS not the same as getting false from accessField
// (latter means that property IS known, but has no value in the context it was queried)
// HOWEVER, for the vdc API it was decided that for reading, these cases should NOT be
// distinguished for getProperty. If a property does not exist for either reason, the return tree just does
// no contain that property.
// Also note that not having a property is not the same as not having a property VALUE:
// latter case will explicitly return a NULL value
if (!wildcard && !foundone && aMode!=access_read) {
// query did address a specific property but it is unknown -> report as error (for read AND write!)
// - collect error message, but do not abort query processing
if (!errorMsg.empty()) errorMsg += "; ";
errorMsg += string_format("Unknown property '%s' -> ignored", queryName.c_str());
}
}
} while (Error::isOK(err) && propIndex!=PROPINDEX_NONE);
}
// now generate error if we have collected a non-empty error message
if (!errorMsg.empty()) {
err = ErrorPtr(new VdcApiError(404,errorMsg));
}
#if DEBUGLOGGING
if (aMode==access_read) {
FOCUSLOG("- query element named '%s' now has result object: %s\n", queryName.c_str(), aResultObject->description().c_str());
}
#endif
}
return err;
}
void VdcJsonApiConnection::jsonResponseHandler(VdcApiResponseCB aResponseHandler, int32_t aResponseId, ErrorPtr &aError, JsonObjectPtr aResultOrErrorData)
{
if (aResponseHandler) {
// create request object just to hold the response ID
string respId = string_format("%d", aResponseId);
ApiValuePtr resultOrErrorData = JsonApiValue::newValueFromJson(aResultOrErrorData);
VdcApiRequestPtr request = VdcJsonApiRequestPtr(new VdcJsonApiRequest(VdcJsonApiConnectionPtr(this), respId.c_str()));
if (Error::isOK(aError)) {
LOG(LOG_INFO,"vdSM -> vDC (JSON) result received: id='%s', result=%s\n", request->requestId().c_str(), resultOrErrorData ? resultOrErrorData->description().c_str() : "<none>");
}
else {
LOG(LOG_INFO,"vdSM -> vDC (JSON) error received: id='%s', error=%s, errordata=%s\n", request->requestId().c_str(), aError->description().c_str(), resultOrErrorData ? resultOrErrorData->description().c_str() : "<none>");
}
aResponseHandler(VdcApiConnectionPtr(this), request, aError, resultOrErrorData);
}
}
ErrorPtr VdcJsonApiConnection::sendRequest(const string &aMethod, ApiValuePtr aParams, VdcApiResponseCB aResponseHandler)
{
JsonApiValuePtr params = boost::dynamic_pointer_cast<JsonApiValue>(aParams);
ErrorPtr err;
if (aResponseHandler) {
// method call expecting response
err = jsonRpcComm->sendRequest(aMethod.c_str(), params->jsonObject(), boost::bind(&VdcJsonApiConnection::jsonResponseHandler, this, aResponseHandler, _1, _2, _3));
LOG(LOG_INFO,"vdSM <- vDC (JSON) method call sent: requestid='%d', method='%s', params=%s\n", jsonRpcComm->lastRequestId(), aMethod.c_str(), aParams ? aParams->description().c_str() : "<none>");
}
else {
// notification
err = jsonRpcComm->sendRequest(aMethod.c_str(), params->jsonObject(), NULL);
LOG(LOG_INFO,"vdSM <- vDC (JSON) notification sent: method='%s', params=%s\n", aMethod.c_str(), aParams ? aParams->description().c_str() : "<none>");
}
return err;
}
void VdcJsonApiConnection::jsonRequestHandler(const char *aMethod, const char *aJsonRpcId, JsonObjectPtr aParams)
{
ErrorPtr respErr;
if (apiRequestHandler) {
// create params API value
ApiValuePtr params = JsonApiValue::newValueFromJson(aParams);
VdcApiRequestPtr request;
// create request object in case this request expects an answer
if (aJsonRpcId) {
// Method
request = VdcJsonApiRequestPtr(new VdcJsonApiRequest(VdcJsonApiConnectionPtr(this), aJsonRpcId));
LOG(LOG_INFO,"vdSM -> vDC (JSON) method call '%s' received: requestid='%s', params=%s\n", aMethod, request->requestId().c_str(), params ? params->description().c_str() : "<none>");
}
else {
// Notification
LOG(LOG_INFO,"vdSM -> vDC (JSON) notification '%s' received: params=%s\n", aMethod, params ? params->description().c_str() : "<none>");
}
// call handler
apiRequestHandler(VdcJsonApiConnectionPtr(this), request, aMethod, params);
}
}
ErrorPtr VdcJsonApiRequest::sendResult(ApiValuePtr aResult)
{
LOG(LOG_INFO,"vdSM <- vDC (JSON) result sent: requestid='%s', result=%s\n", requestId().c_str(), aResult ? aResult->description().c_str() : "<none>");
JsonApiValuePtr result = boost::dynamic_pointer_cast<JsonApiValue>(aResult);
return jsonConnection->jsonRpcComm->sendResult(requestId().c_str(), result ? result->jsonObject() : NULL);
}