d_storeMMFKernel
d_storeMMFKernelNew (
c_base base,
const c_char *name)
{
d_storeMMFKernel kernel, found;
c_type type;
c_bool success;
/* load meta-data */
success = loadkernelModule(base);
assert(success);
success = loaddurabilityModule2(base);
assert(success);
/* create storeKernel */
type = c_resolve(base,"durabilityModule2::d_storeMMFKernel");
kernel = (d_storeMMFKernel)c_new(type);
c_free(type);
if(kernel) {
/* Init storeKernel members */
/* groups is a table of d_groupInfo with topic+partition as key */
type = c_resolve(base,"durabilityModule2::d_groupInfo");
assert(type);
kernel->groups = c_tableNew(type, "partition,topic.name");
kernel->backup = c_tableNew(type, "partition,topic.name");
c_free(type);
type = c_resolve(base,"durabilityModule2::d_topicInfo");
assert(type);
kernel->topics = c_tableNew(type, "name");
c_free(type);
type = c_resolve(base,"durabilityModule2::d_nameSpaceInfo");
assert(type);
kernel->nameSpaces = c_tableNew(type, "name");
c_free(type);
/* bind storeKernel */
found = ospl_c_bind(kernel, name);
assert(found == kernel);
} else {
OS_REPORT(OS_ERROR,
"d_storeMMFKernelNew",0,
"Failed to allocate kernel.");
found = NULL;
}
return found;
}
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);
}
/**************************************************************
* Protected functions
**************************************************************/
v_partitionAdmin
v_partitionAdminNew(
v_kernel kernel)
{
v_partitionAdmin da;
assert(C_TYPECHECK(kernel,v_kernel));
da = v_partitionAdmin(v_objectNew(kernel, K_DOMAINADMIN));
if (da != NULL) {
da->partitions = c_tableNew(v_kernelType(kernel, K_DOMAIN),"name");
da->partitionInterests = c_tableNew(v_kernelType(kernel, K_DOMAININTEREST), "expression");
c_mutexInit(&da->mutex,SHARED_MUTEX);
if ((da->partitions == NULL) || (da->partitionInterests == NULL)) {
c_free(da);
da = NULL;
}
}
return da;
}
d_storeResult
d_groupInfoBackup(
d_groupInfo _this,
const d_store store,
d_groupInfo* backup)
{
c_base base;
c_type groupInfoType, instanceType;
c_string keyExpr;
d_storeResult result;
assert(_this);
assert(backup);
base = c_getBase(_this->kernel);
groupInfoType = c_resolve(base,"durabilityModule2::d_groupInfo");
*backup = d_groupInfo(c_new(groupInfoType));
c_free(groupInfoType);
if (*backup) {
(*backup)->kernel = _this->kernel; /* Unmanaged pointer */
(*backup)->topic = c_keep(_this->topic);
(*backup)->partition = c_keep(_this->partition);
(*backup)->quality = _this->quality;
(*backup)->completeness = _this->completeness;
instanceType = d_topicInfoGetInstanceType(_this->topic);
keyExpr = d_topicInfoGetInstanceKeyExpr(_this->topic);
(*backup)->instances = _this->instances; /*Here's the trick */
_this->instances = c_tableNew(instanceType, keyExpr);
c_free(keyExpr);
c_free(instanceType);
if(_this->instances){
result = D_STORE_RESULT_OK;
} else {
_this->instances = (*backup)->instances;
(*backup)->instances = NULL;
c_free(*backup);
*backup = NULL;
result = D_STORE_RESULT_OUT_OF_RESOURCES;
}
} else {
assert(FALSE);
result = D_STORE_RESULT_OUT_OF_RESOURCES;
}
return result;
}
d_groupInfo
d_groupInfoNew (
const d_storeMMFKernel kernel,
const d_topicInfo topic,
const d_group dgroup)
{
d_groupInfo group;
c_base base;
c_char* partition;
c_type instanceType, groupInfoType;
c_char *keyExpr;
if(kernel && topic && dgroup){
base = c_getBase(kernel);
groupInfoType = c_resolve(base,"durabilityModule2::d_groupInfo");
group = d_groupInfo(c_new(groupInfoType));
c_free(groupInfoType);
if (group) {
group->kernel = kernel; /* Unmanaged pointer */
group->topic = c_keep(topic);
partition = d_groupGetPartition(dgroup);
group->partition = c_stringNew(base, partition);
os_free(partition);
group->quality = d_groupGetQuality(dgroup);
group->completeness = d_groupGetCompleteness(dgroup);
instanceType = d_topicInfoGetInstanceType(topic);
keyExpr = d_topicInfoGetInstanceKeyExpr(topic);
group->instances = c_tableNew(instanceType, keyExpr);
c_free(keyExpr);
c_free(instanceType);
} else {
OS_REPORT(OS_ERROR,
"d_groupInfoNew",0,
"Failed to allocate d_groupInfo.");
assert(FALSE);
group = NULL;
}
} else {
OS_REPORT(OS_ERROR,
"d_groupInfoNew",0,
"Illegal constructor parameter.");
group = NULL;
}
return group;
}
/* protected */
void
v_entryInit(
v_entry e,
v_reader r)
{
v_kernel kernel;
assert(C_TYPECHECK(e,v_entry));
assert(C_TYPECHECK(r,v_reader));
kernel = v_objectKernel(r);
e->reader = r;
e->groups = c_tableNew(v_kernelType(kernel,K_PROXY),
"source.index,source.server");
assert(e->groups != NULL);
}
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");
}
void
v_cfElementInit (
v_cfElement element,
v_configuration config,
const c_char *tagName)
{
c_type attrType;
c_type nodeType;
const c_char *keyList;
assert(C_TYPECHECK(element, v_cfElement));
assert(tagName != NULL);
v_cfNodeInit(v_cfNode(element), config, V_CFELEMENT, tagName);
attrType = c_resolve(c_getBase(element), "kernelModule::v_cfAttribute");
nodeType = c_resolve(c_getBase(element), "kernelModule::v_cfNode");
keyList = "name";
element->attributes = c_tableNew(attrType, keyList);
element->children = c_setNew(nodeType);
}
c_bool
v_partitionAdminSet(
v_partitionAdmin da,
v_partitionPolicy partitionExpr,
c_iter *addedPartitions,
c_iter *removedPartitions)
{
c_iter dexpressions; /* iterator of partition expressions */
c_char *dexpr; /* partition expression */
v_partitionInterest di;
struct resolvePartitionsArg resolveArg;
struct updatePartitionsArg updateArg;
assert(C_TYPECHECK(da, v_partitionAdmin));
assert(removedPartitions != NULL);
assert(addedPartitions != NULL);
*removedPartitions = NULL;
*addedPartitions = NULL;
resolveArg.kernel = v_objectKernel(da);
c_mutexLock(&da->mutex);
/*
* The absolute partition names will be added at the end of
* the algorithm.
* The partition expressions in the parameter of partitionExpr,
* replace the existing in da->partitionInterests.
*/
c_free(da->partitionInterests);
da->partitionInterests = c_tableNew(v_kernelType(resolveArg.kernel, K_DOMAININTEREST),
"expression");
assert(c_count(da->partitionInterests) == 0);
dexpressions = v_partitionPolicySplit(partitionExpr);
if (dexpressions == NULL) {
/* switch to default */
*addedPartitions = c_iterInsert(*addedPartitions, v_partitionNew(resolveArg.kernel, "", NULL));
} else {
dexpr = (c_char *)c_iterTakeFirst(dexpressions);
while (dexpr != NULL) {
if (v_partitionExpressionIsAbsolute(dexpr)) {
*addedPartitions = c_iterInsert(*addedPartitions,
v_partitionNew(resolveArg.kernel, dexpr, NULL));
/* ref transferred to addedPartitions */
} else {
di = v_partitionInterestNew(resolveArg.kernel, (const c_char *)dexpr);
c_tableInsert(da->partitionInterests, di);
c_free(di);
}
os_free(dexpr);
dexpr = (c_char *)c_iterTakeFirst(dexpressions);
}
c_iterFree(dexpressions);
}
/*
* The given expressions are now divided across
* 'addedpartitions' and 'da->partitionInterests'.
* Now first add partitions to 'addedpartitions' that fit the
* expressions in 'da->partitionInterests'.
*/
resolveArg.partitions = addedPartitions;
c_tableWalk(da->partitionInterests, resolvePartitions, (c_voidp)&resolveArg);
/*
* Now 'addedpartitions' contains all partitions to be added
* by the publisher/subscriber.
* 'da->partitions' contains the old set of partitions.
* We must check whether those partitions must remain in
* the set or must be removed.
* For every partition in 'da->partitions' do
* if partition in 'addedpartitions' then remove from 'addedpartitions'
* else add to 'removedpartitions'
* For every partition in 'removedpartitions' remove from 'da->partitions'.
*/
updateArg.addPartitions = addedPartitions;
updateArg.removePartitions = removedPartitions;
c_tableWalk(da->partitions, updatePartitions, (c_voidp)&updateArg);
c_iterWalk(*removedPartitions, removePartition, (c_voidp)da->partitions);
/*
* The da->partitions now contains partitions that still comply to new
* partitionPolicy. So all partitions in added partitions, must be added
* to da->partitions, so it reflects all connected partitions.
*/
c_iterWalk(*addedPartitions, addPartition, (c_voidp)da->partitions);
c_mutexUnlock(&da->mutex);
return TRUE;
}
v_deliveryService
v_deliveryServiceNew (
v_subscriber subscriber,
const c_char *name)
{
v_kernel kernel;
v_deliveryService _this;
v_readerQos q;
v_topic topic;
c_base base;
c_type type;
v_entry entry, found;
assert(C_TYPECHECK(subscriber,v_subscriber));
base = c_getBase(subscriber);
kernel = v_objectKernel(subscriber);
topic = v_lookupTopic (kernel, V_DELIVERYINFO_NAME);
/* ES, dds1576: Before creating the ackreader we have to verify that read
* access to the topic is allowed. We can accomplish this by checking the
* access mode of the topic.
*/
if(!topic)
{
OS_REPORT(OS_ERROR, "v_deliveryServiceNew",0,
"DeliveryService not created: "
"Could not locate topic with name DCPS_Delivery.");
return NULL;
}
if(v_topicAccessMode(topic) == V_ACCESS_MODE_READ ||
v_topicAccessMode(topic) == V_ACCESS_MODE_READ_WRITE)
{
q = v_readerQosNew(kernel,NULL);
if (q == NULL) {
OS_REPORT(OS_ERROR, "v_deliveryServiceNew", 0,
"DeliveryService not created: inconsistent qos");
return NULL;
}
_this = v_deliveryService(v_objectNew(kernel,K_DELIVERYSERVICE));
type = c_resolve(base, "kernelModule::v_deliveryGuard");
_this->guards = c_tableNew(type, "writerGID.localId");
c_free(type);
type = c_resolve(base, "kernelModule::v_subscriptionInfoTemplate");
_this->subscriptions = c_tableNew(type, "userData.key.systemId,userData.key.localId");
c_free(type);
q->userKey.enable = TRUE;
q->userKey.expression = NULL;
v_readerInit(v_reader(_this),name, subscriber,q, NULL, TRUE);
c_free(q);
entry = v_entry(v_deliveryServiceEntryNew(_this,topic));
found = v_readerAddEntry(v_reader(_this),v_entry(entry));
c_free(entry);
c_free(found);
v_deliveryServiceEnable(_this);
} else
{
OS_REPORT_1(OS_ERROR, "v_deliveryServiceNew", 0,
"Creation of DeliveryService <%s> failed. Topic DCPS_Delivery."
"does not have read access rights.", name);
_this = NULL;
}
return _this;
}
void
v_indexInit(
v_index index,
c_type instanceType,
c_array keyList,
v_reader reader)
{
c_property keyProperty;
c_structure keyStructure;
c_char fieldName[16];
c_char *keyExpr;
c_size i,nrOfKeys,totalSize;
assert(index != NULL);
assert(C_TYPECHECK(index,v_index));
assert(C_TYPECHECK(instanceType,c_type));
keyProperty = c_property(c_metaResolve(c_metaObject(instanceType),"key"));
if (keyProperty) {
keyStructure = c_structure(keyProperty->type);
nrOfKeys = c_arraySize(keyStructure->members);
c_free(keyProperty);
} else {
nrOfKeys = 0;
}
if (nrOfKeys>0) {
totalSize = nrOfKeys * strlen("key.field0,");
if (nrOfKeys > 9) {
/* For each key number greater than one digit
* i.e. number of keys > 9 add one additional
* character space to the total size.
*/
totalSize += (nrOfKeys-9);
if (nrOfKeys > 99) {
/* For each key number greater than two digits
* i.e. number of keys > 99 add one additional
* character space to the total size.
*/
totalSize += (nrOfKeys-99);
}
}
keyExpr = (char *)os_alloca(totalSize);
keyExpr[0] = 0;
for (i=0;i<nrOfKeys;i++) {
os_sprintf(fieldName,"key.field%d",i);
os_strcat(keyExpr,fieldName);
if (i<(nrOfKeys-1)) { os_strcat(keyExpr,","); }
}
} else {
keyExpr = NULL;
}
index->reader = reader;
index->sourceKeyList = createKeyList(instanceType, keyList);
index->messageKeyList = c_keep(keyList); /* keyList is either topic->messageKeyList or a user-defined keylist */
index->objects = c_tableNew(instanceType,keyExpr);
index->notEmptyList = c_tableNew(instanceType,keyExpr);
if(keyExpr){
os_freea(keyExpr);
}
index->objectType = c_keep(instanceType);
}
v_subscriber
v_subscriberNew(
v_participant p,
const c_char *name,
v_subscriberQos qos,
c_bool enable)
{
v_kernel kernel;
v_subscriber s;
v_subscriberQos q;
v_entity found;
v_accessMode access;
kernel = v_objectKernel(p);
/* ES, dds1576: If a partition policy was provided then we need to verify
* if the partition policy does not contain any partition expressions for
* which read access is not allowed.
* If read access is not allowed for one of the partitions listed in the
* partition policy of the qos, then the subscriber will not be created at
* all.
*/
if(qos && qos->partition)
{
access = v_kernelPartitionAccessMode(kernel, qos->partition);
} else
{
access = V_ACCESS_MODE_READ_WRITE;/* default */
}
if(access == V_ACCESS_MODE_READ_WRITE || access == V_ACCESS_MODE_READ)
{
q = v_subscriberQosNew(kernel,qos);
if (q != NULL) {
s = v_subscriber(v_objectNew(kernel,K_SUBSCRIBER));
v_observerInit(v_observer(s),name, NULL, enable);
s->qos = q;
c_mutexInit(&s->sharesMutex, SHARED_MUTEX);
if (q->share.enable) {
v_lockShares(kernel);
found = v_addShareUnsafe(kernel,v_entity(s));
if (found != v_entity(s)) {
/* Make sure to set the partition list to NULL, because
* v_publicFree will cause a crash in the v_subscriberDeinit
* otherwise.
*/
s->partitions = NULL;
/*v_publicFree to free reference held by the handle server.*/
v_publicFree(v_public(s));
/*Now free the local reference as well.*/
c_free(s);
pa_increment(&(v_subscriber(found)->shareCount));
v_unlockShares(kernel);
return c_keep(found);
}
s->shares = c_tableNew(v_kernelType(kernel,K_READER),
"qos.share.name");
} else {
s->shares = NULL;
}
s->shareCount = 1;
s->partitions = v_partitionAdminNew(kernel);
s->readers = c_setNew(v_kernelType(kernel,K_READER));
if (q->share.enable) {
s->participant = kernel->builtin->participant;
} else {
s->participant = p;
}
c_lockInit(&s->lock,SHARED_LOCK);
v_participantAdd(v_participant(s->participant),v_entity(s));
if (q->share.enable) {
v_unlockShares(kernel);
}
if (enable) {
v_subscriberEnable(s);
}
} else {
OS_REPORT(OS_ERROR,
"v_subscriberNew", 0,
"Subscriber not created: inconsistent qos");
s = NULL;
}
} else
{
OS_REPORT(OS_ERROR,
"v_subscriberNew", 0,
"Subscriber not created: Access rights for one of the partitions listed in the partition list was not sufficient (i.e. read or readwrite).");
s = NULL;
}
return s;
}
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;
}