d_newGroup d_newGroupNew( d_admin admin, const c_char* partition, const c_char* topic, d_durabilityKind kind, d_completeness completeness, d_quality quality) { d_newGroup newGroup = NULL; if(admin){ newGroup = d_newGroup(os_malloc(C_SIZEOF(d_newGroup))); d_messageInit(d_message(newGroup), admin); if(partition){ newGroup->partition = (c_char*)(os_malloc(strlen(partition) + 1)); os_sprintf(newGroup->partition, partition); } else { newGroup->partition = NULL; } if(topic){ newGroup->topic = (c_char*)(os_malloc(strlen(topic) + 1)); os_sprintf(newGroup->topic, topic); } else { newGroup->topic = NULL; } newGroup->durabilityKind = kind; newGroup->completeness = completeness; newGroup->quality.seconds = quality.seconds; newGroup->quality.nanoseconds = quality.nanoseconds; newGroup->alignerCount = 0; } return newGroup; }
d_deleteData d_deleteDataNew( d_admin admin, d_timestamp actionTime, const c_char* partitionExpr, const c_char* topicExpr) { d_deleteData deleteData = NULL; if(admin){ deleteData = d_deleteData(os_malloc(C_SIZEOF(d_deleteData))); d_messageInit(d_message(deleteData), admin); deleteData->actionTime.seconds = actionTime.seconds; deleteData->actionTime.nanoseconds = actionTime.nanoseconds; if(partitionExpr){ deleteData->partitionExpr = os_strdup(partitionExpr); } else { deleteData->partitionExpr = NULL; } if(topicExpr){ deleteData->topicExpr = os_strdup(topicExpr); } else { deleteData->topicExpr = NULL; } } return deleteData; }
d_sampleChain d_sampleChainNew( d_admin admin, const c_char* partition, const c_char* topic, d_durabilityKind kind, d_networkAddress source) { d_sampleChain sampleChain = NULL; assert(admin); assert(partition); assert(topic); if(admin && partition && topic){ sampleChain = d_sampleChain(os_malloc(C_SIZEOF(d_sampleChain))); d_messageInit(d_message(sampleChain), admin); sampleChain->msgBody._d = BEAD; sampleChain->msgBody._u.bead.size = 0; sampleChain->partition = os_strdup(partition); sampleChain->topic = os_strdup(topic); sampleChain->durabilityKind = kind; sampleChain->addressees = NULL; sampleChain->addresseesCount = 0; sampleChain->source.systemId = source->systemId; sampleChain->source.localId = source->localId; sampleChain->source.lifecycleId = source->lifecycleId; } return sampleChain; }
d_groupsRequest d_groupsRequestNew( d_admin admin, d_partition partition, d_topic topic) { d_groupsRequest groupsRequest = NULL; if(admin){ groupsRequest = d_groupsRequest(os_malloc(C_SIZEOF(d_groupsRequest))); d_messageInit(d_message(groupsRequest), admin); if(partition){ groupsRequest->partition = os_strdup(partition); } else { groupsRequest->partition = NULL; } if(topic){ groupsRequest->topic = os_strdup(topic); } else { groupsRequest->topic = NULL; } } return groupsRequest; }
d_status d_statusNew( d_admin admin) { d_status status = NULL; if(admin){ status = d_status(os_malloc(C_SIZEOF(d_status))); d_messageInit(d_message(status), admin); } return status; }
d_nameSpacesRequest d_nameSpacesRequestNew( d_admin admin) { d_nameSpacesRequest request; request = NULL; if(admin){ request = d_nameSpacesRequest(os_malloc(C_SIZEOF(d_nameSpacesRequest))); if(request){ d_messageInit(d_message(request), admin); } } return request; }
void d_nameSpacesRequestListenerReportNameSpaces( d_nameSpacesRequestListener listener) { c_long count, i; d_networkAddress addr; d_nameSpaces ns; d_admin admin; d_publisher publisher; c_iter nameSpaces; assert(d_listenerIsValid(d_listener(listener), D_NAMESPACES_REQ_LISTENER)); if(listener){ addr = d_networkAddressUnaddressed(); admin = d_listenerGetAdmin(d_listener(listener)); assert (admin); publisher = d_adminGetPublisher(admin); /* Get list of namespaces */ nameSpaces = updateNameSpaces(listener); count = c_iterLength(nameSpaces); for(i=0; i<count; i++){ ns = d_nameSpaces(c_iterObject(nameSpaces, i)); d_messageInit(d_message(ns), admin); d_messageSetAddressee(d_message(ns), addr); d_publisherNameSpacesWrite(publisher, ns, addr); } d_networkAddressFree(addr); /* Free namespace list */ cleanNameSpaces (nameSpaces); } return; }
d_sampleRequest d_sampleRequestNew( d_admin admin, const c_char* partition, const c_char* topic, d_durabilityKind kind, d_timestamp requestTime, c_bool withTimeRange, d_timestamp beginTime, d_timestamp endTime) { d_sampleRequest sampleRequest = NULL; if(admin){ sampleRequest = d_sampleRequest(os_malloc(C_SIZEOF(d_sampleRequest))); d_messageInit(d_message(sampleRequest), admin); sampleRequest->partition = os_strdup(partition); sampleRequest->topic = os_strdup(topic); sampleRequest->durabilityKind = kind; sampleRequest->requestTime = requestTime; sampleRequest->withTimeRange = withTimeRange; sampleRequest->beginTime = beginTime; sampleRequest->endTime = endTime; sampleRequest->source.systemId = 0; sampleRequest->source.localId = 0; sampleRequest->source.lifecycleId = 0; sampleRequest->filter = NULL; sampleRequest->filterParams = NULL; sampleRequest->filterParamsCount = 0; sampleRequest->maxSamples = -1; sampleRequest->maxInstances = -1; sampleRequest->maxSamplesPerInstance = -1; } return sampleRequest; }
d_nameSpaces d_nameSpacesNew( d_admin admin, d_nameSpace nameSpace, d_quality initialQuality, c_ulong total) { d_nameSpaces ns = NULL; d_networkAddress master; d_mergeState state; c_sequence *mergedStatesPtr; struct nsWalkHelper helper; if(nameSpace){ ns = d_nameSpaces(os_malloc(C_SIZEOF(d_nameSpaces))); if(ns){ master = d_networkAddressUnaddressed(); d_messageInit(d_message(ns), admin); ns->aligner = d_nameSpaceIsAligner(nameSpace); ns->durabilityKind = d_nameSpaceGetDurabilityKind(nameSpace); ns->alignmentKind = d_nameSpaceGetAlignmentKind(nameSpace); ns->partitions = d_nameSpaceGetPartitionTopics(nameSpace); ns->total = total; ns->initialQuality.seconds = initialQuality.seconds; ns->initialQuality.nanoseconds = initialQuality.nanoseconds; ns->master.systemId = master->systemId; ns->master.localId = master->localId; ns->master.lifecycleId = master->lifecycleId; ns->isComplete = TRUE; ns->name = os_strdup (d_nameSpaceGetName(nameSpace)); ns->masterConfirmed = d_nameSpaceIsMasterConfirmed(nameSpace); state = d_nameSpaceGetMergeState(nameSpace, NULL); if(state) { ns->state.role = os_strdup(state->role); ns->state.value = state->value; d_mergeStateFree(state); } else { ns->state.role = d_nameSpaceGetRole(nameSpace); ns->state.value = -1; } ns->mergedStatesCount = d_tableSize(nameSpace->mergedRoleStates); if(ns->mergedStatesCount > 0){ ns->mergedStates = os_malloc(C_SIZEOF(d_mergeState)*ns->mergedStatesCount); helper.states = (d_mergeState*)(mergedStatesPtr = &(ns->mergedStates)); helper.index = 0; d_tableWalk(nameSpace->mergedRoleStates, addMergeState, &helper); } else { ns->mergedStates = NULL; } d_networkAddressFree(master); } } return ns; }
void d_nameSpacesRequestListenerAction( d_listener listener, d_message message) { d_durability durability; d_admin admin; d_fellow fellow; d_publisher publisher; c_ulong i, count; d_nameSpaces ns; d_networkAddress addr; d_nameSpacesRequest request; c_bool added; c_iter nameSpaces; assert(d_listenerIsValid(d_listener(listener), D_NAMESPACES_REQ_LISTENER)); admin = d_listenerGetAdmin(listener); durability = d_adminGetDurability(admin); addr = d_networkAddressNew(message->senderAddress.systemId, message->senderAddress.localId, message->senderAddress.lifecycleId); fellow = d_adminGetFellow(admin, addr); publisher = d_adminGetPublisher(admin); d_printTimedEvent(durability, D_LEVEL_FINE, D_THREAD_NAMESPACES_REQUEST_LISTENER, "Received nameSpacesRequest from fellow %d.\n", message->senderAddress.systemId); /* Update nameSpaces list for listener */ nameSpaces = updateNameSpaces(d_nameSpacesRequestListener(listener)); if(!fellow){ fellow = d_fellowNew(addr, message->senderState); d_fellowUpdateStatus(fellow, message->senderState, v_timeGet()); added = d_adminAddFellow(admin, fellow); if(added == FALSE){ d_fellowFree(fellow); fellow = d_adminGetFellow(admin, addr); assert(fellow); } else { fellow = d_adminGetFellow(admin, addr); d_printTimedEvent(durability, D_LEVEL_FINE, D_THREAD_NAMESPACES_REQUEST_LISTENER, "Fellow %d unknown, added to administration and requesting nameSpaces.\n", message->senderAddress.systemId); request = d_nameSpacesRequestNew(admin); d_messageSetAddressee(d_message(request), addr); d_publisherNameSpacesRequestWrite(publisher, request, addr); d_nameSpacesRequestFree(request); } } d_fellowUpdateStatus(fellow, message->senderState, v_timeGet()); count = c_iterLength(nameSpaces); for(i=0; i<count; i++){ ns = d_nameSpaces(c_iterObject(nameSpaces, i)); d_messageInit(d_message(ns), admin); d_messageSetAddressee(d_message(ns), addr); d_publisherNameSpacesWrite(publisher, ns, addr); } cleanNameSpaces (nameSpaces); d_fellowFree(fellow); d_networkAddressFree(addr); return; }