qeo_retcode_t qeo_json_state_change_reader_enable(qeo_json_state_change_reader_t *reader)
{
qeo_retcode_t ret = QEO_EINVAL;
qeojson_reader_t *jsonreader = (qeojson_reader_t *) reader;
do {
if (reader == NULL) {
break;
}
ret = qeocore_reader_enable(jsonreader->reader);
if (ret != QEO_OK) {
break;
}
ret = QEO_OK;
} while (0);
return ret;
}
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;
}
static void client_state_machine_eval_ul(qeo_factory_t *factory,
client_state_events_t event,
qeo_mgmt_client_locator_t *locator,
int64_t device_id)
{
qeo_log_i("received event %s in state %s", client_event_to_str(event),
client_state_to_str(factory->fwd.u.client.state));
switch (factory->fwd.u.client.state) {
case FWD_CLIENT_STATE_INIT:
switch (event) {
case CLIENT_EVENT_START:
factory->fwd.device_id = -1;
if (QEO_OK == client_start_timer(factory, 1)) {
factory->fwd.u.client.state = FWD_CLIENT_STATE_WAIT;
}
if (QEO_OK != qeocore_reader_enable(factory->fwd.reader)) {
qeo_log_e("error enabling forwarder topic reader");
}
if (QEO_OK != fwd_get_list(factory)) {
qeo_log_e("error requesting list of forwarders");
}
break;
default:
qeo_log_e("unexpected event %s in state %s", client_event_to_str(event),
client_state_to_str(factory->fwd.u.client.state));
break;
}
break;
case FWD_CLIENT_STATE_WAIT:
switch (event) {
case CLIENT_EVENT_TIMEOUT:
if (QEO_OK == client_start_timer(factory, 0)) {
factory->fwd.u.client.state = FWD_CLIENT_STATE_WAIT;
}
if (QEO_OK != fwd_get_list(factory)) {
qeo_log_e("error requesting list of forwarders");
}
break;
case CLIENT_EVENT_LOC_SRV_DATA_RECEIVED:
fwd_client_reconfig(factory, locator, device_id);
factory->fwd.u.client.state = FWD_CLIENT_STATE_WAIT_READER;
break;
case CLIENT_EVENT_FWD_DATA_RECEIVED:
fwd_client_reconfig(factory, locator, device_id);
DDS_Timer_stop(factory->fwd.timer);
factory->fwd.u.client.state = FWD_CLIENT_STATE_READY;
break;
default:
qeo_log_e("unexpected event %s in state %s", client_event_to_str(event),
client_state_to_str(factory->fwd.u.client.state));
break;
}
break;
case FWD_CLIENT_STATE_WAIT_READER:
switch (event) {
case CLIENT_EVENT_TIMEOUT:
if (QEO_OK == client_start_timer(factory, 0)) {
factory->fwd.u.client.state = FWD_CLIENT_STATE_WAIT;
}
fwd_locator_destroy(factory);
factory->fwd.device_id = -1;
if (QEO_OK != fwd_get_list(factory)) {
qeo_log_e("error requesting list of forwarders");
}
break;
case CLIENT_EVENT_FWD_DATA_RECEIVED:
DDS_Timer_stop(factory->fwd.timer);
factory->fwd.u.client.state = FWD_CLIENT_STATE_READY;
if (factory->fwd.device_id != device_id) {
fwd_client_reconfig(factory, locator, device_id);
}
break;
default:
qeo_log_e("unexpected event %s in state %s", client_event_to_str(event),
client_state_to_str(factory->fwd.u.client.state));
break;
}
break;
case FWD_CLIENT_STATE_READY:
switch (event) {
case CLIENT_EVENT_FWD_DATA_REMOVED:
if (QEO_OK == client_start_timer(factory, 1)) {
factory->fwd.u.client.state = FWD_CLIENT_STATE_WAIT;
}
fwd_locator_destroy(factory);
factory->fwd.device_id = -1;
if (QEO_OK != fwd_get_list(factory)) {
qeo_log_e("error requesting list of forwarders");
}
break;
default:
qeo_log_e("unexpected event %s in state %s", client_event_to_str(event),
client_state_to_str(factory->fwd.u.client.state));
break;
}
break;
}
qeo_log_i("new state %s", client_state_to_str(factory->fwd.u.client.state));
}
/**
* \pre This should be called with the factory lock taken.
*
* param[in] num_local Number of local forwarders discovered, -1 if not counted
* param[in] timeout True if a timeout occurred
*/
static qeo_retcode_t fwd_server_state_machine_eval_ul(qeo_factory_t *factory,
int num_local,
bool timeout,
bool public_ip_available)
{
qeo_retcode_t rc = QEO_OK;
qeo_log_i("old state %s : local fwd count = %d, timeout = %s, public ip available = %s",
server_state_to_str(factory->fwd.u.server.state), num_local, bool2str(timeout), bool2str(public_ip_available));
switch (factory->fwd.u.server.state) {
case FWD_STATE_INIT: {
/* done with initialization */
int timeout = qeocore_parameter_get_number("FWD_WAIT_LOCAL_FWD");
rc = ddsrc_to_qeorc(DDS_Timer_start(factory->fwd.timer, timeout, (uintptr_t)factory,
fwd_server_timeout));
if (QEO_OK != rc) {
qeo_log_e("failed to start forwarder timer");
break;
}
rc = qeocore_reader_enable(factory->fwd.reader);
if (QEO_OK != rc) {
qeo_log_e("failed to enable forwarder reader");
break;
}
factory->fwd.u.server.state = FWD_STATE_WAIT_LOCAL;
break;
}
case FWD_STATE_WAIT_LOCAL:
/* done waiting for local forwarder */
if (timeout) {
/* no local forwarders found, try start forwarding ourselves */
factory->fwd.u.server.state = FWD_STATE_STARTING;
unlock(&factory->mutex);
factory->listener.on_fwdfactory_get_public_locator(factory);
lock(&factory->mutex);
}
else if (num_local > 0) {
/* local forwarder(s) available stop timer */
DDS_Timer_stop(factory->fwd.timer);
factory->fwd.u.server.state = FWD_STATE_DISABLED;
}
break;
case FWD_STATE_STARTING:
/* done waiting for publicly available locator */
if (num_local > 0) {
factory->fwd.u.server.state = FWD_STATE_DISABLED;
}
else if (public_ip_available) {
if (QEO_OK == fwd_server_start_forwarding(factory)) {
factory->fwd.u.server.state = FWD_STATE_ENABLED;
}
else {
/* failed to start */
factory->fwd.u.server.state = FWD_STATE_DISABLED;
}
}
break;
case FWD_STATE_ENABLED:
if (public_ip_available) {
if (QEO_OK == fwd_server_start_forwarding(factory)) {
factory->fwd.u.server.state = FWD_STATE_ENABLED;
}
else {
/* failed to start */
factory->fwd.u.server.state = FWD_STATE_DISABLED;
}
}
break;
case FWD_STATE_DISABLED:
if (0 == num_local) {
/* no local forwarders anymore, try start forwarding ourselves */
factory->fwd.u.server.state = FWD_STATE_STARTING;
unlock(&factory->mutex);
factory->listener.on_fwdfactory_get_public_locator(factory);
lock(&factory->mutex);
}
break;
}
qeo_log_i("new state %s", server_state_to_str(factory->fwd.u.server.state));
return rc;
}
