char *
idl_genXMLmeta (
c_type type)
{
sd_serializer metaSer;
sd_serializedData serData;
char *metaDescription = NULL;
c_iter replaceInfo;
c_iter replaceInfoStac;
replaceInfo = idl_catsDefConvertAll(idl_catsDefDefGet());
replaceInfoStac = idl_stacDefConvertAll(idl_stacDefDefGet());
metaSer = sd_serializerXMLTypeinfoNew (c_getBase(c_object(type)), TRUE);
if (metaSer)
{
serData = sd_serializerSerialize (metaSer, c_object(type));
if (serData)
{
metaDescription = sd_serializerToString (metaSer, serData);
}
sd_serializerFree (metaSer);
}
idl_catsDefRestoreAll(idl_catsDefDefGet(), replaceInfo);
idl_stacDefRestoreAll(idl_stacDefDefGet(), replaceInfoStac);
return metaDescription;
}
v_result v_participantCandMCommandSetDisposeAllData(v_participant participant,
v_message msg,
char *topicExpr,
char *partitionExpr)
{
v_kernel kernel;
v_topic topic;
c_base base;
v_controlAndMonitoringCommand *command;
struct v_commandDisposeAllData *disposeCmd;
assert(participant != NULL);
assert(C_TYPECHECK(participant,v_participant));
assert(msg != NULL );
assert(C_TYPECHECK(msg,v_message));
kernel = v_objectKernel(participant);
topic = v_builtinTopicLookup(kernel->builtin, V_C_AND_M_COMMAND_ID);
command = v_builtinControlAndMonitoringCommandData(kernel->builtin, msg);
command->u._d = V_COMMAND_DISPOSE_ALL_DATA;
base = c_getBase(c_object(topic));
disposeCmd = &command->u._u.dispose_all_data_info;
disposeCmd->topicExpr = c_stringNew(base, topicExpr);
disposeCmd->partitionExpr = c_stringNew(base, partitionExpr);
return ( ( disposeCmd->topicExpr != NULL
&& disposeCmd->partitionExpr != NULL )
? V_RESULT_OK
: V_RESULT_OUT_OF_MEMORY );
}
const c_char*
cmx_participantRegisterType(
const c_char* participant,
const c_char* type)
{
sd_serializer serializer;
sd_serializedData meta_data;
cmx_entityKernelArg kernelArg;
c_type topicType;
cmx_entity ce;
const c_char* result;
const c_char* msg;
ce = cmx_entityClaim(participant);
if(ce != NULL){
kernelArg = cmx_entityKernelArg(os_malloc(C_SIZEOF(cmx_entityKernelArg)));
if (u_observableAction(u_observable(ce->uentity),
cmx_entityKernelAction,
(c_voidp)kernelArg) == U_RESULT_OK)
{
serializer = sd_serializerXMLMetadataNew(c_getBase(c_object(kernelArg->kernel)));
if(serializer != NULL){
meta_data = sd_serializerFromString(serializer, type);
if (meta_data != NULL) {
topicType = c_type(sd_serializerDeserialize(serializer, meta_data));
if (topicType == NULL) {
msg = sd_serializerLastValidationMessage(serializer);
OS_REPORT(OS_ERROR,
CM_XML_CONTEXT, 0,
"Data type could not be registered, "
"because it is not valid: %s",
msg);
result = CMX_RESULT_FAILED;
} else {
result = CMX_RESULT_OK;
}
sd_serializedDataFree(meta_data);
} else {
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Construction of serialized data failed.");
result = CMX_RESULT_FAILED;
}
sd_serializerFree(serializer);
} else {
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Serializer could not be initialized");
result = CMX_RESULT_FAILED;
}
} else {
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Kernel object could not be retrieved");
result = CMX_RESULT_FAILED;
}
os_free(kernelArg);
cmx_entityRelease(ce);
} else {
result = CMX_RESULT_FAILED;
}
return result;
}
void
v_subscriberUnSubscribe(
v_subscriber s,
const c_char *partitionExpr)
{
v_partition d;
v_dataReaderConnectionChanges arg;
v_partitionPolicy old;
assert(s != NULL);
assert(C_TYPECHECK(s,v_subscriber));
arg.addedPartitions = NULL;
c_lockWrite(&s->lock);
arg.removedPartitions = v_partitionAdminRemove(s->partitions, partitionExpr);
old = s->qos->partition;
s->qos->partition = v_partitionPolicyRemove(old, partitionExpr,
c_getBase(c_object(s)));
c_free(old);
c_setWalk(s->readers, qosChangedAction, &arg);
d = v_partition(c_iterTakeFirst(arg.removedPartitions));
while (d != NULL) {
c_free(d);
d = v_partition(c_iterTakeFirst(arg.removedPartitions));
}
c_iterFree(arg.removedPartitions);
c_lockUnlock(&s->lock);
}
c_char*
cmx_writerNew(
const c_char* publisher,
const c_char* name,
const c_char* topic,
const c_char* qos)
{
u_publisher pub;
u_topic top;
u_writer wri;
c_char* result;
cmx_entityArg arg;
u_result ur;
cmx_entityKernelArg kernelArg;
v_writerQos wQos;
result = NULL;
pub = u_publisher(cmx_entityUserEntity(publisher));
if(pub != NULL){
top = u_topic(cmx_entityUserEntity(topic));
if(top != NULL){
kernelArg = cmx_entityKernelArg(os_malloc(C_SIZEOF(cmx_entityKernelArg)));
u_entityAction(u_entity(pub), cmx_entityKernelAction, (c_voidp)kernelArg);
if(qos != NULL){
wQos = v_writerQos(cmx_qosKernelQosFromKind(qos, K_WRITER, c_getBase(c_object(kernelArg->kernel))));
if(wQos == NULL){
wQos = v_writerQosNew(kernelArg->kernel, NULL);
wQos->reliability.kind = V_RELIABILITY_RELIABLE;
}
} else {
wQos = v_writerQosNew(kernelArg->kernel, NULL);
wQos->reliability.kind = V_RELIABILITY_RELIABLE;
}
wri = u_writerNew(pub, name, top, NULL, wQos, TRUE);
os_free(kernelArg);
c_free(wQos);
if(wri != NULL){
cmx_registerEntity(u_entity(wri));
arg = cmx_entityArg(os_malloc(C_SIZEOF(cmx_entityArg)));
arg->entity = u_entity(wri);
arg->create = FALSE;
arg->participant = NULL;
arg->result = NULL;
ur = u_entityAction(u_entity(wri), cmx_entityNewFromAction, (c_voidp)(arg));
if(ur == U_RESULT_OK){
result = arg->result;
os_free(arg);
}
}
}
}
return result;
}
v_subscriber
v_participantGetBuiltinSubscriber(
v_participant p)
{
v_subscriberQos sQos;
v_readerQos rQos;
v_kernel kernel;
c_bool create_builtin_readers = FALSE;
assert(p != NULL);
assert(C_TYPECHECK(p, v_participant));
c_mutexLock(&p->builtinLock);
if (p->builtinSubscriber == NULL) {
kernel = v_objectKernel(p);
sQos = v_subscriberQosNew(kernel, NULL);
sQos->presentation.access_scope = V_PRESENTATION_TOPIC;
c_free(sQos->partition);
sQos->partition = c_stringNew(c_getBase(c_object(kernel)),
V_BUILTIN_PARTITION);
sQos->entityFactory.autoenable_created_entities = TRUE;
p->builtinSubscriber = v_subscriberNew(p, V_BUILTINSUBSCRIBER_NAME,
sQos, TRUE);
v_subscriberQosFree(sQos);
create_builtin_readers = TRUE;
c_mutexUnlock(&p->builtinLock);
assert(p->builtinSubscriber != NULL);
rQos = v_readerQosNew(kernel, NULL);
rQos->durability.kind = V_DURABILITY_TRANSIENT;
rQos->reliability.kind = V_RELIABILITY_RELIABLE;
rQos->history.kind = V_HISTORY_KEEPLAST;
rQos->history.depth = 1;
#define _CREATE_READER_(topicName) {\
q_expr expr; \
v_dataReader dr; \
expr = q_parse("select * from " topicName);\
dr = v_dataReaderNew(p->builtinSubscriber, topicName "Reader", \
expr, NULL, rQos, TRUE);\
c_free(dr); \
q_dispose(expr); \
}
_CREATE_READER_(V_PARTICIPANTINFO_NAME)
_CREATE_READER_(V_TOPICINFO_NAME)
_CREATE_READER_(V_PUBLICATIONINFO_NAME)
_CREATE_READER_(V_SUBSCRIPTIONINFO_NAME)
#undef _CREATE_READER_
v_readerQosFree(rQos);
} else {
c_mutexUnlock(&p->builtinLock);
}
return c_keep(p->builtinSubscriber);
}
void
v_messageExtConvertHeaderToExtNoAllocTime (
v_messageExt xmsg,
const struct v_message_s *vmsg)
{
c_bool y2038Ready = c_baseGetY2038Ready(c_getBase(c_object(vmsg)));
v_messageExtConvertHeaderToExtCommon(xmsg, vmsg, y2038Ready);
xmsg->allocTime.seconds = 0;
xmsg->allocTime.nanoseconds = 0;
}
v_qos
v_qosCreate(
v_kernel kernel,
v_qosKind kind)
{
v_qos qos;
c_base base;
c_type type;
assert(kernel != NULL);
assert(C_TYPECHECK(kernel,v_kernel));
base = c_getBase(c_object(kernel));
#define _CASE_(l,t) case l: type = c_resolve(base,t); break
switch (kind) {
_CASE_(V_PARTITION_QOS, "kernelModule::v_partitionQos");
_CASE_(V_PARTICIPANT_QOS, "kernelModule::v_participantQos");
_CASE_(V_TOPIC_QOS, "kernelModule::v_topicQos");
_CASE_(V_WRITER_QOS, "kernelModule::v_writerQos");
_CASE_(V_READER_QOS, "kernelModule::v_readerQos");
_CASE_(V_PUBLISHER_QOS, "kernelModule::v_publisherQos");
_CASE_(V_SUBSCRIBER_QOS, "kernelModule::v_subscriberQos");
_CASE_(V_INDEX_QOS, "kernelModule::v_indexQos");
_CASE_(V_WRITERHISTORY_QOS, "kernelModule::v_writerHistoryQos");
_CASE_(V_GROUPHISTORY_QOS, "kernelModule::v_groupHistoryQos");
_CASE_(V_VIEW_QOS, "kernelModule::v_viewQos");
_CASE_(V_DATAVIEW_QOS, "kernelModule::v_dataViewQos");
_CASE_(V_KERNEL_QOS, "kernelModule::v_kernelQos");
default:
OS_REPORT_1(OS_ERROR,"v_qos::Create",0,
"Illegal Qos kind specified (%s)",
v_qosKindImage(kind));
return NULL;
}
qos = v_qos(c_new(type));
c_free(type);
if (qos) {
qos->kind = kind;
} else {
OS_REPORT(OS_ERROR,
"v_qosCreate",0,
"Failed to allocate qos.");
assert(FALSE);
}
return qos;
#undef _CASE_
}
void
v_messageExtConvertHeaderToExt (
v_messageExt xmsg,
const struct v_message_s *vmsg)
{
c_bool y2038Ready = c_baseGetY2038Ready(c_getBase(c_object(vmsg)));
v_messageExtConvertHeaderToExtCommon(xmsg, vmsg, y2038Ready);
if (y2038Ready) {
xmsg->allocTime = c_timeFromUint64(OS_TIMEE_GET_VALUE(vmsg->allocTime));
} else {
xmsg->allocTime = c_timeFromTimeE(vmsg->allocTime);
}
}
v_cfNode
v_cfElementAddChild(
v_cfElement element,
v_cfNode child)
{
v_cfNode ch;
assert(C_TYPECHECK(element, v_cfElement));
assert(C_TYPECHECK(child, v_cfNode));
ch = v_cfNode(c_insert(element->children,
c_object(child)));
return ch;
}
/**************************************************************
* Protected functions
**************************************************************/
void
v_collectionInit(
v_collection c,
const c_char *name,
v_statistics s,
c_bool enable)
{
c_base base;
assert(C_TYPECHECK(c,v_collection));
v_observerInit(v_observer(c), name, s, enable);
base = c_getBase(c_object(c));
c->queries = c_setNew(c_resolve(base,"kernelModule::v_query"));
}
/**************************************************************
* Public functions
**************************************************************/
v_cfAttribute
v_cfElementAddAttribute (
v_cfElement element,
v_cfAttribute attribute)
{
v_cfAttribute attr;
assert(C_TYPECHECK(element, v_cfElement));
assert(C_TYPECHECK(attribute, v_cfAttribute));
attr = v_cfAttribute(c_insert(element->attributes,
c_object(attribute)));
return attr;
}
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);
}
v_networkQueueStatistics v_networkQueueStatisticsNew(v_kernel k, const c_char *name)
{
v_networkQueueStatistics nqs;
c_string channelName;
assert(k != NULL);
assert(C_TYPECHECK(k, v_kernel));
if (networkQueueStatisticsType == NULL) {
networkQueueStatisticsType = c_resolve(c_getBase(k), "kernelModule::v_networkQueueStatistics");
}
nqs = v_networkQueueStatistics(v_new(k, networkQueueStatisticsType));
channelName = c_stringNew(c_getBase(c_object(k)),name);
v_networkQueueStatisticsInit(nqs,channelName);
return nqs;
}
static void
_DataReaderViewCopyIn (
c_type type,
void *data,
void *to)
{
c_base base = c_getBase(c_object(type));
readerViewCopyInInfo *info = data;
if (info->reader->copy_cache) {
C_STRUCT(gapi_srcInfo) dataInfo;
dataInfo.copyProgram = info->reader->copy_cache;
dataInfo.src = info->data;
info->reader->copy_in (base, &dataInfo, to);
} else {
info->reader->copy_in (base, info->data, to);
}
}
v_partitionInterest
v_partitionInterestNew(
v_kernel kernel,
const char *partitionExpression)
{
v_partitionInterest result = NULL;
result = c_new(v_kernelType(kernel, K_DOMAININTEREST));
if (result) {
result->expression = c_stringNew(c_getBase(c_object(kernel)), partitionExpression);
} else {
OS_REPORT(OS_ERROR,
"v_partitionInterestNew",0,
"Failed to allocate partition interest.");
}
return result;
}
v_networkChannelStatistics
v_networkChannelStatisticsNew(
v_kernel k,
const c_char *name)
{
v_networkChannelStatistics ncs;
c_string channelName;
c_type type;
assert(k != NULL);
assert(C_TYPECHECK(k, v_kernel));
type = c_resolve(c_getBase(k), "kernelModuleI::v_networkChannelStatistics");
assert(type);
ncs = v_networkChannelStatistics(v_new(k, type));
c_free(type);
channelName = c_stringNew(c_getBase(c_object(k)),name);
v_networkChannelStatisticsInit(ncs,channelName);
return ncs;
}
static c_bool
_DataWriterCopy (
c_type type,
void *data,
void *to)
{
c_bool result;
c_base base = c_getBase(c_object(type));
writerInfo *info = (writerInfo *)data;
if (info->writer->copy_cache) {
C_STRUCT(gapi_srcInfo) dataInfo;
dataInfo.copyProgram = info->writer->copy_cache;
dataInfo.src = info->data;
result = info->writer->copy_in (base, &dataInfo, to);
} else {
result = info->writer->copy_in (base, info->data, to);
}
return result;
}
v_rnrStorageStatistics
v_rnrStorageStatisticsNew(
v_kernel k,
const c_char *name)
{
v_rnrStorageStatistics _this;
c_string storageName;
c_type type;
assert(k && name);
assert(C_TYPECHECK(k, v_kernel));
type = c_resolve(c_getBase(k), "kernelModule::v_rnrStorageStatistics");
_this = v_rnrStorageStatistics(c_new(type));
storageName = c_stringNew(c_getBase(c_object(k)), name);
c_free(type);
v_rnrStorageStatisticsInit(_this, k, storageName);
return _this;
}
v_topic
v_lookupTopic(
v_kernel kernel,
const char *name)
{
v_topic topicFound;
C_STRUCT(v_topic) dummyTopic;
c_base base = c_getBase(c_object(kernel));
/* Create a dummy topic for look-up */
memset(&dummyTopic, 0, sizeof(dummyTopic));
((v_entity)(&dummyTopic))->name = c_stringNew(base,name);
topicFound = NULL;
c_lockRead(&kernel->lock);
/* This does not remove anything because the alwaysFalse function always
* returns false */
c_remove(kernel->topics, &dummyTopic, alwaysFalse, &topicFound);
c_lockUnlock(&kernel->lock);
c_free(((v_entity)(&dummyTopic))->name);
return topicFound;
}
void
v_cfAttributeInit (
v_cfAttribute attribute,
v_configuration config,
const c_char *name,
c_value value)
{
assert(C_TYPECHECK(attribute, v_cfAttribute));
assert(name != NULL);
v_cfNodeInit(v_cfNode(attribute), config, V_CFATTRIBUTE, name);
attribute->value = value;
switch (value.kind) {
case V_STRING:
attribute->value.is.String = c_stringNew(c_getBase(c_object(config)),
value.is.String);
break;
case V_UNDEFINED:
case V_BOOLEAN: case V_OCTET:
case V_SHORT: case V_LONG: case V_LONGLONG:
case V_USHORT: case V_ULONG: case V_ULONGLONG:
case V_FLOAT: case V_DOUBLE:
case V_CHAR:
case V_WCHAR: case V_WSTRING:
case V_FIXED: case V_OBJECT:
default:
/* nothing to copy */
OS_REPORT_1(OS_ERROR,
"kernel", 0,
"Unknown value (%d) type given at creation of "
"configuration attribute.",
value.kind);
break;
}
}
#include "os_report.h"
static const v_qosChangeMask immutableMask = V_POLICY_BIT_USERKEY;
v_dataViewQos
v_dataViewQosNew(
v_kernel kernel,
v_dataViewQos template)
{
v_dataViewQos q;
c_base base;
assert(kernel != NULL);
assert(C_TYPECHECK(kernel,v_kernel));
base = c_getBase(c_object(kernel));
q = v_dataViewQos(v_qosCreate(kernel,V_DATAVIEW_QOS));
if (q != NULL) {
if (template != NULL) {
if (((v_qos)template)->kind != V_DATAVIEW_QOS) {
OS_REPORT_1(OS_ERROR,
"v_dataViewQos::New",0,
"Illegal Qos kind specified (%s)",
v_qosKindImage(v_qos(template)->kind));
c_free(q);
return NULL;
} else {
q->userKey.enable = template->userKey.enable;
if (q->userKey.enable) {
q->userKey.expression = c_stringNew(base,template->userKey.expression);
/**************************************************************
* 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);
}
}
void
v_serviceInit(
v_service service,
const c_char *name,
const c_char *extStateName,
v_serviceType serviceType,
v_participantQos qos,
c_bool enable)
{
c_char *typeName;
os_duration lp = 300*OS_DURATION_SECOND;
v_kernel kernel;
v_serviceManager manager;
assert(service != NULL);
assert(serviceType != V_SERVICETYPE_NONE);
assert(C_TYPECHECK(service, v_service));
assert(C_TYPECHECK(qos, v_participantQos));
assert(name != NULL);
kernel = v_objectKernel(service);
manager = v_getServiceManager(kernel);
/* v_participantInit writes the DCPSParticipant and CMParticipant topics, but
* it downcasts to v_service to extract serviceType, and hence needs it available.
*/
service->serviceType = serviceType;
v_participantInit(v_participant(service), name, qos);
if(enable) {
(void)v_entityEnable(v_entity(service));
}
service->state = v_serviceManagerRegister(manager, service, extStateName);
service->lease = v_leaseMonotonicNew(kernel, lp);
service->newGroups = NULL;
if(service->lease)
{
v_result result;
result = v_leaseManagerRegister(
kernel->livelinessLM,
service->lease,
V_LEASEACTION_SERVICESTATE_EXPIRED,
v_public(service->state),
FALSE/*do not repeat */);
if(result != V_RESULT_OK)
{
c_free(service->lease);
service->lease = NULL;
OS_REPORT(OS_FATAL, "v_service", result,
"A fatal error was detected when trying to register the liveliness lease "
"to the liveliness lease manager of the kernel. The result code was %d.", result);
}
} else
{
OS_REPORT(OS_FATAL, "v_service", V_RESULT_INTERNAL_ERROR,
"Unable to create a liveliness lease! Most likely not enough shared "
"memory available to complete the operation.");
}
if(service->lease)/* aka everything is ok so far */
{
v_result result;
c_iter participants;
v_participant splicedParticipant;
participants = v_resolveParticipants(kernel, V_SPLICED_NAME);
assert(c_iterLength(participants) == 1 || 0 == strcmp(name, V_SPLICED_NAME));
splicedParticipant = v_participant(c_iterTakeFirst(participants));
if(splicedParticipant)
{
result = v_leaseManagerRegister(
v_participant(service)->leaseManager,
v_service(splicedParticipant)->lease,
V_LEASEACTION_SERVICESTATE_EXPIRED,
v_public(v_service(splicedParticipant)->state),
FALSE /* only observing, do not repeat */);
if(result != V_RESULT_OK)
{
c_free(service->lease);
service->lease = NULL;
OS_REPORT(OS_FATAL, "v_service", result,
"A fatal error was detected when trying to register the spliced's liveliness lease "
"to the lease manager of participant %p (%s). The result code was %d.", (void*)service, name, result);
}
c_free(splicedParticipant);
}
c_iterFree(participants);
}
if (service->state != NULL) {
/* check if state has correct type */
typeName = c_metaScopedName(c_metaObject(c_getType(c_object(service->state))));
if (extStateName == NULL) {
extStateName = VSERVICESTATE_NAME;
}
if (strcmp(typeName, extStateName) == 0) {
/* Splicedaemon may not observer itself! */
if (strcmp(name, V_SPLICED_NAME) != 0) {
v_serviceState splicedState;
splicedState = v_serviceManagerGetServiceState(manager, V_SPLICED_NAME);
(void)OSPL_ADD_OBSERVER(splicedState, service, V_EVENT_SERVICESTATE_CHANGED, NULL);
}
} else {
OS_REPORT(OS_ERROR, "v_service",
V_RESULT_ILL_PARAM, "Requested state type (%s) differs with existing state type (%s)",
extStateName, typeName);
c_free(service->state);
service->state = NULL;
}
os_free(typeName);
}
}
void
v_waitsetNotify(
v_waitset _this,
v_event e,
c_voidp userData)
/* the userData argument is the data associated to the observable
* for this waitset during the v_waitsetAttach call.
* This data is unique for this association between this waitset and
* the attached observable.
*/
{
v_waitsetEvent event,found;
c_base base;
v_historyDeleteEventData hde;
v_waitsetEventHistoryDelete wehd;
v_waitsetEventHistoryRequest wehr;
v_waitsetEventPersistentSnapshot weps;
v_kernel k;
assert(_this != NULL);
assert(C_TYPECHECK(_this,v_waitset));
if (e != NULL) {
k = v_objectKernel(_this);
if (e->kind == V_EVENT_HISTORY_DELETE) {
/* delete historical data */
wehd = c_new(v_kernelType(k,K_WAITSETEVENTHISTORYDELETE));
base = c_getBase(c_object(_this));
hde = (v_historyDeleteEventData)e->userData;
wehd->deleteTime = hde->deleteTime;
wehd->partitionExpr = c_stringNew(base,hde->partitionExpression);
wehd->topicExpr = c_stringNew(base,hde->topicExpression);
event = (v_waitsetEvent)wehd;
} else if (e->kind == V_EVENT_HISTORY_REQUEST) {
/* request historical data */
wehr = c_new(v_kernelType(k, K_WAITSETEVENTHISTORYREQUEST));
wehr->request = (v_historicalDataRequest)c_keep(e->userData);
event = (v_waitsetEvent)wehr;
} else if (e->kind == V_EVENT_PERSISTENT_SNAPSHOT) {
/* request persistent snapshot data */
weps = c_new(v_kernelType(k, K_WAITSETEVENTPERSISTENTSNAPSHOT));
weps->request = (v_persistentSnapshotRequest)c_keep(e->userData);
event = (v_waitsetEvent)weps;
} else {
/* Group events by origin of event */
/* What about events while no threads are waiting?
* It seems that the list of events can grow to infinite length.
*/
found = v_waitsetEvent(v_waitsetEventList(_this));
while ((found != NULL) && (!v_handleIsEqual(found->source,e->source))){
found = found->next;
}
if (found == NULL) {
event = v_waitsetEventNew(_this);
} else {
found->kind |= e->kind;
event = NULL;
}
}
if (event) {
event->source.server = e->source.server;
event->source.index = e->source.index;
event->source.serial = e->source.serial;
event->kind = e->kind;
event->userData = userData;
event->next = v_waitsetEvent(v_waitsetEventList(_this));
v_waitsetEventList(_this) = (c_voidp)event;
}
}
}
void
idl_registerType (
c_base base,
const char *basename,
c_iter typeNames
)
{
sd_serializer metaSer;
sd_serializedData serData;
char *metaDescription = NULL;
char *typeName;
c_char *fname;
c_metaObject type;
int i;
fname = os_malloc((size_t)((int)strlen(basename)+20));
snprintf (fname, (size_t)((int)strlen(basename)+20), "%s_register.h", basename);
idl_fileSetCur (idl_fileOutNew (fname, "w"));
if (idl_fileCur () == NULL) {
idl_reportOpenError (fname);
}
idl_registerHeaderFile (basename);
idl_fileOutFree (idl_fileCur());
snprintf (fname, (size_t)((int)strlen(basename)+20), "%s_register.c", basename);
idl_fileSetCur (idl_fileOutNew (fname, "w"));
if (idl_fileCur () == NULL) {
idl_reportOpenError (fname);
}
idl_registerBodyHeader (basename);
for (i = 0; i < c_iterLength(typeNames); i++) {
typeName = c_iterObject(typeNames, i);
type = c_metaResolve ((c_metaObject)base, (const char *)typeName);
if (type) {
metaSer = sd_serializerXMLTypeinfoNew (base, TRUE);
if (metaSer) {
serData = sd_serializerSerialize (metaSer, c_object(type));
if (serData) {
metaDescription = sd_serializerToString (metaSer, serData);
if (metaDescription) {
idl_registerBody (typeName, metaDescription);
os_free (metaDescription);
}
}
sd_serializerFree (metaSer);
}
} else {
printf ("Specified type %s not found\n", typeName);
}
}
idl_fileOutPrintf (idl_fileCur(), "\n");
idl_fileOutPrintf (idl_fileCur(), "void\n");
idl_fileOutPrintf (idl_fileCur(), "%s__register_types (c_base base)\n", basename);
idl_fileOutPrintf (idl_fileCur(), "{\n");
for (i = 0; i < c_iterLength(typeNames); i++) {
typeName = c_iterObject(typeNames, i);
idl_fileOutPrintf (idl_fileCur(), " %s__register_type (base);\n", idl_cScopedTypeName(typeName));
}
idl_fileOutPrintf (idl_fileCur(), "}\n");
idl_fileOutFree (idl_fileCur());
os_free (fname);
}
c_char*
cmx_dataReaderNew(
const c_char* subscriber,
const c_char* name,
const c_char* view,
const c_char* qos)
{
u_subscriber sub;
u_dataReader rea;
c_char* result;
cmx_entityArg arg;
u_result ur;
cmx_entityKernelArg kernelArg;
v_readerQos rqos;
q_expr qexpr;
result = NULL;
sub = u_subscriber(cmx_entityUserEntity(subscriber));
if(sub != NULL){
kernelArg = cmx_entityKernelArg(os_malloc(C_SIZEOF(cmx_entityKernelArg)));
u_entityAction(u_entity(sub),
cmx_entityKernelAction,
(c_voidp)kernelArg);
if(qos != NULL){
rqos = v_readerQos(cmx_qosKernelQosFromKind(qos, K_DATAREADER, c_getBase(c_object(kernelArg->kernel))));
if(rqos == NULL){
rqos = v_readerQosNew(kernelArg->kernel, NULL);
}
} else {
rqos = v_readerQosNew(kernelArg->kernel, NULL);
}
if(view != NULL){
qexpr = q_parse(view);
if(qexpr != NULL){
rea = u_dataReaderNew(sub, name, qexpr, NULL, rqos, TRUE);
q_dispose(qexpr);
} else {
rea = NULL;
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0,
"cmx_dataReaderNew: invalid view expression.");
}
} else {
rea = u_dataReaderNew(sub, name, NULL, NULL, rqos, TRUE);
}
c_free(rqos);
os_free(kernelArg);
if(rea != NULL){
cmx_registerEntity(u_entity(rea));
arg = cmx_entityArg(os_malloc((os_uint32)(C_SIZEOF(cmx_entityArg))));
arg->entity = u_entity(rea);
arg->create = FALSE;
arg->participant = NULL;
arg->result = NULL;
ur = u_entityAction(u_entity(rea),
cmx_entityNewFromAction,
(c_voidp)(arg));
if(ur == U_RESULT_OK){
result = arg->result;
os_free(arg);
}
}
}
return result;
}
void
v_serviceInit(
v_service service,
v_serviceManager manager,
const c_char *name,
const c_char *extStateName,
v_participantQos qos,
v_statistics stats)
{
c_char *typeName;
v_duration lp = {300, 0};
v_kernel kernel;
assert(service != NULL);
assert(C_TYPECHECK(service, v_service));
assert(C_TYPECHECK(qos, v_participantQos));
assert(name != NULL);
kernel = v_objectKernel(service);
v_participantInit(v_participant(service), name, qos, stats, TRUE);
service->state = v_serviceManagerRegister(manager, service, extStateName);
service->lease = v_leaseNew(kernel, lp);
if(service->lease)
{
v_result result;
result = v_leaseManagerRegister(
kernel->livelinessLM,
service->lease,
V_LEASEACTION_SERVICESTATE_EXPIRED,
v_public(service->state),
FALSE/*do not repeat */);
if(result != V_RESULT_OK)
{
c_free(service->lease);
service->lease = NULL;
OS_REPORT_1(OS_ERROR, "v_service", 0,
"A fatal error was detected when trying to register the liveliness lease "
"to the liveliness lease manager of the kernel. The result code was %d.", result);
}
} else
{
OS_REPORT(OS_ERROR, "v_service", 0,
"Unable to create a liveliness lease! Most likely not enough shared "
"memory available to complete the operation.");
}
if(service->lease)/* aka everything is ok so far */
{
v_result result;
c_iter participants;
v_participant splicedParticipant;
participants = v_resolveParticipants(kernel, V_SPLICED_NAME);
assert(c_iterLength(participants) == 1 || 0 == strcmp(name, V_SPLICED_NAME));
splicedParticipant = v_participant(c_iterTakeFirst(participants));
if(splicedParticipant)
{
result = v_leaseManagerRegister(
v_participant(service)->leaseManager,
v_service(splicedParticipant)->lease,
V_LEASEACTION_SERVICESTATE_EXPIRED,
v_public(v_service(splicedParticipant)->state),
FALSE /* only observing, do not repeat */);
if(result != V_RESULT_OK)
{
c_free(service->lease);
service->lease = NULL;
OS_REPORT_3(OS_ERROR, "v_service", 0,
"A fatal error was detected when trying to register the spliced's liveliness lease "
"to the lease manager of participant %p (%s). The result code was %d.", service, name, result);
}
}
c_iterFree(participants);
}
if (service->state != NULL) {
/* check if state has correct type */
typeName = c_metaScopedName(c_metaObject(c_getType(c_object(service->state))));
if (extStateName == NULL) {
extStateName = VSERVICESTATE_NAME;
}
if (strcmp(typeName, extStateName) == 0) {
if (strcmp(name, V_SPLICED_NAME) != 0) {
/* Splicedaemon may not observer itself! */
v_serviceWatchSplicedaemon(service);
}
} else {
OS_REPORT_2(OS_ERROR, "v_service",
0, "Requested state type (%s) differs with existing state type (%s)",
extStateName, typeName);
c_free(service->state);
service->state = NULL;
}
os_free(typeName);
}
}
void
v_networkReaderEntryFree(
v_networkReaderEntry e)
{
c_free(c_object(e));
}
