PARCJSON * ccnxManifestHashGroup_ToJson(const CCNxManifestHashGroup *group) { PARCJSON *root = parcJSON_Create(); PARCJSONArray *ptrList = parcJSONArray_Create(); for (size_t i = 0; i < parcLinkedList_Size(group->pointers); i++) { CCNxManifestHashGroupPointer *ptr = (CCNxManifestHashGroupPointer *) parcLinkedList_GetAtIndex(group->pointers, i); PARCJSON *ptrJson = parcJSON_Create(); // Type. parcJSON_AddInteger(ptrJson, "type", ccnxManifestHashGroupPointer_GetType(ptr)); // Digest. char *digestString = parcBuffer_ToHexString(ptr->digest); parcJSON_AddString(ptrJson, "digest", digestString); parcMemory_Deallocate(&digestString); // Add the tuple to the list. PARCJSONValue *val = parcJSONValue_CreateFromJSON(ptrJson); parcJSONArray_AddValue(ptrList, val); // Cleanup parcJSONValue_Release(&val); parcJSON_Release(&ptrJson); } root = parcJSON_AddArray(root, "HashGroup", ptrList); parcJSONArray_Release(&ptrList); if (group->overallDataDigest != NULL) { char *digestString = parcBuffer_ToHexString(group->overallDataDigest); root = parcJSON_AddString(root, "overallDataDigest", digestString); parcMemory_Deallocate((void **) &digestString); } if (group->locator != NULL) { char *locatorString = ccnxName_ToString(group->locator); root = parcJSON_AddString(root, "locator", locatorString); parcMemory_Deallocate((void **) &locatorString); } if (group->entrySize > 0) { root = parcJSON_AddInteger(root, "entrySize", group->entrySize); } if (group->dataSize > 0) { root = parcJSON_AddInteger(root, "dataSize", group->dataSize); } if (group->blockSize > 0) { root = parcJSON_AddInteger(root, "blockSize", group->blockSize); } if (group->treeHeight > 0) { root = parcJSON_AddInteger(root, "treeHeight", group->treeHeight); } return root; }
PARCJSONValue * parcJSONValue_CreateFromTimespec(const struct timespec *timespec) { PARCJSON *jsonTimespec = parcJSON_Create(); parcJSON_AddInteger(jsonTimespec, "seconds", timespec->tv_sec); parcJSON_AddInteger(jsonTimespec, "nanos", timespec->tv_nsec); PARCJSONValue *result = _createValue(PARCJSONValueType_JSON); if (result != NULL) { result->value.object = jsonTimespec; } return result; }
PARCJSONValue * parcJSONValue_CreateFromTimeval(const struct timeval *timeval) { PARCJSON *jsonTimeval = parcJSON_Create(); parcJSON_AddInteger(jsonTimeval, "seconds", timeval->tv_sec); parcJSON_AddInteger(jsonTimeval, "micros", timeval->tv_usec); PARCJSONValue *result = _createValue(PARCJSONValueType_JSON); if (result != NULL) { result->value.object = jsonTimeval; } return result; }
CCNxControl * cpi_CreateResponse(CCNxControl *request, PARCJSON *operation) { PARCJSON *requestJson = ccnxControl_GetJson(request); // use the same key as the request uint64_t seqnum = controlPlaneInterface_GetSequenceNumber(requestJson); PARCJSONValue *value = parcJSON_GetValueByName(requestJson, cpiRequest); assertNotNull(value, "Could not get request or response"); assertTrue(parcJSONValue_IsJSON(value), "cpiRequest should be a JSON object"); PARCJSON *operationJson = parcJSONValue_GetJSON(value); PARCJSONPair *pair = parcJSON_GetPairByIndex(operationJson, 1); const PARCBuffer *opKeyBuf = parcJSONPair_GetName(pair); const char *opKey = parcBuffer_ToString(opKeyBuf); PARCJSON *response = parcJSON_Create(); parcJSON_AddInteger(response, cpiSeqnum, (int) seqnum); parcJSON_AddObject(response, opKey, operation); parcMemory_Deallocate(&opKey); PARCJSON *responseJson = parcJSON_Create(); parcJSON_AddObject(responseJson, cpiResponse, response); parcJSON_Release(&response); CCNxControl *result = ccnxControl_CreateCPIRequest(responseJson); parcJSON_Release(&responseJson); return result; }
/** * Create a PARCBuffer payload containing a JSON string with information about this ContentStore's * size. */ static PARCBuffer * _createStatSizeResponsePayload(const AthenaLRUContentStore *impl, const CCNxName *name, uint64_t chunkNumber) { PARCJSON *json = parcJSON_Create(); parcJSON_AddString(json, "moduleName", AthenaContentStore_LRUImplementation.description); parcJSON_AddInteger(json, "time", parcClock_GetTime(impl->wallClock)); parcJSON_AddInteger(json, "numEntries", impl->numEntries); parcJSON_AddInteger(json, "sizeInBytes", impl->currentSizeInBytes); char *jsonString = parcJSON_ToString(json); parcJSON_Release(&json); PARCBuffer *result = parcBuffer_CreateFromArray(jsonString, strlen(jsonString)); parcMemory_Deallocate(&jsonString); return parcBuffer_Flip(result); }
static CCNxMetaMessage * _create_stats_response(Athena *athena, CCNxName *ccnxName) { PARCJSON *json = parcJSON_Create(); struct timeval tv; gettimeofday(&tv, NULL); uint64_t nowInMillis = (tv.tv_sec * 1000) + (tv.tv_usec / 1000); parcJSON_AddString(json, "moduleName", athenaAbout_Name()); parcJSON_AddInteger(json, "time", nowInMillis); parcJSON_AddInteger(json, "numProcessedInterests", athena->stats.numProcessedInterests); parcJSON_AddInteger(json, "numProcessedContentObjects", athena->stats.numProcessedContentObjects); parcJSON_AddInteger(json, "numProcessedControlMessages", athena->stats.numProcessedControlMessages); parcJSON_AddInteger(json, "numProcessedInterestReturns", athena->stats.numProcessedInterestReturns); char *jsonString = parcJSON_ToString(json); parcJSON_Release(&json); PARCBuffer *payload = parcBuffer_CreateFromArray(jsonString, strlen(jsonString)); parcMemory_Deallocate(&jsonString); CCNxContentObject *contentObject = ccnxContentObject_CreateWithNameAndPayload(ccnxName, parcBuffer_Flip(payload)); ccnxContentObject_SetExpiryTime(contentObject, nowInMillis + 100); // this response is good for 100 millis CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(contentObject); ccnxContentObject_Release(&contentObject); parcBuffer_Release(&payload); return result; }
PARCJSON * parcStopwatch_ToJSON(const PARCStopwatch *instance) { PARCJSON *result = parcJSON_Create(); if (result != NULL) { PARCJSON *start = parcJSON_Create(); parcJSON_AddInteger(start, "seconds", instance->start.tv_sec); parcJSON_AddInteger(start, "microseconds", instance->start.tv_usec); PARCJSON *stop = parcJSON_Create(); parcJSON_AddInteger(stop, "seconds", instance->stop.tv_sec); parcJSON_AddInteger(stop, "microseconds", instance->stop.tv_usec); parcJSON_AddObject(result, "start", start); parcJSON_AddObject(result, "stop", stop); parcJSON_Release(&start); parcJSON_Release(&stop); } return result; }
/** * Given the inner operation member, wrap it in a Request with a sequence number * * Example: * @code * <#example#> * @endcode */ PARCJSON * cpi_CreateRequest(const char *key, PARCJSON *operation) { PARCJSON *result = parcJSON_Create(); PARCJSON *request = parcJSON_Create(); uint64_t seqnum = cpi_GetNextSequenceNumber(); parcJSON_AddInteger(request, cpiSeqnum, (int) seqnum); parcJSON_AddObject(request, key, operation); parcJSON_AddObject(result, cpiRequest, request); parcJSON_Release(&request); return result; }
PARCJSON * ccnxPortalAnchor_ToJSON(const CCNxPortalAnchor *anchor) { ccnxPortalAnchor_OptionalAssertValid(anchor); PARCJSON *result = parcJSON_Create(); if (result != NULL) { char *prefix = ccnxName_ToString(anchor->prefix); parcJSON_AddString(result, "namePrefix", prefix); parcJSON_AddInteger(result, "expireTime", (int64_t) anchor->expireTime); parcMemory_Deallocate(&prefix); } return result; }
LONGBOW_TEST_CASE(JSON, parcJSON_AddInteger) { PARCJSON *json = parcJSON_Create(); char *expectedName = "integer"; uint64_t expectedValue = 12345; parcJSON_AddInteger(json, expectedName, expectedValue); const PARCJSONPair *pair = parcJSON_GetPairByName(json, expectedName); PARCBuffer *actualName = parcJSONPair_GetName(pair); PARCJSONValue *actualValue = parcJSONPair_GetValue(pair); assertTrue(strcmp(expectedName, parcBuffer_Overlay(actualName, 0)) == 0, "Expected name %s, actual %s", expectedName, (char *) parcBuffer_ToString(actualName)); assertTrue(expectedValue == parcJSONValue_GetInteger(actualValue), "Expected %" PRIi64 "d actual %" PRIi64 "d", expectedValue, parcJSONValue_GetInteger(actualValue)); parcJSON_Release(&json); }
static CCNxMetaMessage * _create_linkList_response(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, CCNxName *ccnxName) { PARCJSONArray *jsonLinkList = parcJSONArray_Create(); for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->listenerList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->listenerList, index); const char *linkName = athenaTransportLink_GetName(athenaTransportLink); bool notLocal = athenaTransportLink_IsNotLocal(athenaTransportLink); bool localForced = athenaTransportLink_IsForceLocal(athenaTransportLink); PARCJSON *jsonItem = parcJSON_Create(); parcJSON_AddString(jsonItem, "linkName", linkName); parcJSON_AddInteger(jsonItem, "index", -1); parcJSON_AddBoolean(jsonItem, "notLocal", notLocal); parcJSON_AddBoolean(jsonItem, "localForced", localForced); PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem); parcJSON_Release(&jsonItem); parcJSONArray_AddValue(jsonLinkList, jsonItemValue); parcJSONValue_Release(&jsonItemValue); if (notLocal) { parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link listener%s: %s", localForced ? " (forced remote)" : "", linkName); } else { parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link listener%s: %s", localForced ? " (forced local)" : "", linkName); } } for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->instanceList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, index); if (athenaTransportLink) { const char *linkName = athenaTransportLink_GetName(athenaTransportLink); bool notLocal = athenaTransportLink_IsNotLocal(athenaTransportLink); bool localForced = athenaTransportLink_IsForceLocal(athenaTransportLink); PARCJSON *jsonItem = parcJSON_Create(); parcJSON_AddString(jsonItem, "linkName", linkName); parcJSON_AddInteger(jsonItem, "index", index); parcJSON_AddBoolean(jsonItem, "notLocal", notLocal); parcJSON_AddBoolean(jsonItem, "localForced", localForced); PARCJSONValue *jsonItemValue = parcJSONValue_CreateFromJSON(jsonItem); parcJSON_Release(&jsonItem); parcJSONArray_AddValue(jsonLinkList, jsonItemValue); parcJSONValue_Release(&jsonItemValue); if (notLocal) { parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link instance [%d] %s: %s", index, localForced ? "(forced remote)" : "(remote)", linkName); } else { parcLog_Debug(athenaTransportLinkAdapter->log, "\n Link instance [%d] %s: %s", index, localForced ? "(forced local)" : "(local)", linkName); } } } char *jsonString = parcJSONArray_ToString(jsonLinkList); parcJSONArray_Release(&jsonLinkList); PARCBuffer *payload = parcBuffer_CreateFromArray(jsonString, strlen(jsonString)); CCNxContentObject *contentObject = ccnxContentObject_CreateWithDataPayload(ccnxName, parcBuffer_Flip(payload)); struct timeval tv; gettimeofday(&tv, NULL); uint64_t nowInMillis = (tv.tv_sec * 1000) + (tv.tv_usec / 1000); ccnxContentObject_SetExpiryTime(contentObject, nowInMillis + 100); // this response is good for 100 millis CCNxMetaMessage *result = ccnxMetaMessage_CreateFromContentObject(contentObject); ccnxContentObject_Release(&contentObject); parcBuffer_Release(&payload); parcMemory_Deallocate(&jsonString); athena_EncodeMessage(result); return result; }