#include "network_function.h"
#include "utils/log_utils.h"
#include "utils/sys_utils.h"
+#include "utils/nts_utils.h"
#include <stdio.h>
#include <pthread.h>
#include <assert.h>
#include "features/netconf_call_home/netconf_call_home.h"
#include "features/web_cut_through/web_cut_through.h"
+#include "app_common.h"
+
+#define NF_FUNCTION_CONTROL_BUFFER_LENGTH 32
+
#define IETF_NETCONF_MONITORING_MODULE "ietf-netconf-monitoring"
#define IETF_NETCONF_MONITORING_STATE_SCHEMAS_SCHEMA_XPATH "/ietf-netconf-monitoring:netconf-state/schemas"
#define NTS_NETWORK_FUNCTION_MODULE "nts-network-function"
#define NTS_NETWORK_FUNCTION_SCHEMA_XPATH "/nts-network-function:simulation/network-function"
-#define POPULATE_RPC_SCHEMA_XPATH "/nts-network-function:datastore-random-populate"
+#define POPULATE_RPC_SCHEMA_XPATH "/nts-network-function:datastore-populate"
#define FEATURE_CONTROL_SCHEMA_XPATH "/nts-network-function:feature-control"
#define FAULTS_CLEAR_SCHEMA_XPATH "/nts-network-function:clear-fault-counters"
#define FAULTS_LIST_SCHEMA_XPATH "/nts-network-function:simulation/network-function/fault-generation"
#define FAULTS_NC_ENABLED_SCHEMA_XPATH "/nts-network-function:simulation/network-function/netconf/faults-enabled"
#define FAULTS_VES_ENABLED_SCHEMA_XPATH "/nts-network-function:simulation/network-function/ves/faults-enabled"
+#define STARTED_FEATURES_LIST_SCHEMA_XPATH "/nts-network-function:info/started-features"
+
static int netconf_monitoring_state_schemas_cb(sr_session_ctx_t *session, const char *module_name, const char *path, const char *request_xpath, uint32_t request_id, struct lyd_node **parent, void *private_data);
static int notifications_streams_cb(sr_session_ctx_t *session, const char *module_name, const char *path, const char *request_xpath, uint32_t request_id, struct lyd_node **parent, void *private_data);
static int network_function_faults_change_cb(sr_session_ctx_t *session, const char *module_name, const char *xpath, sr_event_t event, uint32_t request_id, void *private_data);
static int network_function_faults_count_get_items_cb(sr_session_ctx_t *session, const char *module_name, const char *xpath, const char *request_xpath, uint32_t request_id, struct lyd_node **parent, void *private_data);
+static int network_function_started_features_get_items_cb(sr_session_ctx_t *session, const char *module_name, const char *xpath, const char *request_xpath, uint32_t request_id, struct lyd_node **parent, void *private_data);
+
static int network_function_change_cb(sr_session_ctx_t *session, const char *module_name, const char *xpath, sr_event_t event, uint32_t request_id, void *private_data);
static int faults_update_config(sr_session_ctx_t *session); //not protected by lock
static void *faults_thread_routine(void *arg);
static pthread_mutex_t nf_function_control_lock;
-static char *nf_function_control_string = 0;
+static char *nf_function_control_buffer[NF_FUNCTION_CONTROL_BUFFER_LENGTH];
+static int nf_function_control_buffer_in;
+static int nf_function_control_buffer_out;
static pthread_t faults_thread;
static pthread_mutex_t faults_lock;
-static pthread_mutex_t network_function_change_lock;
-static char *function_type_default = 0;
-static char *function_type_val = 0;
-static char *mount_point_addressing_method_default = 0;
-static char *mount_point_addressing_method_val = 0;
-
int network_function_run(void) {
assert_session();
- log_message(1, LOG_COLOR_BOLD_YELLOW"\nrunning as NETWORK FUNCTION daemon...\n"LOG_COLOR_RESET);
+ nf_function_control_buffer_in = 0;
+ nf_function_control_buffer_out = 0;
+
+ log_add_verbose(1, LOG_COLOR_BOLD_YELLOW"running as NETWORK FUNCTION daemon...\n"LOG_COLOR_RESET);
+
+ int rc = app_common_init();
+ if(rc != NTS_ERR_OK) {
+ log_error("app_common_init failed\n");
+ return NTS_ERR_FAILED;
+ }
+
+ if(strlen(framework_environment.nts.nf_standalone_start_features)) {
+ rc = nts_utils_populate_info(session_running, framework_environment.nts.function_type);
+ if(rc != NTS_ERR_OK) {
+ log_error("nts_utils_populate_info failed\n");
+ return NTS_ERR_FAILED;
+ }
+ }
if(pthread_mutex_init(&nf_function_control_lock, NULL) != 0) {
- log_error("mutex init has failed");
+ log_error("mutex init has failed\n");
return NTS_ERR_FAILED;
}
//ietf-netconf-monitoring schemas populate with modules and submodules (overwrite default Netopeer2 behaviour)
- int rc = sr_oper_get_items_subscribe(session_running, IETF_NETCONF_MONITORING_MODULE, IETF_NETCONF_MONITORING_STATE_SCHEMAS_SCHEMA_XPATH, netconf_monitoring_state_schemas_cb, 0, SR_SUBSCR_DEFAULT, &session_subscription);
+ rc = sr_oper_get_items_subscribe(session_running, IETF_NETCONF_MONITORING_MODULE, IETF_NETCONF_MONITORING_STATE_SCHEMAS_SCHEMA_XPATH, netconf_monitoring_state_schemas_cb, 0, SR_SUBSCR_DEFAULT, &session_subscription);
if(rc != SR_ERR_OK) {
- log_error("error from sr_oper_get_items_subscribe: %s", sr_strerror(rc));
+ log_error("error from sr_oper_get_items_subscribe: %s\n", sr_strerror(rc));
return 0;
}
//nc-notifications overwrite
rc = sr_oper_get_items_subscribe(session_running, NC_NOTIFICATIONS_MODULE, NC_NOTIFICATIONS_STREAMS_SCHEMA_XPATH, notifications_streams_cb, 0, SR_SUBSCR_DEFAULT, &session_subscription);
if(rc != SR_ERR_OK) {
- log_error("error from sr_oper_get_items_subscribe: %s", sr_strerror(rc));
+ log_error("error from sr_oper_get_items_subscribe: %s\n", sr_strerror(rc));
return 0;
}
//populate
rc = sr_rpc_subscribe(session_running, POPULATE_RPC_SCHEMA_XPATH, network_function_populate_cb, 0, 0, SR_SUBSCR_CTX_REUSE, &session_subscription);
if(rc != SR_ERR_OK) {
- log_error("error from sr_rpc_subscribe: %s", sr_strerror(rc));
+ log_error("error from sr_rpc_subscribe: %s\n", sr_strerror(rc));
return NTS_ERR_FAILED;
}
//feature control
rc = sr_rpc_subscribe(session_running, FEATURE_CONTROL_SCHEMA_XPATH, network_function_feature_control_cb, 0, 0, SR_SUBSCR_CTX_REUSE, &session_subscription);
if(rc != SR_ERR_OK) {
- log_error("error from sr_rpc_subscribe: %s", sr_strerror(rc));
+ log_error("error from sr_rpc_subscribe: %s\n", sr_strerror(rc));
return NTS_ERR_FAILED;
}
rc = sr_oper_get_items_subscribe(session_running, NTS_NETWORK_FUNCTION_MODULE, FAULTS_COUNT_LIST_SCHEMA_XPATH, network_function_faults_count_get_items_cb, NULL, SR_SUBSCR_CTX_REUSE, &session_subscription);
if(rc != SR_ERR_OK) {
- log_error("could not subscribe to oper faults: %s", sr_strerror(rc));
+ log_error("could not subscribe to oper faults: %s\n", sr_strerror(rc));
return 0;
}
rc = sr_rpc_subscribe(session_running, FAULTS_CLEAR_SCHEMA_XPATH, network_function_faults_clear_cb, 0, 0, SR_SUBSCR_CTX_REUSE, &session_subscription);
if(rc != SR_ERR_OK) {
- log_error("error from sr_rpc_subscribe: %s", sr_strerror(rc));
+ log_error("error from sr_rpc_subscribe: %s\n", sr_strerror(rc));
return NTS_ERR_FAILED;
}
+ rc = sr_oper_get_items_subscribe(session_running, NTS_NETWORK_FUNCTION_MODULE, STARTED_FEATURES_LIST_SCHEMA_XPATH, network_function_started_features_get_items_cb, NULL, SR_SUBSCR_CTX_REUSE, &session_subscription);
+ if(rc != SR_ERR_OK) {
+ log_error("could not subscribe to oper started-features: %s\n", sr_strerror(rc));
+ return 0;
+ }
+
+
//subscribe to any changes on the main
- rc = sr_module_change_subscribe(session_running, NTS_NETWORK_FUNCTION_MODULE, NTS_NETWORK_FUNCTION_SCHEMA_XPATH, network_function_change_cb, NULL, 0, SR_SUBSCR_CTX_REUSE, &session_subscription);
+ rc = sr_module_change_subscribe(session_running, NTS_NETWORK_FUNCTION_MODULE, NTS_NETWORK_FUNCTION_SCHEMA_XPATH, network_function_change_cb, NULL, 0, SR_SUBSCR_CTX_REUSE | SR_SUBSCR_UPDATE, &session_subscription);
if(rc != SR_ERR_OK) {
- log_error("could not subscribe to simulation changes");
+ log_error("could not subscribe to simulation changes\n");
return NTS_ERR_FAILED;
}
rc = faults_init();
if(rc != NTS_ERR_OK) {
- log_error("faults_init error", sr_strerror(rc));
+ log_error("faults_init error\n", sr_strerror(rc));
return NTS_ERR_FAILED;
}
if(pthread_mutex_init(&faults_lock, NULL) != 0) {
- log_error("mutex init has failed");
+ log_error("mutex init has failed\n");
return NTS_ERR_FAILED;
}
if(pthread_create(&faults_thread, 0, faults_thread_routine, 0)) {
- log_error("could not create thread for heartbeat");
+ log_error("could not create thread for heartbeat\n");
return NTS_ERR_FAILED;
}
- if(pthread_mutex_init(&network_function_change_lock, NULL) != 0) {
- log_error("mutex init has failed");
- return NTS_ERR_FAILED;
- }
-
- while(!framework_sigint) {
- pthread_mutex_lock(&network_function_change_lock);
- if(function_type_val) {
- rc = sr_set_item_str(session_running, NTS_NETWORK_FUNCTION_SCHEMA_XPATH"/function-type", function_type_val, 0, 0);
- if(rc != SR_ERR_OK) {
- log_error("sr_set_item_str failed");
- }
+ //check standalone mode
+ if(strlen(framework_environment.nts.nf_standalone_start_features)) {
+ char *start_features = 0;
- rc = sr_apply_changes(session_running, 0, 0);
- if(rc != SR_ERR_OK) {
- log_error("sr_apply_changes failed");
- }
+ asprintf(&start_features, "1 %s", framework_environment.nts.nf_standalone_start_features);
+ nf_function_control_buffer[nf_function_control_buffer_in] = start_features;
+ nf_function_control_buffer_in++;
+ if(nf_function_control_buffer_in >= NF_FUNCTION_CONTROL_BUFFER_LENGTH) {
+ nf_function_control_buffer_in = 0;
+ }
- function_type_val = 0;
+ log_add_verbose(1, LOG_COLOR_BOLD_YELLOW"running in NETWORK FUNCTION STANDALONE mode!\n"LOG_COLOR_RESET);
+ log_add_verbose(1, "Currently enabled features are: %s\n", framework_environment.nts.nf_standalone_start_features);
+ log_add_verbose(1, LOG_COLOR_BOLD_YELLOW"Docker IP:"LOG_COLOR_RESET" %s\n", framework_environment.settings.ip_v6_enabled ? framework_environment.settings.ip_v6 : framework_environment.settings.ip_v4);
+ log_add_verbose(1, LOG_COLOR_BOLD_YELLOW"Docker ports"LOG_COLOR_RESET": ");
+ if(framework_environment.settings.ssh_connections) {
+ log_add(1, "NETCONF SSH: %d (%d)", STANDARD_NETCONF_PORT, framework_environment.settings.ssh_connections);
+ }
+ else {
+ log_add(1, "NETCONF SSH: disabled");
+ }
+ if(framework_environment.settings.tls_connections) {
+ log_add(1, " | NETCONF TLS: %d (%d)", STANDARD_NETCONF_PORT + framework_environment.settings.ssh_connections, framework_environment.settings.tls_connections);
}
+ else {
+ log_add(1, " | NETCONF TLS: disabled");
+ }
+ if(framework_environment.settings.ftp_connections) {
+ log_add(1, " | FTP: %d (%d)", STANDARD_FTP_PORT, framework_environment.settings.ftp_connections);
+ }
+ else {
+ log_add(1, " | FTP: disabled");
+ }
+ if(framework_environment.settings.sftp_connections) {
+ log_add(1, " | SFTP: %d (%d)", STANDARD_SFTP_PORT, framework_environment.settings.sftp_connections);
+ }
+ else {
+ log_add(1, " | SFTP: disabled");
+ }
+ log_add(1,"\n");
+ }
- if(mount_point_addressing_method_val) {
- rc = sr_set_item_str(session_running, NTS_NETWORK_FUNCTION_SCHEMA_XPATH"/mount-point-addressing-method", mount_point_addressing_method_val, 0, 0);
- if(rc != SR_ERR_OK) {
- log_error("sr_set_item_str failed");
+ while(!framework_sigint) {
+ pthread_mutex_lock(&nf_function_control_lock);
+ while(nf_function_control_buffer_in != nf_function_control_buffer_out) {
+ //get current function control string
+ char *nf_function_control_string = nf_function_control_buffer[nf_function_control_buffer_out];
+ nf_function_control_buffer_out++;
+ if(nf_function_control_buffer_out >= NF_FUNCTION_CONTROL_BUFFER_LENGTH) {
+ nf_function_control_buffer_out = 0;
}
- rc = sr_apply_changes(session_running, 0, 0);
- if(rc != SR_ERR_OK) {
- log_error("sr_apply_changes failed");
+ if(strstr(nf_function_control_string, "datastore-populate") != 0) {
+ rc = datastore_populate(3);
+ if(rc != NTS_ERR_OK) {
+ log_error("datastore_populate() failed\n");
+ }
}
- mount_point_addressing_method_val = 0;
- }
- pthread_mutex_unlock(&network_function_change_lock);
-
- pthread_mutex_lock(&nf_function_control_lock);
- if(nf_function_control_string) {
if(strstr(nf_function_control_string, "ves-file-ready") != 0) {
- // start feature for handling the fileReady VES message
- rc = ves_file_ready_feature_start(session_running);
- if(rc != 0) {
- log_error("ves_file_ready_feature_start() failed");
+ if(nf_function_control_string[0] == '1') {
+ // start feature for handling the fileReady VES message
+ rc = ves_file_ready_feature_start(session_running);
+ if(rc != 0) {
+ log_error("ves_file_ready_feature_start() failed\n");
+ }
+ }
+ else if(nf_function_control_string[0] == '0') {
+ // stop feature for handling the fileReady VES message
+ rc = ves_file_ready_feature_stop();
+ if(rc != 0) {
+ log_error("ves_file_ready_feature_stop() failed\n");
+ }
}
}
if(strstr(nf_function_control_string, "ves-pnf-registration") != 0) {
- // check if PNF registration is enabled and send PNF registration message if so
- rc = ves_pnf_registration_feature_start(session_running);
- if(rc != 0) {
- log_error("ves_pnf_registration_feature_start() failed");
+ if(nf_function_control_string[0] == '1') {
+ // check if PNF registration is enabled and send PNF registration message if so
+ rc = ves_pnf_registration_feature_start(session_running);
+ if(rc != 0) {
+ log_error("ves_pnf_registration_feature_start() failed\n");
+ }
}
}
if(strstr(nf_function_control_string, "ves-heartbeat") != 0) {
- // start feature for handling the heartbeat VES message
- rc = ves_heartbeat_feature_start(session_running);
- if(rc != 0) {
- log_error("ves_heartbeat_feature_start() failed");
+ if(nf_function_control_string[0] == '1') {
+ // start feature for handling the heartbeat VES message
+ rc = ves_heartbeat_feature_start(session_running);
+ if(rc != 0) {
+ log_error("ves_heartbeat_feature_start() failed\n");
+ }
+ }
+ else if(nf_function_control_string[0] == '0') {
+ // stop feature for handling the heartbeat VES message
+ rc = ves_heartbeat_feature_stop();
+ if(rc != 0) {
+ log_error("ves_heartbeat_feature_stop() failed\n");
+ }
}
}
if(strstr(nf_function_control_string, "manual-notification-generation") != 0) {
- // start feature for manual notification
- rc = manual_notification_feature_start(session_running);
- if(rc != 0) {
- log_error("manual_notification_feature_start() failed");
+ if(nf_function_control_string[0] == '1') {
+ // start feature for manual notification
+ rc = manual_notification_feature_start(session_running);
+ if(rc != 0) {
+ log_error("manual_notification_feature_start() failed\n");
+ }
+ }
+ else if(nf_function_control_string[0] == '0') {
+ // stop feature for manual notification
+ rc = manual_notification_feature_stop();
+ if(rc != 0) {
+ log_error("manual_notification_feature_stop() failed\n");
+ }
}
}
if(strstr(nf_function_control_string, "netconf-call-home") != 0) {
- // start feature for NETCONF Call Home
- rc = netconf_call_home_feature_start(session_running);
- if(rc != 0) {
- log_error("netconf_call_home_feature_start() failed");
+ if(nf_function_control_string[0] == '1') {
+ // start feature for NETCONF Call Home
+ rc = netconf_call_home_feature_start(session_running);
+ if(rc != 0) {
+ log_error("netconf_call_home_feature_start() failed\n");
+ }
}
}
if(strstr(nf_function_control_string, "web-cut-through") != 0) {
- // start feature for NETCONF Call Home
- rc = web_cut_through_feature_start(session_running);
- if(rc != 0) {
- log_error("web_cut_through_feature_start() failed");
+ if(nf_function_control_string[0] == '1') {
+ // start feature for web cut-through
+ rc = web_cut_through_feature_start(session_running);
+ if(rc != 0) {
+ log_error("web_cut_through_feature_start() failed\n");
+ }
+ }
+ else if(nf_function_control_string[0] == '0') {
+ // stop feature for web cut-through
+ rc = web_cut_through_feature_stop(session_running);
+ if(rc != 0) {
+ log_error("web_cut_through_feature_stop() failed\n");
+ }
}
}
// get all modules from context
while ((mod = ly_ctx_get_module_iter(session_context, &i))) {
+ // we skip the internal sysrepo modules
+ if (!strcmp("sysrepo", mod->name) || !strcmp("sysrepo-monitoring", mod->name) || !strcmp("sysrepo-plugind", mod->name)) {
+ continue;
+ }
+
list = lyd_new(root, NULL, "schema");
lyd_new_leaf(list, NULL, "identifier", mod->name);
lyd_new_leaf(list, NULL, "version", (mod->rev ? mod->rev[0].date : NULL));
/* go through all the sysrepo modules */
int rc = sr_get_module_info(session_connection, &sr_data);
if(rc != SR_ERR_OK) {
- log_error("sr_get_module_info failed");
+ log_error("sr_get_module_info failed\n");
return SR_ERR_OPERATION_FAILED;
}
return rc;
}
- rc = schema_populate();
- if(rc != NTS_ERR_OK) {
- rc = sr_val_build_str_data(output[0], SR_ENUM_T, "%s", "ERROR");
- }
- else {
- rc = sr_val_build_str_data(output[0], SR_ENUM_T, "%s", "SUCCESS");
+ pthread_mutex_lock(&nf_function_control_lock);
+ nf_function_control_buffer[nf_function_control_buffer_in] = strdup("datastore-populate");
+ nf_function_control_buffer_in++;
+ if(nf_function_control_buffer_in >= NF_FUNCTION_CONTROL_BUFFER_LENGTH) {
+ nf_function_control_buffer_in = 0;
}
+ pthread_mutex_unlock(&nf_function_control_lock);
+ rc = sr_val_build_str_data(output[0], SR_ENUM_T, "%s", "SUCCESS");
return rc;
}
int rc;
int total_errors = 0;
+ char start_features[16][64];
+ int start_features_cnt = 0;
+
+ char stop_features[16][64];
+ int stop_features_cnt = 0;
+
+ char *start_input = 0;
+ char *stop_input = 0;
+
+ for(int i = 0; i < input_cnt; i++) {
+ if(input[i].data.bits_val == 0) {
+ continue;
+ }
+
+ char *val = strdup(input[i].data.bits_val);
+
+ if(strstr(input[i].xpath, "start")) {
+ start_input = input[i].data.bits_val;
+
+ const char *tok = " ";
+ char *token = strtok(val, tok);
+ while(token) {
+ strcpy(start_features[start_features_cnt++], token);
+ token = strtok(0, tok);
+ }
+ }
+
+ if(strstr(input[i].xpath, "stop")) {
+ stop_input = input[i].data.bits_val;
+
+ const char *tok = " ";
+ char *token = strtok(val, tok);
+ while(token) {
+ strcpy(stop_features[stop_features_cnt++], token);
+ token = strtok(0, tok);
+ }
+ }
+
+ free(val);
+ }
+
+ for(int i = 0; i < start_features_cnt; i++) {
+ for(int j = 0; j < stop_features_cnt; j++) {
+ if(strcmp(start_features[i], stop_features[j]) == 0) {
+ total_errors++;
+ }
+ }
+ }
+
*output_cnt = 1;
rc = sr_new_values(*output_cnt, output);
if(SR_ERR_OK != rc) {
}
else {
rc = sr_val_build_str_data(output[0], SR_ENUM_T, "%s", "SUCCESS");
+
+ pthread_mutex_lock(&nf_function_control_lock);
+ if(start_features_cnt) {
+ asprintf(&nf_function_control_buffer[nf_function_control_buffer_in], "1 %s", start_input);
+ nf_function_control_buffer_in++;
+ if(nf_function_control_buffer_in >= NF_FUNCTION_CONTROL_BUFFER_LENGTH) {
+ nf_function_control_buffer_in = 0;
+ }
+ }
+
+ if(stop_features_cnt) {
+ asprintf(&nf_function_control_buffer[nf_function_control_buffer_in], "0 %s", stop_input);
+ nf_function_control_buffer_in++;
+ if(nf_function_control_buffer_in >= NF_FUNCTION_CONTROL_BUFFER_LENGTH) {
+ nf_function_control_buffer_in = 0;
+ }
+ }
+ pthread_mutex_unlock(&nf_function_control_lock);
}
- pthread_mutex_lock(&nf_function_control_lock);
- nf_function_control_string = strdup(input[0].data.bits_val);
- pthread_mutex_unlock(&nf_function_control_lock);
+
return rc;
}
rc = faults_update_config(session);
pthread_mutex_unlock(&faults_lock);
if(rc != NTS_ERR_OK) {
- log_error("faults_update_config failed");
+ log_error("faults_update_config failed\n");
return SR_ERR_VALIDATION_FAILED;
}
}
*parent = lyd_new_path(NULL, sr_get_context(sr_session_get_connection(session)), FAULTS_COUNT_LIST_SCHEMA_XPATH, 0, 0, 0);
if(*parent == 0) {
+ log_error("lyd_new_path failed\n");
return SR_ERR_OPERATION_FAILED;
}
sprintf(value, "%d", counters.normal);
if(lyd_new_path(*parent, NULL, FAULTS_COUNT_LIST_SCHEMA_XPATH"/normal", value, 0, 0) == 0) {
+ log_error("lyd_new_path failed\n");
return SR_ERR_OPERATION_FAILED;
}
sprintf(value, "%d", counters.warning);
if(lyd_new_path(*parent, NULL, FAULTS_COUNT_LIST_SCHEMA_XPATH"/warning", value, 0, 0) == 0) {
+ log_error("lyd_new_path failed\n");
return SR_ERR_OPERATION_FAILED;
}
sprintf(value, "%d", counters.minor);
if(lyd_new_path(*parent, NULL, FAULTS_COUNT_LIST_SCHEMA_XPATH"/minor", value, 0, 0) == 0) {
+ log_error("lyd_new_path failed\n");
return SR_ERR_OPERATION_FAILED;
}
sprintf(value, "%d", counters.major);
if(lyd_new_path(*parent, NULL, FAULTS_COUNT_LIST_SCHEMA_XPATH"/major", value, 0, 0) == 0) {
+ log_error("lyd_new_path failed\n");
return SR_ERR_OPERATION_FAILED;
}
sprintf(value, "%d", counters.critical);
if(lyd_new_path(*parent, NULL, FAULTS_COUNT_LIST_SCHEMA_XPATH"/critical", value, 0, 0) == 0) {
+ log_error("lyd_new_path failed\n");
+ return SR_ERR_OPERATION_FAILED;
+ }
+
+ return SR_ERR_OK;
+}
+
+static int network_function_started_features_get_items_cb(sr_session_ctx_t *session, const char *module_name, const char *xpath, const char *request_xpath, uint32_t request_id, struct lyd_node **parent, void *private_data) {
+ char value[1024];
+ value[0] = 0;
+
+ if(ves_file_ready_feature_get_status()) {
+ strcat(value, "ves-file-ready ");
+ }
+
+ if(ves_pnf_registration_feature_get_status()) {
+ strcat(value, "ves-pnf-registration ");
+ }
+
+ if(ves_heartbeat_feature_get_status()) {
+ strcat(value, "ves-heartbeat ");
+ }
+
+ if(manual_notification_feature_get_status()) {
+ strcat(value, "manual-notification-generation ");
+ }
+
+ if(netconf_call_home_feature_get_status()) {
+ strcat(value, "netconf-call-home ");
+ }
+
+ if(web_cut_through_feature_get_status()) {
+ strcat(value, "web-cut-through ");
+ }
+
+ if(strlen(value)) {
+ value[strlen(value) - 1] = 0;
+ }
+
+ *parent = lyd_new_path(NULL, sr_get_context(sr_session_get_connection(session)), STARTED_FEATURES_LIST_SCHEMA_XPATH, value, 0, 0);
+ if(*parent == 0) {
+ log_error("lyd_new_path failed\n");
return SR_ERR_OPERATION_FAILED;
}
struct lyd_node *data;
rc = sr_get_subtree(session, FAULTS_LIST_SCHEMA_XPATH, 0, &data);
if(rc != SR_ERR_OK) {
- log_error("sr_get_subtree failed");
- ret = NTS_ERR_FAILED;
+ log_error("sr_get_subtree failed\n");
+ return NTS_ERR_FAILED;
}
faults_fault_list_clear();
faults_counters_clear();
+ if(data == 0) {
+ return NTS_ERR_OK;
+ }
+
if(data->child == 0) {
goto faults_update_config_free;
}
if(strcmp(delay_list_entry->schema->name, "delay-period") == 0) {
rc = faults_fault_list_add(((const struct lyd_node_leaf_list *)delay_list_entry)->value.uint16);
if(rc != NTS_ERR_OK) {
- log_error("faults_fault_list_add failed");
+ log_error("faults_fault_list_add failed\n");
ret = NTS_ERR_FAILED;
goto faults_update_config_free;
}
sr_session_ctx_t *current_session_running = 0;
rc = sr_session_start(session_connection, SR_DS_RUNNING, ¤t_session_running);
if (rc != SR_ERR_OK) {
- log_error("sr_session_start failed");
+ log_error("sr_session_start failed\n");
return 0;
}
sr_session_ctx_t *current_session_operational = 0;
rc = sr_session_start(session_connection, SR_DS_OPERATIONAL, ¤t_session_operational);
if (rc != SR_ERR_OK) {
- log_error("sr_session_start failed");
+ log_error("sr_session_start failed\n");
return 0;
}
pthread_mutex_lock(&faults_lock);
rc = faults_update_config(current_session_running);
if(rc != NTS_ERR_OK) {
- log_error("faults_update_config failed");
+ log_error("faults_update_config failed\n");
return 0;
}
pthread_mutex_unlock(&faults_lock);
fault_details_t *fault = faults_generate_fault();
if(fault == 0) {
- log_error("faults_generate_fault failed");
+ log_error("faults_generate_fault failed\n");
pthread_mutex_unlock(&faults_lock);
sleep(1);
continue;
rc = faults_counters_increase(fault->severity);
if(rc != NTS_ERR_OK) {
- log_error("faults_counters_increase failed");
+ log_error("faults_counters_increase failed\n");
}
pthread_mutex_unlock(&faults_lock);
if(nc_fault_enabled) {
struct lyd_node *notif = 0;
+ log_add_verbose(1, "[faults] notification is '%s'\n", fault->yang_notif_processed);
notif = lyd_parse_mem(session_context, fault->yang_notif_processed, LYD_XML, LYD_OPT_NOTIF, 0);
if(notif == 0) {
- log_error("lyd_parse_mem failed");
+ log_error("lyd_parse_mem failed\n");
goto fault_send_ves;
}
rc = sr_event_notif_send_tree(current_session_running, notif);
lyd_free(notif);
if(rc != SR_ERR_OK) {
- log_error("sr_event_notif_send_tree failed");
+ log_error("sr_event_notif_send_tree failed\n");
}
}
if(ves_fault_enabled) {
rc = faults_ves_message_send(current_session_running, fault->condition, fault->object, fault->severity, fault->date_time, fault->specific_problem);
if(rc != NTS_ERR_OK) {
- log_error("faults_ves_message_send failed");
+ log_error("faults_ves_message_send failed\n");
}
}
+ log_add_verbose(1, "[faults] delaying %d sec\n", new_delay);
sleep(new_delay);
}
else {
sr_val_t *old_value = 0;
sr_val_t *new_value = 0;
- static bool function_type_set = false;
- static bool mount_point_addressing_method_set = false;
-
- if(event == SR_EV_DONE) {
+ if(event == SR_EV_UPDATE) {
rc = sr_get_changes_iter(session, NTS_NETWORK_FUNCTION_SCHEMA_XPATH"//.", &it);
if(rc != SR_ERR_OK) {
- log_error("sr_get_changes_iter failed");
+ log_error("sr_get_changes_iter failed\n");
return SR_ERR_VALIDATION_FAILED;
}
while((rc = sr_get_change_next(session, it, &oper, &old_value, &new_value)) == SR_ERR_OK) {
if(new_value->xpath && (strcmp(new_value->xpath, NTS_NETWORK_FUNCTION_SCHEMA_XPATH"/function-type") == 0)) {
- if(function_type_set == false) {
- function_type_set = true;
- function_type_default = strdup(new_value->data.string_val);
- }
- else {
- //prevent changing function_type
- if(strcmp(new_value->data.string_val, function_type_default) != 0) {
- pthread_mutex_lock(&network_function_change_lock);
- function_type_val = function_type_default;
- pthread_mutex_unlock(&network_function_change_lock);
+ if(old_value && !old_value->dflt) {
+ rc = sr_set_item(session, old_value->xpath, old_value, 0);
+ if(rc != SR_ERR_OK) {
+ log_error("sr_set_item failed\n");
+ return SR_ERR_VALIDATION_FAILED;
}
}
}
if(new_value->xpath && (strcmp(new_value->xpath, NTS_NETWORK_FUNCTION_SCHEMA_XPATH"/mount-point-addressing-method") == 0)) {
- if(mount_point_addressing_method_set == false) {
- mount_point_addressing_method_set = true;
- mount_point_addressing_method_default = strdup(new_value->data.string_val);
- }
- else {
- //prevent changing mount_point_addressing_method
- if(strcmp(new_value->data.string_val, mount_point_addressing_method_default) != 0) {
- pthread_mutex_lock(&network_function_change_lock);
- mount_point_addressing_method_val = mount_point_addressing_method_default;
- pthread_mutex_unlock(&network_function_change_lock);
+ if(old_value && !old_value->dflt) {
+ rc = sr_set_item(session, old_value->xpath, old_value, 0);
+ if(rc != SR_ERR_OK) {
+ log_error("sr_set_item failed\n");
+ return SR_ERR_VALIDATION_FAILED;
}
}
}
Code Review / sim / o1-interface.git / blobdiff