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); } }