static bool
timer_tick(void *data)
{
struct sol_flow_node *node = data;
struct boolean_generator_data *mdata = sol_flow_node_get_private_data(node);
bool out_packet;
if (*mdata->it == 'T') {
out_packet = true;
} else if (*mdata->it == 'F') {
out_packet = false;
} else {
mdata->timer = NULL;
sol_flow_send_error_packet(node, ECANCELED,
"Unknown sample: %c. Option 'sequence' must be composed by 'T' and/or 'F' chars.",
*mdata->it);
return false;
}
sol_flow_send_bool_packet(node, SOL_FLOW_NODE_TYPE_TEST_BOOLEAN_GENERATOR__OUT__OUT,
out_packet);
mdata->it++;
return *mdata->it != '\0';
}
int
blob_validator_process(
struct sol_flow_node *node,
void *data,
uint16_t port,
uint16_t conn_id,
const struct sol_flow_packet *packet)
{
struct blob_validator_data *mdata = data;
struct sol_blob *val;
bool match;
int r;
if (mdata->done) {
sol_flow_send_error_packet(node, ECANCELED,
"Input stream already deviated from expected data, ignoring packets.");
return 0;
}
r = sol_flow_packet_get_blob(packet, &val);
SOL_INT_CHECK(r, < 0, r);
match = (mdata->expected.size == val->size) && memcmp(mdata->expected.mem, val->mem, val->size) == 0;
sol_flow_send_bool_packet(node, SOL_FLOW_NODE_TYPE_TEST_BOOLEAN_VALIDATOR__OUT__OUT, match);
mdata->done = true;
return 0;
}
void
service_status_cb(void *data, const struct sol_netctl_service *service)
{
struct sol_flow_node *node = data;
struct network_service_data *mdata = sol_flow_node_get_private_data(node);
enum sol_netctl_service_state current_state;
const char *name;
int r;
name = sol_netctl_service_get_name(service);
if (!name || strcmp(name, mdata->service_name))
return;
current_state = sol_netctl_service_get_state(service);
if (current_state == mdata->state)
return;
r = sol_flow_send_string_packet(node,
SOL_FLOW_NODE_TYPE_NETCTL_SERVICE__OUT__OUT,
sol_netctl_service_state_to_str(current_state));
SOL_INT_CHECK_GOTO(r, < 0, error);
if (mdata->state == SOL_NETCTL_SERVICE_STATE_ONLINE) {
r = sol_flow_send_bool_packet(node,
SOL_FLOW_NODE_TYPE_NETCTL_SERVICE__OUT__ONLINE,
false);
SOL_INT_CHECK_GOTO(r, < 0, error);
}
static void
check_cb(void *data, int status, const struct sol_update_info *response)
{
struct sol_flow_node *node = data;
struct update_data *mdata = sol_flow_node_get_private_data(node);
if (status < 0) {
sol_flow_send_error_packet(node, -status,
"Error while checking for updates: %s", sol_util_strerrora(-status));
goto end;
}
#ifndef SOL_NO_API_VERSION
if (SOL_UNLIKELY(response->api_version != SOL_UPDATE_INFO_API_VERSION)) {
SOL_WRN("Update info config version '%u' is unexpected, expected '%u'",
response->api_version, SOL_UPDATE_INFO_API_VERSION);
return;
}
#endif
sol_flow_send_string_packet(node,
SOL_FLOW_NODE_TYPE_UPDATE_CHECK__OUT__VERSION, response->version);
sol_flow_send_irange_value_packet(node,
SOL_FLOW_NODE_TYPE_UPDATE_CHECK__OUT__SIZE, response->size);
sol_flow_send_bool_packet(node,
SOL_FLOW_NODE_TYPE_UPDATE_CHECK__OUT__NEED_UPDATE, response->need_update);
end:
mdata->handle = NULL;
}
int
int_validator_process(
struct sol_flow_node *node,
void *data,
uint16_t port,
uint16_t conn_id,
const struct sol_flow_packet *packet)
{
struct int_validator_data *mdata = data;
struct sol_irange val;
int32_t *op;
bool match;
int r;
if (mdata->done) {
sol_flow_send_error_packet(node, ECANCELED,
"Input stream already deviated from expected data, ignoring packets.");
return 0;
}
r = sol_flow_packet_get_irange(packet, &val);
SOL_INT_CHECK(r, < 0, r);
op = sol_vector_get(&mdata->values, mdata->next_index);
match = val.val == *op;
mdata->next_index++;
if (mdata->next_index == mdata->values.len || !match) {
sol_flow_send_bool_packet(node,
SOL_FLOW_NODE_TYPE_TEST_INT_VALIDATOR__OUT__OUT, match);
mdata->done = true;
}
return 0;
}
int
float_validator_process(
struct sol_flow_node *node,
void *data,
uint16_t port,
uint16_t conn_id,
const struct sol_flow_packet *packet)
{
struct float_validator_data *mdata = data;
struct sol_drange input;
double *op;
bool match;
int r;
if (mdata->done) {
sol_flow_send_error_packet(node, ECANCELED,
"Input stream already deviated from expected data, ignoring packets.");
return 0;
}
r = sol_flow_packet_get_drange(packet, &input);
SOL_INT_CHECK(r, < 0, r);
op = sol_vector_get(&mdata->values, mdata->next_index);
SOL_NULL_CHECK(op, -EINVAL);
match = sol_util_double_eq(input.val, *op);
mdata->next_index++;
if (mdata->next_index == mdata->values.len || !match) {
sol_flow_send_bool_packet(node, SOL_FLOW_NODE_TYPE_TEST_FLOAT_VALIDATOR__OUT__OUT,
match);
mdata->done = true;
}
return 0;
}
static void
boolean_receiver(void *data, uint32_t id, struct sol_blob *message)
{
struct sol_flow_node *node = data;
sol_flow_send_bool_packet(node,
SOL_FLOW_NODE_TYPE_IPM_BOOLEAN_READER__OUT__OUT, *(bool *)message->mem);
sol_blob_unref(message);
}
static void
on_toggle_changed(GtkRange *range, gpointer data)
{
bool value;
struct gtk_common_data *mdata = data;
value = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(mdata->widget));
sol_flow_send_bool_packet(mdata->node,
SOL_FLOW_NODE_TYPE_GTK_TOGGLE__OUT__OUT,
value);
}
static void
on_minutes_packet(void *data, struct sol_flow_node *n, uint16_t port, const struct sol_flow_packet *packet)
{
int32_t value = get_int32_packet_and_log(n, port, packet);
static int i = 0;
if (value < 0)
return;
/* do some logic.
*
* Here we will disconnect the 'OUT' output port from 'seconds',
* this would have single-node to stop delivering packets on that
* port to 'on_seconds_packet()', if running with
* SOL_LOG_LEVELS=sol-flow:4 you'd see that packets were dropped.
*
* And we send a boolean packet with value 'false' to the input
* port 'ENABLED' of 'seconds' node so it will stop emitting these
* packets.
*
* in the next minute we reverse it, re-connecting the 'OUT' port
* and sending true to 'ENABLED'.
*/
i++;
if (i == 1)
return; /* first time let it go */
if (i % 2 == 0) {
puts("stop seconds and disconnect output port, will change in 1 minute");
sol_flow_single_disconnect_port_out(seconds, seconds_port_out);
sol_flow_send_bool_packet(seconds, seconds_port_enabled, false);
} else {
puts("start seconds and connect output port, will change in 1 minute");
sol_flow_single_connect_port_out(seconds, seconds_port_out);
sol_flow_send_bool_packet(seconds, seconds_port_enabled, true);
}
}
/*
* WARNING: Do NOT use it for anything else than test purposes.
*/
static int
random_boolean_generate(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
struct random_node_data *mdata = data;
bool value;
int r;
r = sol_random_get_bool(mdata->engine, &value);
if (r < 0)
return r;
return sol_flow_send_bool_packet(node,
SOL_FLOW_NODE_TYPE_RANDOM_BOOLEAN__OUT__OUT,
value);
}
static void
install_cb(void *data, int status)
{
struct sol_flow_node *node = data;
struct update_data *mdata = sol_flow_node_get_private_data(node);
if (status < 0) {
sol_flow_send_error_packet(node, -status,
"Error while installing update: %s", sol_util_strerrora(-status));
}
sol_flow_send_bool_packet(node,
SOL_FLOW_NODE_TYPE_UPDATE_INSTALL__OUT__SUCCESS, status == 0);
mdata->handle = NULL;
}
