v_cmsoap
v_cmsoapNew(
v_serviceManager manager,
const c_char *name,
const c_char *extStateName,
v_participantQos qos)
{
v_kernel k;
v_cmsoap s;
v_participantQos q;
assert(C_TYPECHECK(manager, v_serviceManager));
assert(name != NULL);
k = v_objectKernel(manager);
q = v_participantQosNew(k, qos);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_cmsoapNew", 0,
"CMSoap service not created: inconsistent qos");
s = NULL;
} else {
s = v_cmsoap(v_objectNew(k, K_CMSOAP));
v_serviceInit(v_service(s), manager, name, extStateName, q, v_statistics(v_cmsoapStatisticsNew(k)));
c_free(q);
/* always add, even when s->state==NULL, since v_participantFree always
removes the participant.*/
v_addParticipant(k, v_participant(s));
if (v_service(s)->state == NULL) {
v_serviceFree(v_service(s));
s = NULL;
}
}
return s;
}
void
v_writerStatisticsInit(
v_writerStatistics ws)
{
assert(ws != NULL);
assert(C_TYPECHECK(ws, v_writerStatistics));
v_statisticsInit(v_statistics(ws));
ws->numberOfWrites = 0;
ws->numberOfDisposes = 0;
ws->numberOfRegisters = 0;
ws->numberOfImplicitRegisters = 0;
ws->numberOfUnregisters = 0;
ws->numberOfTimedOutWrites = 0;
ws->numberOfWritesBlockedBySamplesLimit = 0;
ws->numberOfWritesBlockedByInstanceLimit = 0;
ws->numberOfWritesBlockedBySamplesPerInstanceLimit = 0;
ws->numberOfRetries = 0;
ws->numberOfInstancesWithStatusAlive = 0;
ws->numberOfInstancesWithStatusDisposed = 0;
ws->numberOfInstancesWithStatusUnregistered = 0;
ws->numberOfSamples = 0;
v_maxValueInit(&ws->maxNumberOfSamplesPerInstance);
}
v_networkReader
v_networkReaderNew(
v_subscriber subscriber,
const c_char *name,
v_readerQos qos,
c_bool ignoreReliabilityQoS)
{
/* Note: currently, no qos-es are supported. Everything is redirected
* to the defaultQueue */
v_kernel kernel;
v_networkReader reader;
v_readerQos q;
v_statistics s;
c_type queueType;
c_long i;
assert(C_TYPECHECK(subscriber,v_subscriber));
/* Creation */
kernel = v_objectKernel(subscriber);
q = v_readerQosNew(kernel,qos);
if (q != NULL) {
reader = v_networkReader(v_objectNew(kernel,K_NETWORKREADER));
s = v_statistics(v_networkReaderStatisticsNew(kernel));
/* Initialization of parent */
v_readerInit(v_reader(reader), name, subscriber, q, s, TRUE);
c_free(q); /* ref now in v_reader(queue)->qos */
/* This function only ever called once per network instance so no
* need to store queueType as static variable. Look up as needed (once)
*/
queueType = c_resolve(c_getBase(subscriber),"kernelModule::v_networkQueue");
/* Initialization of self */
reader->queues = NULL;
reader->queues = c_arrayNew(queueType, NW_MAX_NOF_QUEUES);
reader->nofQueues = 0;
reader->defaultQueue = NULL;
reader->remoteActivity = FALSE;
reader->ignoreReliabilityQoS = ignoreReliabilityQoS;
reader->queueCache = c_arrayNew(queueType, 2*NW_MAX_QUEUE_CACHE_PRIO);
for( i= 0; i < 2*NW_MAX_QUEUE_CACHE_PRIO; i++) {
reader->queueCache[i] = NULL;
}
c_free(queueType);
/* Add to subscriber */
v_subscriberAddReader(subscriber,v_reader(reader));
} else {
OS_REPORT(OS_ERROR, "v_networkReaderNew", 0,
"NetworkReader not created: inconsistent qos");
reader = NULL;
}
return reader;
}
void v_queryStatisticsInit(v_queryStatistics qs)
{
assert(qs != NULL);
assert(C_TYPECHECK(qs,v_queryStatistics));
v_statisticsInit(v_statistics(qs));
qs->numberOfReads = 0;
qs->numberOfInstanceReads = 0;
qs->numberOfNextInstanceReads = 0;
qs->numberOfTakes = 0;
qs->numberOfInstanceTakes = 0;
qs->numberOfNextInstanceTakes = 0;
}
c_bool v_readerStatisticsReset(v_readerStatistics rs, const c_char* fieldName)
{
c_bool result;
assert(rs!=NULL);
assert(C_TYPECHECK(rs, v_readerStatistics));
result = FALSE;
if (fieldName != NULL) {
result = v_statisticsResetField(v_statistics(rs), fieldName);
} else {
v_maxValueReset(&rs->maxSampleSize);
v_maxValueReset(&rs->maxSamplesPerInstance);
v_maxValueReset(&rs->maxNumberOfSamples);
v_maxValueReset(&rs->maxNumberOfInstances);
v_fullCounterReset(&rs->readLatency);
v_fullCounterReset(&rs->transportLatency);
v_statisticsULongResetInternal(v_reader, numberOfSamples, rs);
v_statisticsULongResetInternal(v_reader, numberOfInstances, rs);
v_statisticsULongResetInternal(v_reader, numberOfInstancesWithStatusNew, rs);
v_statisticsULongResetInternal(v_reader, numberOfInstancesWithStatusAlive, rs);
v_statisticsULongResetInternal(v_reader, numberOfInstancesWithStatusDisposed, rs);
v_statisticsULongResetInternal(v_reader, numberOfInstancesWithStatusNoWriters, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesWithStatusRead, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesExpired, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesPurgedByDispose, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesPurgedByNoWriters, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesArrived, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesInserted, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesDiscarded, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesRead, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesTaken, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesRejectedBySamplesLimit, rs);
v_statisticsULongResetInternal(v_reader, numberOfSamplesRejectedByInstancesLimit, rs);
v_statisticsULongResetInternal(v_reader, numberOfReads, rs);
v_statisticsULongResetInternal(v_reader, numberOfInstanceReads, rs);
v_statisticsULongResetInternal(v_reader, numberOfNextInstanceReads, rs);
v_statisticsULongResetInternal(v_reader, numberOfInstanceLookups, rs);
v_statisticsULongResetInternal(v_reader, numberOfTakes, rs);
v_statisticsULongResetInternal(v_reader, numberOfInstanceTakes, rs);
v_statisticsULongResetInternal(v_reader, numberOfNextInstanceTakes, rs);
result = TRUE;
}
return result;
}
v_networking
v_networkingNew(
v_serviceManager manager,
const c_char *name,
const c_char *extStateName,
v_participantQos qos)
{
v_kernel k;
v_networking s;
v_participantQos q;
v_networkingStatistics ns;
assert(C_TYPECHECK(manager, v_serviceManager));
assert(name != NULL);
k = v_objectKernel(manager);
q = v_participantQosNew(k, qos);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_networkingNew", 0,
"Networking service not created: inconsistent qos");
s = NULL;
} else {
s = v_networking(v_objectNew(k, K_NETWORKING));
if (v_isEnabledStatistics(k, V_STATCAT_NETWORKING)) {
ns = v_networkingStatistics(v_networkingStatisticsNew(k));
} else {
ns = NULL;
}
v_serviceInit(v_service(s),
manager,
name,
extStateName,
q,
v_statistics(ns));
c_free(q);
/* always add, even when s->state==NULL,
* since v_participantFree always removes the participant.
*/
v_addParticipant(k, v_participant(s));
if (v_service(s)->state == NULL) {
v_serviceFree(v_service(s));
s = NULL;
}
}
return s;
}
void
v_networkingStatisticsInit(
v_networkingStatistics _this,
v_kernel k)
{
assert(_this != NULL);
assert(C_TYPECHECK(_this, v_networkingStatistics));
v_statisticsInit(v_statistics(_this));
_this->numberOfErrors = 0;
_this->channelsCount = 0;
_this->channels = c_arrayNew(c_resolve(c_getBase(c_object(k)),
"kernelModule::v_networkChannelStatistics"),64);
}
void
v_rnrStorageStatisticsInit(
v_rnrStorageStatistics _this,
v_kernel k,
c_string name)
{
c_type type;
assert(_this && name);
assert(C_TYPECHECK(_this, v_rnrStorageStatistics));
v_statisticsInit(v_statistics(_this));
_this->name = name;
type = c_resolve(c_getBase(k), "kernelModule::v_rnrGroupStatistics");
_this->topics = c_tableNew(type, "name");
}
c_bool
v_networkingStatisticsReset(
v_networkingStatistics _this, const c_char* fieldName)
{
c_bool result;
assert(_this!=NULL);
assert(C_TYPECHECK(_this, v_networkingStatistics));
result = FALSE;
if (fieldName != NULL) {
result = v_statisticsResetField(v_statistics(_this), fieldName);
} else {
_this->numberOfErrors = 0;
result = TRUE;
}
return result;
}
v_durability
v_durabilityNew(
v_serviceManager manager,
const c_char *name,
const c_char *extStateName,
v_participantQos qos)
{
v_kernel k;
v_durability s;
v_participantQos q;
v_durabilityStatistics dStat;
assert(C_TYPECHECK(manager, v_serviceManager));
assert(name != NULL);
k = v_objectKernel(manager);
q = v_participantQosNew(k, qos);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_durabilityNew", 0,
"Durability service not created: inconsistent qos");
s = NULL;
} else {
s = v_durability(v_objectNew(k, K_DURABILITY));
if (v_isEnabledStatistics(k, V_STATCAT_DURABILITY)) {
dStat = v_durabilityStatisticsNew(k);
} else {
dStat = NULL;
}
v_serviceInit(v_service(s), manager, name, extStateName, q, v_statistics(dStat));
c_free(q);
/* always add, even when s->state==NULL, since v_participantFree always
removes the participant.*/
v_addParticipant(k, v_participant(s));
if (v_service(s)->state == NULL) {
v_serviceFree(v_service(s));
s = NULL;
}
}
return s;
}
void v_readerStatisticsInit(v_readerStatistics rs)
{
assert(rs != NULL);
assert(C_TYPECHECK(rs,v_readerStatistics));
v_statisticsInit(v_statistics(rs));
v_maxValueInit(&rs->maxSampleSize);
v_maxValueInit(&rs->maxSamplesPerInstance);
v_maxValueInit(&rs->maxNumberOfSamples);
v_maxValueInit(&rs->maxNumberOfInstances);
v_fullCounterInit(&rs->readLatency);
v_fullCounterInit(&rs->transportLatency);
rs->numberOfSamples = 0;
rs->numberOfInstances = 0;
rs->numberOfInstancesWithStatusNew = 0;
rs->numberOfInstancesWithStatusAlive = 0;
rs->numberOfInstancesWithStatusDisposed = 0;
rs->numberOfInstancesWithStatusNoWriters = 0;
rs->numberOfSamplesWithStatusRead = 0;
rs->numberOfSamplesExpired = 0;
rs->numberOfSamplesPurgedByDispose = 0;
rs->numberOfSamplesPurgedByNoWriters = 0;
rs->numberOfSamplesArrived = 0;
rs->numberOfSamplesInserted = 0;
rs->numberOfSamplesDiscarded = 0;
rs->numberOfSamplesRead = 0;
rs->numberOfSamplesTaken = 0;
rs->numberOfSamplesRejectedBySamplesLimit = 0;
rs->numberOfSamplesRejectedByInstancesLimit = 0;
rs->numberOfReads = 0;
rs->numberOfInstanceReads = 0;
rs->numberOfNextInstanceReads = 0;
rs->numberOfInstanceLookups = 0;
rs->numberOfTakes = 0;
rs->numberOfInstanceTakes = 0;
rs->numberOfNextInstanceTakes = 0;
}
void v_durabilityStatisticsInit(v_durabilityStatistics ds)
{
assert(ds != NULL);
assert(C_TYPECHECK(ds, v_durabilityStatistics));
v_statisticsInit(v_statistics(ds));
ds->persistentSamplesWritten = 0;
v_maxValueInit(&ds->fellowsKnownMax);
ds->fellowsKnown = 0;
ds->fellowsApproved = 0;
ds->fellowsIncompatibleState = 0;
ds->fellowsIncompatibleDataModel = 0;
ds->nameSpacesKnown = 0;
ds->nameSpacesMaster = 0;
ds->nameSpacesSlave = 0;
ds->groupsToCreateTotal = 0;
ds->groupsToCreateVolatile = 0;
ds->groupsToCreateTransient = 0;
ds->groupsToCreatePersistent = 0;
ds->groupsKnownTotal = 0;
ds->groupsKnownVolatile = 0;
ds->groupsKnownTransient = 0;
ds->groupsKnownPersistent = 0;
ds->groupsCompleteTotal = 0;
ds->groupsCompleteVolatile = 0;
ds->groupsCompleteTransient = 0;
ds->groupsCompletePersistent = 0;
ds->groupsIncompleteTotal = 0;
ds->groupsIncompleteVolatile = 0;
ds->groupsIncompleteTransient = 0;
ds->groupsIncompletePersistent = 0;
ds->groupsIgnoredTotal = 0;
ds->groupsIgnoredVolatile = 0;
ds->groupsIgnoredTransient = 0;
ds->groupsIgnoredPersistent = 0;
ds->alignerRequestsReceived = 0;
ds->alignerRequestsIgnored = 0;
ds->alignerRequestsAnswered = 0;
ds->alignerRequestsOpen = 0;
v_maxValueInit(&ds->alignerRequestsOpenMax);
ds->alignerRequestsCombined = 0;
ds->alignerRequestsCombinedOpen = 0;
v_maxValueInit(&ds->alignerRequestsCombinedOpenMax);
ds->alignerRequestsCombinedAnswered = 0;
ds->aligneeRequestsSent = 0;
v_maxValueInit(&ds->aligneeRequestsOpenMax);
ds->aligneeRequestsOpen = 0;
ds->aligneeRequestsWaiting = 0;
v_maxValueInit(&ds->aligneeRequestsWaitingMax);
ds->aligneeSamplesTotal = 0;
ds->aligneeSamplesRegister = 0;
ds->aligneeSamplesWrite = 0;
ds->aligneeSamplesDispose = 0;
ds->aligneeSamplesWriteDispose = 0;
ds->aligneeSamplesUnregister = 0;
ds->alignerSamplesTotal = 0;
ds->alignerSamplesRegister = 0;
ds->alignerSamplesWrite = 0;
ds->alignerSamplesDispose = 0;
ds->alignerSamplesWriteDispose = 0;
ds->alignerSamplesUnregister = 0;
ds->aligneeTotalSize = 0;
ds->alignerTotalSize = 0;
return;
}
c_bool v_durabilityStatisticsReset(v_durabilityStatistics ds, const c_char* fieldName)
{
c_bool result;
assert(ds != NULL);
assert(C_TYPECHECK(ds, v_durabilityStatistics));
result = FALSE;
if (fieldName != NULL) {
result = v_statisticsResetField(v_statistics(ds), fieldName);
} else {
v_statisticsULongResetInternal(v_durability, persistentSamplesWritten, ds);
v_maxValueReset(&ds->fellowsKnownMax);
v_statisticsULongResetInternal(v_durability, fellowsKnown, ds);
v_maxValueSetValue(&ds->fellowsKnownMax, ds->fellowsKnown);
v_statisticsULongResetInternal(v_durability, fellowsApproved, ds);
v_statisticsULongResetInternal(v_durability, fellowsIncompatibleState, ds);
v_statisticsULongResetInternal(v_durability, fellowsIncompatibleDataModel, ds);
v_statisticsULongResetInternal(v_durability, nameSpacesKnown, ds);
v_statisticsULongResetInternal(v_durability, nameSpacesMaster, ds);
v_statisticsULongResetInternal(v_durability, nameSpacesSlave, ds);
v_statisticsULongResetInternal(v_durability, groupsToCreateTotal, ds);
v_statisticsULongResetInternal(v_durability, groupsToCreateVolatile, ds);
v_statisticsULongResetInternal(v_durability, groupsToCreateTransient, ds);
v_statisticsULongResetInternal(v_durability, groupsToCreatePersistent, ds);
v_statisticsULongResetInternal(v_durability, groupsKnownTotal, ds);
v_statisticsULongResetInternal(v_durability, groupsKnownVolatile, ds);
v_statisticsULongResetInternal(v_durability, groupsKnownTransient, ds);
v_statisticsULongResetInternal(v_durability, groupsKnownPersistent, ds);
v_statisticsULongResetInternal(v_durability, groupsCompleteTotal, ds);
v_statisticsULongResetInternal(v_durability, groupsCompleteVolatile, ds);
v_statisticsULongResetInternal(v_durability, groupsCompleteTransient, ds);
v_statisticsULongResetInternal(v_durability, groupsCompletePersistent, ds);
v_statisticsULongResetInternal(v_durability, groupsIncompleteTotal, ds);
v_statisticsULongResetInternal(v_durability, groupsIncompleteVolatile, ds);
v_statisticsULongResetInternal(v_durability, groupsIncompleteTransient, ds);
v_statisticsULongResetInternal(v_durability, groupsIncompletePersistent, ds);
v_statisticsULongResetInternal(v_durability, groupsIgnoredTotal, ds);
v_statisticsULongResetInternal(v_durability, groupsIgnoredVolatile, ds);
v_statisticsULongResetInternal(v_durability, groupsIgnoredTransient, ds);
v_statisticsULongResetInternal(v_durability, groupsIgnoredPersistent, ds);
v_statisticsULongResetInternal(v_durability, alignerRequestsReceived, ds);
v_statisticsULongResetInternal(v_durability, alignerRequestsIgnored, ds);
v_statisticsULongResetInternal(v_durability, alignerRequestsAnswered, ds);
v_statisticsULongResetInternal(v_durability, alignerRequestsOpen, ds);
v_statisticsULongResetInternal(v_durability, alignerRequestsCombined, ds);
v_statisticsULongResetInternal(v_durability, alignerRequestsCombinedOpen, ds);
v_statisticsULongResetInternal(v_durability, alignerRequestsCombinedAnswered, ds);
v_maxValueReset(&ds->alignerRequestsOpenMax);
v_maxValueSetValue(&ds->alignerRequestsOpenMax, ds->alignerRequestsOpen);
v_maxValueReset(&ds->alignerRequestsCombinedOpenMax);
v_maxValueSetValue(&ds->alignerRequestsCombinedOpenMax, ds->alignerRequestsCombinedOpen);
v_statisticsULongResetInternal(v_durability, aligneeRequestsSent, ds);
v_statisticsULongResetInternal(v_durability, aligneeRequestsOpen, ds);
v_maxValueReset(&ds->aligneeRequestsOpenMax);
v_maxValueSetValue(&ds->aligneeRequestsOpenMax, ds->aligneeRequestsOpen);
v_statisticsULongResetInternal(v_durability, aligneeRequestsWaiting, ds);
v_maxValueReset(&ds->aligneeRequestsWaitingMax);
v_maxValueSetValue(&ds->aligneeRequestsWaitingMax, ds->aligneeRequestsWaiting);
v_statisticsULongResetInternal(v_durability, aligneeSamplesTotal, ds);
v_statisticsULongResetInternal(v_durability, aligneeSamplesRegister, ds);
v_statisticsULongResetInternal(v_durability, aligneeSamplesWrite, ds);
v_statisticsULongResetInternal(v_durability, aligneeSamplesDispose, ds);
v_statisticsULongResetInternal(v_durability, aligneeSamplesWriteDispose, ds);
v_statisticsULongResetInternal(v_durability, aligneeSamplesUnregister, ds);
v_statisticsULongResetInternal(v_durability, alignerSamplesTotal, ds);
v_statisticsULongResetInternal(v_durability, alignerSamplesRegister, ds);
v_statisticsULongResetInternal(v_durability, alignerSamplesWrite, ds);
v_statisticsULongResetInternal(v_durability, alignerSamplesDispose, ds);
v_statisticsULongResetInternal(v_durability, alignerSamplesWriteDispose, ds);
v_statisticsULongResetInternal(v_durability, alignerSamplesUnregister, ds);
v_statisticsULongResetInternal(v_durability, aligneeTotalSize, ds);
v_statisticsULongResetInternal(v_durability, alignerTotalSize, ds);
result = TRUE;
}
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;
}
