static void*
in_discoveryClientWriterMonitor(
void* arg)
{
c_bool result, sendTo, more;
v_message message;
c_ulong sequenceNumber, priority;
v_gid sender, receiver;
c_time sendBefore;
v_networkReaderEntry entry;
os_time sleepTime;
in_writer writer;
os_boolean proceed = TRUE;
v_networkReaderWaitResult nrwr;
if(vclientQueue){
sleepTime.tv_sec = 0;
sleepTime.tv_nsec = 50 * 1000 * 1000;
while(!terminate && proceed){
nrwr = v_networkReaderWait(vclientReader, queueId, &vclientQueue);
if((nrwr & V_WAITRESULT_MSGWAITING) == V_WAITRESULT_MSGWAITING){
more = TRUE;
while(more){
result = v_networkQueueTakeFirst(
vclientQueue, &message, &entry, &sequenceNumber, &sender,
&sendTo, &receiver, &sendBefore, &priority, &more);
if(result){
os_mutexLock (&gluelock);
writer = in_writerLookup(&sender);
if(writer){
if(v_nodeState(message) == L_WRITE){
proceed = in_writerWrite(writer, message);
} else if(v_nodeState(message) == L_DISPOSED){
proceed = in_writerDispose(writer, message);
} else if(v_nodeState(message) == L_UNREGISTER){
proceed = in_writerUnregister(writer, message);
}
}
os_mutexUnlock (&gluelock);
}
}
} else if((nrwr & V_WAITRESULT_TRIGGERED) == V_WAITRESULT_TRIGGERED){
in_printf(IN_LEVEL_FINER, "clientReader triggered...\n");
proceed = FALSE;
}
}
}
return NULL;
}
v_actionResult
nb_topicObjectReaderAction(
c_object o,
c_voidp copyArg, /* c_iter<nb_topicObject> * */
nb_topicObjectAllocFunc allocFunc)
{
nb_topicObject to;
v_actionResult result = 0;
assert(allocFunc);
if(o != NULL){
c_iter *iter;
v_dataReaderSample s = v_dataReaderSample(o);
v_message message = v_dataReaderSampleMessage(s);
const void * from = C_DISPLACE (message, C_MAXALIGNSIZE(sizeof(*message)));
iter = (c_iter*)copyArg;
assert(iter);
v_actionResultSet(result, V_PROCEED);
to = allocFunc();
to->state = v_nodeState(message);
to->writeTime = message->writeTime;
nb_topicObjectCopyOut(to, from);
*iter = c_iterAppend(*iter, to);
}
return result;
}
static v_message
createUnregisterMessage(
v_group group,
v_message message)
{
c_array messageKeyList;
c_long i, nrOfKeys;
v_message unregisterMessage;
assert(!v_stateTest(v_nodeState(message), L_UNREGISTER));
/* Create new message objec */
unregisterMessage = v_topicMessageNew
(group->topic);
/* Copy keyvalues to unregistermessage */
messageKeyList = v_topicMessageKeyList(v_groupTopic(group));
nrOfKeys = c_arraySize(messageKeyList);
for (i=0;i<nrOfKeys;i++) {
c_fieldAssign (messageKeyList[i],
unregisterMessage,
c_fieldValue(messageKeyList[i],message));
}
/* Set instance & writer GID */
unregisterMessage->writerGID =
message->writerGID;
unregisterMessage->writerInstanceGID =
message->writerInstanceGID;
/* Copy messageQos */
c_keep (message->qos);
unregisterMessage->qos = message->qos;
/* Set nodestate to unregister */
v_nodeState(unregisterMessage) = L_UNREGISTER;
unregisterMessage->writeTime = v_timeGet();
#ifndef _NAT_
unregisterMessage->allocTime = unregisterMessage->writeTime;
#endif
return unregisterMessage;
}
static d_storeResult
d_instanceRemoveHistoricalData(
d_instance instance,
const v_groupAction until)
{
d_sample ptr, current;
d_storeResult result;
c_equality equality;
v_state state;
ptr = d_instanceGetTail(instance);
if(ptr){
equality = v_timeCompare(until->actionTime,
d_sampleGetMessage(ptr)->writeTime);
while ((equality != C_LT) && ptr) {
current = ptr;
ptr = ptr->newer;
current->newer = NULL;
d_instanceSetTail(instance, ptr);
state = v_nodeState(d_sampleGetMessage(current));
if (v_stateTest(state, L_WRITE)) {
instance->count--;
instance->messageCount--;
}
if (v_stateTest(state, L_DISPOSED)) {
instance->count--;
}
if(ptr){
ptr->older = NULL;
equality = v_timeCompare(until->actionTime,
d_sampleGetMessage(ptr)->writeTime);
} else {
d_instanceSetHead(instance, NULL);
}
c_free(current);
}
if (instance->oldest == NULL) {
v_stateSet(instance->state, L_EMPTY);
}
assert((instance->count == 0) == (d_instanceGetTail(instance) == NULL));
assert((instance->count == 0) == (d_instanceGetHead(instance) == NULL));
result = D_STORE_RESULT_OK;
} else {
result = D_STORE_RESULT_OK;
}
return result;
}
static d_storeResult
d_instanceRemove (
d_instance instance,
v_message message)
{
d_sample current, sample;
v_state state;
v_message m;
d_storeResult result;
if ((instance != NULL) && (message != NULL)) {
sample = NULL;
current = d_instanceGetHead(instance);
while(!sample && current){
m = d_sampleGetMessage(current);
if(c_timeCompare(m->writeTime, message->writeTime) == C_EQ){
if(v_gidCompare(m->writerGID, message->writerGID) == C_EQ){
if(m->sequenceNumber == message->sequenceNumber){
sample = current;
}
}
}
if(!sample){
current = current->older;
}
}
if(sample){
if (sample->newer != NULL) {
d_sample(sample->newer)->older = c_keep(sample->older);
} else {
assert(d_instanceGetHead(instance) == sample);
d_instanceSetHead(instance,sample->older);
}
if (sample->older != NULL) {
d_sample(sample->older)->newer = sample->newer;
} else {
assert(d_instanceGetTail(instance) == sample);
d_instanceSetTail(instance,sample->newer);
}
state = v_nodeState(d_sampleGetMessage(sample));
if (v_stateTest(state, L_WRITE)) {
instance->count--;
instance->messageCount--;
}
if (v_stateTest(state, L_DISPOSED)) {
instance->count--;
}
c_free(sample);
if (instance->oldest == NULL) {
v_stateSet(instance->state, L_EMPTY);
}
}
assert((instance->count == 0) == (d_instanceGetTail(instance) == NULL));
assert((instance->count == 0) == (d_instanceGetHead(instance) == NULL));
result = D_STORE_RESULT_OK;
} else {
result = D_STORE_RESULT_ILL_PARAM;
}
return result;
}
static d_storeResult
d_instanceInsert(
d_instance instance,
v_message msg,
d_groupInfo groupInfo,
d_sample toInsert)
{
d_sample sample;
d_sample oldest;
d_sample ptr;
v_state state;
c_equality equality;
v_topicQos topicQos;
assert(C_TYPECHECK(instance, d_instance));
assert(C_TYPECHECK(msg, v_message));
assert(C_TYPECHECK(groupInfo, d_groupInfo));
if (msg == NULL) {
return D_STORE_RESULT_ILL_PARAM;
}
topicQos = groupInfo->topic->qos;
if(toInsert){
sample = toInsert;
sample->instance = instance;
} else {
sample = d_groupInfoSampleNew(groupInfo, instance, msg);
}
if (!sample) {
return D_STORE_RESULT_OUT_OF_RESOURCES;
}
if (v_stateTest(instance->state, L_EMPTY)) {
assert(d_instanceGetHead(instance) == NULL);
assert(d_instanceGetTail(instance) == NULL);
assert(instance->count == 0);
d_instanceSetHead(instance,sample);
v_stateClear(instance->state, L_EMPTY);
} else {
assert(d_instanceGetHead(instance) != NULL);
assert(d_instanceGetTail(instance) != NULL);
assert(instance->count != 0);
if(topicQos->orderby.kind == V_ORDERBY_RECEPTIONTIME){
sample->older = d_instanceGetHead(instance);
d_instanceSetHead(instance, sample);
} else {
ptr = d_instanceGetHead(instance);
equality = v_timeCompare(msg->writeTime,
d_sampleGetMessage(ptr)->writeTime);
if (equality == C_LT) {
while (ptr->older != NULL) {
equality = v_timeCompare(msg->writeTime,
d_sampleGetMessage(ptr->older)->writeTime);
if (equality != C_LT) {
break;
}
ptr = ptr->older;
}
sample->newer = ptr;
sample->older = ptr->older;
ptr->older = c_keep(sample);
} else {
sample->older = d_instanceGetHead(instance);
d_instanceSetHead(instance,sample);
}
}
}
assert(c_refCount(sample) == 2);
if (sample->older != NULL) {
sample->older->newer = sample;
} else {
d_instanceSetTail(instance,sample);
}
sample->instance = instance;
state = v_nodeState(msg);
if (v_stateTest(state,L_DISPOSED)) {
instance->count++;
}
if (v_stateTest(state, L_WRITE)) {
if (topicQos->history.kind == V_HISTORY_KEEPALL
|| instance->messageCount < topicQos->history.depth) {
instance->count++;
instance->messageCount++;
} else {
ptr = NULL;
oldest = instance->oldest;
while (!v_messageStateTest(d_sampleGetMessage(oldest),L_WRITE)) {
instance->count--;
ptr = oldest;
oldest = oldest->newer;
}
if (v_messageStateTest(d_sampleGetMessage(oldest),L_DISPOSED)) {
instance->count--;
}
ptr = oldest;
oldest = oldest->newer;
while (!v_messageStateTest(d_sampleGetMessage(oldest),L_WRITE)) {
instance->count--;
ptr = oldest;
oldest = oldest->newer;
}
d_instanceSetTail(instance,oldest);
oldest->older = NULL;
ptr->newer = NULL;
while(ptr){
oldest = ptr->older;
ptr->older = NULL;
c_free(ptr);
ptr = oldest;
}
}
}
if (v_messageStateTest(d_sampleGetMessage(d_instanceGetHead(instance)), L_DISPOSED)) {
v_stateSet(instance->state, L_DISPOSED);
} else {
if (v_stateTest(instance->state, L_DISPOSED)) {
v_stateClear(instance->state, L_DISPOSED);
}
}
c_free(sample);
assert((instance->count == 0) == (d_instanceGetTail(instance) == NULL));
assert((instance->count == 0) == (d_instanceGetHead(instance) == NULL));
return D_STORE_RESULT_OK;
}
