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;
}
END_TEST
START_TEST(test_dynamic_type)
{
qeocore_type_t *structure = NULL, *sequence = NULL, *string = NULL, *primitive = NULL;
qeocore_member_id_t id;
/* init */
stub_init();
/* test */
fail_unless(NULL != (structure = qeocore_type_struct_new("a_dynamic_struct")));
fail_unless(NULL != (string = qeocore_type_string_new(0)));
fail_unless(NULL != (primitive = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT32)));
fail_unless(NULL != (sequence = qeocore_type_sequence_new(primitive)));
qeocore_type_free(primitive);
id = QEOCORE_MEMBER_ID_DEFAULT;
fail_unless(QEO_OK == qeocore_type_struct_add(structure, string, "a_string", &id, QEOCORE_FLAG_KEY));
qeocore_type_free(string);
id = QEOCORE_MEMBER_ID_DEFAULT;
fail_unless(QEO_OK == qeocore_type_struct_add(structure, sequence, "a_sequence", &id, QEOCORE_FLAG_NONE));
qeocore_type_free(sequence);
/* clean up */
qeocore_type_free(structure);
stub_fini();
}
static qeocore_type_t *type_unnest_register(qeo_factory_t *factory)
{
qeocore_type_t *outer = NULL;
qeocore_type_t *member = NULL;
// the outer struct
assert(NULL != (outer = qeocore_type_struct_new("org.qeo.test.NestedTests")));
assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT32)));
assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_int32", &_outer_int32_id, QEOCORE_FLAG_KEY));
qeocore_type_free(member);
assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT8)));
assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_int8", &_outer_int8_id, QEOCORE_FLAG_NONE));
qeocore_type_free(member);
assert(NULL != (member = qeocore_type_string_new(0)));
assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_string", &_outer_string_id, QEOCORE_FLAG_NONE));
qeocore_type_free(member);
assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT16)));
assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_int16", &_outer_int16_id, QEOCORE_FLAG_NONE));
qeocore_type_free(member);
assert(NULL != (member = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT64)));
assert(QEO_OK == qeocore_type_struct_add(outer, member, "outer_int64", &_outer_int64_id, QEOCORE_FLAG_NONE));
qeocore_type_free(member);
assert(QEO_OK == qeocore_type_register(factory, outer, "org.qeo.test.QDMTestDynType"));
return outer;
}
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);
}
static qeocore_type_t *type_register(qeo_factory_t *factory)
{
qeocore_type_t *bigdata = NULL;
qeocore_type_t *primitive = NULL;
qeocore_type_t *sequence = NULL;
assert(NULL != (bigdata = qeocore_type_struct_new("org.qeo.test.bigdata")));
assert(NULL != (primitive = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT32)));
assert(QEO_OK == qeocore_type_struct_add(bigdata, primitive, "size", &_size_id, QEOCORE_FLAG_KEY));
qeocore_type_free(primitive);
assert(NULL != (primitive = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT8)));
assert(NULL != (sequence = qeocore_type_sequence_new(primitive)));
assert(QEO_OK == qeocore_type_struct_add(bigdata, sequence, "buf", &_buf_id, QEOCORE_FLAG_NONE));
qeocore_type_free(sequence);
qeocore_type_free(primitive);
assert(QEO_OK == qeocore_type_register(factory, bigdata, "org.qeo.test.bigdata"));
return bigdata;
}
static void run_writer(pid_t peer)
{
// writer is a type_nest_i writer
qeo_factory_t *factory;
qeocore_type_t *type_nest_i;
qeocore_writer_t *writer;
qeocore_data_t *outer=NULL;
qeocore_data_t *inner=NULL;
int status;
/* initialize */
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(factory);
assert(NULL != (type_nest_i = type_nest_i_register(factory)));
assert(NULL != (writer = qeocore_writer_open(factory, type_nest_i, NULL,
QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE,
NULL, NULL)));
log_pid("=================================== writer initialized");
assert(NULL != (outer = qeocore_writer_data_new(writer)));
/* fill outer struct */
assert(QEO_OK == qeocore_data_set_member(outer, _outer_int32_id, &_outer_int32_value));
assert(QEO_OK == qeocore_data_set_member(outer, _outer_int8_id, &_outer_int8_value));
assert(QEO_OK == qeocore_data_set_member(outer, _outer_string_id, &_outer_string_value));
assert(QEO_OK == qeocore_data_set_member(outer, _outer_int16_id, &_outer_int16_value));
assert(QEO_OK == qeocore_data_set_member(outer, _outer_int64_id, &_outer_int64_value));
/* fill inner struct */
assert(QEO_OK == qeocore_data_get_member(outer, _inner_id, &inner));
assert(QEO_OK == qeocore_data_set_member(inner, _inner_int32_id, &_inner_int32_value));
assert(QEO_OK == qeocore_data_set_member(inner, _inner_int8_id, &_inner_int8_value));
assert(QEO_OK == qeocore_data_set_member(inner, _inner_string_id, &_inner_string_value));
assert(QEO_OK == qeocore_data_set_member(inner, _inner_int16_id, &_inner_int16_value));
assert(QEO_OK == qeocore_data_set_member(inner, _inner_int64_id, &_inner_int64_value));
assert(QEO_OK == qeocore_data_set_member(outer, _inner_id, &inner));
log_verbose(" =================== _outer_int32_value = %u \n", _outer_int32_value );
log_verbose(" =================== _outer_int8_value = %u \n", _outer_int8_value );
log_verbose(" =================== _outer_int16_value = %u \n", _outer_int16_value );
log_verbose(" =================== _outer_int64_value = %"PRIu64" \n", _outer_int64_value );
log_verbose(" =================== _inner_int32_value = %u \n", _inner_int32_value );
log_verbose(" =================== _inner_int8_value = %u \n", _inner_int8_value );
log_verbose(" =================== _inner_int16_value = %u \n", _inner_int16_value );
log_verbose(" =================== _inner_int64_value = %"PRIu64" \n", _inner_int64_value );
/* write */
assert(QEO_OK == qeocore_writer_write(writer, outer));
log_pid("===================================== writer wrote outer data");
assert(peer == waitpid(peer, &status, 0));
assert(0 == status);
log_pid("===================================== writer done");
/* clean up */
qeocore_data_free(inner);
qeocore_data_free(outer);
qeocore_writer_close(writer);
qeocore_type_free(type_nest_i);
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;
}
static qeo_retcode_t object_add_member(const qeo_factory_t *factory, qeocore_type_t *type, const char *member_name, json_t *member)
{
qeo_retcode_t result = QEO_EFAIL;
qeocore_type_t *qeoType = NULL;
qeocore_member_id_t qeo_member_id = QEOCORE_MEMBER_ID_DEFAULT;
json_t *member_key = json_object_get(member, KEY_KEY); // optional => BOOLEAN
json_t *member_id = json_object_get(member, KEY_ID); // optional => INTxx
assert(factory != NULL);
if (((NULL != member_key) && !json_is_boolean(member_key)) ||
((NULL != member_id) && !json_is_integer(member_id)) ||
(NULL == member_name)) {
// syntax error
return QEO_EINVAL;
}
qeo_log_d("Processing %s", member_name);
qeoType = build_member_type(factory, member);
if (NULL == qeoType) {
qeo_log_e("Could not build member_type");
return result;
}
bool is_key = (member_key && json_is_true(member_key));
do {
result = qeocore_type_struct_add(type, // container
qeoType, // new member to add
member_name, // name of member
&qeo_member_id, // member id
is_key ? QEOCORE_FLAG_KEY : 0); // flag
if (QEO_OK != result) {
qeo_log_e("qeocore_type_struct_add failed for member %s", member_name);
break;
}
qeocore_type_free(qeoType);
// Modify the json member to add/update the qeo member id
json_object_set_new(member, KEY_ID, json_integer(qeo_member_id));
} while (0);
return result;
}
static void run_writer(pid_t peer)
{
qeo_factory_t *factory;
qeocore_type_t *type;
qeocore_writer_t *writer;
qeocore_data_t *data, *seqdata;
byte_array_t array;
int status, i;
/* initialize */
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(factory);
assert(NULL != (type = type_register(factory)));
assert(NULL != (writer = qeocore_writer_open(factory, type, NULL,
QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE,
NULL, NULL)));
log_pid("writer initialized");
assert(NULL != (data = qeocore_writer_data_new(writer)));
assert(QEO_OK == qeocore_data_set_member(data, _size_id, &_test_size));
/* init sequence */
DDS_SEQ_INIT(array);
assert(NULL != (DDS_SEQ_DATA(array) = malloc(_test_size * sizeof(char))));
DDS_SEQ_LENGTH(array) = DDS_SEQ_MAXIMUM(array) = _test_size;
for (i = 0; i < _test_size; i++) {
DDS_SEQ_ITEM(array, i) = i & 0xff;
}
assert(QEO_OK == qeocore_data_get_member(data, _buf_id, &seqdata));
assert(QEO_OK == qeocore_data_sequence_set(seqdata, (const qeo_sequence_t *)&array, 0));
assert(QEO_OK == qeocore_data_set_member(data, _buf_id, &seqdata));
/* write */
assert(QEO_OK == qeocore_writer_write(writer, data));
log_pid("writer wrote data");
assert(peer == waitpid(peer, &status, 0));
assert(0 == status);
log_pid("writer done");
/* clean up */
free(DDS_SEQ_DATA(array));
qeocore_data_free(seqdata);
qeocore_data_free(data);
qeocore_writer_close(writer);
qeocore_type_free(type);
qeocore_factory_close(factory);
}
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;
}
static void run_reader(void)
{
qeo_factory_t *factory;
qeocore_type_t *type_nest_i;
qeocore_reader_t *reader;
qeocore_reader_listener_t listener = { .on_data = my_on_data_available };
sem_init(&_sync, 0, 0);
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(factory);
assert(NULL != (type_nest_i = type_nest_i_register(factory)));
assert(NULL != (reader = qeocore_reader_open(factory, type_nest_i, NULL,
QEOCORE_EFLAG_STATE_DATA | QEOCORE_EFLAG_ENABLE,
&listener, NULL)));
log_pid("=============================== reader initialized");
sem_wait(&_sync); /* wait for sample */
log_pid("=============================== reader done");
sem_destroy(&_sync);
qeocore_reader_close(reader);
qeocore_type_free(type_nest_i);
qeocore_factory_close(factory);
}
int main(int argc, const char **argv)
{
qeo_factory_t *factory;
qeocore_reader_t *reader;
qeocore_writer_t *writer;
qeocore_type_t *type;
qeocore_data_t *rdata, *wdata;
int i;
for (i = 0; i < 2; i++) {
/* initialize */
assert(NULL != (factory = qeocore_factory_new(QEO_IDENTITY_DEFAULT)));
init_factory(factory);
assert(NULL != (type = nested_type_get(1, 0, 0)));
assert(QEO_OK == qeocore_type_register(factory, type, "nested"));
assert(NULL != (reader = qeocore_reader_open(factory, type, NULL,
QEOCORE_EFLAG_STATE_UPDATE | QEOCORE_EFLAG_ENABLE, NULL, NULL)));
assert(NULL != (writer = qeocore_writer_open(factory, type, NULL,
QEOCORE_EFLAG_STATE_UPDATE | QEOCORE_EFLAG_ENABLE, NULL, NULL)));
/* write */
assert(NULL != (wdata = qeocore_writer_data_new(writer)));
fill_data(wdata);
assert(QEO_OK == qeocore_writer_write(writer, wdata));
/* check data */
assert(NULL != (rdata = qeocore_reader_data_new(reader)));
assert(QEO_OK == qeocore_reader_read(reader, NULL, rdata));
expected_status = QEOCORE_DATA;
validate_data(rdata);
/* remove */
assert(QEO_OK == qeocore_writer_remove(writer, wdata));
/* clean up */
qeocore_data_free(wdata);
qeocore_data_free(rdata);
qeocore_writer_close(writer);
qeocore_reader_close(reader);
qeocore_type_free(type);
qeocore_factory_close(factory);
}
}
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);
}
END_TEST
START_TEST(wifi_datamodel_endtobegin)
{
qeocore_type_t *type;
qeo_tsm_dynamic_type_hndl_t types;
ck_assert_int_eq(qeo_register_tsm(_factory, org_qeo_wifi_ScanRequest_type, &type, &types), QEO_OK);
ck_assert_int_ne(type, NULL);
ck_assert_int_ne(types, NULL);
ck_assert_int_eq(qeo_unregister_tsm(&types), QEO_OK);
qeocore_type_free(type);
ck_assert_int_eq(qeo_register_tsm(_factory, org_qeo_wifi_ScanList_type, &type, &types), QEO_OK);
ck_assert_int_ne(type, NULL);
ck_assert_int_ne(types, NULL);
ck_assert_int_eq(qeo_unregister_tsm(&types), QEO_OK);
qeocore_type_free(type);
ck_assert_int_eq(qeo_register_tsm(_factory, org_qeo_wifi_ScanListEntry_type, &type, &types), QEO_OK);
ck_assert_int_ne(type, NULL);
ck_assert_int_ne(types, NULL);
ck_assert_int_eq(qeo_unregister_tsm(&types), QEO_OK);
qeocore_type_free(type);
ck_assert_int_eq(qeo_register_tsm(_factory, org_qeo_wifi_AssociatedStation_type, &type, &types), QEO_OK);
ck_assert_int_ne(type, NULL);
ck_assert_int_ne(types, NULL);
ck_assert_int_eq(qeo_unregister_tsm(&types), QEO_OK);
qeocore_type_free(type);
ck_assert_int_eq(qeo_register_tsm(_factory, org_qeo_wifi_Interface_type, &type, &types), QEO_OK);
ck_assert_int_ne(type, NULL);
ck_assert_int_ne(types, NULL);
ck_assert_int_eq(qeo_unregister_tsm(&types), QEO_OK);
qeocore_type_free(type);
ck_assert_int_eq(qeo_register_tsm(_factory, org_qeo_wifi_Radio_type, &type, &types), QEO_OK);
ck_assert_int_ne(type, NULL);
ck_assert_int_ne(types, NULL);
qeocore_type_free(type);
ck_assert_int_eq(qeo_unregister_tsm(&types), QEO_OK);
}
static qeojson_writer_t *qeojson_writer_open(const qeo_factory_t *factory,
qeojson_writer_type_t writer_type,
void *listener,
const char *json_type,
uintptr_t userdata)
{
qeo_retcode_t ret = QEO_EFAIL;
qeojson_writer_t *jsonwriter = NULL;
qeocore_type_t *typedesc = NULL;
json_writer_dispatcher_cookie_t *dc = NULL;
json_t *jsonTypeDesc = NULL;
json_t *behavior = NULL;
const char *expected_behaviour = NULL;
int flags = QEOCORE_EFLAG_NONE;
qeocore_writer_listener_t l = { 0 };
if ((NULL == factory) || (NULL == json_type)) {
return NULL;
}
do {
dc = calloc(1, sizeof(json_writer_dispatcher_cookie_t));
if (NULL == dc) {
break;
}
dc->userdata = userdata;
switch (writer_type) {
case QEOJSON_WRITER_TYPE_EVENT_WRITER:
flags = QEOCORE_EFLAG_EVENT_DATA;
expected_behaviour = "event";
qeo_json_event_writer_listener_t *event_listener = (qeo_json_event_writer_listener_t *) listener;
dc->etype = QEO_ETYPE_EVENT_DATA;
dc->listener.event = *event_listener;
if (NULL != event_listener->on_policy_update) {
l.on_policy_update = qeojson_core_writer_policy_update_callback_dispatcher;
}
break;
case QEOJSON_WRITER_TYPE_STATE_WRITER:
flags = QEOCORE_EFLAG_STATE_DATA;
expected_behaviour = "state";
qeo_json_state_writer_listener_t *state_listener = (qeo_json_state_writer_listener_t *)listener;
dc->etype = QEO_ETYPE_STATE_DATA;
dc->listener.state = *state_listener;
if (NULL != state_listener->on_policy_update) {
l.on_policy_update = qeojson_core_writer_policy_update_callback_dispatcher;
}
break;
}
jsonTypeDesc = json_loads(json_type, 0, NULL);
if (NULL == jsonTypeDesc) {
break;
}
if (!json_is_object(jsonTypeDesc)) {
break;
}
behavior = json_object_get(jsonTypeDesc, KEY_BEHAVIOR);
if (!json_is_string(behavior)) {
break;
}
if (0 != strcmp(json_string_value(behavior), expected_behaviour)) {
qeo_log_e("not matching expected behaviour %s", expected_behaviour);
break;
}
jsonwriter = calloc(1, sizeof(qeojson_writer_t));
if (jsonwriter == NULL) {
break;
}
jsonwriter->policy_cache = json_object();
json_object_set_new(jsonwriter->policy_cache, "users", json_array());
jsonwriter->policy = json_object();
json_object_set_new(jsonwriter->policy, "users", json_array());
#ifdef __USE_GNU
/* compile with -D_GNU_SOURCE */
#ifndef NDEBUG
jsonwriter->policy_mutex = (pthread_mutex_t)PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
#else
jsonwriter->policy_mutex = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
#endif
#else
jsonwriter->policy_mutex = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
#endif
typedesc = types_from_json(factory, jsonTypeDesc);
if (NULL == typedesc) {
qeo_log_e("typedesc == NULL");
break;
}
dc->typedesc = jsonTypeDesc;
l.userdata = (uintptr_t)dc;
dc->jsonwriter = jsonwriter;
jsonwriter->writer = qeocore_writer_open(factory, // factory
typedesc, // type
NULL, // callback dispatcher
flags, // flags
&l, // callback cookie
NULL); // return code
qeocore_type_free(typedesc);
if (NULL == jsonwriter->writer) {
break;
}
ret = QEO_OK;
} while (0);
if (QEO_OK != ret) {
json_decref(jsonTypeDesc);
qeojson_writer_close(jsonwriter);
jsonwriter = NULL;
free(dc);
}
return jsonwriter;
}
static qeocore_type_t *build_object(const qeo_factory_t *factory, json_t *typedesc)
{
qeocore_type_t *qeoType = NULL;
const char *name = NULL;
json_t *value = NULL;
qeo_retcode_t ret = QEO_EFAIL;
bool iret = true;
const char *topic = NULL;
assert(typedesc != NULL);
assert(factory != NULL);
do {
json_t *type_topic = json_object_get(typedesc, KEY_TOPIC);
if ((NULL == type_topic) || !json_is_string(type_topic)) {
qeo_log_e("Invalid type_topic (%p)", type_topic);
return qeoType;
}
json_t *properties = json_object_get(typedesc, KEY_PROPERTIES);
if ((NULL == properties) || !json_is_object(properties)) {
qeo_log_e("Invalid properties (%p)", properties);
return qeoType;
}
topic = json_string_value(type_topic);
//Replace all "::" with ".", because there's a mismatch in topic definitions found in the TSM structs, with "." and the QDM topic definitions with "::"
find_and_replace((char *) topic, "::", ".");
qeoType = qeocore_type_struct_new(topic);
if (qeoType == NULL) {
qeo_log_e("qeocore_type_struct_new failed for topic:%s", topic);
break;
}
qeo_log_d("Registered new struct with name %s", topic);
void *iter = json_object_iter(properties);
while (iter) {
name = json_object_iter_key(iter);
if (name == NULL) {
qeo_log_e("name == NULL");
iret = false;
break;
}
value = json_object_iter_value(iter);
if (value == NULL) {
qeo_log_e("value == NULL");
iret = false;
break;
}
if (!json_is_object(value)) {
qeo_log_e("no json object");
iret = false;
break;
}
if (QEO_OK != object_add_member(factory, qeoType, name, value)) {
qeo_log_e("object add member failed");
iret = false;
break;
}
iter = json_object_iter_next(properties, iter);
}
if (true != iret) {
break;
}
if (QEO_OK != qeocore_type_register(factory, qeoType, topic)) {
qeo_log_e("failed to register type: %s", topic);
}
ret = QEO_OK;
} while (0);
if (ret != QEO_OK) {
qeocore_type_free(qeoType);
qeoType = NULL;
}
return qeoType;
}
static qeocore_type_t *build_member_type(const qeo_factory_t *factory, json_t *member)
{
qeocore_type_t *memberType = NULL;
qeocore_typecode_t qeoTypeCode;
json_t *member_type = json_object_get(member, KEY_TYPE);
if (!((NULL != member_type) && (json_is_string(member_type)))) {
qeo_log_e("Could not retrieve type");
return memberType;
}
const char *jsonTypeCode = json_string_value(member_type);
do {
if (!strcmp(jsonTypeCode, "boolean")) {
memberType = qeocore_type_primitive_new(QEOCORE_TYPECODE_BOOLEAN);
qeoTypeCode = QEOCORE_TYPECODE_BOOLEAN;
}
else if (!strcmp(jsonTypeCode, "byte")) {
memberType = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT8);
qeoTypeCode = QEOCORE_TYPECODE_INT8;
}
else if (!strcmp(jsonTypeCode, "int16")) {
memberType = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT16);
qeoTypeCode = QEOCORE_TYPECODE_INT16;
}
else if (!strcmp(jsonTypeCode, "int32")) {
memberType = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT32);
qeoTypeCode = QEOCORE_TYPECODE_INT32;
}
else if (!strcmp(jsonTypeCode, "int64")) {
memberType = qeocore_type_primitive_new(QEOCORE_TYPECODE_INT64);
qeoTypeCode = QEOCORE_TYPECODE_INT64;
}
else if (!strcmp(jsonTypeCode, "float32")) {
memberType = qeocore_type_primitive_new(QEOCORE_TYPECODE_FLOAT32);
qeoTypeCode = QEOCORE_TYPECODE_FLOAT32;
}
else if (!strcmp(jsonTypeCode, "string")) {
size_t size = 0;
memberType = qeocore_type_string_new(size);
qeoTypeCode = QEOCORE_TYPECODE_STRING;
}
else if (!strcmp(jsonTypeCode, "object")) {
json_t *item = json_object_get(member, KEY_ITEM);
if ((NULL == item) || !json_is_object(item)) {
qeo_log_e("Could not find item");
break;
}
memberType = build_object(factory, item);
qeoTypeCode = QEOCORE_TYPECODE_STRUCT;
}
else if (!strcmp(jsonTypeCode, "array")) {
json_t *items = json_object_get(member, KEY_ITEMS);
if ((NULL == items) || !json_is_object(items)) {
qeo_log_e("Could not find items");
break;
}
qeocore_type_t *elemtype = build_member_type(factory, items);
if (elemtype == NULL){
qeo_log_e("Could not build member for array");
break;
}
memberType = qeocore_type_sequence_new(elemtype);
qeocore_type_free(elemtype);
qeoTypeCode = QEOCORE_TYPECODE_SEQUENCE;
}
else if (!strcmp(jsonTypeCode, "enum")){
json_t *item = json_object_get(member, KEY_ITEM);
if ((NULL == item) || !json_is_object(item)) {
qeo_log_e("Could not find item");
break;
}
memberType = build_enum(factory, item);
qeoTypeCode = QEOCORE_TYPECODE_ENUM;
}
else {
qeo_log_e("Unsupported jsonTypeCode %s", jsonTypeCode);
}
} while (0);
if (NULL == memberType) {
qeo_log_e("Could not make type (%s)", jsonTypeCode);
return memberType;
}
json_object_set_new(member, KEY_QEO_TYPE_CODE, json_integer(qeoTypeCode));
return memberType;
}
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;
}
