void
cmx_serviceAction(
v_entity service,
c_voidp args)
{
assert( (v_object(service)->kind == K_SERVICE) ||
(v_object(service)->kind == K_SPLICED) ||
(v_object(service)->kind == K_NETWORKING) ||
(v_object(service)->kind == K_DURABILITY) ||
(v_object(service)->kind == K_CMSOAP));
cmx_entityNewFromAction(v_entity(v_service(service)->state), args);
}
v_listener
v_listenerNew(
v_participant p,
c_bool combine)
{
v_listener _this;
v_kernel kernel;
assert(C_TYPECHECK(p,v_participant));
kernel = v_objectKernel(p);
_this = v_listener(v_objectNew(kernel,K_LISTENER));
if (_this != NULL) {
v_publicInit(v_public(_this));
(void)c_mutexInit(c_getBase(_this), &_this->mutex);
c_condInit(c_getBase(_this), &_this->cv, &_this->mutex);
_this->participant = p;
_this->eventList = NULL;
_this->lastEvent = NULL;
v_participantAdd(p, v_object(_this));
_this->terminate = FALSE;
_this->waitCount = 0;
_this->combine = combine;
}
return _this;
}
void
cmx_writerDataTypeAction(
v_entity entity,
c_voidp args)
{
sd_serializer ser;
sd_serializedData data;
c_type type;
struct cmx_writerTypeArg *arg;
arg = (struct cmx_writerTypeArg *)args;
type = NULL;
switch(v_object(entity)->kind){
case K_WRITER:
type = v_topicDataType(v_writer(entity)->topic);
break;
default:
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Trying to resolve dataType of writer that is not a writer.\n");
assert(FALSE);
break;
}
if(type != NULL){
ser = sd_serializerXMLMetadataNew(c_getBase(type));
data = sd_serializerSerialize(ser, type);
arg->result = sd_serializerToString(ser, data);
sd_serializedDataFree(data);
sd_serializerFree(ser);
}
}
v_handleResult
v_handleRelease (
v_handle handle)
{
v_handleInfo *info;
v_handleResult result;
result = v_handleServerInfo(handle, &info);
if (result == V_HANDLE_OK) {
assert(info != NULL);
assert(info->count > 0);
info->count--;
#if CHECK_REF
if (v_object(info->object)->kind == CHECK_REF_TYPE) {
UT_TRACE("\n\n=========== Release (0x%x): %d -> %d ============\n",
info->object, info->count+1, info->count);
}
#endif
if (info->count == 0) {
if (info->freed) {
/* at this point the handle was deregistered but could not
* be invalidated because it was claimed, so it must be invalidated now.
*/
v_handleInvalidate(handle,info);
} else {
c_mutexUnlock(&info->mutex);
}
} else {
c_mutexUnlock(&info->mutex);
}
}
return result;
}
void
v_topicAdapterInit(
v_topicAdapter adapter,
v_topic topic,
v_participant p,
const c_char *name)
{
v_eventMask mask = V_EVENT_ALL_DATA_DISPOSED | V_EVENT_INCONSISTENT_TOPIC;
assert(adapter != NULL);
assert(p != NULL);
assert(C_TYPECHECK(adapter, v_topicAdapter));
assert(C_TYPECHECK(p,v_participant));
assert(C_TYPECHECK(topic,v_topic));
v_entityInit(v_entity(adapter), name);
adapter->topic = c_keep(topic);
(void)v_entityEnable(v_entity(adapter));
(void)v_observerSetEvent(v_observer(adapter), mask);
OSPL_ADD_OBSERVER(topic, adapter, mask, NULL);
v_participantAdd(p, v_object(adapter));
v_topic(adapter)->owner = p;
}
v_dataViewInstance
v_dataViewInstanceNew(
v_dataView dataView,
v_dataViewSample viewSample)
{
v_dataViewInstance instance;
assert(dataView);
assert(viewSample);
assert(C_TYPECHECK(dataView,v_dataView));
assert(C_TYPECHECK(viewSample,v_dataViewSample));
instance = v_dataViewInstance(c_new(dataView->instanceType));
if (instance) {
v_object(instance)->kernel = v_objectKernel(dataView);
v_objectKind(instance) = K_DATAVIEWINSTANCE;
v_instanceInit(v_instance(instance), v_entity(dataView));
viewSample->next = viewSample;
v_dataViewInstanceTemplate(instance)->sample = viewSample;
instance->sampleCount = 1;
v_stateSet(v_instanceState(instance),L_NEW);
v_stateClear(v_readerSample(viewSample)->sampleState,L_READ);
assert(C_TYPECHECK(instance,v_dataViewInstance));
CHECK_INSTANCE(instance);
} else {
OS_REPORT(OS_FATAL, OS_FUNCTION, V_RESULT_INTERNAL_ERROR,
"Failed to allocate v_dataViewInstance");
assert(FALSE);
}
return instance;
}
void
cmx_writerSnapshotNewAction(
v_entity e,
c_voidp args)
{
v_writer writer;
struct cmx_writerSnapshotArg* arg;
arg = (struct cmx_writerSnapshotArg*)args;
switch(v_object(e)->kind){
case K_WRITER:
arg->success = TRUE;
arg->snapshot = cmx_writerSnapshot(os_malloc(C_SIZEOF(cmx_writerSnapshot)));
arg->snapshot->samples = NULL;
writer = v_writer(e);
v_writerRead(writer, cmx_writerHistoryCopy, args);
if(arg->serializer != NULL){
sd_serializerFree(arg->serializer);
}
break;
default:
break;
}
}
v_handleResult
v_handleClaim (
v_handle handle,
v_object *o)
{
v_handleInfo *info;
v_handleResult result;
v_handleServer server;
server = v_handleServer((c_object)handle.server);
if (server == NULL) {
return V_HANDLE_ILLEGAL;
}
if(server->suspended == TRUE) {
/* For now the suspended state means that an unrecoverable error has
* occured. This implies that from now on any access to the kernel is
* unsafe and the result is undefined.
* So because of this skip this action and return NULL.
*/
return V_HANDLE_SUSPENDED;
}
result = v_handleServerInfo(handle, &info);
if (result != V_HANDLE_OK) {
*o = NULL;
return result;
}
if (info->freed) { /* Too late, it is already being freed... */
result = V_HANDLE_EXPIRED;
*o = NULL;
} else {
info->count++;
#if CHECK_REF
if (v_object(info->object)->kind == CHECK_REF_TYPE) {
UT_TRACE("\n\n============ Claim (0x%x): %d -> %d =============\n",
info->object, info->count -1, info->count);
}
#endif
*o = (v_object)info->object;
if(*o == NULL)
{
OS_REPORT(OS_WARNING, "v_handleClaim", 0,
"Unable to obtain kernel entity for handle");
result = V_HANDLE_ILLEGAL;
}
}
c_mutexUnlock(&info->mutex);
return result;
}
static c_bool
checkTopic (
c_object o,
c_voidp arg)
{
v_dataReaderEntry entry;
c_char *topicName = (c_char *)arg;
if(v_object(o)->kind == K_DATAREADERENTRY){
entry = v_dataReaderEntry(o);
if (strcmp(v_topicName(entry->topic),topicName) == 0) {
return FALSE;
}
}
return TRUE;
}
v_dataViewInstance
v_dataViewInstanceNew(
v_dataView dataView,
v_readerSample sample)
{
v_dataViewInstance instance;
v_dataViewSample viewSample;
assert(dataView);
assert(sample);
assert(C_TYPECHECK(dataView,v_dataView));
assert(C_TYPECHECK(sample,v_readerSample));
instance = v_dataViewInstance(c_new(dataView->instanceType));
if (instance) {
v_object(instance)->kernel = v_objectKernel(dataView);
v_objectKind(instance) = K_DATAVIEWINSTANCE;
instance->dataView = (c_voidp)dataView;
viewSample = v_dataViewSampleNew(instance,sample);
if (viewSample) {
v_dataViewInstanceTemplate(instance)->sample = viewSample;
viewSample->next = NULL;
viewSample->prev = NULL;
v_readerSampleAddViewSample(sample,viewSample);
instance->sampleCount = 1;
v_stateSet(instance->instanceState,L_NEW);
v_stateClear(v_readerSample(viewSample)->sampleState,L_READ);
assert(C_TYPECHECK(instance,v_dataViewInstance));
v_dataViewNotifyDataAvailable(dataView, viewSample);
}
CHECK_INSTANCE(instance);
} else {
OS_REPORT(OS_ERROR,
"v_dataViewInstanceNew",0,
"Failed to allocate v_dataViewInstancem");
assert(FALSE);
}
return instance;
}
void
v_topicAdapterFree(
v_topicAdapter adapter)
{
v_participant p;
assert(C_TYPECHECK(adapter,v_topicAdapter));
p = v_topicAdapterParticipant(adapter);
OSPL_REMOVE_OBSERVER(adapter->topic, adapter, V_EVENTMASK_ALL, NULL);
OSPL_REMOVE_OBSERVER(adapter, p, V_EVENTMASK_ALL, NULL);
if (p != NULL) {
v_participantRemove(p,v_object(adapter));
v_topic(adapter)->owner = NULL;
}
v_entityFree(v_entity(adapter));
}
void
cmx_serviceActionGetState(
v_public service,
c_voidp args)
{
v_serviceState state;
c_char** result;
char *special;
assert( (v_object(service)->kind == K_SERVICE) ||
(v_object(service)->kind == K_SPLICED) ||
(v_object(service)->kind == K_NETWORKING) ||
(v_object(service)->kind == K_DURABILITY) ||
(v_object(service)->kind == K_NWBRIDGE) ||
(v_object(service)->kind == K_RNR) ||
(v_object(service)->kind == K_CMSOAP) ||
(v_object(service)->kind == K_DBMSCONNECT));
result = (c_char**)args;
assert(result);
state = (v_service(service))->state;
assert(state);
special = cmx_serviceStateInit(state);
assert(special);
/*
* C&M thinks that the ServiceState is an Entity. Simulate that.
*/
*result = cmx_entityXml((c_string) NULL,
(c_address) NULL,
(v_handle*) &((v_public(state))->handle),
(c_bool) TRUE,
(c_string) special);
os_free(special);
}
void
v_listenerFree(
v_listener _this)
{
v_participant p;
v_listenerEvent event;
os_duration delay;
assert(_this != NULL);
assert(C_TYPECHECK(_this,v_listener));
p = v_participant(_this->participant);
assert(p != NULL);
c_mutexLock(&_this->mutex);
/* wakeup blocking threads to evaluate new condition. */
/* remove all events */
while (_this->eventList != NULL) {
event = _this->eventList;
_this->eventList = event->next;
v_listenerEventDeinit(event);
c_free(event);
}
_this->eventList = NULL;
c_free(_this->lastEvent);
_this->lastEvent = NULL;
_this->terminate = TRUE;
c_condBroadcast(&_this->cv);
c_mutexUnlock(&_this->mutex);
delay = OS_DURATION_INIT(0, 1000);
while (_this->waitCount > 0 && !p->processIsZombie) {
ospl_os_sleep(delay);
}
v_participantRemove(p, v_object(_this));
_this->participant = NULL;
v_publicFree(v_public(_this));
}
c_char*
cmx_readerInit(
v_reader entity)
{
c_char* result;
result = NULL;
switch(v_object(entity)->kind){
case K_DATAREADER:
result = cmx_dataReaderInit((v_dataReader)entity);
break;
case K_NETWORKREADER:
result = cmx_networkReaderInit((v_networkReader)entity);
break;
case K_GROUPQUEUE:
result = cmx_groupQueueInit((v_groupQueue)entity);
break;
default: break;
}
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;
}
/**************************************************************
* constructor/destructor
**************************************************************/
v_serviceState
v_serviceStateNew(
v_kernel k,
const c_char *name,
const c_char *extStateName)
{
v_serviceState s;
c_type type;
assert(C_TYPECHECK(k, v_kernel));
if (extStateName == NULL) {
s = v_serviceState(v_objectNew(k, K_SERVICESTATE));
} else {
type = c_resolve(c_getBase(c_object(k)), extStateName);
if (type != NULL) {
#if !defined NDEBUG
c_type t = type;
c_bool correctType;
correctType = FALSE;
while ((correctType == FALSE) &&
(t != NULL) &&
(c_baseObject(t)->kind == M_CLASS)) {
if (strcmp(c_metaObject(t)->name, "v_serviceState") == 0) {
correctType = TRUE;
} else {
t = c_type(c_class(t)->extends);
}
}
if ((correctType == FALSE) && (t != NULL)) {
OS_REPORT(OS_FATAL, "v_serviceState", 0, "Given type not a class");
assert(0);
} else {
if (correctType == FALSE) {
OS_REPORT(OS_FATAL, "v_serviceState",
0, "Given type does not extend v_serviceState");
assert(0);
}
}
#endif
s = v_serviceState(c_new(type));
if (s) {
v_objectKind(s) = K_SERVICESTATE;
v_object(s)->kernel = k;
} else {
OS_REPORT(OS_ERROR,
"v_serviceStateNew",0,
"Failed to allocate v_serviceState object.");
assert(FALSE);
}
} else {
s = NULL;
}
}
if (s != NULL) {
v_serviceStateInit(s, name);
}
return s;
}
void
cmx_readerSnapshotNewAction(
v_entity e,
c_voidp args)
{
v_dataReader reader;
c_iter instances;
v_dataReaderInstance instance;
v_dataReaderSample sample, prev;
v_query query;
c_bool release;
sd_serializer ser;
sd_serializedData data;
struct cmx_readerSnapshotArg* arg;
release = FALSE;
arg = (struct cmx_readerSnapshotArg*)args;
reader = NULL;
instances = NULL;
ser = NULL;
switch(v_object(e)->kind){
case K_DATAREADER:
reader = v_dataReader(e);
arg->success = TRUE;
arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot)));
v_observerLock(v_observer(reader));
if(reader->index->objects){
instances = c_select(reader->index->notEmptyList, 0);
}
break;
case K_QUERY:
case K_DATAREADERQUERY:
query = v_query(e);
reader = v_dataReader(v_querySource(query));
if(reader != NULL){
release = TRUE;
arg->success = TRUE;
arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot)));
v_observerLock(v_observer(reader));
switch(v_object(query)->kind){
case K_DATAREADERQUERY:
if(v_dataReaderQuery(query)->instanceQ){
instances = c_select((c_collection)(v_dataReaderQuery(query)->instanceQ), 0);
}
break;
default:
OS_REPORT_1(OS_ERROR, CM_XML_CONTEXT, 0,
"cmx_readerSnapshotNewAction unknown kind (%d).",
v_object(query)->kind);
break;
}
}
break;
default:
break;
}
if(arg->success == TRUE){
arg->snapshot->samples = c_iterNew(NULL);
}
if(instances != NULL){
instance = v_dataReaderInstance(c_iterTakeFirst(instances));
while(instance != NULL){
sample = c_keep(v_dataReaderInstanceHead(instance));
if(sample != NULL){
prev = sample->prev;
sample->prev = NULL;
if(ser == NULL){
ser = sd_serializerXMLNewTyped(c_getType(c_object(sample)));
}
data = sd_serializerSerialize(ser, c_object(sample));
arg->snapshot->samples = c_iterInsert(arg->snapshot->samples,
sd_serializerToString(ser, data));
sd_serializedDataFree(data);
sample->prev = prev;
c_free(sample);
}
c_free(instance);
instance = v_dataReaderInstance(c_iterTakeFirst(instances));
}
c_iterFree(instances);
}
if(reader != NULL){
v_observerUnlock(v_observer(reader));
if(release == TRUE){
c_free(reader);
}
}
if(ser != NULL){
sd_serializerFree(ser);
}
}
int
main(
int argc,
char* argv[])
{
int result = 0;
v_participantQos participantQos;
u_result uresult;
os_boolean success;
v_subscriberQos subscriberQos;
c_time resolution;
c_base base;
v_kernel kernel;
/* Necessary to initialize the user layer. Do this just once per process.*/
mlv_init ();
uresult = u_userInitialise();
mlv_setforreal (1);
if(uresult == U_RESULT_OK){
/* Allocate default participant qos*/
participantQos = u_participantQosNew(NULL);
{
os_mutexAttr mattr;
os_mutexAttrInit (&mattr);
mattr.scopeAttr = OS_SCOPE_PRIVATE;
os_mutexInit (&gluelock, &mattr);
}
if(participantQos){
if(argc > 1){
SERVICE_NAME = argv[1];
}
if(argc > 2){
SERVICE_URI = argv[2];
}
/*create participant*/
participant = u_participant(u_serviceNew(
SERVICE_URI, 0, SERVICE_NAME,
NULL,
U_SERVICE_NETWORKING,
(v_qos)participantQos));
if(participant){
struct cfgst *cfgst;
ddsi2_participant_gid = u_entityGid (u_entity (participant));
/*Notify kernel that I am initializing. */
u_serviceChangeState(u_service(participant),STATE_INITIALISING);
/*Start monitoring the splicedaemon state. I need to terminate if he says so*/
u_serviceWatchSpliceDaemon(
u_service(participant),
in_discoveryWatchSpliced,
&terminate);
if ((cfgst = config_init (participant, SERVICE_NAME)) != NULL)
{
unsigned rtps_flags = 0;
struct nn_servicelease *servicelease;
open_tracing_file ();
/* Dependencies between default values is not
handled automatically by the config processing
(yet) */
if (config.many_sockets_mode)
{
if (config.max_participants == 0)
config.max_participants = 100;
}
if (NN_STRICT_P)
{
/* Should not be sending invalid messages when strict */
config.respond_to_rti_init_zero_ack_with_invalid_heartbeat = 0;
config.acknack_numbits_emptyset = 1;
}
config_print_and_free_cfgst (cfgst);
servicelease = nn_servicelease_new (participant);
nn_servicelease_start_renewing (servicelease);
myNetworkId = getNetworkId ();
u_entityAction(u_entity(participant), resolveKernelService, NULL);
base = c_getBase(service);
kernel = v_object(service)->kernel;
rtps_init (base, kernel, config.domainId, config.participantIndex,
rtps_flags, config.networkAddressString, config.peers);
/* Initialize entity administration. */
success = in_entityAdminInit(participant);
if(success){
/*Create subscriber to receive client writers' messages.*/
subscriberQos = u_subscriberQosNew(NULL);
os_free(subscriberQos->partition);
subscriberQos->partition = NULL;
clientSubscriber = u_subscriberNew(
participant,
"clientSubscriber",
subscriberQos,
TRUE);
if(clientSubscriber){
/*Create networkReader to be able to receive client writers' messages.*/
clientReader = u_networkReaderNew(
clientSubscriber,
"clientReader",
NULL,
TRUE);
if(clientReader){
resolution.seconds = 0;
resolution.nanoseconds = 10 * 1000 * 1000; /*10 ms*/
/*Create network queue*/
uresult = u_networkReaderCreateQueue(
clientReader,
1000, 0, FALSE, FALSE,
resolution,
TRUE, &queueId,
"DDSi");
if(uresult == U_RESULT_OK){
struct builtin_datareader_set drset;
u_entityAction(u_entity(clientReader), resolveKernelReader, NULL);
uresult = create_builtin_readers (&drset, participant);
if (uresult == U_RESULT_OK)
{
u_serviceChangeState(u_service(participant),STATE_OPERATIONAL);
uresult = attachAndMonitor(participant, &drset);
if((uresult != U_RESULT_OK) &&
(uresult != U_RESULT_DETACHING))
{
nn_log (LC_ERROR, "Abnormal termination...\n");
result = -1;
} else {
nn_log (LC_INFO, "Deleting entities...\n");
}
destroy_builtin_readers (&drset);
} else {
nn_log (LC_FATAL, "Could not create subscription + readers for builtin topics.\n");
result = -1;
}
terminate = TRUE;
v_networkReaderTrigger(vclientReader, queueId);
os_threadWaitExit(clientWriterThread, NULL);
} else {
nn_log (LC_FATAL, "Could not create networkQueue.\n");
result = -1;
}
/*Clean up networkReader*/
os_mutexLock (&gluelock);
u_networkReaderFree(clientReader);
clientReader = NULL;
vclientReader = NULL;
os_mutexUnlock (&gluelock);
} else {
nn_log (LC_FATAL, "Could not create networkReader.\n");
result = -1;
}
/*Clean up subscriber*/
u_subscriberFree(clientSubscriber);
} else {
nn_log (LC_FATAL, "Could not create subscriber.\n");
result = -1;
}
/*Clean up entity administration*/
in_entityAdminDestroy();
} else {
nn_log (LC_FATAL, "Could not initialize entity adminstration.\n");
result = -1;
}
/* RTPS layer now defines types, cleanup before detaching */
rtps_term();
/*Notify kernel that I've terminated*/
u_serviceChangeState(u_service(participant),STATE_TERMINATED);
nn_servicelease_free (servicelease);
/*Delete participant*/
uresult = u_serviceFree(u_service(participant));
if(uresult != U_RESULT_OK){
nn_log (LC_FATAL, "Deletion of participant failed.\n");
result = -1;
}
} else {
nn_log (LC_FATAL, "Initialization of configuration failed.\n");
result = -1;
}
} else {
nn_log (LC_FATAL, "Could not create participant.\n");
result = -1;
}
u_participantQosFree (participantQos);
} else {
nn_log (LC_FATAL, "Could not allocate participantQos.\n");
result = -1;
}
os_mutexDestroy (&gluelock);
/* Detach user layer */
mlv_setforreal (0);
uresult = u_userDetach();
mlv_fini ();
if(uresult != U_RESULT_OK){
nn_log (LC_FATAL, "Detachment of user layer failed.\n");
result = -1;
}
} else {
nn_log (LC_FATAL, "Initialization of user layer failed.\n");
result = -1;
}
nn_log (LC_INFO, "Finis.\n");
/* Must be really late, or nn_log becomes unhappy -- but it should
be before os_osExit (which appears to be called from
u_userExit(), which is not called by u_userDetach but by an
exit handler, it appears.) */
config_fini ();
return result;
}
void
cmx_readerSnapshotNewAction(
v_public p,
c_voidp args)
{
v_dataReader reader;
c_iter instances;
v_dataReaderInstance instance;
v_dataReaderSample sample;
v_query query;
c_bool release;
sd_serializer ser;
sd_serializedData data;
struct cmx_readerSnapshotArg* arg;
release = FALSE;
arg = (struct cmx_readerSnapshotArg*)args;
reader = NULL;
instances = NULL;
ser = NULL;
switch(v_object(p)->kind){
case K_DATAREADER:
reader = v_dataReader(p);
arg->success = TRUE;
arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot)));
v_observerLock(v_observer(reader));
if(reader->index->objects){
instances = ospl_c_select(reader->index->notEmptyList, 0);
}
break;
case K_QUERY:
case K_DATAREADERQUERY:
query = v_query(p);
reader = v_dataReader(v_querySource(query));
if(reader != NULL){
release = TRUE;
arg->success = TRUE;
arg->snapshot = cmx_readerSnapshot(os_malloc(C_SIZEOF(cmx_readerSnapshot)));
v_observerLock(v_observer(reader));
switch(v_object(query)->kind){
case K_DATAREADERQUERY:
if(v_dataReaderQuery(query)->instanceQ){
instances = ospl_c_select((c_collection)(v_dataReaderQuery(query)->instanceQ), 0);
}
break;
default:
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0,
"cmx_readerSnapshotNewAction unknown kind (%d).",
v_object(query)->kind);
break;
}
}
break;
default:
break;
}
if(arg->success == TRUE){
arg->snapshot->samples = c_iterNew(NULL);
}
if(instances != NULL){
v_dataReaderSample sampleShallowCopy = NULL;
instance = v_dataReaderInstance(c_iterTakeFirst(instances));
while(instance != NULL){
v_state ivState = instance->_parent._parent.state & (L_DISPOSED | L_NOWRITERS | L_NEW);
sample = v_dataReaderInstanceOldest(instance);
if (sample != NULL) {
do {
v_state state = ivState | ((sample->_parent.sampleState & (L_READ | L_LAZYREAD)) ? L_READ : 0);
if (sampleShallowCopy == NULL) {
sampleShallowCopy = c_new(c_getType(c_object(sample)));
}
memcpy(sampleShallowCopy, sample, c_typeSize(c_getType(sampleShallowCopy)));
sampleShallowCopy->newer = NULL;
sampleShallowCopy->_parent.sampleState &= ~(L_DISPOSED | L_NOWRITERS | L_NEW | L_READ | L_LAZYREAD);
sampleShallowCopy->_parent.sampleState |= state;
if(ser == NULL){
ser = sd_serializerXMLNewTyped(c_getType(c_object(sampleShallowCopy)));
}
data = sd_serializerSerialize(ser, c_object(sampleShallowCopy));
arg->snapshot->samples = c_iterInsert(arg->snapshot->samples, sd_serializerToString(ser, data));
sd_serializedDataFree(data);
sample = sample->newer;
} while (sample != NULL);
}
c_free(instance);
instance = v_dataReaderInstance(c_iterTakeFirst(instances));
}
c_iterFree(instances);
if (sampleShallowCopy != NULL) {
memset(sampleShallowCopy, 0, c_typeSize(c_getType(sampleShallowCopy)));
c_free(sampleShallowCopy);
}
}
if(reader != NULL){
v_observerUnlock(v_observer(reader));
if(release == TRUE){
c_free(reader);
}
}
if(ser != NULL){
sd_serializerFree(ser);
}
}
d_readerRequest
d_readerRequestNew(
d_admin admin,
v_handle source,
c_char* filter,
c_char** filterParams,
c_long filterParamsCount,
struct v_resourcePolicy resourceLimits,
c_time minSourceTimestamp,
c_time maxSourceTimestamp)
{
d_readerRequest request;
c_long i;
v_handleResult handleResult;
v_reader vreader, *vreaderPtr;
c_iter partitions;
v_partition partition;
v_topic topic;
d_group dgroup;
c_char *topicName;
d_quality quality;
request = d_readerRequest(os_malloc(C_SIZEOF(d_readerRequest)));
if(request){
d_lockInit(d_lock(request), D_READER_REQUEST, d_readerRequestDeinit);
request->admin = admin;
request->readerHandle.index = source.index;
request->readerHandle.serial = source.serial;
request->readerHandle.server = source.server;
request->requests = d_tableNew(d_chainCompare, d_chainFree);
if(filter){
request->filter = os_strdup(filter);
} else {
request->filter = NULL;
}
request->resourceLimits = resourceLimits;
request->minSourceTimestamp = minSourceTimestamp;
request->maxSourceTimestamp = maxSourceTimestamp;
request->filterParamsCount = filterParamsCount;
if(filterParamsCount > 0){
request->filterParams = (c_char**)(os_malloc(
filterParamsCount*sizeof(c_char*)));
for(i=0; i<filterParamsCount; i++){
request->filterParams[i] = os_strdup(filterParams[i]);
}
} else {
request->filterParams = NULL;
}
request->groups = d_tableNew(d_groupCompare, d_groupFree);
handleResult = v_handleClaim(source, (v_object*)(vreaderPtr = &vreader));
if(handleResult == V_HANDLE_OK){
if(v_object(vreader)->kind == K_DATAREADER){
topic = v_dataReaderGetTopic(v_dataReader(vreader));
topicName = v_entity(topic)->name;
partitions = ospl_c_select(v_subscriber(vreader->subscriber)->partitions->partitions, 0);
partition = v_partition(c_iterTakeFirst(partitions));
while(partition){
quality.seconds = 0;
quality.nanoseconds = 0;
dgroup = d_groupNew(
v_entity(partition)->name, topicName,
topic->qos->durability.kind,
D_GROUP_KNOWLEDGE_UNDEFINED,
quality);
d_tableInsert(request->groups, dgroup);
c_free(partition);
partition = v_partition(c_iterTakeFirst(partitions));
}
c_free(topic);
} else {
d_readerRequestFree(request);
request = NULL;
}
v_handleRelease(source);
} else {
d_readerRequestFree(request);
request = NULL;
}
}
return request;
}
void
cmx_readerDataTypeAction(
v_entity entity,
c_voidp args)
{
sd_serializer ser;
sd_serializedData data;
c_type type;
v_dataReader r;
v_query query;
v_topic topic;
struct cmx_readerArg *arg;
arg = (struct cmx_readerArg *)args;
type = NULL;
switch(v_object(entity)->kind){
case K_DATAREADER:
r = v_dataReader(entity);
v_observerLock(v_observer(r));
topic = v_dataReaderGetTopic(r);
type = v_topicDataType(topic);
c_free(topic);
v_observerUnlock(v_observer(r));
break;
case K_DATAREADERQUERY:
query = v_query(entity);
r = v_dataReader(v_querySource(query));
v_observerLock(v_observer(r));
topic = v_dataReaderGetTopic(r);
type = v_topicDataType(topic);
c_free(topic);
v_observerUnlock(v_observer(r));
c_free(r);
break;
case K_NETWORKREADER:
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0,
"Resolving data type of networkReader unsupported.\n");
assert(FALSE);
break;
case K_GROUPQUEUE:
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0,
"Resolving data type of groupQueue unsupported.\n");
assert(FALSE);
break;
default:
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0,
"Trying to resolve dataType of unknown reader type.\n");
assert(FALSE);
break;
}
if(type != NULL){
ser = sd_serializerXMLMetadataNew(c_getBase(type));
data = sd_serializerSerialize(ser, type);
arg->result = sd_serializerToString(ser, data);
sd_serializedDataFree(data);
sd_serializerFree(ser);
}
}
