void Session::session_stop()
{
int ret = sr_session_stop(_sess);
if (ret != SR_ERR_OK) {
throw_exception(ret);
}
}
static void
perf_get_item_test(void **state) {
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_val_t *value = NULL;
int rc = 0;
/* start a session */
rc = sr_session_start(conn, SR_DS_STARTUP, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
/* perform a get-item request */
for (size_t i = 0; i<100000; i++){
/* existing leaf */
rc = sr_get_item(session, "/example-module:container/list[key1='key1'][key2='key2']/leaf", &value);
assert_int_equal(rc, SR_ERR_OK);
assert_non_null(value);
assert_int_equal(SR_STRING_T, value->type);
sr_free_val(value);
}
/* stop the session */
rc = sr_session_stop(session);
assert_int_equal(rc, SR_ERR_OK);
}
/**
* @brief Check the session and reconnect if it is needed.
*/
static void
sr_pd_session_check(sr_pd_ctx_t *ctx)
{
int rc = SR_ERR_OK;
CHECK_NULL_ARG_VOID(ctx);
rc = sr_session_check(ctx->session);
if (SR_ERR_OK != rc) {
SR_LOG_DBG_MSG("Reconnecting to Sysrepo Engine.");
/* disconnect */
sr_session_stop(ctx->session);
sr_disconnect(ctx->connection);
ctx->session = NULL;
ctx->connection = NULL;
/* reconnect */
rc = sr_connect("sysrepo-plugind", connect_options, &ctx->connection);
if (SR_ERR_OK == rc) {
rc = sr_session_start(ctx->connection, SR_DS_STARTUP, SR_SESS_DEFAULT, &ctx->session);
}
if (SR_ERR_OK != rc) {
SR_LOG_ERR("Error by reconnecting to Sysrepo Engine: %s", sr_strerror(rc));
}
}
}
int
main(int argc, char **argv)
{
sr_conn_ctx_t *connection = NULL;
sr_session_ctx_t *session = NULL;
int rc = SR_ERR_OK;
/* connect to sysrepo */
rc = sr_connect("example_application", SR_CONN_DEFAULT, &connection);
if (SR_ERR_OK != rc) {
fprintf(stderr, "Error by sr_connect: %s\n", sr_strerror(rc));
goto cleanup;
}
/* start session */
rc = sr_session_start(connection, SR_DS_RUNNING, SR_SESS_DEFAULT, &session);
if (SR_ERR_OK != rc) {
fprintf(stderr, "Error by sr_session_start: %s\n", sr_strerror(rc));
goto cleanup;
}
/* run as an event notification subscriber */
printf("This application will be a subscriber for the 'paused' event notification of 'turing-machine'.\n");
printf("This notification is sent by the RPC handler in rpc_example and rpc_tree_example.\n");
rc = event_notif_subscriber(session);
cleanup:
if (NULL != session) {
sr_session_stop(session);
}
if (NULL != connection) {
sr_disconnect(connection);
}
return rc;
}
static int received_anykey(int fd, int revents, void *user_data)
{
/* Avoid compiler warnings. */
(void)fd;
(void)revents;
(void)user_data;
sr_session_stop();
return TRUE;
}
static int received_anykey(int fd, int revents, void *cb_data)
{
struct sr_session *session;
(void)fd;
(void)revents;
session = cb_data;
sr_session_source_remove(session, STDIN_FILENO);
sr_session_stop(session);
return TRUE;
}
static void load_input_file(void)
{
if (sr_session_load(opt_input_file) == SR_OK) {
/* sigrok session file */
sr_session_datafeed_callback_add(datafeed_in);
sr_session_start();
sr_session_run();
sr_session_stop();
}
else {
/* fall back on input modules */
load_input_file_format();
}
}
static void
cl_notif_priority_test(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
priority_t priority = {0};
int rc = SR_ERR_OK;
/* start session */
rc = sr_session_start(conn, SR_DS_RUNNING, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "test-module", priority_zero_cb, &priority,
0, SR_SUBSCR_DEFAULT, &subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "test-module", priority_two_cb, &priority,
2, SR_SUBSCR_DEFAULT | SR_SUBSCR_CTX_REUSE, &subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "test-module", priority_one_cb, &priority,
1, SR_SUBSCR_DEFAULT | SR_SUBSCR_CTX_REUSE, &subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_set_item(session, "/test-module:user[name='userA']", NULL, SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
/* timeout 10 sec */
for (size_t i = 0; i < 1000; i++) {
if (priority.count >= 3) break;
usleep(10000); /* 10 ms */
}
assert_int_equal(priority.count, 3);
assert_int_equal(2, priority.cb [0]);
assert_int_equal(1, priority.cb [1]);
assert_int_equal(0, priority.cb [2]);
/* check that cb were called in correct order according to the priority */
sr_unsubscribe(session, subscription);
sr_session_stop(session);
}
int main(int argc, char **argv) {
int rc = SR_ERR_OK;
sr_conn_ctx_t *conn = NULL;
sr_session_ctx_t *sess = NULL;
sr_val_t val = {0};
sr_log_stderr(SR_LL_DBG);
rc = sr_connect("push kea config", SR_CONN_DEFAULT, &conn);
CHECK_RC(rc, cleanup);
rc = sr_session_start(conn, SR_DS_STARTUP, SR_SESS_DEFAULT, &sess);
CHECK_RC(rc, cleanup);
/* socket type */
val.xpath = "/ietf-kea-dhcpv6:server/serv-attributes/control-socket/socket-type";
val.type = SR_STRING_T;
val.data.string_val = "unix";
rc = sr_set_item(sess, val.xpath, &val, SR_EDIT_DEFAULT);
CHECK_RC(rc, cleanup);
/* socket name */
val.xpath = "/ietf-kea-dhcpv6:server/serv-attributes/control-socket/socket-name";
val.type = SR_STRING_T;
val.data.string_val = "/tmp/kea-dhcp6-ctrl.sock";
rc = sr_set_item(sess, val.xpath, &val, SR_EDIT_DEFAULT);
CHECK_RC(rc, cleanup);
rc = sr_commit(sess);
/* retrieve field */
sr_val_t* val2 = 0;
rc = sr_get_item(sess, val.xpath, &val2);
printf("Retrieved: [%s]\n", val.data.string_val);
sr_free_val(val2);
CHECK_RC(rc, cleanup);
cleanup:
sr_session_stop(sess);
sr_disconnect(conn);
}
int
main(int argc, char **argv)
{
sr_conn_ctx_t *conn = NULL;
sr_session_ctx_t *sess = NULL;
sr_val_t *value = NULL;
sr_val_iter_t *iter = NULL;
int rc = SR_ERR_OK;
/* connect to sysrepo */
rc = sr_connect("app3", SR_CONN_DEFAULT, &conn);
if (SR_ERR_OK != rc) {
goto cleanup;
}
/* start session */
rc = sr_session_start(conn, SR_DS_STARTUP, SR_SESS_DEFAULT, &sess);
if (SR_ERR_OK != rc) {
goto cleanup;
}
/* get all list instances with their content (recursive) */
rc = sr_get_items_iter(sess, "/ietf-interfaces:interfaces/interface//*", &iter);
if (SR_ERR_OK != rc) {
goto cleanup;
}
while (SR_ERR_OK == sr_get_item_next(sess, iter, &value)){
print_value(value);
sr_free_val(value);
}
sr_free_val_iter(iter);
cleanup:
if (NULL != sess) {
sr_session_stop(sess);
}
if (NULL != conn) {
sr_disconnect(conn);
}
return rc;
}
int
main(int argc, char **argv)
{
sr_conn_ctx_t *connection = NULL;
sr_session_ctx_t *session = NULL;
int rc = SR_ERR_OK;
/* connect to sysrepo */
rc = sr_connect("example_application", SR_CONN_DEFAULT, &connection);
if (SR_ERR_OK != rc) {
fprintf(stderr, "Error by sr_connect: %s\n", sr_strerror(rc));
goto cleanup;
}
/* start session */
rc = sr_session_start(connection, SR_DS_RUNNING, SR_SESS_DEFAULT, &session);
if (SR_ERR_OK != rc) {
fprintf(stderr, "Error by sr_session_start: %s\n", sr_strerror(rc));
goto cleanup;
}
if (1 == argc) {
/* run as a RPC handler */
printf("This application will be an RPC handler for 'run-until' operation of 'turing-machine'.\n");
printf("Run the same executable (or rpc_example) with one (any) argument to execute the RPC.\n");
rc = rpc_handler(session);
} else {
/* run as a RPC caller */
printf("Executing RPC 'run-until' of 'turing-machine':\n");
rc = rpc_caller(session);
}
cleanup:
if (NULL != session) {
sr_session_stop(session);
}
if (NULL != connection) {
sr_disconnect(connection);
}
return rc;
}
/**
* @brief Main routine of the sysrepo configuration tool.
*/
int
main(int argc, char* argv[])
{
int c = 0;
srcfg_operation_t operation = SRCFG_OP_EDIT;
char *module_name = NULL, *datastore_name = "running";
char *format_name = "xml", *editor = NULL;
char *filepath = NULL;
srcfg_datastore_t datastore = SRCFG_STORE_RUNNING;
LYD_FORMAT format = LYD_XML;
bool enabled = false, keep = false, permanent = false;
int log_level = -1;
char local_schema_search_dir[PATH_MAX] = { 0, };
int rc = SR_ERR_OK;
struct option longopts[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'v' },
{ "datastore", required_argument, NULL, 'd' },
{ "format", required_argument, NULL, 'f' },
{ "editor", required_argument, NULL, 'e' },
{ "import", optional_argument, NULL, 'i' },
{ "export", optional_argument, NULL, 'x' },
{ "keep", no_argument, NULL, 'k' },
{ "permanent", no_argument, NULL, 'p' },
{ "level", required_argument, NULL, 'l' },
{ 0, 0, 0, 0 }
};
/* read mandatory <module_name> argument */
if (1 < argc && '-' != argv[argc-1][0]) {
module_name = argv[argc-1];
--argc;
}
/* parse options */
while ((c = getopt_long(argc, argv, ":hvd:f:e:i:x:kpl:0:", longopts, NULL)) != -1) {
switch (c) {
case 'h':
srcfg_print_help();
goto terminate;
break;
case 'v':
srcfg_print_version();
goto terminate;
break;
case 'd':
if (NULL != optarg) {
datastore_name = optarg;
}
break;
case 'f':
if (NULL != optarg) {
format_name = optarg;
}
break;
case 'e':
editor = optarg;
break;
case 'i':
operation = SRCFG_OP_IMPORT;
if (NULL != optarg && 0 != strcmp("-", optarg)) {
filepath = optarg;
}
break;
case 'x':
operation = SRCFG_OP_EXPORT;
if (NULL != optarg && 0 != strcmp("-", optarg)) {
filepath = optarg;
}
break;
case 'k':
keep = true;
break;
case 'p':
permanent = true;
break;
case 'l':
log_level = atoi(optarg);
break;
case '0':
/* 'hidden' option - custom repository location */
if (NULL != optarg) {
strncpy(local_schema_search_dir, optarg, PATH_MAX - 6);
strcat(local_schema_search_dir, "/yang/");
srcfg_schema_search_dir = local_schema_search_dir;
srcfg_custom_repository = true;
}
break;
case ':':
/* missing option argument */
switch (optopt) {
case 'i':
operation = SRCFG_OP_IMPORT;
break;
case 'x':
operation = SRCFG_OP_EXPORT;
break;
default:
fprintf(stderr, "%s: option `-%c' requires an argument\n", argv[0], optopt);
rc = SR_ERR_INVAL_ARG;
goto terminate;
}
break;
case '?':
default:
/* invalid option */
fprintf(stderr, "%s: option `-%c' is invalid. Exiting.\n", argv[0], optopt);
rc = SR_ERR_INVAL_ARG;
goto terminate;
}
}
/* check argument values */
/* -> module */
if (NULL == module_name) {
fprintf(stderr, "%s: Module name is not specified.\n", argv[0]);
rc = SR_ERR_INVAL_ARG;
goto terminate;
}
/* -> format */
if (strcasecmp("xml", format_name) == 0) {
format = LYD_XML;
} else if (strcasecmp("json", format_name) == 0) {
format = LYD_JSON;
} else {
fprintf(stderr, "%s: Unsupported data format (xml and json are supported).\n", argv[0]);
rc = SR_ERR_INVAL_ARG;
goto terminate;
}
/* -> datastore */
if (strcasecmp("startup", datastore_name) == 0) {
datastore = SRCFG_STORE_STARTUP;
} else if (strcasecmp("running", datastore_name) == 0) {
datastore = SRCFG_STORE_RUNNING;
} else {
fprintf(stderr, "%s: Invalid datastore specified (select either \"running\" or \"startup\").\n", argv[0]);
rc = SR_ERR_INVAL_ARG;
goto terminate;
}
/* -> find default editor if none specified */
if (NULL == editor && SRCFG_OP_EDIT == operation) {
editor = getenv("VISUAL");
if (NULL == editor) {
editor = getenv("EDITOR");
}
if (NULL == editor) {
fprintf(stderr, "%s: Preferred text editor is not specified (select using the -e/--editor option).\n", argv[0]);
rc = SR_ERR_INVAL_ARG;
goto terminate;
}
}
/* set log levels */
sr_log_stderr(SR_LL_ERR);
sr_log_syslog(SR_LL_NONE);
if ((log_level >= SR_LL_NONE) && (log_level <= SR_LL_DBG)) {
sr_log_stderr(log_level);
}
/* connect to sysrepo */
rc = sr_connect("sysrepocfg", SR_CONN_DEFAULT, &srcfg_connection);
if (SR_ERR_OK == rc) {
rc = sr_session_start(srcfg_connection, datastore == SRCFG_STORE_RUNNING ? SR_DS_RUNNING : SR_DS_STARTUP,
SR_SESS_DEFAULT, &srcfg_session);
}
if (SRCFG_STORE_RUNNING == datastore) {
rc = sr_check_enabled_running(srcfg_session, module_name, &enabled);
if (SR_ERR_OK == rc && !enabled) {
printf("Cannot operate on the running datastore as there are no active subscriptions.\n"
"Cancelling the operation.\n");
rc = SR_ERR_INTERNAL;
goto terminate;
}
}
if (SR_ERR_OK != rc) {
srcfg_report_error(rc);
printf("Unable to connect to sysrepo. Cancelling the operation.\n");
goto terminate;
}
/* call selected operation */
switch (operation) {
case SRCFG_OP_EDIT:
rc = srcfg_edit_operation(module_name, datastore, format, editor, keep, permanent);
break;
case SRCFG_OP_IMPORT:
rc = srcfg_import_operation(module_name, datastore, filepath, format, permanent);
break;
case SRCFG_OP_EXPORT:
rc = srcfg_export_operation(module_name, filepath, format);
break;
}
terminate:
if (NULL != srcfg_session) {
sr_session_stop(srcfg_session);
}
if (NULL != srcfg_connection) {
sr_disconnect(srcfg_connection);
}
return (SR_ERR_OK == rc) ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main(int argc, char **argv){
sigset_t mask, oldmask;
/* Set up the mask of signals to temporarily block. */
sigemptyset (&mask);
sigaddset (&mask, SIGUSR1);
sigprocmask (SIG_BLOCK, &mask, &oldmask);
printf("Pid: %d\n", getpid());
signal(SIGUSR1, sig_handler);
sr_conn_ctx_t *connection = NULL;
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
int rc = SR_ERR_OK;
sr_log_stderr(SR_LL_DBG);
/* connect to sysrepo */
rc = sr_connect("example_application", SR_CONN_DEFAULT, &connection);
if (SR_ERR_OK != rc) {
goto cleanup;
}
/* start session */
rc = sr_session_start(connection, SR_DS_STARTUP, SR_SESS_DEFAULT, &session);
if (SR_ERR_OK != rc) {
goto cleanup;
}
/* read startup config */
printf("\n\n ========== READING STARTUP CONFIG: ==========\n\n");
/* subscribe for changes in running config */
rc = sr_module_change_subscribe(session, "ietf-interfaces", module_change_cb, NULL,
0, SR_SUBSCR_DEFAULT, &subscription);
if (SR_ERR_OK != rc) {
goto cleanup;
}
printf("\n\n ========== STARTUP CONFIG APPLIED AS RUNNING ==========\n\n");
/* Wait for a signal to arrive. */
while (!usr_interrupt) {
sigsuspend (&oldmask);
}
sigprocmask (SIG_UNBLOCK, &mask, NULL);
printf("Signal received\n");
cleanup:
if (NULL != subscription) {
sr_unsubscribe(session, subscription);
}
if (NULL != session) {
sr_session_stop(session);
}
if (NULL != connection) {
sr_disconnect(connection);
}
return rc;
}
/**
* Halt the current session.
*
* This function is deprecated and should not be used in new code, use
* sr_session_stop() instead. The behaviour of this function is identical to
* sr_session_stop().
*
* @return SR_OK upon success, SR_ERR_BUG if no session exists.
*/
SR_API int sr_session_halt(void)
{
return sr_session_stop();
}
void MainWindow::on_action_Get_samples_triggered()
{
uint64_t samplerate;
QString s;
GSList *devs = NULL;
int opt_dev;
struct sr_dev *dev;
QComboBox *n = ui->comboBoxNumSamples;
opt_dev = 0; /* FIXME */
/*
* The number of samples to get is a drop-down list, but you can also
* manually enter a value. If the latter, we have to get the value from
* the lineEdit object, otherwise via itemData() and the list index.
*/
if (n->lineEdit() != NULL) {
limit_samples = n->lineEdit()->text().toLongLong();
} else {
limit_samples = n->itemData(n->currentIndex()).toLongLong();
}
samplerate = ui->comboBoxSampleRate->itemData(
ui->comboBoxSampleRate->currentIndex()).toLongLong();
/* TODO: Sanity checks. */
/* TODO: Assumes unitsize == 1. */
if (!(sample_buffer = (uint8_t *)malloc(limit_samples))) {
/* TODO: Error handling. */
return;
}
sr_session_new();
sr_session_datafeed_callback_add(datafeed_in);
devs = sr_dev_list();
dev = (struct sr_dev *)g_slist_nth_data(devs, opt_dev);
/* Set the number of samples we want to get from the device. */
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK) {
qDebug("Failed to set sample limit.");
sr_session_destroy();
return;
}
if (sr_session_dev_add(dev) != SR_OK) {
qDebug("Failed to use device.");
sr_session_destroy();
return;
}
/* Set the samplerate. */
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_SAMPLERATE, &samplerate) != SR_OK) {
qDebug("Failed to set samplerate.");
sr_session_destroy();
return;
};
if (dev->driver->dev_config_set(dev->driver_index,
SR_HWCAP_PROBECONFIG, (char *)dev->probes) != SR_OK) {
qDebug("Failed to configure probes.");
sr_session_destroy();
return;
}
if (sr_session_start() != SR_OK) {
qDebug("Failed to start session.");
sr_session_destroy();
return;
}
progress = new QProgressDialog("Getting samples from logic analyzer...",
"Abort", 0, limit_samples, this);
progress->setWindowModality(Qt::WindowModal);
progress->setMinimumDuration(100);
sr_session_run();
sr_session_stop();
sr_session_destroy();
for (int i = 0; i < getNumChannels(); ++i) {
channelForms[i]->setNumSamples(limit_samples);
// channelForms[i]->setSampleStart(0);
// channelForms[i]->setSampleEnd(limit_samples);
/* If any of the scale factors change, update all of them.. */
connect(channelForms[i], SIGNAL(scaleFactorChanged(float)),
w, SLOT(updateScaleFactors(float)));
channelForms[i]->generatePainterPath();
// channelForms[i]->update();
}
setNumSamples(limit_samples);
/* Enable the relevant labels/buttons. */
ui->labelSampleStart->setEnabled(true);
ui->labelSampleEnd->setEnabled(true);
ui->labelScaleFactor->setEnabled(true);
ui->action_Save_as->setEnabled(true);
// sr_hw_get_samples_shutdown(&ctx, 1000);
}
static void
cl_get_changes_create_test(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
changes_t changes = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cv = PTHREAD_COND_INITIALIZER, 0};
struct timespec ts;
sr_val_t *val = NULL;
const char *xpath = NULL;
int rc = SR_ERR_OK;
xpath = "/example-module:container/list[key1='abc'][key2='def']";
/* start session */
rc = sr_session_start(conn, SR_DS_CANDIDATE, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "example-module", list_changes_cb, &changes,
0, SR_SUBSCR_DEFAULT, &subscription);
assert_int_equal(rc, SR_ERR_OK);
/* check the list presence in candidate */
rc = sr_get_item(session, xpath, &val);
assert_int_equal(rc, SR_ERR_NOT_FOUND);
/* create the list instance */
rc = sr_set_item(session, xpath, NULL, SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
/* save changes to running */
pthread_mutex_lock(&changes.mutex);
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
sr_clock_get_time(CLOCK_REALTIME, &ts);
ts.tv_sec += COND_WAIT_SEC;
pthread_cond_timedwait(&changes.cv, &changes.mutex, &ts);
assert_int_equal(changes.cnt, 3);
assert_int_equal(changes.oper[0], SR_OP_CREATED);
assert_non_null(changes.new_values[0]);
assert_null(changes.old_values[0]);
assert_string_equal(xpath, changes.new_values[0]->xpath);
assert_int_equal(changes.oper[1], SR_OP_CREATED);
assert_non_null(changes.new_values[1]);
assert_null(changes.old_values[1]);
assert_string_equal("/example-module:container/list[key1='abc'][key2='def']/key1", changes.new_values[1]->xpath);
assert_int_equal(changes.oper[2], SR_OP_CREATED);
assert_non_null(changes.new_values[2]);
assert_null(changes.old_values[2]);
assert_string_equal("/example-module:container/list[key1='abc'][key2='def']/key2", changes.new_values[2]->xpath);
for (size_t i = 0; i < changes.cnt; i++) {
sr_free_val(changes.new_values[i]);
sr_free_val(changes.old_values[i]);
}
pthread_mutex_unlock(&changes.mutex);
rc = sr_unsubscribe(NULL, subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_session_stop(session);
assert_int_equal(rc, SR_ERR_OK);
}
static void
cl_get_changes_modified_test(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
changes_t changes = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cv = PTHREAD_COND_INITIALIZER, 0};
struct timespec ts;
sr_val_t *val = NULL;
const char *xpath = NULL;
int rc = SR_ERR_OK;
xpath = "/example-module:container/list[key1='key1'][key2='key2']/leaf";
/* start session */
rc = sr_session_start(conn, SR_DS_CANDIDATE, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "example-module", list_changes_cb, &changes,
0, SR_SUBSCR_DEFAULT, &subscription);
assert_int_equal(rc, SR_ERR_OK);
/* check the list presence in candidate */
rc = sr_get_item(session, xpath, &val);
assert_int_equal(rc, SR_ERR_OK);
sr_val_t new_val = {0};
new_val.type = SR_STRING_T;
new_val.data.string_val = "abcdef";
/* create the list instance */
rc = sr_set_item(session, xpath, &new_val, SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
/* save changes to running */
pthread_mutex_lock(&changes.mutex);
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
sr_clock_get_time(CLOCK_REALTIME, &ts);
ts.tv_sec += COND_WAIT_SEC;
pthread_cond_timedwait(&changes.cv, &changes.mutex, &ts);
assert_int_equal(changes.cnt, 1);
assert_int_equal(changes.oper[0], SR_OP_MODIFIED);
assert_non_null(changes.new_values[0]);
assert_non_null(changes.old_values[0]);
assert_string_equal(val->data.string_val, changes.old_values[0]->data.string_val);
assert_string_equal(new_val.data.string_val, changes.new_values[0]->data.string_val);
for (size_t i = 0; i < changes.cnt; i++) {
sr_free_val(changes.new_values[i]);
sr_free_val(changes.old_values[i]);
}
sr_free_val(val);
pthread_mutex_unlock(&changes.mutex);
rc = sr_unsubscribe(NULL, subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_session_stop(session);
assert_int_equal(rc, SR_ERR_OK);
}
static void
cl_get_changes_deleted_test(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
changes_t changes = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cv = PTHREAD_COND_INITIALIZER, 0};
struct timespec ts;
sr_val_t *val = NULL;
const char *xpath = NULL;
int rc = SR_ERR_OK;
xpath = "/example-module:container";
/* start session */
rc = sr_session_start(conn, SR_DS_CANDIDATE, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "example-module", list_changes_cb, &changes,
0, SR_SUBSCR_DEFAULT, &subscription);
assert_int_equal(rc, SR_ERR_OK);
/* check the list presence in candidate */
rc = sr_get_item(session, xpath, &val);
assert_int_equal(rc, SR_ERR_OK);
sr_free_val(val);
/* delete container */
rc = sr_delete_item(session, xpath, SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
/* save changes to running */
pthread_mutex_lock(&changes.mutex);
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
sr_clock_get_time(CLOCK_REALTIME, &ts);
ts.tv_sec += COND_WAIT_SEC;
pthread_cond_timedwait(&changes.cv, &changes.mutex, &ts);
assert_int_equal(changes.cnt, 5);
assert_int_equal(changes.oper[0], SR_OP_DELETED);
assert_null(changes.new_values[0]);
assert_non_null(changes.old_values[0]);
assert_string_equal(xpath, changes.old_values[0]->xpath);
assert_int_equal(changes.oper[1], SR_OP_DELETED);
assert_null(changes.new_values[1]);
assert_non_null(changes.old_values[1]);
assert_string_equal("/example-module:container/list[key1='key1'][key2='key2']", changes.old_values[1]->xpath);
assert_int_equal(changes.oper[2], SR_OP_DELETED);
assert_null(changes.new_values[2]);
assert_non_null(changes.old_values[2]);
assert_string_equal("/example-module:container/list[key1='key1'][key2='key2']/key1", changes.old_values[2]->xpath);
assert_int_equal(changes.oper[3], SR_OP_DELETED);
assert_null(changes.new_values[3]);
assert_non_null(changes.old_values[3]);
assert_string_equal("/example-module:container/list[key1='key1'][key2='key2']/key2", changes.old_values[3]->xpath);
assert_int_equal(changes.oper[4], SR_OP_DELETED);
assert_null(changes.new_values[4]);
assert_non_null(changes.old_values[4]);
assert_string_equal("/example-module:container/list[key1='key1'][key2='key2']/leaf", changes.old_values[4]->xpath);
for (size_t i = 0; i < changes.cnt; i++) {
sr_free_val(changes.new_values[i]);
sr_free_val(changes.old_values[i]);
}
pthread_mutex_unlock(&changes.mutex);
rc = sr_unsubscribe(NULL, subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_session_stop(session);
assert_int_equal(rc, SR_ERR_OK);
}
static void
cl_get_changes_moved_test(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
changes_t changes = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cv = PTHREAD_COND_INITIALIZER, 0};
struct timespec ts;
const char *xpath = NULL;
int rc = SR_ERR_OK;
xpath = "/test-module:ordered-numbers";
/* start session */
rc = sr_session_start(conn, SR_DS_STARTUP, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
sr_val_t v = {0};
v.type = SR_UINT8_T;
v.data.uint8_val = 1;
/* create user ordered leaf-list instance */
rc = sr_set_item(session, xpath, &v, SR_EDIT_STRICT);
assert_int_equal(rc, SR_ERR_OK);
v.data.uint8_val = 2;
rc = sr_set_item(session, xpath, &v, SR_EDIT_STRICT);
assert_int_equal(rc, SR_ERR_OK);
v.data.uint8_val = 3;
rc = sr_set_item(session, xpath, &v, SR_EDIT_STRICT);
assert_int_equal(rc, SR_ERR_OK);
/* save changes to running */
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_session_switch_ds(session, SR_DS_CANDIDATE);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "test-module", list_changes_cb, &changes,
0, SR_SUBSCR_DEFAULT, &subscription);
assert_int_equal(rc, SR_ERR_OK);
/* move leaf-list */
rc = sr_move_item(session, "/test-module:ordered-numbers[.='3']", SR_MOVE_AFTER, "/test-module:ordered-numbers[.='1']");
assert_int_equal(rc, SR_ERR_OK);
/* save changes to running */
pthread_mutex_lock(&changes.mutex);
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
sr_clock_get_time(CLOCK_REALTIME, &ts);
ts.tv_sec += COND_WAIT_SEC;
pthread_cond_timedwait(&changes.cv, &changes.mutex, &ts);
assert_int_equal(changes.cnt, 1);
assert_int_equal(changes.oper[0], SR_OP_MOVED);
assert_non_null(changes.new_values[0]);
assert_non_null(changes.old_values[0]);
assert_string_equal(xpath, changes.old_values[0]->xpath);
assert_int_equal(changes.new_values[0]->data.uint8_val, 2);
assert_int_equal(changes.old_values[0]->data.uint8_val, 3);
for (size_t i = 0; i < changes.cnt; i++) {
sr_free_val(changes.new_values[i]);
sr_free_val(changes.old_values[i]);
}
pthread_mutex_unlock(&changes.mutex);
rc = sr_unsubscribe(NULL, subscription);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_session_stop(session);
assert_int_equal(rc, SR_ERR_OK);
}
typedef struct priority_s {
int count;
int cb[3];
}priority_t;
static int
priority_zero_cb(sr_session_ctx_t *session, const char *module_name, sr_notif_event_t ev, void *private_ctx)
{
priority_t *pr = (priority_t *) private_ctx;
pr->cb[pr->count] = 0;
pr->count++;
return SR_ERR_OK;
}
void datafeed_in(const struct sr_dev_inst *sdi,
const struct sr_datafeed_packet *packet, void *cb_data)
{
const struct sr_datafeed_meta *meta;
const struct sr_datafeed_logic *logic;
const struct sr_datafeed_analog *analog;
struct sr_config *src;
struct sr_channel *ch;
static struct sr_output *o = NULL;
static uint64_t rcvd_samples_logic = 0;
static uint64_t rcvd_samples_analog = 0;
static uint64_t samplerate = 0;
static int triggered = 0;
static FILE *outfile = NULL;
GSList *l;
GString *out;
GVariant *gvar;
uint64_t end_sample;
uint64_t input_len;
int i;
char **channels;
(void) cb_data;
/* If the first packet to come in isn't a header, don't even try. */
if (packet->type != SR_DF_HEADER && o == NULL)
return;
switch (packet->type) {
case SR_DF_HEADER:
g_debug("cli: Received SR_DF_HEADER.");
o = setup_output_format(sdi);
/* Prepare non-stdout output. */
outfile = stdout;
if (opt_output_file) {
if (default_output_format) {
outfile = NULL;
} else {
/* saving to a file in whatever format was set
* with --format, so all we need is a filehandle */
outfile = g_fopen(opt_output_file, "wb");
}
}
rcvd_samples_logic = rcvd_samples_analog = 0;
if (sr_config_get(sdi->driver, sdi, NULL, SR_CONF_SAMPLERATE,
&gvar) == SR_OK) {
samplerate = g_variant_get_uint64(gvar);
g_variant_unref(gvar);
}
#ifdef HAVE_SRD
if (opt_pds) {
if (samplerate) {
if (srd_session_metadata_set(srd_sess, SRD_CONF_SAMPLERATE,
g_variant_new_uint64(samplerate)) != SRD_OK) {
g_critical("Failed to configure decode session.");
break;
}
}
if (srd_session_start(srd_sess) != SRD_OK) {
g_critical("Failed to start decode session.");
break;
}
}
#endif
break;
case SR_DF_META:
g_debug("cli: Received SR_DF_META.");
meta = packet->payload;
for (l = meta->config; l; l = l->next) {
src = l->data;
switch (src->key) {
case SR_CONF_SAMPLERATE:
samplerate = g_variant_get_uint64(src->data);
g_debug("cli: Got samplerate %"PRIu64" Hz.", samplerate);
#ifdef HAVE_SRD
if (opt_pds) {
if (srd_session_metadata_set(srd_sess, SRD_CONF_SAMPLERATE,
g_variant_new_uint64(samplerate)) != SRD_OK) {
g_critical("Failed to pass samplerate to decoder.");
}
}
#endif
break;
case SR_CONF_SAMPLE_INTERVAL:
samplerate = g_variant_get_uint64(src->data);
g_debug("cli: Got sample interval %"PRIu64" ms.", samplerate);
break;
default:
/* Unknown metadata is not an error. */
break;
}
}
break;
case SR_DF_TRIGGER:
g_debug("cli: Received SR_DF_TRIGGER.");
triggered = 1;
break;
case SR_DF_LOGIC:
logic = packet->payload;
g_message("cli: Received SR_DF_LOGIC (%"PRIu64" bytes, unitsize = %d).",
logic->length, logic->unitsize);
if (logic->length == 0)
break;
/* Don't store any samples until triggered. */
if (opt_wait_trigger && !triggered)
break;
if (limit_samples && rcvd_samples_logic >= limit_samples)
break;
end_sample = rcvd_samples_logic + logic->length / logic->unitsize;
/* Cut off last packet according to the sample limit. */
if (limit_samples && end_sample > limit_samples)
end_sample = limit_samples;
input_len = (end_sample - rcvd_samples_logic) * logic->unitsize;
if (opt_output_file && default_output_format) {
/* Saving to a session file. */
if (rcvd_samples_logic == 0) {
/* First packet with logic data, init session file. */
channels = g_malloc(sizeof(char *) * g_slist_length(sdi->channels));
for (i = 0, l = sdi->channels; l; l = l->next) {
ch = l->data;
if (ch->enabled && ch->type == SR_CHANNEL_LOGIC)
channels[i++] = ch->name;
}
channels[i] = NULL;
sr_session_save_init(opt_output_file, samplerate,
channels);
g_free(channels);
}
save_chunk_logic(logic->data, input_len, logic->unitsize);
} else {
if (opt_pds) {
#ifdef HAVE_SRD
if (srd_session_send(srd_sess, rcvd_samples_logic, end_sample,
logic->data, input_len) != SRD_OK)
sr_session_stop();
#endif
}
}
rcvd_samples_logic = end_sample;
break;
case SR_DF_ANALOG:
analog = packet->payload;
g_message("cli: Received SR_DF_ANALOG (%d samples).", analog->num_samples);
if (analog->num_samples == 0)
break;
if (limit_samples && rcvd_samples_analog >= limit_samples)
break;
rcvd_samples_analog += analog->num_samples;
break;
case SR_DF_FRAME_BEGIN:
g_debug("cli: Received SR_DF_FRAME_BEGIN.");
break;
case SR_DF_FRAME_END:
g_debug("cli: Received SR_DF_FRAME_END.");
break;
default:
break;
}
if (o && outfile && !opt_pds) {
if (sr_output_send(o, packet, &out) == SR_OK && out) {
fwrite(out->str, 1, out->len, outfile);
fflush(outfile);
g_string_free(out, TRUE);
}
}
/* SR_DF_END needs to be handled after the output module's receive()
* is called, so it can properly clean up that module. */
if (packet->type == SR_DF_END) {
g_debug("cli: Received SR_DF_END.");
if (o)
sr_output_free(o);
o = NULL;
if (outfile && outfile != stdout)
fclose(outfile);
if (opt_output_file && default_output_format)
/* Flush whatever is left out to the session file. */
save_chunk_logic(NULL, 0, 0);
if (limit_samples) {
if (rcvd_samples_logic > 0 && rcvd_samples_logic < limit_samples)
g_warning("Device only sent %" PRIu64 " samples.",
rcvd_samples_logic);
else if (rcvd_samples_analog > 0 && rcvd_samples_analog < limit_samples)
g_warning("Device only sent %" PRIu64 " samples.",
rcvd_samples_analog);
}
}
}
static void
cl_fd_poll_test(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
sr_fd_change_t *fd_change_set = NULL;
size_t fd_change_set_cnt = 0;
int init_fd = 0;
int ret = 0, rc = SR_ERR_OK;
bool callback_called = false;
/* init app-local watcher */
rc = sr_fd_watcher_init(&init_fd);
assert_int_equal(rc, SR_ERR_OK);
poll_fd_set[0].fd = init_fd;
poll_fd_set[0].events = POLLIN;
poll_fd_cnt = 1;
/* start session */
rc = sr_session_start(conn, SR_DS_CANDIDATE, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
/* subscribe for changes */
rc = sr_module_change_subscribe(session, "example-module", module_change_cb, &callback_called, 0,
SR_SUBSCR_DEFAULT | SR_SUBSCR_APPLY_ONLY, &subscription);
assert_int_equal(rc, SR_ERR_OK);
/* create the list instance */
rc = sr_set_item(session, "/example-module:container/list[key1='123'][key2='456']", NULL, SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
/* commit changes */
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
do {
ret = poll(poll_fd_set, poll_fd_cnt, -1);
assert_int_not_equal(ret, -1);
for (size_t i = 0; i < poll_fd_cnt; i++) {
assert_false((poll_fd_set[i].revents & POLLERR) || (poll_fd_set[i].revents & POLLHUP) || (poll_fd_set[i].revents & POLLNVAL));
if (poll_fd_set[i].revents & POLLIN) {
rc = sr_fd_event_process(poll_fd_set[i].fd, SR_FD_INPUT_READY, &fd_change_set, &fd_change_set_cnt);
assert_int_equal(rc, SR_ERR_OK);
cl_fd_change_set_process(fd_change_set, fd_change_set_cnt);
free(fd_change_set);
fd_change_set = NULL;
fd_change_set_cnt = 0;
}
if (poll_fd_set[i].revents & POLLOUT) {
rc = sr_fd_event_process(poll_fd_set[i].fd, SR_FD_OUTPUT_READY, &fd_change_set, &fd_change_set_cnt);
assert_int_equal(rc, SR_ERR_OK);
cl_fd_change_set_process(fd_change_set, fd_change_set_cnt);
free(fd_change_set);
fd_change_set = NULL;
fd_change_set_cnt = 0;
}
}
} while ((SR_ERR_OK == rc) && !callback_called);
/* unsubscribe after callback has been called */
rc = sr_unsubscribe(session, subscription);
assert_int_equal(rc, SR_ERR_OK);
callback_called = false;
/* stop the session */
rc = sr_session_stop(session);
assert_int_equal(rc, SR_ERR_OK);
/* cleanup app-local watcher */
sr_fd_watcher_cleanup();
}
void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
{
static int num_probes = 0;
static int logic_probelist[SR_MAX_NUM_PROBES + 1] = { 0 };
static uint64_t received_samples = 0;
static int triggered = 0;
static int unitsize = 0;
struct sr_probe *probe;
static struct sr_datafeed_header *header;
struct sr_datafeed_meta_logic *meta_logic;
struct sr_datafeed_logic *logic;
int num_enabled_probes, sample_size, ret;
uint64_t sample;
uint64_t filter_out_len;
uint8_t *filter_out;
/* If the first packet to come in isn't a header, don't even try. */
// if (packet->type != SR_DF_HEADER && o == NULL)
// return;
/* TODO: Also check elsewhere? */
/* TODO: Abort acquisition too, if user pressed cancel. */
if (progress && progress->wasCanceled())
return;
sample_size = -1;
switch (packet->type) {
case SR_DF_HEADER:
qDebug("SR_DF_HEADER");
header = (struct sr_datafeed_header *)packet->payload;
case SR_DF_END:
qDebug("SR_DF_END");
/* TODO: o */
sr_session_stop();
// progress->setValue(received_samples); /* FIXME */
break;
case SR_DF_TRIGGER:
qDebug("SR_DF_TRIGGER");
/* TODO */
triggered = 1;
break;
case SR_DF_META_LOGIC:
qDebug("SR_DF_META_LOGIC");
meta_logic = (struct sr_datafeed_meta_logic *)packet->payload;
num_probes = meta_logic->num_probes;
num_enabled_probes = 0;
for (int i = 0; i < meta_logic->num_probes; ++i) {
probe = (struct sr_probe *)g_slist_nth_data(dev->probes, i);
if (probe->enabled)
logic_probelist[num_enabled_probes++] = probe->index;
}
qDebug() << "Acquisition with" << num_enabled_probes << "/"
<< num_probes << "probes at"
<< sr_samplerate_string(meta_logic->samplerate)
<< "starting at" << ctime(&header->starttime.tv_sec)
<< "(" << limit_samples << "samples)";
/* TODO: realloc() */
break;
case SR_DF_LOGIC:
logic = (sr_datafeed_logic *)packet->payload;
qDebug() << "SR_DF_LOGIC (length =" << logic->length
<< ", unitsize = " << logic->unitsize << ")";
sample_size = logic->unitsize;
if (sample_size == -1)
break;
/* Don't store any samples until triggered. */
// if (opt_wait_trigger && !triggered)
// return;
if (received_samples >= limit_samples)
break;
/* TODO */
ret = sr_filter_probes(sample_size, 1 /* unitsize */, logic_probelist,
(uint8_t *)logic->data, logic->length,
&filter_out, &filter_out_len);
if (ret != SR_OK)
break;
for (uint64_t i = 0; i < filter_out_len; ++i) {
sample = filter_out[i];
sample_buffer[i] = (uint8_t)(sample & 0xff); /* FIXME */
// qDebug("Sample %" PRIu64 ": 0x%x", i, sample);
}
received_samples += logic->length / sample_size;
progress->setValue(received_samples);
break;
default:
qDebug("SR_DF_XXXX, not yet handled");
break;
}
}
/**
* @brief Main routine of the sysrepo daemon.
*/
int
main(int argc, char* argv[])
{
sr_pd_ctx_t ctx = { 0, };
pid_t parent_pid = 0;
int pidfile_fd = -1;
int c = 0;
bool debug_mode = false;
int log_level = -1;
int rc = SR_ERR_OK;
while ((c = getopt (argc, argv, "hvdDl:")) != -1) {
switch (c) {
case 'v':
sr_pd_print_version();
return 0;
break;
case 'd':
debug_mode = true;
break;
case 'D':
connect_options |= SR_CONN_DAEMON_START;
break;
case 'l':
log_level = atoi(optarg);
break;
default:
sr_pd_print_help();
return 0;
}
}
/* init logger */
sr_logger_init("sysrepo-plugind");
/* daemonize the process */
parent_pid = sr_daemonize(debug_mode, log_level, SR_PLUGIN_DAEMON_PID_FILE, &pidfile_fd);
SR_LOG_DBG_MSG("Sysrepo plugin daemon initialization started.");
/* init the event loop */
ctx.event_loop = ev_loop_new(EVFLAG_AUTO);
/* init signal watchers */
ev_signal_init(&ctx.signal_watcher[0], sr_pd_signal_cb, SIGTERM);
ev_signal_start(ctx.event_loop, &ctx.signal_watcher[0]);
ev_signal_init(&ctx.signal_watcher[1], sr_pd_signal_cb, SIGINT);
ev_signal_start(ctx.event_loop, &ctx.signal_watcher[1]);
/* init timers */
ev_timer_init(&ctx.health_check_timer, sr_pd_health_check_timer_cb, SR_PLUGIN_HEALTH_CHECK_TIMEOUT,
SR_PLUGIN_HEALTH_CHECK_TIMEOUT);
ctx.health_check_timer.data = &ctx;
ev_timer_init(&ctx.init_retry_timer, sr_pd_init_retry_timer_cb, SR_PLUGIN_INIT_RETRY_TIMEOUT, SR_PLUGIN_INIT_RETRY_TIMEOUT);
ctx.init_retry_timer.data = &ctx;
/* connect to sysrepo */
rc = sr_connect("sysrepo-plugind", connect_options, &ctx.connection);
CHECK_RC_LOG_GOTO(rc, cleanup, "Unable to connect to sysrepod: %s", sr_strerror(rc));
/* start the session */
rc = sr_session_start(ctx.connection, SR_DS_STARTUP, SR_SESS_DEFAULT, &ctx.session);
CHECK_RC_LOG_GOTO(rc, cleanup, "Unable to connect to sysrepo: %s", sr_strerror(rc));
/* tell the parent process that we are okay */
if (!debug_mode) {
sr_daemonize_signal_success(parent_pid);
}
/* load the plugins */
rc = sr_pd_load_plugins(&ctx);
SR_LOG_INF_MSG("Sysrepo plugin daemon initialized successfully.");
/* start health check timer */
ev_timer_start(ctx.event_loop, &ctx.health_check_timer);
/* run the event loop */
ev_run(ctx.event_loop, 0);
ev_loop_destroy(ctx.event_loop);
/* check whether the session is still valid & reconnect if needed */
sr_pd_session_check(&ctx);
cleanup:
sr_pd_cleanup_plugins(&ctx);
if (NULL != ctx.session) {
sr_session_stop(ctx.session);
}
if (NULL != ctx.connection) {
sr_disconnect(ctx.connection);
}
SR_LOG_INF_MSG("Sysrepo plugin daemon terminated.");
sr_logger_cleanup();
unlink(SR_PLUGIN_DAEMON_PID_FILE);
if (-1 != pidfile_fd) {
close(pidfile_fd);
}
exit((SR_ERR_OK == rc) ? EXIT_SUCCESS : EXIT_FAILURE);
}
static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
{
static struct sr_output *o = NULL;
static int logic_probelist[SR_MAX_NUM_PROBES] = { 0 };
static struct sr_probe *analog_probelist[SR_MAX_NUM_PROBES];
static uint64_t received_samples = 0;
static int unitsize = 0;
static int triggered = 0;
static FILE *outfile = NULL;
static int num_analog_probes = 0;
struct sr_probe *probe;
struct sr_datafeed_logic *logic;
struct sr_datafeed_meta_logic *meta_logic;
struct sr_datafeed_analog *analog;
struct sr_datafeed_meta_analog *meta_analog;
static int num_enabled_analog_probes = 0;
int num_enabled_probes, sample_size, ret, i;
uint64_t output_len, filter_out_len;
uint8_t *output_buf, *filter_out;
/* If the first packet to come in isn't a header, don't even try. */
if (packet->type != SR_DF_HEADER && o == NULL)
return;
sample_size = -1;
switch (packet->type) {
case SR_DF_HEADER:
g_debug("cli: Received SR_DF_HEADER");
/* Initialize the output module. */
if (!(o = g_try_malloc(sizeof(struct sr_output)))) {
g_critical("Output module malloc failed.");
exit(1);
}
o->format = output_format;
o->dev = dev;
o->param = output_format_param;
if (o->format->init) {
if (o->format->init(o) != SR_OK) {
g_critical("Output format initialization failed.");
exit(1);
}
}
break;
case SR_DF_END:
g_debug("cli: Received SR_DF_END");
if (!o) {
g_debug("cli: double end!");
break;
}
if (o->format->event) {
o->format->event(o, SR_DF_END, &output_buf, &output_len);
if (output_buf) {
if (outfile)
fwrite(output_buf, 1, output_len, outfile);
g_free(output_buf);
output_len = 0;
}
}
if (limit_samples && received_samples < limit_samples)
g_warning("Device only sent %" PRIu64 " samples.",
received_samples);
if (opt_continuous)
g_warning("Device stopped after %" PRIu64 " samples.",
received_samples);
sr_session_stop();
if (outfile && outfile != stdout)
fclose(outfile);
g_free(o);
o = NULL;
break;
case SR_DF_TRIGGER:
g_debug("cli: received SR_DF_TRIGGER");
if (o->format->event)
o->format->event(o, SR_DF_TRIGGER, &output_buf,
&output_len);
triggered = 1;
break;
case SR_DF_META_LOGIC:
g_message("cli: Received SR_DF_META_LOGIC");
meta_logic = packet->payload;
num_enabled_probes = 0;
for (i = 0; i < meta_logic->num_probes; i++) {
probe = g_slist_nth_data(dev->probes, i);
if (probe->enabled)
logic_probelist[num_enabled_probes++] = probe->index;
}
/* How many bytes we need to store num_enabled_probes bits */
unitsize = (num_enabled_probes + 7) / 8;
outfile = stdout;
if (opt_output_file) {
if (default_output_format) {
/* output file is in session format, which means we'll
* dump everything in the datastore as it comes in,
* and save from there after the session. */
outfile = NULL;
ret = sr_datastore_new(unitsize, &(dev->datastore));
if (ret != SR_OK) {
printf("Failed to create datastore.\n");
exit(1);
}
} else {
/* saving to a file in whatever format was set
* with --format, so all we need is a filehandle */
outfile = g_fopen(opt_output_file, "wb");
}
}
if (opt_pds)
srd_session_start(num_enabled_probes, unitsize,
meta_logic->samplerate);
break;
case SR_DF_LOGIC:
logic = packet->payload;
g_message("cli: received SR_DF_LOGIC, %"PRIu64" bytes", logic->length);
sample_size = logic->unitsize;
if (logic->length == 0)
break;
/* Don't store any samples until triggered. */
if (opt_wait_trigger && !triggered)
break;
if (limit_samples && received_samples >= limit_samples)
break;
ret = sr_filter_probes(sample_size, unitsize, logic_probelist,
logic->data, logic->length,
&filter_out, &filter_out_len);
if (ret != SR_OK)
break;
/* what comes out of the filter is guaranteed to be packed into the
* minimum size needed to support the number of samples at this sample
* size. however, the driver may have submitted too much -- cut off
* the buffer of the last packet according to the sample limit.
*/
if (limit_samples && (received_samples + logic->length / sample_size >
limit_samples * sample_size))
filter_out_len = limit_samples * sample_size - received_samples;
if (dev->datastore)
sr_datastore_put(dev->datastore, filter_out,
filter_out_len, sample_size, logic_probelist);
if (opt_output_file && default_output_format)
/* saving to a session file, don't need to do anything else
* to this data for now. */
goto cleanup;
if (opt_pds) {
if (srd_session_send(received_samples, (uint8_t*)filter_out,
filter_out_len) != SRD_OK)
sr_session_stop();
} else {
output_len = 0;
if (o->format->data && packet->type == o->format->df_type)
o->format->data(o, filter_out, filter_out_len, &output_buf, &output_len);
if (output_buf) {
fwrite(output_buf, 1, output_len, outfile);
fflush(outfile);
g_free(output_buf);
}
}
cleanup:
g_free(filter_out);
received_samples += logic->length / sample_size;
break;
case SR_DF_META_ANALOG:
g_message("cli: Received SR_DF_META_ANALOG");
meta_analog = packet->payload;
num_analog_probes = meta_analog->num_probes;
num_enabled_analog_probes = 0;
for (i = 0; i < num_analog_probes; i++) {
probe = g_slist_nth_data(dev->probes, i);
if (probe->enabled)
analog_probelist[num_enabled_analog_probes++] = probe;
}
outfile = stdout;
if (opt_output_file) {
if (default_output_format) {
/* output file is in session format, which means we'll
* dump everything in the datastore as it comes in,
* and save from there after the session. */
outfile = NULL;
ret = sr_datastore_new(unitsize, &(dev->datastore));
if (ret != SR_OK) {
printf("Failed to create datastore.\n");
exit(1);
}
} else {
/* saving to a file in whatever format was set
* with --format, so all we need is a filehandle */
outfile = g_fopen(opt_output_file, "wb");
}
}
break;
case SR_DF_ANALOG:
analog = packet->payload;
g_message("cli: received SR_DF_ANALOG, %d samples", analog->num_samples);
if (analog->num_samples == 0)
break;
if (limit_samples && received_samples >= limit_samples)
break;
if (o->format->data && packet->type == o->format->df_type) {
o->format->data(o, (const uint8_t *)analog->data,
analog->num_samples * sizeof(float),
&output_buf, &output_len);
if (output_buf) {
fwrite(output_buf, 1, output_len, outfile);
fflush(outfile);
g_free(output_buf);
}
}
received_samples += analog->num_samples;
break;
case SR_DF_FRAME_BEGIN:
g_debug("cli: received SR_DF_FRAME_BEGIN");
if (o->format->event) {
o->format->event(o, SR_DF_FRAME_BEGIN, &output_buf,
&output_len);
if (output_buf) {
fwrite(output_buf, 1, output_len, outfile);
fflush(outfile);
g_free(output_buf);
}
}
break;
case SR_DF_FRAME_END:
g_debug("cli: received SR_DF_FRAME_END");
if (o->format->event) {
o->format->event(o, SR_DF_FRAME_END, &output_buf,
&output_len);
if (output_buf) {
fwrite(output_buf, 1, output_len, outfile);
fflush(outfile);
g_free(output_buf);
}
}
break;
default:
g_message("received unknown packet type %d", packet->type);
}
}
static void
cl_children_subscription_test(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
changes_t changes = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cv = PTHREAD_COND_INITIALIZER, 0};
struct timespec ts;
int rc = SR_ERR_OK;
/* start session */
rc = sr_session_start(conn, SR_DS_RUNNING, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_subtree_change_subscribe(session, "/example-module:container/list/leaf", subtree_example_change_cb, &changes,
0, SR_SUBSCR_DEFAULT, &subscription);
assert_int_equal(rc, SR_ERR_OK);
/* delete the parent of the subscribed node */
rc = sr_delete_item(session, "/example-module:*", SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
pthread_mutex_lock(&changes.mutex);
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
sr_clock_get_time(CLOCK_REALTIME, &ts);
ts.tv_sec += COND_WAIT_SEC;
pthread_cond_timedwait(&changes.cv, &changes.mutex, &ts);
assert_int_equal(changes.cnt, 5);
for (int i= 0; i < changes.cnt; i++) {
assert_int_equal(changes.oper[i], SR_OP_DELETED);
}
assert_string_equal("/example-module:container", changes.old_values[0]->xpath);
assert_string_equal("/example-module:container/list[key1='key1'][key2='key2']", changes.old_values[1]->xpath);
assert_string_equal("/example-module:container/list[key1='key1'][key2='key2']/key1", changes.old_values[2]->xpath);
assert_string_equal("/example-module:container/list[key1='key1'][key2='key2']/key2", changes.old_values[3]->xpath);
assert_string_equal("/example-module:container/list[key1='key1'][key2='key2']/leaf", changes.old_values[4]->xpath);
for (size_t i = 0; i < changes.cnt; i++) {
sr_free_val(changes.new_values[i]);
sr_free_val(changes.old_values[i]);
}
pthread_mutex_unlock(&changes.mutex);
/* check that cb were called in correct order according to the priority */
sr_unsubscribe(session, subscription);
sr_session_stop(session);
}
int
main()
{
const struct CMUnitTest tests[] = {
cmocka_unit_test_setup_teardown(cl_get_changes_create_test, sysrepo_setup, sysrepo_teardown),
cmocka_unit_test_setup_teardown(cl_get_changes_modified_test, sysrepo_setup, sysrepo_teardown),
cmocka_unit_test_setup_teardown(cl_get_changes_deleted_test, sysrepo_setup, sysrepo_teardown),
cmocka_unit_test_setup_teardown(cl_get_changes_moved_test, sysrepo_setup, sysrepo_teardown),
cmocka_unit_test_setup_teardown(cl_notif_priority_test, sysrepo_setup, sysrepo_teardown),
cmocka_unit_test_setup_teardown(cl_whole_module_changes, sysrepo_setup, sysrepo_teardown),
cmocka_unit_test_setup_teardown(cl_invalid_xpath_test, sysrepo_setup, sysrepo_teardown),
cmocka_unit_test_setup_teardown(cl_children_subscription_test, sysrepo_setup, sysrepo_teardown),
};
return cmocka_run_group_tests(tests, NULL, NULL);
}
static void
cl_invalid_xpath_test(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
changes_t changes = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cv = PTHREAD_COND_INITIALIZER, 0};
struct timespec ts;
int rc = SR_ERR_OK;
/* start session */
rc = sr_session_start(conn, SR_DS_RUNNING, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "test-module", cl_invalid_change_xpath_cb, &changes,
0, SR_SUBSCR_DEFAULT, &subscription);
assert_int_equal(rc, SR_ERR_OK);
sr_val_t v = {0};
v.type = SR_UINT8_T;
v.data.uint8_val = 19;
rc = sr_set_item(session, "/test-module:main/ui8", &v, SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
pthread_mutex_lock(&changes.mutex);
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
sr_clock_get_time(CLOCK_REALTIME, &ts);
ts.tv_sec += COND_WAIT_SEC;
pthread_cond_timedwait(&changes.cv, &changes.mutex, &ts);
pthread_mutex_unlock(&changes.mutex);
/* check that cb were called in correct order according to the priority */
sr_unsubscribe(session, subscription);
sr_session_stop(session);
}
int subtree_example_change_cb(sr_session_ctx_t *session, const char *xpath,
sr_notif_event_t event, void *private_ctx) {
changes_t *ch = (changes_t *) private_ctx;
sr_change_iter_t *it = NULL;
int rc = SR_ERR_OK;
pthread_mutex_lock(&ch->mutex);
rc = sr_get_changes_iter(session, "/example-module:*" , &it);
puts("Iteration over changes started");
if (SR_ERR_OK != rc) {
puts("sr get changes iter failed");
goto cleanup;
}
ch->cnt = 0;
while (ch->cnt < MAX_CHANGE) {
rc = sr_get_change_next(session, it,
&ch->oper[ch->cnt],
&ch->old_values[ch->cnt],
&ch->new_values[ch->cnt]);
if (SR_ERR_OK != rc) {
break;
}
ch->cnt++;
}
cleanup:
sr_free_change_iter(it);
pthread_cond_signal(&ch->cv);
pthread_mutex_unlock(&ch->mutex);
return SR_ERR_OK;
}
static void
cl_whole_module_changes(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
sr_session_ctx_t *session = NULL;
sr_subscription_ctx_t *subscription = NULL;
changes_t changes = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cv = PTHREAD_COND_INITIALIZER, 0};
struct timespec ts;
int rc = SR_ERR_OK;
/* start session */
rc = sr_session_start(conn, SR_DS_RUNNING, SR_SESS_DEFAULT, &session);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_module_change_subscribe(session, "test-module", cl_whole_module_cb, &changes,
0, SR_SUBSCR_DEFAULT, &subscription);
assert_int_equal(rc, SR_ERR_OK);
sr_val_t v = {0};
v.type = SR_UINT8_T;
v.data.uint8_val = 19;
rc = sr_set_item(session, "/test-module:main/ui8", &v, SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
rc = sr_set_item(session, "/test-module:user[name='userA']", NULL, SR_EDIT_DEFAULT);
assert_int_equal(rc, SR_ERR_OK);
pthread_mutex_lock(&changes.mutex);
rc = sr_commit(session);
assert_int_equal(rc, SR_ERR_OK);
sr_clock_get_time(CLOCK_REALTIME, &ts);
ts.tv_sec += COND_WAIT_SEC;
pthread_cond_timedwait(&changes.cv, &changes.mutex, &ts);
for (int i= 0; i < changes.cnt; i++) {
if (NULL != changes.new_values[i]) {
puts(changes.new_values[i]->xpath);
}
}
assert_int_equal(changes.cnt, 4);
assert_int_equal(changes.oper[0], SR_OP_MODIFIED);
assert_non_null(changes.new_values[0]);
assert_non_null(changes.old_values[0]);
assert_string_equal("/test-module:main/ui8", changes.new_values[0]->xpath);
assert_int_equal(changes.oper[1], SR_OP_CREATED);
assert_non_null(changes.new_values[1]);
assert_null(changes.old_values[1]);
assert_string_equal("/test-module:user[name='userA']", changes.new_values[1]->xpath);
assert_int_equal(changes.oper[2], SR_OP_CREATED);
assert_non_null(changes.new_values[2]);
assert_null(changes.old_values[2]);
assert_string_equal("/test-module:user[name='userA']/name", changes.new_values[2]->xpath);
assert_int_equal(changes.oper[3], SR_OP_MOVED);
assert_non_null(changes.new_values[3]);
assert_null(changes.old_values[3]);
assert_string_equal("/test-module:user[name='userA']", changes.new_values[3]->xpath);
for (size_t i = 0; i < changes.cnt; i++) {
sr_free_val(changes.new_values[i]);
sr_free_val(changes.old_values[i]);
}
pthread_mutex_unlock(&changes.mutex);
/* check that cb were called in correct order according to the priority */
sr_unsubscribe(session, subscription);
sr_session_stop(session);
}
int
cl_invalid_change_xpath_cb(sr_session_ctx_t *session, const char *module_name, sr_notif_event_t ev, void *private_ctx)
{
changes_t *ch = (changes_t *) private_ctx;
sr_change_iter_t *it = NULL;
int rc = SR_ERR_OK;
pthread_mutex_lock(&ch->mutex);
char change_path[50] = {0,};
snprintf(change_path, 50, "/---ERR%s:*", module_name);
rc = sr_get_changes_iter(session, change_path, &it);
assert_int_not_equal(SR_ERR_OK, rc);
snprintf(change_path, 50, "/%s:abcdefgh", module_name);
rc = sr_get_changes_iter(session, change_path, &it);
assert_int_not_equal(SR_ERR_OK, rc);
pthread_cond_signal(&ch->cv);
pthread_mutex_unlock(&ch->mutex);
return SR_ERR_OK;
}
