int main()
{
qeo_factory_t *open_qeo = NULL;
qeo_factory_t *closed_qeo = NULL;
qeocore_type_t *tsm_type = NULL;
qeocore_type_t *dyn_type = NULL;
/* create two factories */
assert(NULL != (open_qeo = qeocore_factory_new(QEO_IDENTITY_OPEN)));
init_factory(open_qeo);
assert(NULL != (closed_qeo = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(closed_qeo);
/* register TSM type in open domain factory */
assert(NULL != (tsm_type = qeocore_type_register_tsm(open_qeo, org_qeo_system_RegistrationRequest_type,
org_qeo_system_RegistrationRequest_type->name)));
/* register dynamic type in closed domain factory */
assert(NULL != (dyn_type = types_get(org_qeo_system_RegistrationRequest_type)));
assert(QEO_OK == qeocore_type_register(closed_qeo, dyn_type, org_qeo_system_RegistrationRequest_type->name));
/* clean up */
qeocore_type_free(dyn_type);
qeocore_type_free(tsm_type);
qeocore_factory_close(closed_qeo);
qeocore_factory_close(open_qeo);
return 0;
}
int main(int argc, const char **argv)
{
qeo_factory_t *factory;
qeocore_type_t *type;
qeocore_reader_t *reader;
qeocore_reader_listener_t listener = { .on_data = on_data_available };
qeocore_writer_t *writer;
pthread_t th = 0;
/* initialize */
sem_init(&_sync, 0, 0);
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(factory);
assert(NULL != (type = qeocore_type_register_tsm(factory, _tsm, _tsm[0].name)));
assert(NULL != (reader = qeocore_reader_open(factory, type, NULL, QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE,
&listener, NULL)));
assert(NULL != (writer = qeocore_writer_open(factory, type, NULL, QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE,
NULL, NULL)));
/* start writer thread */
assert(0 == pthread_create(&th, NULL, run, writer));
/* make sure writing has started */
sem_wait(&_sync);
/* shutdown reader */
qeocore_reader_close(reader);
_closed = 1;
/* shutdown writer */
_done = 1;
pthread_join(th, NULL);
qeocore_writer_close(writer);
qeocore_type_free(type);
qeocore_factory_close(factory);
}
END_TEST
START_TEST(test_cache_refcnt)
{
qeocore_type_t *ti1, *ti2;
/* init */
stub_init();
core_register_type_IgnoreAndReturn(QEO_OK);
core_unregister_type_IgnoreAndReturn(QEO_OK);
/* test */
ti1 = qeocore_type_register_tsm(_factory, _tsm_simple, "simple");
fail_unless(NULL != ti1);
ti2 = qeocore_type_register_tsm(_factory, _tsm_simple, "simple");
fail_unless(ti1->u.tsm_based.ts == ti2->u.tsm_based.ts);
/* fini */
qeocore_type_free(ti1);
qeocore_type_free(ti2);
stub_fini();
}
qeo_state_reader_t *qeo_factory_create_state_reader(const qeo_factory_t *factory,
const DDS_TypeSupport_meta *type,
const qeo_state_reader_listener_t *listener,
uintptr_t userdata)
{
qeo_state_reader_t *reader = NULL;
if ((NULL != factory) && (NULL != type) &&
((NULL == listener) || (NULL != listener->on_update) || (NULL != listener->on_policy_update))) {
qeocore_reader_listener_t l = { 0 }, *pl = NULL;
reader_dispatcher_cookie *dc = NULL;
qeo_retcode_t rc = QEO_OK;
qeocore_type_t *t = NULL;
if (NULL != listener) {
dc = calloc(1, sizeof(*dc));
if (NULL != dc) {
dc->etype = QEO_ETYPE_STATE_UPDATE;
dc->listener.state = *listener;
dc->userdata = userdata;
if (NULL != listener->on_update) {
l.on_data = core_callback_dispatcher;
}
if (NULL != listener->on_policy_update) {
l.on_policy_update = core_reader_policy_update_callback_dispatcher;
}
l.userdata = (uintptr_t)dc;
pl = &l;
}
else {
rc = QEO_ENOMEM;
}
}
if (QEO_OK == rc) {
t = qeocore_type_register_tsm(factory, type, type->name);
if (NULL != t) {
reader = (qeo_state_reader_t *)qeocore_reader_open(factory, t, NULL,
QEOCORE_EFLAG_STATE_UPDATE | QEOCORE_EFLAG_ENABLE,
pl, NULL);
qeocore_type_free(t);
}
if (NULL == reader) {
free(dc);
}
}
}
return reader;
}
qeo_retcode_t fwd_init_post_auth(qeo_factory_t *factory)
{
qeo_retcode_t rc = QEO_EFAIL;
qeocore_type_t *type = NULL;
/* this will eventually also take the factory lock, so postponing our lock */
type = qeocore_type_register_tsm(factory, org_qeo_system_Forwarder_type, org_qeo_system_Forwarder_type->name);
if (NULL != type) {
lock(&factory->mutex);
if (factory->flags.is_forwarder) {
factory->fwd.listener.on_data = fwd_server_on_data;
factory->fwd.reader = qeocore_reader_open(factory, type, org_qeo_system_Forwarder_type->name,
QEOCORE_EFLAG_STATE_UPDATE, &factory->fwd.listener, NULL);
if (NULL != factory->fwd.reader) {
factory->fwd.u.server.writer = qeocore_writer_open(factory, type, org_qeo_system_Forwarder_type->name,
QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE,
NULL, NULL);
if (NULL != factory->fwd.u.server.writer) {
factory->fwd.u.server.state = FWD_STATE_INIT;
rc = fwd_server_state_machine_eval_ul(factory, -1, false, false);
}
}
} else {
factory->fwd.listener.on_data = fwd_client_on_data;
factory->fwd.listener.userdata = (uintptr_t)factory;
factory->fwd.reader = qeocore_reader_open(factory, type, org_qeo_system_Forwarder_type->name,
QEOCORE_EFLAG_STATE_DATA, &factory->fwd.listener, NULL);
/* note: reader construction failure is not fatal */
if (qeocore_parameter_get_number("FWD_DISABLE_FORWARDING")) {
qeo_log_i("Disable forwarding");
factory->fwd.u.client.state = FWD_CLIENT_STATE_READY;
}
else {
factory->fwd.u.client.state = FWD_CLIENT_STATE_INIT;
client_state_machine_eval_ul(factory, CLIENT_EVENT_START, NULL, -1);
}
rc = QEO_OK;
}
unlock(&factory->mutex);
qeocore_type_free(type);
}
return rc;
}
qeo_state_change_reader_t *qeo_factory_create_state_change_reader(const qeo_factory_t *factory,
const DDS_TypeSupport_meta *type,
const qeo_state_change_reader_listener_t *listener,
uintptr_t userdata)
{
qeo_state_change_reader_t *reader = NULL;
if ((NULL != factory) && (NULL != type) && (NULL != listener) &&
((NULL != listener->on_data) || (NULL != listener->on_remove))) {
reader_dispatcher_cookie *dc = calloc(1, sizeof(*dc));
if (NULL != dc) {
qeocore_type_t *t = qeocore_type_register_tsm(factory, type, type->name);
if (NULL != t) {
qeocore_reader_listener_t l = { 0 };
dc->etype = QEO_ETYPE_STATE_DATA;
dc->listener.state_change = *listener;
dc->userdata = userdata;
l.on_data = core_callback_dispatcher;
if (NULL != listener->on_policy_update) {
l.on_policy_update = core_reader_policy_update_callback_dispatcher;
}
l.userdata = (uintptr_t)dc;
reader = (qeo_state_change_reader_t *)qeocore_reader_open(factory, t, NULL,
QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE,
&l, NULL);
qeocore_type_free(t);
}
if (NULL == reader) {
free(dc);
}
}
}
return reader;
}
int main(int argc, const char **argv)
{
qeo_factory_t *factory;
qeocore_type_t *type;
qeocore_reader_t *reader;
qeocore_reader_listener_t listener = { .on_data = on_data_available };
qeocore_writer_t *writer;
int i = 0;
/* initialize */
sem_init(&_sync, 0, 0);
sem_init(&_sync_nodata, 0, 0);
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(factory);
assert(NULL != (type = qeocore_type_register_tsm(factory, org_qeo_dynamic_qdm_test_TypeWithStructs_type, org_qeo_dynamic_qdm_test_TypeWithStructs_type[0].name)));
assert(NULL != (reader = qeocore_reader_open(factory, type, NULL, QEOCORE_EFLAG_EVENT_DATA, &listener, NULL)));
assert(NULL != (writer = qeocore_writer_open(factory, type, NULL, QEOCORE_EFLAG_EVENT_DATA, NULL, NULL)));
/* test late enabling of readers/writers */
assert(QEO_OK == qeocore_reader_enable(reader));
assert(QEO_OK == qeocore_writer_enable(writer));
/* send structure */
for(i = 0; i < 20; i++){
log_verbose("testing with %d", i);
assert(QEO_OK == write_generated_data(writer, i));
log_verbose("waiting for data");
/* wait for reception */
sem_wait(&_sync);
sem_wait(&_sync_nodata);
}
/* clean up */
qeocore_writer_close(writer);
qeocore_reader_close(reader);
qeocore_type_free(type);
qeocore_factory_close(factory);
sem_destroy(&_sync);
}
int main(int argc, const char **argv)
{
pid_t pid;
pid = fork();
if (pid == -1) {
perror("fork failed");
exit(EXIT_FAILURE);
}
else if (pid == 0) {
log_verbose("=================== WRITER of type 1 \n");
qeo_factory_t *factory;
qeocore_type_t *type1;
qeocore_writer_t *writer;
/* initialize */
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(factory);
log_verbose(" =================== c qeocore_type_register_tsm(factory, _tsm_type_qdm_version1, _tsm_type_qdm_version1[0].name) \n");
assert(NULL != (type1 = qeocore_type_register_tsm(factory, _tsm_type_qdm_version1, _tsm_type_qdm_version1[0].name)));
log_verbose(" =================== c qeocore_writer_open(factory, type1, NULL, QEOCORE_EFLAG_EVENT_DATA, NULL, NULL) \n");
assert(NULL != (writer = qeocore_writer_open(factory, type1, NULL, QEOCORE_EFLAG_EVENT_DATA, NULL, NULL)));
/* test late enabling of readers/writers */
log_verbose(" =================== c qeocore_writer_enable(writer) \n");
assert(QEO_OK == qeocore_writer_enable(writer));
/* send structure */
sleep(2);
log_verbose(" =================== c qeocore_writer_write(writer, &_type_qdm_version1) \n");
assert(QEO_OK == qeocore_writer_write(writer, &_type_qdm_version1));
sleep(2);
/* clean up */
qeocore_writer_close(writer);
qeocore_type_free(type1);
qeocore_factory_close(factory);
_exit(EXIT_SUCCESS);
}
else {
log_verbose("=================== READER of type 2 \n");
qeo_factory_t *factory;
qeocore_type_t *type2;
qeocore_reader_t *reader;
qeocore_reader_listener_t listener = { .on_data = on_data_available };
/* initialize */
sem_init(&_sync, 0, 0);
sem_init(&_sync_nodata, 0, 0);
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(factory);
log_verbose(" =================== p qeocore_type_register_tsm(factory, _tsm_type_qdm_version2, _tsm_type_qdm_version2[0].name) \n");
assert(NULL != (type2 = qeocore_type_register_tsm(factory, _tsm_type_qdm_version2, _tsm_type_qdm_version2[0].name)));
log_verbose(" =================== p qeocore_reader_open(factory, type2, NULL, QEOCORE_EFLAG_EVENT_DATA, &listener, NULL) \n");
assert(NULL != (reader = qeocore_reader_open(factory, type2, NULL, QEOCORE_EFLAG_EVENT_DATA, &listener, NULL)));
/* test late enabling of readers/writers */
log_verbose(" =================== p qeocore_reader_enable(reader) \n");
assert(QEO_OK == qeocore_reader_enable(reader));
/* wait for reception */
log_verbose(" =================== p sem_wait(&_sync) \n");
sem_wait(&_sync);
log_verbose(" =================== p sem_wait(&_sync_nodata) \n");
sem_wait(&_sync_nodata);
/* clean up */
qeocore_reader_close(reader);
qeocore_type_free(type2);
qeocore_factory_close(factory);
sem_destroy(&_sync);
int status;
(void)waitpid(pid, &status, 0);
}
return EXIT_SUCCESS;
}
qeo_factory_t *factory;
qeocore_type_t *type[2];
qeocore_reader_t *reader[2];
qeocore_reader_t *change[2];
qeocore_reader_listener_t listener[2] = { {.on_data = on_regreq_available }, {.on_data = on_regcred_available } };
qeocore_writer_t *writer[2];
/* initialize */
log_verbose("initialization start");
sem_init(&_sync, 0, 0);
sem_init(&_notify_sync, 0, 0);
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_OPEN)));
init_factory(factory);
assert(NULL != (type[0] = qeocore_type_register_tsm(factory, org_qeo_system_RegistrationRequest_type, org_qeo_system_RegistrationRequest_type[0].name)));
assert(NULL != (writer[0] = qeocore_writer_open(factory, type[0], NULL,
QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE, NULL, NULL)));
/* send registration request */
log_verbose("send registration request 1");
_current_regreq = &_regreq[0];
/* Already write before creating the readers. (see DE2772) */
qeocore_writer_write(writer[0], _current_regreq);
assert(NULL != (reader[0] = qeocore_reader_open(factory, type[0], NULL,
QEOCORE_EFLAG_STATE_UPDATE | QEOCORE_EFLAG_ENABLE, &listener[0],
NULL)));
assert(NULL != (change[0] = qeocore_reader_open(factory, type[0], NULL,
QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE, &listener[0],
NULL)));
assert(NULL != (type[1] = qeocore_type_register_tsm(factory, org_qeo_system_RegistrationCredentials_type, org_qeo_system_RegistrationCredentials_type[0].name)));
