v_result v_subscriberEnable ( v_subscriber _this) { v_kernel kernel; c_iter list; c_char *partitionName; v_result result = V_RESULT_ILL_PARAM; if (_this) { kernel = v_objectKernel(_this); v_observableAddObserver(v_observable(kernel->groupSet), v_observer(_this), NULL); if (_this->qos->partition != NULL) { list = v_partitionPolicySplit(_this->qos->partition); while((partitionName = c_iterTakeFirst(list)) != NULL) { v_subscriberSubscribe(_this,partitionName); os_free(partitionName); } c_iterFree(list); } result = V_RESULT_OK; } return result; }
void v_topicAdapterNotify( v_topicAdapter adapter, v_event event, c_voidp userData) { C_STRUCT(v_event) e; c_bool forward = TRUE; OS_UNUSED_ARG(userData); assert(adapter != NULL); assert(C_TYPECHECK(adapter,v_topicAdapter)); assert(event != NULL); switch (event->kind) { case V_EVENT_ALL_DATA_DISPOSED: v_statusNotifyAllDataDisposed(v_entity(adapter)->status); break; case V_EVENT_INCONSISTENT_TOPIC: v_statusNotifyInconsistentTopic(v_entity(adapter)->status); break; default: forward = FALSE; break; } if (forward) { e.kind = event->kind; e.source = v_observable(adapter); e.data = NULL; (void)v_entityNotifyListener(v_entity(adapter), &e); } }
/** * PRE: observer must be locked. */ void v_groupStreamNotifyDataAvailable( v_groupStream stream) { /* This Notify method is part of the observer-observable pattern. * It is designed to be invoked when _this object as observer receives * an event from an observable object. * It must be possible to pass the event to the subclass of itself by * calling <subclass>Notify(_this, event, userData). * This implies that _this cannot be locked within any Notify method * to avoid deadlocks. * For consistency _this must be locked by v_observerLock(_this) before * calling this method. */ C_STRUCT(v_event) event; c_bool changed; assert(stream != NULL); assert(C_TYPECHECK(stream,v_groupStream)); changed = v_statusNotifyDataAvailable(v_entity(stream)->status); if (changed) { event.kind = V_EVENT_DATA_AVAILABLE; event.source = v_publicHandle(v_public(stream)); event.userData = NULL; v_observableNotify(v_observable(stream), &event); } return; }
void v_participantInit( v_participant p, const c_char *name, v_participantQos qos, v_statistics s, c_bool enable) { v_kernel kernel; c_base base; v_message builtinMsg; c_type writerProxyType; assert(C_TYPECHECK(p,v_participant)); assert(C_TYPECHECK(qos, v_participantQos)); kernel = v_objectKernel(p); base = c_getBase(p); v_observerInit(v_observer(p),name,s,enable); p->entities = c_setNew(c_resolve(base,"kernelModule::v_entity")); p->qos = c_keep(qos); /* Currently default LIVELINESS policy is used: kind=AUTOMATIC, * duration=INFINITE This setting implies no lease registration. */ p->lease = NULL; p->leaseManager = v_leaseManagerNew(kernel); p->resendQuit = FALSE; c_mutexInit(&p->resendMutex, SHARED_MUTEX); c_condInit(&p->resendCond, &p->resendMutex, SHARED_COND); writerProxyType = v_kernelType(kernel,K_PROXY); p->resendWriters = c_tableNew(writerProxyType, "source.index,source.serial"); p->builtinSubscriber = NULL; if (!v_observableAddObserver(v_observable(kernel),v_observer(p), NULL)) { if (name != NULL) { OS_REPORT_1(OS_WARNING,"Kernel Participant",0, "%s: Cannot observe Kernel events",name); } else { OS_REPORT(OS_WARNING,"Kernel Participant",0, "Cannot observe Kernel events"); } } c_mutexInit(&p->newGroupListMutex,SHARED_MUTEX); p->newGroupList = c_listNew(c_resolve(base, "kernelModule::v_group")); v_observerSetEventMask(v_observer(p), V_EVENT_NEW_GROUP); c_lockInit(&p->lock,SHARED_LOCK); c_mutexInit(&p->builtinLock,SHARED_MUTEX); /* Here the Builtin Topic of the participant is published. * This call mabe a noop in case builtin is disabled on kernel level. */ builtinMsg = v_builtinCreateParticipantInfo(kernel->builtin,p); v_writeBuiltinTopic(kernel, V_PARTICIPANTINFO_ID, builtinMsg); c_free(builtinMsg); }
void v_subscriberFree( v_subscriber s) { v_kernel kernel; v_participant p; v_reader o; v_entity found; c_long sc; kernel = v_objectKernel(s); sc = (c_long)pa_decrement(&(s->shareCount)); if (sc > 0) return; if(sc == 0){ v_observableRemoveObserver(v_observable(kernel->groupSet),v_observer(s), NULL); if (s->qos->share.enable) { found = v_removeShare(kernel,v_entity(s)); assert(found == v_entity(s)); c_free(found); } while ((o = c_take(s->readers)) != NULL) { switch (v_objectKind(o)) { case K_DATAREADER: v_dataReaderFree(v_dataReader(o)); break; case K_DELIVERYSERVICE: v_deliveryServiceFree(v_deliveryService(o)); break; case K_GROUPQUEUE: v_groupQueueFree(v_groupQueue(o)); break; case K_NETWORKREADER: v_networkReaderFree(v_networkReader(o)); break; default: OS_REPORT_1(OS_ERROR, "v_subscriber", 0, "Unknown reader %d", v_objectKind(o)); assert(FALSE); break; } c_free(o); } p = v_participant(s->participant); if (p != NULL) { v_participantRemove(p,v_entity(s)); s->participant = NULL; } v_publicFree(v_public(s)); } else { OS_REPORT_1(OS_ERROR, "v_subscriberFree", 0, "subscriber already freed (shareCount is now %d).", sc); assert(sc == 0); } }
void v_observerDeinit( v_observer o) { assert(o != NULL); assert(C_TYPECHECK(o,v_observer)); v_observableDeinit(v_observable(o)); }
/************************************************************** * Protected functions **************************************************************/ void v_serviceNotify( v_service service, v_event event, c_voidp userData) { v_group group; assert(service != NULL); assert(C_TYPECHECK(service, v_service)); if (event != NULL) { switch (event->kind) { case V_EVENT_SERVICESTATE_CHANGED: break; case V_EVENT_NEW_GROUP: group = v_group(event->userData); if ((group != NULL) && (v_observer(service)->eventData != NULL)) { /* Update new group admin */ c_insert((c_set)v_observer(service)->eventData, group); } /* This allows receiving the event by means of a waitset.*/ v_observableNotify(v_observable(service), event); break; case V_EVENT_HISTORY_DELETE: /* This allows receiving the event by means of a waitset.*/ v_observableNotify(v_observable(service), event); break; case V_EVENT_HISTORY_REQUEST: /* This allows receiving the event by means of a waitset.*/ v_observableNotify(v_observable(service), event); break; case V_EVENT_CONNECT_WRITER: case V_EVENT_PERSISTENT_SNAPSHOT: /* This allows receiving the event by means of a waitset.*/ v_observableNotify(v_observable(service), event); break; default: break; } } v_participantNotify(v_participant(service), event, userData); }
void v_serviceStateInit( v_serviceState serviceState, const c_char *name) { assert(C_TYPECHECK(serviceState, v_serviceState)); v_observableInit(v_observable(serviceState),name, NULL, TRUE); c_lockInit(&serviceState->lock, SHARED_LOCK); serviceState->stateKind = STATE_NONE; }
void v_observerFree( v_observer o) { assert(C_TYPECHECK(o,v_observer)); c_mutexLock(&o->mutex); o->eventFlags |= V_EVENT_OBJECT_DESTROYED; c_condBroadcast(&o->cv); c_mutexUnlock(&o->mutex); v_observableFree(v_observable(o)); }
/************************************************************** * private functions **************************************************************/ static void v_serviceWatchSplicedaemon( v_service service) { v_kernel k; v_serviceManager m; v_serviceState splicedState; k = v_objectKernel(service); m = v_getServiceManager(k); splicedState = v_serviceManagerGetServiceState(m, V_SPLICED_NAME); v_observableAddObserver(v_observable(splicedState), v_observer(service), NULL); }
void v_participantDeleteHistoricalData( v_participant participant, const c_char* partitionExpr, const c_char* topicExpr) { c_iter matchingGroups; v_group group; c_time t; c_value params[2]; C_STRUCT(v_event) event; C_STRUCT(v_historyDeleteEventData) hde; assert(participant != NULL); assert(C_TYPECHECK(participant, v_participant)); assert(partitionExpr); assert(topicExpr); if(partitionExpr && topicExpr){ params[0] = c_stringValue((c_string)partitionExpr); params[1] = c_stringValue((c_string)topicExpr); c_lockRead(&participant->lock); t = v_timeGet(); matchingGroups = v_groupSetSelect( v_objectKernel(participant)->groupSet, "partition.name like %0 AND topic.name like %1", params); c_lockUnlock(&participant->lock); group = v_group(c_iterTakeFirst(matchingGroups)); while(group){ v_groupDeleteHistoricalData(group, t); c_free(group); group = v_group(c_iterTakeFirst(matchingGroups)); } c_iterFree(matchingGroups); hde.partitionExpression = (c_char *)partitionExpr; hde.topicExpression = (c_char *)topicExpr; hde.deleteTime = t; event.kind = V_EVENT_HISTORY_DELETE; event.source = v_publicHandle(v_public(participant)); event.userData = &hde; v_observableNotify(v_observable(v_objectKernel(participant)),&event); } return; }
static void cmx_participantInitDetach( v_public entity, c_voidp args) { v_kernel k; v_serviceManager m; v_serviceState splicedState; OS_UNUSED_ARG(args); k = v_objectKernel(entity); m = v_getServiceManager(k); splicedState = v_serviceManagerGetServiceState(m, V_SPLICED_NAME); v_observableAddObserver(v_observable(splicedState), v_observer(entity), V_EVENTMASK_ALL, NULL); }
void v_serviceFillNewGroups( v_service service) { c_set newGroups; C_STRUCT(v_event) ge; v_group g; v_kernel kernel; c_iter groups = NULL; assert(service != NULL); assert(C_TYPECHECK(service, v_service)); kernel = v_objectKernel(service); newGroups = (c_voidp)c_setNew(v_kernelType(kernel, K_GROUP)); if (newGroups != NULL) { groups = v_groupSetSelectAll(kernel->groupSet); /* Take the first group and at the end notify the service about this new group. * But before push all other groups to the servive newGroup set so that only one trigger * is required to notify all groups. * The first group is automatically added to the newGroup set by the notification. * TODO : get rid of this mechanism. */ ge.data = v_group(c_iterTakeFirst(groups)); if (ge.data) { ge.kind = V_EVENT_NEW_GROUP; ge.source = v_observable(kernel); ospl_c_insert(newGroups, ge.data); while ((g = v_group(c_iterTakeFirst(groups))) != NULL) { ospl_c_insert(newGroups, g); c_free(g); } OSPL_BLOCK_EVENTS(service); c_free(service->newGroups); service->newGroups = (c_voidp)newGroups; OSPL_UNBLOCK_EVENTS(service); OSPL_TRIGGER_EVENT((service), &ge, NULL); } c_iterFree(groups); } }
void v_observerInit( v_observer o, const c_char *name, v_statistics s, c_bool enable) { assert(o != NULL); assert(C_TYPECHECK(o,v_observer)); c_mutexInit(&o->mutex,SHARED_MUTEX); /* mutex to protect attributes */ c_condInit(&o->cv, &o->mutex, SHARED_COND); /* condition variable */ o->waitCount = 0; /* number of waiting threads */ o->eventMask = 0; /* specifies, interested events */ o->eventFlags = 0; /* ocurred events */ o->eventData = NULL; /* general post box for derived classes */ v_observableInit(v_observable(o),name, s, enable); }
v_result v_kernelCreatePersistentSnapshot( v_kernel _this, const c_char * partition_expression, const c_char * topic_expression, const c_char * uri) { v_result result = V_RESULT_OK; C_STRUCT(v_event) event; v_persistentSnapshotRequest request; request = v_persistentSnapshotRequestNew(_this, partition_expression, topic_expression, uri); if(request) { event.kind = V_EVENT_PERSISTENT_SNAPSHOT; event.source = v_publicHandle(v_public(_this)); event.userData = request; v_observableNotify(v_observable(_this),&event); } else { result = V_RESULT_OUT_OF_MEMORY; } return result; }
/************************************************************** * Public functions **************************************************************/ c_bool v_serviceStateChangeState( v_serviceState serviceState, v_serviceStateKind stateKind) { c_bool changed; C_STRUCT(v_event) event; assert(C_TYPECHECK(serviceState, v_serviceState)); c_lockWrite(&serviceState->lock); switch (stateKind) { case STATE_NONE: break; case STATE_DIED: if ((serviceState->stateKind != STATE_NONE) && (serviceState->stateKind != STATE_TERMINATED)) { serviceState->stateKind = stateKind; } break; case STATE_INITIALISING: if ((serviceState->stateKind == STATE_NONE) || (serviceState->stateKind == STATE_DIED)) { serviceState->stateKind = stateKind; } break; case STATE_OPERATIONAL: if (serviceState->stateKind == STATE_INITIALISING) { serviceState->stateKind = stateKind; } break; case STATE_INCOMPATIBLE_CONFIGURATION: if ((serviceState->stateKind == STATE_OPERATIONAL) || (serviceState->stateKind == STATE_INITIALISING)) { serviceState->stateKind = stateKind; } break; case STATE_TERMINATING: if ((serviceState->stateKind == STATE_INITIALISING) || (serviceState->stateKind == STATE_OPERATIONAL)) { serviceState->stateKind = stateKind; } break; case STATE_TERMINATED: if (serviceState->stateKind == STATE_TERMINATING) { serviceState->stateKind = stateKind; } break; default: OS_REPORT_1(OS_ERROR,"Kernel::ServiceState",0, "Unkown state (%d) kind provided.",stateKind); assert(FALSE); /* unknown state */ break; } if (serviceState->stateKind == stateKind) { changed = TRUE; } else { changed = FALSE; } c_lockUnlock(&serviceState->lock); event.kind = V_EVENT_SERVICESTATE_CHANGED; event.source = v_publicHandle(v_public(serviceState)); event.userData = NULL; v_observableNotify(v_observable(serviceState),&event); return changed; }
void v_participantFree( v_participant p) { v_message builtinMsg; v_participant found; v_entity e; v_kernel kernel; /* Not clear yet why builtin subscriber lock and participant lock are not taken now? * Also not clear why observer lock is not taken but is freed at the end! */ if (p != NULL) { assert(C_TYPECHECK(p,v_participant)); kernel = v_objectKernel(p); if (!v_observableRemoveObserver(v_observable(kernel),v_observer(p), NULL)) { if (v_participantName(p) != NULL) { OS_REPORT_1(OS_WARNING,"v_participantFree",0, "Participant '%s' cannot disconnect from Kernel events", v_participantName(p)); } else { OS_REPORT(OS_WARNING,"v_participantFree",0, "Participant cannot disconnect from Kernel events"); } } builtinMsg = v_builtinCreateParticipantInfo(kernel->builtin,p); v_writeDisposeBuiltinTopic(kernel, V_PARTICIPANTINFO_ID, builtinMsg); c_free(builtinMsg); builtinMsg = v_builtinCreateParticipantInfo(kernel->builtin,p); v_unregisterBuiltinTopic(kernel, V_PARTICIPANTINFO_ID, builtinMsg); c_free(builtinMsg); if (p->builtinSubscriber) { v_subscriberFree(p->builtinSubscriber); p->builtinSubscriber = NULL; } while ((e = c_take(p->entities)) != NULL) { switch (v_objectKind(e)) { case K_PUBLISHER: v_publisherFree(v_publisher(e)); break; case K_SUBSCRIBER: v_subscriberFree(v_subscriber(e)); break; case K_WAITSET: v_waitsetFree(v_waitset(e)); break; default: OS_REPORT_1(OS_WARNING,"Kernel Participant",0, "Illegal contained object (%s)", v_participantName(p)); break; } c_free(e); /* deref o since c_take will not */ } found = v_removeParticipant(kernel,p); assert(found == p); c_free(found); v_observerFree(v_observer(p)); } }
v_historyResult v_readerWaitForHistoricalDataWithCondition( v_reader _this, c_char* filter, c_char* params[], c_ulong paramsLength, c_time minSourceTime, c_time maxSourceTime, struct v_resourcePolicy *resourceLimits, c_time timeout) { c_iter entries; c_object e; v_historyResult result; v_historicalDataRequest request; c_bool doRequest, doWait; struct historicalWaitArg arg; C_STRUCT(v_event) event; arg._expire_time = c_timeAdd(v_timeGet(), timeout); arg._status = TRUE; request = v_historicalDataRequestNew(v_objectKernel(_this), filter, params, paramsLength, minSourceTime, maxSourceTime, resourceLimits); if(request){ V_READER_LOCK(_this); if(_this->historicalDataRequest) { /* Historical data request already in progress or complete, check * whether request is equal to the original one. */ doRequest = FALSE; if(v_historicalDataRequestEquals(request, _this->historicalDataRequest)){ /* Request is equal to original request*/ result = V_HISTORY_RESULT_OK; if(_this->historicalDataComplete){ /* Request has already been fulfilled. Consider this call * a no-operation. */ doWait = FALSE; } else { /* Request is still in progress, wait for data to arrive*/ doWait = TRUE; } } else { /* The requested parameters are not equal to the originally * requested set. Return a precondition not met. */ doWait = FALSE; result = V_HISTORY_RESULT_PRE_NOT_MET; } c_free(request); } else { /* No active request, so validate it now.*/ if(v_historicalDataRequestIsValid(request, _this)){ /* This request is valid, so request data.*/ doRequest = TRUE; doWait = TRUE; result = V_HISTORY_RESULT_OK; _this->historicalDataRequest = request; } else { /* Request is not valid, so return bad parameter.*/ doRequest = FALSE; doWait = FALSE; result = V_HISTORY_RESULT_BAD_PARAM; c_free(request); } } V_READER_UNLOCK(_this); } else { doRequest = FALSE; doWait = FALSE; result = V_HISTORY_RESULT_ERROR; } if(doWait){ v_readerEntrySetLock(_this); entries = c_select(_this->entrySet.entries, 0); v_readerEntrySetUnlock(_this); if(doRequest){ /* Historical data must be requested, since this is the first time * the operation is called and the request is valid. */ if (_this->qos->durability.kind == V_DURABILITY_VOLATILE) { /* If reader is volatile, the historical data from the * group(s) has/have not been retrieved yet, so do it now. */ e = c_iterTakeFirst(entries); while (e != NULL) { getHistoricalData(e, _this->historicalDataRequest); c_free(e); e = c_iterTakeFirst(entries); } c_iterFree(entries); } event.kind = V_EVENT_HISTORY_REQUEST; event.source = v_publicHandle(v_public(_this)); event.userData = _this->historicalDataRequest; v_observableNotify(v_observable(v_objectKernel(_this)),&event); } V_READER_LOCK(_this); if(!_this->historicalDataComplete){ if (c_timeCompare(timeout, C_TIME_INFINITE) != C_EQ) { if (c_condTimedWait(&_this->historicalDataCondition, &V_READER_GET_LOCK(_this), timeout) != SYNC_RESULT_SUCCESS) { result = V_HISTORY_RESULT_TIMEOUT; } } else if (c_condWait(&_this->historicalDataCondition, &V_READER_GET_LOCK(_this)) != SYNC_RESULT_SUCCESS) { result = V_HISTORY_RESULT_TIMEOUT; } assert( (result == V_HISTORY_RESULT_OK) == _this->historicalDataComplete); } V_READER_UNLOCK(_this); } return result; }
v_kernel v_kernelNew( c_base base, const c_char *name, v_kernelQos qos) { v_kernel kernel; v_kernelStatistics kernelStatistics; v_spliced sd; kernel = c_lookup(base,name); if (kernel != NULL) { assert(C_TYPECHECK(kernel,v_kernel)); kernel->userCount++; return kernel; } loadkernelModule(base); kernel = (v_kernel)c_new(c_resolve(base,"kernelModule::v_kernel")); if (!kernel) { OS_REPORT(OS_ERROR, "v_kernelNew",0, "Failed to allocate kernel."); return NULL; } v_objectKind(kernel) = K_KERNEL; v_object(kernel)->kernel = (c_voidp)kernel; kernel->handleServer = v_handleServerNew(base); #define INITTYPE(k,t,l) k->type[l] = c_resolve(base,#t) INITTYPE(kernel,kernelModule::v_kernel, K_KERNEL); INITTYPE(kernel,kernelModule::v_participant, K_PARTICIPANT); INITTYPE(kernel,kernelModule::v_waitset, K_WAITSET); INITTYPE(kernel,kernelModule::v_condition, K_CONDITION); INITTYPE(kernel,kernelModule::v_query, K_QUERY); INITTYPE(kernel,kernelModule::v_dataReaderQuery, K_DATAREADERQUERY); INITTYPE(kernel,kernelModule::v_dataViewQuery, K_DATAVIEWQUERY); INITTYPE(kernel,kernelModule::v_dataView, K_DATAVIEW); INITTYPE(kernel,kernelModule::v_dataViewSample, K_DATAVIEWSAMPLE); INITTYPE(kernel,kernelModule::v_dataViewInstance, K_DATAVIEWINSTANCE); INITTYPE(kernel,kernelModule::v_projection, K_PROJECTION); INITTYPE(kernel,kernelModule::v_mapping, K_MAPPING); INITTYPE(kernel,kernelModule::v_topic, K_TOPIC); INITTYPE(kernel,kernelModule::v_message, K_MESSAGE); INITTYPE(kernel,kernelModule::v_transaction, K_TRANSACTION); INITTYPE(kernel,kernelModule::v_dataReaderInstance, K_DATAREADERINSTANCE); INITTYPE(kernel,kernelModule::v_purgeListItem, K_PURGELISTITEM); INITTYPE(kernel,kernelModule::v_groupPurgeItem, K_GROUPPURGEITEM); INITTYPE(kernel,kernelModule::v_dataReaderSample, K_READERSAMPLE); INITTYPE(kernel,kernelModule::v_publisher, K_PUBLISHER); INITTYPE(kernel,kernelModule::v_subscriber, K_SUBSCRIBER); INITTYPE(kernel,kernelModule::v_partition, K_DOMAIN); INITTYPE(kernel,kernelModule::v_partitionInterest, K_DOMAININTEREST); INITTYPE(kernel,kernelModule::v_partitionAdmin, K_DOMAINADMIN); INITTYPE(kernel,kernelModule::v_reader, K_READER); INITTYPE(kernel,kernelModule::v_writer, K_WRITER); INITTYPE(kernel,kernelModule::v_writerGroup, K_WRITERGROUP); INITTYPE(kernel,kernelModule::v_group, K_GROUP); INITTYPE(kernel,kernelModule::v_groupInstance, K_GROUPINSTANCE); INITTYPE(kernel,kernelModule::v_groupSample, K_GROUPSAMPLE); INITTYPE(kernel,kernelModule::v_groupCacheItem, K_GROUPCACHEITEM); INITTYPE(kernel,kernelModule::v_cache, K_CACHE); INITTYPE(kernel,kernelModule::v_entry, K_ENTRY); INITTYPE(kernel,kernelModule::v_dataReaderEntry, K_DATAREADERENTRY); INITTYPE(kernel,kernelModule::v_groupAction, K_GROUPACTION); INITTYPE(kernel,kernelModule::v_groupStream, K_GROUPSTREAM); INITTYPE(kernel,kernelModule::v_groupQueue, K_GROUPQUEUE); INITTYPE(kernel,kernelModule::v_groupQueueSample, K_GROUPQUEUESAMPLE); INITTYPE(kernel,kernelModule::v_dataReader, K_DATAREADER); INITTYPE(kernel,kernelModule::v_deliveryService, K_DELIVERYSERVICE); INITTYPE(kernel,kernelModule::v_deliveryServiceEntry, K_DELIVERYSERVICEENTRY); INITTYPE(kernel,kernelModule::v_index, K_INDEX); INITTYPE(kernel,kernelModule::v_filter, K_FILTER); INITTYPE(kernel,kernelModule::v_readerStatus, K_READERSTATUS); INITTYPE(kernel,kernelModule::v_writerStatus, K_WRITERSTATUS); INITTYPE(kernel,kernelModule::v_partitionStatus, K_DOMAINSTATUS); INITTYPE(kernel,kernelModule::v_topicStatus, K_TOPICSTATUS); INITTYPE(kernel,kernelModule::v_subscriberStatus, K_SUBSCRIBERSTATUS); INITTYPE(kernel,kernelModule::v_status, K_PUBLISHERSTATUS); INITTYPE(kernel,kernelModule::v_status, K_PARTICIPANTSTATUS); INITTYPE(kernel,kernelModule::v_kernelStatus, K_KERNELSTATUS); INITTYPE(kernel,kernelModule::v_readerStatistics, K_READERSTATISTICS); INITTYPE(kernel,kernelModule::v_writerStatistics, K_WRITERSTATISTICS); INITTYPE(kernel,kernelModule::v_queryStatistics, K_QUERYSTATISTICS); INITTYPE(kernel,kernelModule::v_lease, K_LEASE); INITTYPE(kernel,kernelModule::v_leaseAction, K_LEASEACTION); INITTYPE(kernel,kernelModule::v_serviceManager, K_SERVICEMANAGER); INITTYPE(kernel,kernelModule::v_service, K_SERVICE); INITTYPE(kernel,kernelModule::v_serviceState, K_SERVICESTATE); INITTYPE(kernel,kernelModule::v_networking, K_NETWORKING); INITTYPE(kernel,kernelModule::v_durability, K_DURABILITY); INITTYPE(kernel,kernelModule::v_cmsoap, K_CMSOAP); INITTYPE(kernel,kernelModule::v_leaseManager, K_LEASEMANAGER); INITTYPE(kernel,kernelModule::v_groupSet, K_GROUPSET); INITTYPE(kernel,kernelModule::v_proxy, K_PROXY); INITTYPE(kernel,kernelModule::v_waitsetEvent, K_WAITSETEVENT); INITTYPE(kernel,kernelModule::v_waitsetEventHistoryDelete, K_WAITSETEVENTHISTORYDELETE); INITTYPE(kernel,kernelModule::v_waitsetEventHistoryRequest, K_WAITSETEVENTHISTORYREQUEST); INITTYPE(kernel,kernelModule::v_waitsetEventPersistentSnapshot, K_WAITSETEVENTPERSISTENTSNAPSHOT); INITTYPE(kernel,kernelModule::v_writerSample, K_WRITERSAMPLE); INITTYPE(kernel,kernelModule::v_writerInstance, K_WRITERINSTANCE); INITTYPE(kernel,kernelModule::v_writerInstanceTemplate, K_WRITERINSTANCETEMPLATE); INITTYPE(kernel,kernelModule::v_writerCacheItem, K_WRITERCACHEITEM); /* Networking types */ INITTYPE(kernel,kernelModule::v_networkReader, K_NETWORKREADER); INITTYPE(kernel,kernelModule::v_networkReaderEntry, K_NETWORKREADERENTRY); INITTYPE(kernel,kernelModule::v_networkMessage, K_NETWORKMESSAGE); INITTYPE(kernel,kernelModule::v_networkMapEntry, K_NETWORKMAPENTRY); INITTYPE(kernel,kernelModule::v_spliced, K_SPLICED); INITTYPE(kernel,kernelModule::v_configuration, K_CONFIGURATION); INITTYPE(kernel,kernelModule::v_registration, K_REGISTRATION); INITTYPE(kernel,kernelModule::v_historicalDataRequest,K_HISTORICALDATAREQUEST); INITTYPE(kernel,kernelModule::v_persistentSnapshotRequest,K_PERSISTENTSNAPSHOTREQUEST); INITTYPE(kernel,kernelModule::v_pendingDisposeElement,K_PENDINGDISPOSEELEMENT); #undef INITTYPE kernel->pendingDisposeList = c_listNew(v_kernelType(kernel, K_PENDINGDISPOSEELEMENT )); c_mutexInit(&kernel->pendingDisposeListMutex, SHARED_MUTEX); kernelStatistics = v_kernelStatisticsNew(kernel); v_observableInit(v_observable(kernel), V_KERNEL_VERSION, v_statistics(kernelStatistics), TRUE); c_lockInit(&kernel->lock,SHARED_LOCK); kernel->qos = v_kernelQosNew(kernel, qos); { os_time time; /* Fill GID with 'random' value */ memset(&kernel->GID, 0, sizeof(kernel->GID)); time = os_timeGet(); kernel->GID.systemId = time.tv_nsec; } kernel->participants = c_setNew(v_kernelType(kernel,K_PARTICIPANT)); kernel->partitions = c_tableNew(v_kernelType(kernel,K_DOMAIN),"name"); kernel->topics = c_tableNew(v_kernelType(kernel,K_TOPIC),"name"); kernel->groupSet = v_groupSetNew(kernel); kernel->serviceManager = v_serviceManagerNew(kernel); kernel->livelinessLM = v_leaseManagerNew(kernel); kernel->configuration = NULL; kernel->userCount = 1; kernel->transactionCount = 0; kernel->splicedRunning = TRUE; kernel->maxSamplesWarnLevel = V_KERNEL_MAX_SAMPLES_WARN_LEVEL_DEF; kernel->maxSamplesWarnShown = FALSE; kernel->maxSamplesPerInstanceWarnLevel = V_KERNEL_MAX_SAMPLES_PER_INSTANCES_WARN_LEVEL_DEF; kernel->maxSamplesPerInstanceWarnShown = FALSE; kernel->maxInstancesWarnLevel = V_KERNEL_MAX_INSTANCES_WARN_LEVEL_DEF; kernel->maxInstancesWarnShown = FALSE; kernel->enabledStatisticsCategories = c_listNew(c_resolve(base, "kernelModule::v_statisticsCategory")); c_mutexInit(&kernel->sharesMutex, SHARED_MUTEX); kernel->shares = c_tableNew(v_kernelType(kernel,K_SUBSCRIBER), "qos.share.name"); kernel->crc = v_crcNew(kernel, V_CRC_KEY); kernel->builtin = v_builtinNew(kernel); kernel->deliveryService = NULL; sd = v_splicedNew(kernel); c_free(sd); c_bind(kernel,name); return kernel; }