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