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