void d_statusListenerInit( d_statusListener listener, d_subscriber subscriber) { d_admin admin; d_durability durability; d_configuration config; admin = d_subscriberGetAdmin(subscriber); durability = d_adminGetDurability(admin); config = d_durabilityGetConfiguration(durability); assert(d_objectIsValid(d_object(subscriber), D_SUBSCRIBER) == TRUE); assert(d_objectIsValid(d_object(admin), D_ADMIN) == TRUE); assert(d_objectIsValid(d_object(durability), D_DURABILITY) == TRUE); assert(d_objectIsValid(d_object(config), D_CONFIGURATION) == TRUE); d_readerListenerInit( d_readerListener(listener), d_statusListenerAction, subscriber, D_STATUS_TOPIC_NAME, D_STATUS_TOP_NAME, V_RELIABILITY_RELIABLE, V_HISTORY_KEEPLAST, 1, config->heartbeatScheduling, d_statusListenerDeinit); listener->cleanupAction = NULL; }
void d_printEvent( d_durability durability, d_level level, const char *format, ...) { va_list args; d_configuration config; config = d_durabilityGetConfiguration(durability); if (config && (((c_ulong)level) >= ((c_ulong)config->tracingVerbosityLevel))) { va_start (args, format); d_doPrint(config, format, args); va_end (args); } }
static c_bool d_statusListenerRemoveDeadFellows( d_action action, c_bool terminate) { d_admin admin; d_configuration config; d_timestamp removeTime; d_durability durability; c_bool result = FALSE; admin = d_admin(d_actionGetArgs(action)); if(d_objectIsValid(d_object(admin), D_ADMIN) == TRUE){ if(terminate == FALSE){ config = d_durabilityGetConfiguration(d_adminGetDurability(admin)); removeTime.seconds = config->heartbeatExpiryTime.tv_sec; removeTime.nanoseconds = config->heartbeatExpiryTime.tv_nsec; while (removeTime.nanoseconds >= 1000000000) { removeTime.seconds += 1; removeTime.nanoseconds -= 1000000000; } /* * Remove the fellow if it didn't report since current time minus * the heartbeat period times the maximum nomber of heartbeat * misses. */ durability = d_adminGetDurability(admin); if(d_durabilityMustTerminate(durability) == FALSE){ removeTime = c_timeSub(v_timeGet(), removeTime); d_adminCleanupFellows(admin, removeTime); } result = TRUE; } } return result; }
d_publisher d_publisherNew( d_admin admin) { d_publisher publisher; d_durability durability; d_configuration config; v_publisherQos publisherQos; v_writerQos writerQos; publisher = NULL; if(admin){ publisher = d_publisher(os_malloc(C_SIZEOF(d_publisher))); d_objectInit(d_object(publisher), D_PUBLISHER, d_publisherDeinit); publisher->enabled = TRUE; publisher->admin = admin; durability = d_adminGetDurability(admin); config = d_durabilityGetConfiguration(durability); publisherQos = d_publisherQosNew(config->partitionName); publisher->publisher = u_publisherNew( u_participant(d_durabilityGetService(durability)), config->publisherName, publisherQos, TRUE); d_publisherQosFree(publisherQos); if(publisher->publisher){ publisher->statusWriter = NULL; publisher->newGroupWriter = NULL; publisher->groupsRequestWriter = NULL; publisher->statusRequestWriter = NULL; publisher->sampleRequestWriter = NULL; publisher->sampleChainWriter = NULL; publisher->nameSpacesWriter = NULL; publisher->nameSpacesRequestWriter = NULL; publisher->deleteDataWriter = NULL; writerQos = d_writerQosNew( V_DURABILITY_VOLATILE, V_RELIABILITY_RELIABLE, config->heartbeatLatencyBudget, config->heartbeatTransportPriority); publisher->statusNumber = 0; publisher->statusWriter = u_writerNew (publisher->publisher, "statusWriter", d_adminGetStatusTopic(admin), d_publisherStatusWriterCopy, writerQos, TRUE); assert(publisher->statusWriter); d_writerQosFree(writerQos); writerQos = d_writerQosNew (V_DURABILITY_VOLATILE, V_RELIABILITY_RELIABLE, config->latencyBudget, config->transportPriority); u_entityAction(u_entity(publisher->statusWriter), d_publisherEnsureServicesAttached, durability); publisher->newGroupNumber = 0; publisher->newGroupWriter = u_writerNew (publisher->publisher, "newGroupWriter", d_adminGetNewGroupTopic(admin), d_publisherNewGroupWriterCopy, writerQos, TRUE); assert(publisher->newGroupWriter); u_entityAction(u_entity(publisher->newGroupWriter), d_publisherEnsureServicesAttached, durability); publisher->groupsRequestNumber = 0; publisher->groupsRequestWriter = u_writerNew (publisher->publisher, "groupsRequestWriter", d_adminGetGroupsRequestTopic(admin), d_publisherGroupsRequestWriterCopy, writerQos, TRUE); assert(publisher->groupsRequestWriter); u_entityAction(u_entity(publisher->groupsRequestWriter), d_publisherEnsureServicesAttached, durability); publisher->statusRequestNumber = 0; publisher->statusRequestWriter = u_writerNew (publisher->publisher, "statusRequestWriter", d_adminGetStatusRequestTopic(admin), d_publisherStatusRequestWriterCopy, writerQos, TRUE); assert(publisher->statusRequestWriter); u_entityAction(u_entity(publisher->statusRequestWriter), d_publisherEnsureServicesAttached, durability); publisher->sampleRequestNumber = 0; publisher->sampleRequestWriter = u_writerNew (publisher->publisher, "sampleRequestWriter", d_adminGetSampleRequestTopic(admin), d_publisherSampleRequestWriterCopy, writerQos, TRUE); assert(publisher->sampleRequestWriter); u_entityAction(u_entity(publisher->sampleRequestWriter), d_publisherEnsureServicesAttached, durability); publisher->nameSpacesNumber = 0; publisher->nameSpacesWriter = u_writerNew (publisher->publisher, "nameSpacesWriter", d_adminGetNameSpacesTopic(admin), d_publisherNameSpacesWriterCopy, writerQos, TRUE); assert(publisher->nameSpacesWriter); u_entityAction(u_entity(publisher->nameSpacesWriter), d_publisherEnsureServicesAttached, durability); publisher->nameSpacesRequestNumber = 0; publisher->nameSpacesRequestWriter = u_writerNew (publisher->publisher, "nameSpacesRequestWriter", d_adminGetNameSpacesRequestTopic(admin), d_publisherNameSpacesRequestWriterCopy, writerQos, TRUE); assert(publisher->nameSpacesRequestWriter); u_entityAction(u_entity(publisher->nameSpacesRequestWriter), d_publisherEnsureServicesAttached, durability); publisher->deleteDataNumber = 0; publisher->deleteDataWriter = u_writerNew (publisher->publisher, "deleteDataWriter", d_adminGetDeleteDataTopic(admin), d_publisherDeleteDataWriterCopy, writerQos, TRUE); assert(publisher->deleteDataWriter); u_entityAction(u_entity(publisher->deleteDataWriter), d_publisherEnsureServicesAttached, durability); d_writerQosFree(writerQos); writerQos = d_writerQosNew (V_DURABILITY_VOLATILE, V_RELIABILITY_RELIABLE, config->alignerLatencyBudget, config->alignerTransportPriority); publisher->sampleChainNumber = 0; publisher->sampleChainWriter = u_writerNew (publisher->publisher, "sampleChainWriter", d_adminGetSampleChainTopic(admin), d_publisherSampleChainWriterCopy, writerQos, TRUE); assert(publisher->sampleChainWriter); u_entityAction(u_entity(publisher->sampleChainWriter), d_publisherEnsureServicesAttached, durability); d_writerQosFree(writerQos); } else { d_publisherFree(publisher); publisher = NULL; } } return publisher; }
void d_nameSpacesListenerAction( d_listener listener, d_message message) { d_durability durability; d_admin admin; d_publisher publisher; d_fellow fellow; c_bool allowed; d_nameSpace nameSpace, localNameSpace, oldFellowNameSpace; c_ulong count; d_configuration config; d_nameSpacesRequest nsRequest; d_networkAddress sender; d_subscriber subscriber; d_sampleChainListener sampleChainListener; struct compatibilityHelper helper; d_adminStatisticsInfo info; c_bool added; os_time srcTime , curTime, difTime, maxDifTime; struct checkFellowMasterHelper fellowMasterHelper; d_name role; c_iter fellowNameSpaces; d_nameSpace ns; assert(d_listenerIsValid(d_listener(listener), D_NAMESPACES_LISTENER)); admin = d_listenerGetAdmin(listener); publisher = d_adminGetPublisher(admin); durability = d_adminGetDurability(admin); config = d_durabilityGetConfiguration(durability); fellowNameSpaces = NULL; d_printTimedEvent (durability, D_LEVEL_FINE, D_THREAD_NAMESPACES_LISTENER, "Received nameSpace from fellow %d (his master: %d, confirmed: %d, mergeState: %s, %d).\n", message->senderAddress.systemId, d_nameSpaces(message)->master.systemId, d_nameSpaces(message)->masterConfirmed, d_nameSpaces(message)->state.role, d_nameSpaces(message)->state.value); sender = d_networkAddressNew(message->senderAddress.systemId, message->senderAddress.localId, message->senderAddress.lifecycleId); fellow = d_adminGetFellow(admin, sender); if(!fellow){ d_printTimedEvent (durability, D_LEVEL_FINE, D_THREAD_NAMESPACES_LISTENER, "Fellow %d unknown, administrating it.\n", message->senderAddress.systemId); fellow = d_fellowNew(sender, message->senderState); d_fellowUpdateStatus(fellow, message->senderState, v_timeGet()); added = d_adminAddFellow(admin, fellow); if(added == FALSE){ d_fellowFree(fellow); fellow = d_adminGetFellow(admin, sender); assert(fellow); } else { fellow = d_adminGetFellow(admin, sender); /*Do this to allow fellowFree at the end*/ nsRequest = d_nameSpacesRequestNew(admin); d_messageSetAddressee(d_message(nsRequest), sender); d_publisherNameSpacesRequestWrite(publisher, nsRequest, sender); d_nameSpacesRequestFree(nsRequest); } } d_fellowUpdateStatus(fellow, message->senderState, v_timeGet()); nameSpace = d_nameSpaceFromNameSpaces(config, d_nameSpaces(message)); if(d_fellowGetCommunicationState(fellow) == D_COMMUNICATION_STATE_APPROVED){ /* Get old namespace of fellow */ oldFellowNameSpace = d_nameSpaceCopy (d_fellowGetNameSpace (fellow, nameSpace)); /* Update master of fellow nameSpace */ added = d_fellowAddNameSpace(fellow, nameSpace); /* Create namespace with local policy (if a match exists) */ localNameSpace = d_nameSpaceNew (config, d_nameSpaceGetName(nameSpace)); /* If namespace is created, add to administration */ if (localNameSpace) { /* Copy partitions to local nameSpace */ d_nameSpaceCopyPartitions (localNameSpace, nameSpace); d_adminAddNameSpace (admin, localNameSpace); d_nameSpaceFree (localNameSpace); } /* If fellow is master for a namespace, report it to admin */ fellowMasterHelper.admin = admin; fellowMasterHelper.fellow = d_fellowGetAddress(fellow); fellowMasterHelper.oldNameSpace = oldFellowNameSpace; checkFellowMasterWalk (nameSpace, &fellowMasterHelper); d_free (fellowMasterHelper.fellow); /* If the namespace was not added to the fellow (because it already existed there), free it */ if(!added){ d_nameSpaceFree(nameSpace); } d_nameSpaceFree (oldFellowNameSpace); } else { info = d_adminStatisticsInfoNew(); d_fellowSetExpectedNameSpaces(fellow, d_nameSpaces(message)->total); d_fellowAddNameSpace(fellow, nameSpace); count = d_fellowNameSpaceCount(fellow); if(count == d_nameSpaces(message)->total){ allowed = isFellowStateCompatible(durability, fellow); if(allowed == TRUE){ config = d_durabilityGetConfiguration(durability); helper.fellow = fellow; helper.compatible = TRUE; d_adminNameSpaceWalk (admin, areFellowNameSpacesCompatible, &helper); if(helper.compatible == TRUE){ if(config->timeAlignment == TRUE){ curTime.tv_sec = d_readerListener(listener)->lastInsertTime.seconds; curTime.tv_nsec = d_readerListener(listener)->lastInsertTime.nanoseconds; srcTime.tv_sec = d_readerListener(listener)->lastSourceTime.seconds; srcTime.tv_nsec = d_readerListener(listener)->lastSourceTime.nanoseconds; maxDifTime.tv_sec = 1; /*1s*/ maxDifTime.tv_nsec = 0; difTime = os_timeAbs(os_timeSub(curTime, srcTime)); if(os_timeCompare(difTime, maxDifTime) == OS_MORE){ d_printTimedEvent (durability, D_LEVEL_WARNING, D_THREAD_NAMESPACES_LISTENER, "Estimated time difference including latency with " \ "fellow %d is %f seconds, which is larger then " \ "expected.\n", message->senderAddress.systemId, os_timeToReal(difTime)); OS_REPORT_2(OS_WARNING, D_CONTEXT, 0, "Estimated time difference including latency " \ "with fellow '%d' is larger then expected " \ "(%f seconds). Durability alignment might not be " \ "reliable. Please align time between these nodes " \ "and restart.", message->senderAddress.systemId, os_timeToReal(difTime)); } else { d_printTimedEvent (durability, D_LEVEL_FINER, D_THREAD_NAMESPACES_LISTENER, "Estimated time difference including latency with " \ "fellow %d is %f seconds.\n", message->senderAddress.systemId, os_timeToReal(difTime)); } } /* Set role of fellow (take native role from namespace) */ role = d_nameSpaceGetRole(nameSpace); d_fellowSetRole (fellow, role); os_free (role); d_fellowSetCommunicationState(fellow, D_COMMUNICATION_STATE_APPROVED); info->fellowsApprovedDif += 1; subscriber = d_adminGetSubscriber(admin); sampleChainListener = d_subscriberGetSampleChainListener(subscriber); if(sampleChainListener){ d_sampleChainListenerTryFulfillChains(sampleChainListener, NULL); } /* Check if the fellow is master for one or more namespaces and report this to admin */ fellowNameSpaces = c_iterNew(NULL); /* Collect fellow namespaces */ d_fellowNameSpaceWalk (fellow, collectFellowNsWalk, fellowNameSpaces); fellowMasterHelper.admin = admin; fellowMasterHelper.fellow = d_fellowGetAddress(fellow); fellowMasterHelper.oldNameSpace = NULL; c_iterWalk (fellowNameSpaces, checkFellowMasterWalk, &fellowMasterHelper); while ((ns = c_iterTakeFirst(fellowNameSpaces))) { d_nameSpaceFree(ns); } c_iterFree(fellowNameSpaces); d_free (fellowMasterHelper.fellow); } else { info->fellowsIncompatibleDataModelDif += 1; d_printTimedEvent (durability, D_LEVEL_WARNING, D_THREAD_NAMESPACES_LISTENER, "Communication with fellow %d NOT approved, because data model is not compatible\n", message->senderAddress.systemId); d_fellowSetCommunicationState(fellow, D_COMMUNICATION_STATE_INCOMPATIBLE_DATA_MODEL); } } else { info->fellowsIncompatibleStateDif += 1; d_printTimedEvent (durability, D_LEVEL_WARNING, D_THREAD_NAMESPACES_LISTENER, "Communication with fellow %d NOT approved, because state is not compatible my state: %d, fellow state: %d\n", message->senderAddress.systemId, d_durabilityGetState(durability), message->senderState); d_fellowSetCommunicationState(fellow, D_COMMUNICATION_STATE_INCOMPATIBLE_STATE); } } else { d_printTimedEvent (durability, D_LEVEL_WARNING, D_THREAD_NAMESPACES_LISTENER, "Received %u of %u nameSpaces from fellow %u.\n", count, d_nameSpaces(message)->total, message->senderAddress.systemId); } d_adminUpdateStatistics(admin, info); d_adminStatisticsInfoFree(info); } d_fellowFree(fellow); d_networkAddressFree(sender); return; }
d_subscriber d_subscriberNew( d_admin admin) { d_subscriber subscriber; d_durability durability; d_configuration config; v_subscriberQos subscriberQos, psubscriberQos; c_char* partitionExpr; struct initialQualityWalkData walkData; d_storeResult result; d_nameSpace nameSpace; c_iter nameSpaces; c_bool nsComplete; d_durabilityKind dkind; subscriber = NULL; if(admin){ subscriber = d_subscriber(os_malloc(C_SIZEOF(d_subscriber))); d_objectInit(d_object(subscriber), D_SUBSCRIBER, d_subscriberDeinit); subscriber->admin = admin; durability = d_adminGetDurability(admin); config = d_durabilityGetConfiguration(durability); subscriberQos = d_subscriberQosNew(config->partitionName); partitionExpr = getPersistentPartitionExpression(admin, durability); psubscriberQos = d_subscriberQosNew(partitionExpr); os_free(partitionExpr); subscriber->subscriber = u_subscriberNew (u_participant(d_durabilityGetService(durability)), config->subscriberName, subscriberQos, TRUE); subscriber->waitset = d_waitsetNew(subscriber, FALSE, FALSE); subscriber->persistentStore = d_storeOpen(durability, config->persistentStoreMode); if(subscriber->persistentStore) { if(psubscriberQos->partition){ /* Collect nameSpaces from admin. */ nameSpaces = d_adminNameSpaceCollect(admin); /* Loop nameSpaces */ while((nameSpace = c_iterTakeFirst(nameSpaces))) { dkind = d_nameSpaceGetDurabilityKind(nameSpace); /* Walk only over persistent nameSpaces */ if((dkind == D_DURABILITY_PERSISTENT) || (dkind == D_DURABILITY_ALL)){ /* If persistent nameSpace is not complete, restore backup */ result = d_storeNsIsComplete (subscriber->persistentStore, nameSpace, &nsComplete); if ( (result == D_STORE_RESULT_OK) && !nsComplete) { /* Incomplete namespace, restore backup. */ d_printTimedEvent(durability, D_LEVEL_WARNING, D_THREAD_GROUP_LOCAL_LISTENER, "Namespace '%s' is incomplete, trying to restore backup.\n", d_nameSpaceGetName(nameSpace)); if (d_storeRestoreBackup (subscriber->persistentStore, nameSpace) != D_STORE_RESULT_OK) { d_printTimedEvent(durability, D_LEVEL_WARNING, D_THREAD_GROUP_LOCAL_LISTENER, "Backup for namespace '%s' could not be restored as no complete backup did exist on disk. Marking namespace as incomplete and continuing.\n", d_nameSpaceGetName(nameSpace)); OS_REPORT_1(OS_WARNING, D_CONTEXT_DURABILITY, 0, "Backup for namespace '%s' could not be restored as no complete backup did exist on disk. Marking namespace as incomplete and continuing.\n", d_nameSpaceGetName (nameSpace)); /* If backup fails, mark master state for nameSpace !D_STATE_COMPLETE */ d_nameSpaceSetMasterState (nameSpace, D_STATE_INIT); } } } d_nameSpaceFree(nameSpace); } /* Free nameSpaces iterator */ assert(c_iterLength(nameSpaces) == 0); c_iterFree(nameSpaces); subscriber->persistentSubscriber = u_subscriberNew(u_participant(d_durabilityGetService(durability)), config->subscriberName, psubscriberQos, TRUE); assert(subscriber->persistentSubscriber); } else { subscriber->persistentSubscriber = NULL; } walkData.subscriber = subscriber; walkData.i = 0; d_adminNameSpaceWalk(admin, nsInitialQualityWalk, &walkData); } else { subscriber->persistentSubscriber = NULL; } assert(subscriber->subscriber); if(subscriber->subscriber){ subscriber->statusListener = NULL; subscriber->groupLocalListener = NULL; subscriber->groupRemoteListener = NULL; subscriber->groupsRequestListener = NULL; subscriber->sampleRequestListener = NULL; subscriber->sampleChainListener = NULL; subscriber->nameSpacesRequestListener = NULL; subscriber->nameSpacesListener = NULL; subscriber->persistentDataListener = NULL; subscriber->deleteDataListener = NULL; } else { d_subscriberFree(subscriber); subscriber = NULL; } d_subscriberQosFree(subscriberQos); d_subscriberQosFree(psubscriberQos); } return subscriber; }
void d_groupRemoteListenerAction( d_listener listener, d_message message) { d_newGroup remote; d_configuration config; d_durability durability; d_admin admin; d_group group, group2; d_fellow fellow; c_bool createLocally, added; v_duration duration; u_group ugroup; d_networkAddress addr; c_bool result; d_subscriber subscriber; d_sampleChainListener sampleChainListener; d_completeness localCompleteness; assert(d_listenerIsValid(d_listener(listener), D_GROUP_REMOTE_LISTENER)); remote = d_newGroup(message); admin = d_listenerGetAdmin(listener); durability = d_adminGetDurability(admin); config = d_durabilityGetConfiguration(durability); addr = d_networkAddressNew(message->senderAddress.systemId, message->senderAddress.localId, message->senderAddress.lifecycleId); fellow = d_adminGetFellow(admin, addr); if(remote->partition && remote->topic){ d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_GROUP_REMOTE_LISTENER, "Received remote group '%s.%s'.\n", remote->partition, remote->topic); } if(fellow){ if(d_fellowGetCommunicationState(fellow) == D_COMMUNICATION_STATE_APPROVED){ if(!(remote->partition) && !(remote->topic)){ d_fellowSetExpectedGroupCount(fellow, remote->alignerCount); } else { group = d_adminGetLocalGroup(admin, remote->partition, remote->topic, remote->durabilityKind); if(!group){ d_printTimedEvent(durability, D_LEVEL_FINE, D_THREAD_GROUP_REMOTE_LISTENER, "Received remote group %s.%s which is locally unknown.\n", remote->partition, remote->topic); /* Group unknown locally, check if it is in the alignee namespace. */ createLocally = d_adminGroupInAligneeNS( admin, remote->partition, remote->topic, remote->durabilityKind); if(createLocally == TRUE){ group = d_groupNew(remote->partition, remote->topic, remote->durabilityKind, remote->completeness, remote->quality); added = d_fellowAddGroup(fellow, group); d_fellowSetExpectedGroupCount(fellow, remote->alignerCount); if(added == FALSE){ d_groupFree(group); group = d_fellowGetGroup(fellow, remote->partition, remote->topic, remote->durabilityKind); if(group){ d_groupUpdate(group, remote->completeness, remote->quality); d_groupFree(group); } } /* Group unknown locally, check if it should be aligned * initially. */ createLocally = d_adminGroupInInitialAligneeNS( admin, remote->partition, remote->topic, remote->durabilityKind); if(createLocally == TRUE){ d_printTimedEvent(durability, D_LEVEL_FINE, D_THREAD_GROUP_REMOTE_LISTENER, "Remote group %s.%s in initial alignee namespace.\n", remote->partition, remote->topic); duration.seconds = 0; duration.nanoseconds = 10000000; ugroup = u_groupNew( u_participant(d_durabilityGetService(durability)), remote->partition, remote->topic, duration); if(ugroup){ d_printTimedEvent(durability, D_LEVEL_FINE, D_THREAD_GROUP_REMOTE_LISTENER, "Remote group %s.%s with quality %d created locally.\n", remote->partition, remote->topic, remote->quality.seconds); u_entityFree(u_entity(ugroup)); } else { d_printTimedEvent(durability, D_LEVEL_WARNING, D_THREAD_GROUP_REMOTE_LISTENER, "Remote group %s.%s with quality %d could NOT be created locally.\n", remote->partition, remote->topic, remote->quality.seconds); /** * TODO: quality must not be taken over * from remote. */ group2 = d_groupNew(remote->partition, remote->topic, remote->durabilityKind, D_GROUP_INCOMPLETE, remote->quality); result = d_groupCreationQueueAdd( d_groupRemoteListener(listener)->groupCreationQueue, group2); if(result == FALSE){ d_printTimedEvent(durability, D_LEVEL_FINER, D_THREAD_GROUP_REMOTE_LISTENER, "Remote group %s.%s already in creation queue. Skipping this one.\n", remote->partition, remote->topic); d_groupFree(group2); } } } else { d_printTimedEvent(durability, D_LEVEL_FINE, D_THREAD_GROUP_REMOTE_LISTENER, "Remote group %s.%s in alignee namespace, but not initial.\n", remote->partition, remote->topic); } } else { d_printTimedEvent(durability, D_LEVEL_INFO, D_THREAD_GROUP_REMOTE_LISTENER, "Remote group '%s.%s' is not in alignee namespace.\n", remote->partition, remote->topic); } } else { localCompleteness = d_groupGetCompleteness(group); group = d_fellowGetGroup(fellow, remote->partition, remote->topic, remote->durabilityKind); if(group){ d_groupUpdate(group, remote->completeness, remote->quality); d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_GROUP_REMOTE_LISTENER, "Updating remote group '%s.%s' completeness: '%d'.\n", remote->partition, remote->topic, remote->completeness); d_groupFree(group); } else if(localCompleteness != D_GROUP_COMPLETE){ group = d_groupNew(remote->partition, remote->topic, remote->durabilityKind, remote->completeness, remote->quality); added = d_fellowAddGroup(fellow, group); if(added == FALSE){ d_groupFree(group); group = d_fellowGetGroup(fellow, remote->partition, remote->topic, remote->durabilityKind); if(group){ d_groupUpdate(group, remote->completeness, remote->quality); d_groupFree(group); } } else { d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_GROUP_REMOTE_LISTENER, "Remote group '%s.%s' with completeness: '%d' registered for fellow.\n", remote->partition, remote->topic, remote->completeness); } } /* A complete group might be interesting in case there are * still unfullfilled chain requests. */ if(remote->completeness == D_GROUP_COMPLETE){ d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_GROUP_REMOTE_LISTENER, "Remote group '%s.%s' complete, check for unfullfilled chains.\n", remote->partition, remote->topic); subscriber = d_adminGetSubscriber(admin); sampleChainListener = d_subscriberGetSampleChainListener(subscriber); group = d_groupNew(remote->partition, remote->topic, remote->durabilityKind, remote->completeness, remote->quality); d_sampleChainListenerTryFulfillChains(sampleChainListener, group); d_groupFree(group); } } } } else { d_printTimedEvent(durability, D_LEVEL_WARNING, D_THREAD_GROUP_REMOTE_LISTENER, "Fellow not approved, so ignore the message.\n"); } d_fellowFree(fellow); } else { d_printTimedEvent(durability, D_LEVEL_WARNING, D_THREAD_GROUP_REMOTE_LISTENER, "Fellow unknown so far, so ignore the message.\n"); } d_networkAddressFree(addr); return; }