u_subscriber
u_subscriberNew(
u_participant p,
const c_char *name,
v_subscriberQos qos,
c_bool enable)
{
u_subscriber _this = NULL;
v_subscriber ks;
v_participant kp = NULL;
u_result result;
if (name == NULL) {
name = "No name specified";
}
if (p != NULL) {
result = u_entityWriteClaim(u_entity(p),(v_entity*)(&kp));
if (result == U_RESULT_OK) {
assert(kp);
ks = v_subscriberNew(kp,name,qos,enable);
if (ks != NULL) {
_this = u_entityAlloc(p,u_subscriber,ks,TRUE);
if (_this != NULL) {
result = u_subscriberInit(_this,p);
if (result != U_RESULT_OK) {
OS_REPORT_1(OS_ERROR, "u_subscriberNew", 0,
"Initialisation failed. "
"For DataReader: <%s>.", name);
(void)u_subscriberFree(_this);
_this = NULL;
}
} else {
OS_REPORT_1(OS_ERROR, "u_subscriberNew", 0,
"Create user proxy failed. "
"For Subscriber: <%s>.", name);
}
c_free(ks);
} else {
OS_REPORT_1(OS_ERROR, "u_subscriberNew", 0,
"Create kernel entity failed. "
"For Subscriber: <%s>.", name);
}
result = u_entityRelease(u_entity(p));
if (result != U_RESULT_OK) {
OS_REPORT_1(OS_WARNING, "u_subscriberNew", 0,
"Could not release participant."
"However subscriber <%s> is created.", name);
}
} else {
OS_REPORT_1(OS_WARNING, "u_subscriberNew", 0,
"Claim Participant failed. "
"For Subscriber: <%s>.", name);
}
} else {
OS_REPORT_1(OS_ERROR,"u_subscriberNew",0,
"No Participant specified. "
"For Subscriber: <%s>", name);
}
return _this;
}
gapi_returnCode_t
_SubscriberFree (
_Subscriber subscriber)
{
gapi_returnCode_t result = GAPI_RETCODE_OK;
_Status status;
u_subscriber s;
assert(subscriber);
status = _EntityStatus(subscriber);
_StatusSetListener(status, NULL, 0);
_EntityClaim(status);
_StatusDeinit(status);
gapi_dataReaderQos_free(&subscriber->_defDataReaderQos);
s = U_SUBSCRIBER_GET(subscriber);
_EntityDispose(_Entity(subscriber));
if (u_subscriberFree(s) != U_RESULT_OK) {
result = GAPI_RETCODE_ERROR;
}
return result;
}
static void destroy_builtin_readers (struct builtin_datareader_set *drset)
{
if (drset->publication_dr)
u_dataReaderFree (drset->publication_dr);
if (drset->subscription_dr)
u_dataReaderFree (drset->subscription_dr);
if (drset->participant_dr)
u_dataReaderFree (drset->participant_dr);
if (drset->subscriber)
u_subscriberFree (drset->subscriber);
}
void
_BuiltinSubscriberFree (
_Subscriber subscriber)
{
_Status status;
assert(subscriber != NULL);
status = _EntityStatus(subscriber);
_StatusSetListener(status, NULL, 0);
_EntityClaim(status);
_StatusDeinit(status);
u_subscriberFree(U_SUBSCRIBER_GET(subscriber));
_EntityDispose(_Entity(subscriber));
}
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
d_subscriberDeinit(
d_object object)
{
d_subscriber subscriber;
d_durability durability;
assert(d_objectIsValid(object, D_SUBSCRIBER) == TRUE);
if(object){
subscriber = d_subscriber(object);
durability = d_adminGetDurability(subscriber->admin);
if(subscriber->statusListener){
d_statusListenerFree(subscriber->statusListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "statusListener freed\n");
subscriber->statusListener = NULL;
}
if(subscriber->groupLocalListener){
if(subscriber->sampleChainListener){
d_sampleChainListenerStop(subscriber->sampleChainListener);
}
d_groupLocalListenerFree(subscriber->groupLocalListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "groupLocalListener freed\n");
subscriber->groupLocalListener = NULL;
}
if(subscriber->groupRemoteListener){
d_groupRemoteListenerFree(subscriber->groupRemoteListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "groupRemoteListener freed\n");
subscriber->groupRemoteListener = NULL;
}
if(subscriber->groupsRequestListener){
d_groupsRequestListenerFree(subscriber->groupsRequestListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "groupsRequestListener freed\n");
subscriber->groupsRequestListener = NULL;
}
if(subscriber->sampleRequestListener){
d_sampleRequestListenerFree(subscriber->sampleRequestListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "sampleRequestListener freed\n");
subscriber->sampleRequestListener = NULL;
}
if(subscriber->sampleChainListener){
d_sampleChainListenerFree(subscriber->sampleChainListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "sampleChainListener freed\n");
subscriber->sampleChainListener = NULL;
}
if(subscriber->nameSpacesRequestListener){
d_nameSpacesRequestListenerFree(subscriber->nameSpacesRequestListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "nameSpacesRequestListener freed\n");
subscriber->nameSpacesRequestListener = NULL;
}
if(subscriber->nameSpacesListener){
d_nameSpacesListenerFree(subscriber->nameSpacesListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "nameSpacesListener freed\n");
subscriber->nameSpacesListener = NULL;
}
if(subscriber->deleteDataListener){
d_deleteDataListenerFree(subscriber->deleteDataListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "deleteDataListener freed\n");
subscriber->deleteDataListener = NULL;
}
if(subscriber->persistentDataListener){
d_persistentDataListenerFree(subscriber->persistentDataListener);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "persistentDataListener freed\n");
subscriber->persistentDataListener = NULL;
}
if(subscriber->persistentStore){
d_storeClose(subscriber->persistentStore);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "persistent store closed\n");
subscriber->persistentStore = NULL;
}
if(subscriber->waitset) {
d_waitsetFree(subscriber->waitset);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "waitset freed\n");
subscriber->waitset = NULL;
}
if(subscriber->persistentSubscriber){
u_subscriberFree(subscriber->persistentSubscriber);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "user persistent subscriber freed\n");
subscriber->persistentSubscriber = NULL;
}
if(subscriber->subscriber){
u_subscriberFree(subscriber->subscriber);
d_printTimedEvent(durability, D_LEVEL_FINEST, D_THREAD_MAIN, "user subscriber freed\n");
subscriber->subscriber = NULL;
}
}
}
_Subscriber
_SubscriberNew (
u_participant uParticipant,
const gapi_subscriberQos *qos,
const struct gapi_subscriberListener *a_listener,
const gapi_statusMask mask,
const _DomainParticipant participant)
{
_Subscriber newSubscriber;
v_subscriberQos subscriberQos;
gapi_long len;
assert(uParticipant);
assert(qos);
assert(participant);
newSubscriber = _SubscriberAlloc();
if ( newSubscriber != NULL ) {
_EntityInit(_Entity(newSubscriber),
_Entity(participant));
gapi_dataReaderQosCopy (&gapi_dataReaderQosDefault,
&newSubscriber->_defDataReaderQos);
if ( a_listener ) {
newSubscriber->_Listener = *a_listener;
}
}
if (newSubscriber != NULL ) {
subscriberQos = u_subscriberQosNew(NULL);
if ( subscriberQos != NULL ) {
if ( !copySubscriberQosIn(qos, subscriberQos) ) {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
} else {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
if ( newSubscriber != NULL) {
u_subscriber uSubscriber;
uSubscriber = u_subscriberNew(uParticipant, "subscriber", subscriberQos, FALSE);
u_subscriberQosFree(subscriberQos);
if ( uSubscriber != NULL ) {
U_SUBSCRIBER_SET(newSubscriber, uSubscriber);
} else {
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
if ( newSubscriber != NULL) {
_Status status;
status = _StatusNew(_Entity(newSubscriber),
STATUS_KIND_SUBSCRIBER,
(struct gapi_listener *)a_listener, mask);
if (status) {
_EntityStatus(newSubscriber) = status;
len = (gapi_long)qos->partition.name._length;
if ( qos->partition.name._length == 0UL ) {
/*
* behaviour of the kernel in case of an empty sequence
* is that it is related to none of the partitions,
* while DCPS expects it to be conected to all partitions.
* Therefore this has to be done seperately.
*/
u_subscriberSubscribe (U_SUBSCRIBER_GET(newSubscriber), "");
}
newSubscriber->builtin = FALSE;
} else {
u_subscriberFree(U_SUBSCRIBER_GET(newSubscriber));
_EntityDispose(_Entity(newSubscriber));
newSubscriber = NULL;
}
}
return newSubscriber;
}
