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;
}
