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