static void
sysrepo_daemon_test(void **state)
{
sr_conn_ctx_t *conn = NULL;
int rc = SR_ERR_OK, ret = 0;
/* print version */
ret = system("../src/sysrepod -v");
assert_int_equal(ret, 0);
/* print help */
ret = system("../src/sysrepod -h");
assert_int_equal(ret, 0);
/* start the daemon */
ret = system("../src/sysrepod");
assert_int_equal(ret, 0);
/* connect to sysrepo, force daemon connection */
rc = sr_connect("daemon_test", SR_CONN_DAEMON_REQUIRED, &conn);
assert_true(SR_ERR_OK == rc);
/* disconnect */
sr_disconnect(conn);
/* 2nd attempt to start the daemon - should fail since the daemon is running already */
ret = system("../src/sysrepod -l4");
assert_int_not_equal(ret, 0);
}
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;
}
/**
* @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));
}
}
}
static int
test_setup(void **state)
{
sr_conn_ctx_t *conn = NULL;
struct timespec ts = { 0 };
int rc = SR_ERR_OK;
/* connect to sysrepo, force daemon connection */
rc = sr_connect("daemon_test", SR_CONN_DAEMON_REQUIRED, &conn);
sr_disconnect(conn);
assert_true(SR_ERR_OK == rc || SR_ERR_DISCONNECT == rc);
/* kill the daemon if it was running */
if (SR_ERR_OK == rc) {
daemon_run_before_test = true;
daemon_kill();
/* wait for the daemon to terminate */
ts.tv_sec = 0;
ts.tv_nsec = 100000000L; /* 100 milliseconds */
nanosleep(&ts, NULL);
} else {
daemon_run_before_test = false;
}
return 0;
}
static int
sysrepo_teardown(void **state)
{
sr_conn_ctx_t *conn = *state;
assert_non_null(conn);
/* disconnect from sysrepo */
sr_disconnect(conn);
return 0;
}
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;
}
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;
}
/**
* @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;
}
/**
* @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);
}