ntsimulator/ntsim-ng/core/app/manager.c

   1 /*************************************************************************
   2 *
   3 * Copyright 2020 highstreet technologies GmbH and others
   4 *
   5 * Licensed under the Apache License, Version 2.0 (the "License");
   6 * you may not use this file except in compliance with the License.
   7 * You may obtain a copy of the License at
   8 *
   9 *     http://www.apache.org/licenses/LICENSE-2.0
  10 *
  11 * Unless required by applicable law or agreed to in writing, software
  12 * distributed under the License is distributed on an "AS IS" BASIS,
  13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 * See the License for the specific language governing permissions and
  15 * limitations under the License.
  16 ***************************************************************************/
  17
  18 #define _GNU_SOURCE
  19
  20 #include "manager.h"
  21 #include "utils/log_utils.h"
  22 #include "utils/sys_utils.h"
  23 #include <stdio.h>
  24 #include <assert.h>
  25
  26 #include <sysrepo.h>
  27 #include <sysrepo/values.h>
  28
  29 #include "core/framework.h"
  30 #include "core/session.h"
  31 #include "core/context.h"
  32 #include "core/docker.h"
  33
  34 #define NTS_MANAGER_MODULE                          "nts-manager"
  35 #define NTS_SIMULATION_SCHEMA_XPATH                 "/nts-manager:simulation"
  36 #define NTS_FUNCTION_LIST_SCHEMA_XPATH              "/nts-manager:simulation/network-functions/network-function"
  37 #define NTS_SDN_CONTROLLER_CONFIG_XPATH             "/nts-manager:simulation/sdn-controller"
  38 #define NTS_VES_ENDPOINT_CONFIG_XPATH               "/nts-manager:simulation/ves-endpoint"
  39
  40 static manager_network_function_type *manager_context = 0;
  41 static int manager_installed_function_types_count = 0;
  42
  43 static int manager_populate_sysrepo_network_function_list(void);
  44 static int manager_populate_static_status(void);
  45
  46 static void manager_context_free(manager_network_function_type *context);
  47
  48 static int manager_process_change(int context_index, manager_network_function_type *new_context);
  49 static int manager_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);
  50 static int manager_instances_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);
  51 static int manager_stats_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);
  52
  53 int manager_run(void) {
  54     assert_session();
  55
  56     log_message(1, LOG_COLOR_BOLD_YELLOW"\nrunning as MANAGER daemon...\n"LOG_COLOR_RESET);
  57
  58     manager_operations_init();
  59     docker_device_init();
  60
  61     //get installed function types
  62     struct lys_node_leaf *elem = (struct lys_node_leaf *)ly_ctx_get_node(session_context, 0, NTS_FUNCTION_LIST_SCHEMA_XPATH"/function-type", 0);
  63     if(elem == 0) {
  64         log_error("ly_ctx_get_node failed for xpath: %s", NTS_FUNCTION_LIST_SCHEMA_XPATH"/function-type");
  65         return NTS_ERR_FAILED;
  66     }
  67
  68     struct lys_ident **found = 0;
  69     manager_installed_function_types_count = context_get_identity_leafs_of_type(elem->type.info.ident.ref[0], &found);
  70     if(!manager_installed_function_types_count) {
  71         log_error("error network functions");
  72         return NTS_ERR_FAILED;
  73     }
  74
  75     //initial list population
  76     manager_context = (manager_network_function_type *)malloc(sizeof(manager_network_function_type) * manager_installed_function_types_count);
  77     for(int i = 0; i < manager_installed_function_types_count; i++) {
  78         manager_context[i].instance = 0;
  79
  80         manager_context[i].function_type = found[i];
  81         asprintf(&manager_context[i].function_type_string, "%s:%s", found[i]->module->name, found[i]->name);
  82         manager_context[i].docker_image_name = manager_context[i].function_type->ref;
  83         manager_context[i].started_instances = 0;
  84         manager_context[i].mounted_instances = 0;
  85         manager_context[i].mount_point_addressing_method = strdup("docker-mapping");
  86         manager_context[i].docker_instance_name = strdup(manager_context[i].function_type->name);
  87         manager_context[i].docker_version_tag = strdup("");
  88         manager_context[i].docker_repository = strdup("");
  89     }
  90     free(found);
  91
  92     //do initial sysrepo list population
  93     int rc = manager_populate_sysrepo_network_function_list();
  94     if(rc != NTS_ERR_OK) {
  95         log_error("manager_populate_sysrepo_network_function_list failed");
  96         return NTS_ERR_FAILED;
  97     }
  98
  99     rc = manager_populate_static_status();
 100     if(rc != NTS_ERR_OK) {
 101         log_error("manager_populate_static_status failed");
 102         return NTS_ERR_FAILED;
 103     }
 104
 105     //subscribe to any changes on the list
 106     rc = sr_module_change_subscribe(session_running, NTS_MANAGER_MODULE, NTS_SIMULATION_SCHEMA_XPATH, manager_change_cb, NULL, 0, SR_SUBSCR_CTX_REUSE, &session_subscription);
 107     if(rc != SR_ERR_OK) {
 108         log_error("could not subscribe to simulation changes");
 109         return NTS_ERR_FAILED;
 110     }
 111
 112     rc = sr_oper_get_items_subscribe(session_running, NTS_MANAGER_MODULE, NTS_FUNCTION_LIST_SCHEMA_XPATH, manager_instances_get_items_cb, NULL, SR_SUBSCR_CTX_REUSE, &session_subscription);
 113     if(rc != SR_ERR_OK) {
 114         log_error("could not subscribe to oper faults");
 115         return 0;
 116     }
 117
 118     rc = sr_oper_get_items_subscribe(session_running, NTS_MANAGER_MODULE, NTS_SIMULATION_SCHEMA_XPATH, manager_stats_get_items_cb, NULL, SR_SUBSCR_CTX_REUSE, &session_subscription);
 119     if(rc != SR_ERR_OK) {
 120         log_error("could not subscribe to oper faults");
 121         return 0;
 122     }
 123
 124     //daemonize
 125     while(!framework_sigint) {
 126         sleep(1);
 127     }
 128
 129     for(int i = 0; i < manager_installed_function_types_count; i++) {
 130         while(manager_context[i].started_instances) {
 131             manager_stop_instance(&manager_context[i]);
 132         }
 133         manager_context_free(&manager_context[i]);
 134     }
 135
 136     free(manager_context);
 137
 138     return NTS_ERR_OK;
 139 }
 140
 141 static int manager_populate_sysrepo_network_function_list(void) {
 142     //check whether everything is already populated, read and update (if previously ran)
 143     sr_val_t *values = 0;
 144     size_t value_count = 0;
 145     int rc = sr_get_items(session_running, NTS_FUNCTION_LIST_SCHEMA_XPATH, 0, 0, &values, &value_count);
 146     if(rc != SR_ERR_OK) {
 147         log_error("get items failed");
 148         return NTS_ERR_FAILED;
 149     }
 150
 151     //either get values, or if data inconclusive, delete everything
 152     if(value_count) {
 153         log_message(2, "nts-manager instances found (%d). cleaning up for fresh start...\n", value_count);
 154
 155         for(int i = 0; i < value_count; i++) {
 156             rc = sr_delete_item(session_running, values[i].xpath, 0);
 157             if(rc != SR_ERR_OK) {
 158                 log_error("sr_delete_item failed");
 159                 return NTS_ERR_FAILED;
 160             }
 161         }
 162         rc = sr_apply_changes(session_running, 0, 0);
 163         if(rc != SR_ERR_OK) {
 164             log_error("sr_apply_changes failed");
 165             return NTS_ERR_FAILED;
 166         }
 167     }
 168
 169     //populate everything if needed
 170     for(int i = 0; i < manager_installed_function_types_count; i++) {
 171         char *xpath = 0;
 172
 173         asprintf(&xpath, "%s[function-type='%s']/function-type", NTS_FUNCTION_LIST_SCHEMA_XPATH, manager_context[i].function_type_string);
 174         rc = sr_set_item_str(session_running, xpath, (const char *)manager_context[i].function_type_string, 0, 0);
 175         if(rc != SR_ERR_OK) {
 176             log_error("sr_set_item_str failed");
 177             return NTS_ERR_FAILED;
 178         }
 179         free(xpath);
 180
 181         asprintf(&xpath, "%s[function-type='%s']/started-instances", NTS_FUNCTION_LIST_SCHEMA_XPATH, manager_context[i].function_type_string);
 182         rc = sr_set_item_str(session_running, xpath, "0", 0, 0);
 183         if(rc != SR_ERR_OK) {
 184             log_error("sr_set_item_str failed");
 185             return NTS_ERR_FAILED;
 186         }
 187         free(xpath);
 188
 189         asprintf(&xpath, "%s[function-type='%s']/mounted-instances", NTS_FUNCTION_LIST_SCHEMA_XPATH, manager_context[i].function_type_string);
 190         rc = sr_set_item_str(session_running, xpath, "0", 0, 0);
 191         if(rc != SR_ERR_OK) {
 192             log_error("sr_set_item_str failed");
 193             return NTS_ERR_FAILED;
 194         }
 195         free(xpath);
 196
 197         asprintf(&xpath, "%s[function-type='%s']/mount-point-addressing-method", NTS_FUNCTION_LIST_SCHEMA_XPATH, manager_context[i].function_type_string);
 198         rc = sr_set_item_str(session_running, xpath, (const char*)manager_context[i].mount_point_addressing_method, 0, 0);
 199         if(rc != SR_ERR_OK) {
 200             log_error("sr_set_item_str failed");
 201             return NTS_ERR_FAILED;
 202         }
 203         free(xpath);
 204
 205         asprintf(&xpath, "%s[function-type='%s']/docker-instance-name", NTS_FUNCTION_LIST_SCHEMA_XPATH, manager_context[i].function_type_string);
 206         rc = sr_set_item_str(session_running, xpath, (const char*)manager_context[i].docker_instance_name, 0, 0);
 207         if(rc != SR_ERR_OK) {
 208             log_error("sr_set_item_str failed");
 209             return NTS_ERR_FAILED;
 210         }
 211         free(xpath);
 212
 213         asprintf(&xpath, "%s[function-type='%s']/docker-version-tag", NTS_FUNCTION_LIST_SCHEMA_XPATH, manager_context[i].function_type_string);
 214         rc = sr_set_item_str(session_running, xpath, (const char*)manager_context[i].docker_version_tag, 0, 0);
 215         if(rc != SR_ERR_OK) {
 216             log_error("sr_set_item_str failed");
 217             return NTS_ERR_FAILED;
 218         }
 219         free(xpath);
 220
 221         asprintf(&xpath, "%s[function-type='%s']/docker-repository", NTS_FUNCTION_LIST_SCHEMA_XPATH, manager_context[i].function_type_string);
 222         rc = sr_set_item_str(session_running, xpath, (const char*)manager_context[i].docker_repository, 0, 0);
 223         if(rc != SR_ERR_OK) {
 224             log_error("sr_set_item_str failed");
 225             return NTS_ERR_FAILED;
 226         }
 227         free(xpath);
 228     }
 229
 230     char int_to_str[30];
 231
 232     //setup sdn-controller defaults
 233     rc = sr_set_item_str(session_running, NTS_SDN_CONTROLLER_CONFIG_XPATH"/controller-ip", (const char*)framework_environment.sdn_controller_ip, 0, 0);
 234     if(rc != SR_ERR_OK) {
 235         log_error("sr_set_item_str failed");
 236         return NTS_ERR_FAILED;
 237     }
 238
 239     sprintf(int_to_str, "%d", framework_environment.sdn_controller_port);
 240     rc = sr_set_item_str(session_running, NTS_SDN_CONTROLLER_CONFIG_XPATH"/controller-port", (const char*)int_to_str, 0, 0);
 241     if(rc != SR_ERR_OK) {
 242         log_error("sr_set_item_str failed");
 243         return NTS_ERR_FAILED;
 244     }
 245
 246     sprintf(int_to_str, "%d", framework_environment.sdn_controller_callhome_port);
 247     rc = sr_set_item_str(session_running, NTS_SDN_CONTROLLER_CONFIG_XPATH"/controller-netconf-call-home-port", (const char*)int_to_str, 0, 0);
 248     if(rc != SR_ERR_OK) {
 249         log_error("sr_set_item_str failed");
 250         return NTS_ERR_FAILED;
 251     }
 252
 253     rc = sr_set_item_str(session_running, NTS_SDN_CONTROLLER_CONFIG_XPATH"/controller-username", (const char*)framework_environment.sdn_controller_username, 0, 0);
 254     if(rc != SR_ERR_OK) {
 255         log_error("sr_set_item_str failed");
 256         return NTS_ERR_FAILED;
 257     }
 258
 259     rc = sr_set_item_str(session_running, NTS_SDN_CONTROLLER_CONFIG_XPATH"/controller-password", (const char*)framework_environment.sdn_controller_password, 0, 0);
 260     if(rc != SR_ERR_OK) {
 261         log_error("sr_set_item_str failed");
 262         return NTS_ERR_FAILED;
 263     }
 264
 265     //setup ves-endpoint details
 266     rc = sr_set_item_str(session_running, NTS_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-protocol", (const char*)framework_environment.ves_endpoint_protocol, 0, 0);
 267     if(rc != SR_ERR_OK) {
 268         log_error("sr_set_item_str failed");
 269         return NTS_ERR_FAILED;
 270     }
 271
 272     rc = sr_set_item_str(session_running, NTS_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-ip", (const char*)framework_environment.ves_endpoint_ip, 0, 0);
 273     if(rc != SR_ERR_OK) {
 274         log_error("sr_set_item_str failed");
 275         return NTS_ERR_FAILED;
 276     }
 277
 278     sprintf(int_to_str, "%d", framework_environment.ves_endpoint_port);
 279     rc = sr_set_item_str(session_running, NTS_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-port", (const char*)int_to_str, 0, 0);
 280     if(rc != SR_ERR_OK) {
 281         log_error("sr_set_item_str failed");
 282         return NTS_ERR_FAILED;
 283     }
 284
 285     rc = sr_set_item_str(session_running, NTS_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-auth-method", (const char*)framework_environment.ves_endpoint_auth_method, 0, 0);
 286     if(rc != SR_ERR_OK) {
 287         log_error("sr_set_item_str failed");
 288         return NTS_ERR_FAILED;
 289     }
 290
 291     rc = sr_set_item_str(session_running, NTS_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-username", (const char*)framework_environment.ves_endpoint_username, 0, 0);
 292     if(rc != SR_ERR_OK) {
 293         log_error("sr_set_item_str failed");
 294         return NTS_ERR_FAILED;
 295     }
 296
 297     rc = sr_set_item_str(session_running, NTS_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-password", (const char*)framework_environment.ves_endpoint_password, 0, 0);
 298     if(rc != SR_ERR_OK) {
 299         log_error("sr_set_item_str failed");
 300         return NTS_ERR_FAILED;
 301     }
 302
 303     rc = sr_set_item_str(session_running, NTS_VES_ENDPOINT_CONFIG_XPATH"/ves-endpoint-certificate", (const char*)framework_environment.ves_endpoint_certificate, 0, 0);
 304     if(rc != SR_ERR_OK) {
 305         log_error("sr_set_item_str failed");
 306         return NTS_ERR_FAILED;
 307     }
 308
 309     //apply all changes
 310     rc = sr_apply_changes(session_running, 0, 0);
 311     if(rc != SR_ERR_OK) {
 312         log_error("sr_apply_changes failed");
 313         return NTS_ERR_FAILED;
 314     }
 315
 316     return NTS_ERR_OK;
 317 }
 318
 319 static int manager_populate_static_status(void) {
 320     assert_session();
 321
 322     char int_to_str[30];
 323
 324     //setup sdn-controller defaults
 325     sprintf(int_to_str, "%d", framework_environment.host_base_port);
 326     int rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/base-port", (const char*)int_to_str, 0, 0);
 327     if(rc != SR_ERR_OK) {
 328         log_error("sr_set_item_str failed");
 329         return NTS_ERR_FAILED;
 330     }
 331
 332     sprintf(int_to_str, "%d", framework_environment.ssh_connections);
 333     rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/ssh-connections", (const char*)int_to_str, 0, 0);
 334     if(rc != SR_ERR_OK) {
 335         log_error("sr_set_item_str failed");
 336         return NTS_ERR_FAILED;
 337     }
 338
 339     sprintf(int_to_str, "%d", framework_environment.tls_connections);
 340     rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/tls-connections", (const char*)int_to_str, 0, 0);
 341     if(rc != SR_ERR_OK) {
 342         log_error("sr_set_item_str failed");
 343         return NTS_ERR_FAILED;
 344     }
 345
 346     //apply all changes
 347     rc = sr_apply_changes(session_operational, 0, 0);
 348     if(rc != SR_ERR_OK) {
 349         log_error("sr_apply_changes failed");
 350         return NTS_ERR_FAILED;
 351     }
 352
 353     return NTS_ERR_OK;
 354 }
 355
 356 static void manager_context_free(manager_network_function_type *context) {
 357     assert(context);
 358
 359     free(context->function_type_string);
 360     free(context->mount_point_addressing_method);
 361     free(context->docker_instance_name);
 362     free(context->docker_version_tag);
 363     free(context->docker_repository);
 364 }
 365
 366 //take note that this happens in the sysrepo thread
 367 static int manager_process_change(int context_index, manager_network_function_type *new_context) {
 368     assert(context_index < manager_installed_function_types_count);
 369     assert(new_context);
 370
 371     manager_network_function_type *current_context = &manager_context[context_index];
 372     int rc = 0;
 373
 374     current_context->data_changed |= new_context->data_changed;
 375
 376     //process changes, and update data in current_context to resemble new_context
 377     if(new_context->docker_instance_name != 0) {
 378         free(current_context->docker_instance_name);
 379         current_context->docker_instance_name = strdup(new_context->docker_instance_name);
 380     }
 381
 382     if(new_context->docker_version_tag != 0) {
 383         free(current_context->docker_version_tag);
 384         current_context->docker_version_tag = strdup(new_context->docker_version_tag);
 385     }
 386
 387     if(new_context->docker_repository != 0) {
 388         free(current_context->docker_repository);
 389         current_context->docker_repository = strdup(new_context->docker_repository);
 390     }
 391
 392     if(new_context->mount_point_addressing_method != 0) {
 393         free(current_context->mount_point_addressing_method);
 394         current_context->mount_point_addressing_method = strdup(new_context->mount_point_addressing_method);
 395     }
 396
 397     if(new_context->started_instances != -1) {
 398         if(new_context->started_instances < current_context->started_instances) {
 399             //remove started instances
 400             while(current_context->started_instances > new_context->started_instances) {
 401                 log_message(2, "stopping instance of type %s\n", current_context->function_type_string);
 402                 rc = manager_stop_instance(current_context);
 403                 if(rc != NTS_ERR_OK) {
 404                     log_error("manager_stop_instance failed");
 405                     return NTS_ERR_FAILED;
 406                 }
 407             }
 408         }
 409         else if(new_context->started_instances > current_context->started_instances) {
 410             //add started instances
 411             while(current_context->started_instances < new_context->started_instances) {
 412                 log_message(2, "staring instance of type %s\n", current_context->function_type_string);
 413                 rc = manager_start_instance(current_context);
 414                 if(rc != NTS_ERR_OK) {
 415                     log_error("manager_start_instance failed");
 416                     return NTS_ERR_FAILED;
 417                 }
 418             }
 419         }
 420     }
 421
 422     if(new_context->mounted_instances != -1) {
 423         if(new_context->mounted_instances < current_context->mounted_instances) {
 424             //remove mounted instances
 425             while(current_context->mounted_instances > new_context->mounted_instances) {
 426                 log_message(2, "unmounting instance of type %s\n", current_context->function_type_string);
 427                 rc = manager_unmount_instance(current_context);
 428                 if(rc != NTS_ERR_OK) {
 429                     log_error("manager_unmount_instance failed");
 430                     return NTS_ERR_FAILED;
 431                 }
 432             }
 433         }
 434         else if(new_context->mounted_instances > current_context->mounted_instances) {
 435             //add mounted instances
 436             while(current_context->mounted_instances < new_context->mounted_instances) {
 437                 log_message(2, "mouting instance of type %s\n", current_context->function_type_string);
 438                 rc = manager_mount_instance(current_context);
 439                 if(rc != NTS_ERR_OK) {
 440                     log_error("manager_mount_instance failed");
 441                     return NTS_ERR_FAILED;
 442                 }
 443             }
 444         }
 445     }
 446
 447     return NTS_ERR_OK;
 448 }
 449
 450 static int manager_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) {
 451     sr_change_iter_t *it = 0;
 452     int rc = SR_ERR_OK;
 453     sr_change_oper_t oper;
 454     sr_val_t *old_value = 0;
 455     sr_val_t *new_value = 0;
 456
 457     if(event == SR_EV_CHANGE) {
 458         manager_network_function_type new_context;
 459         new_context.function_type = 0;          //not to be used. use only from current_context
 460         new_context.function_type_string = 0;   //not to be used. use only from current_context
 461         int index = -1;
 462
 463         rc = sr_get_changes_iter(session, NTS_FUNCTION_LIST_SCHEMA_XPATH"//.", &it);
 464         if(rc != SR_ERR_OK) {
 465             log_error("sr_get_changes_iter failed");
 466             return SR_ERR_VALIDATION_FAILED;
 467         }
 468
 469         while((rc = sr_get_change_next(session, it, &oper, &old_value, &new_value)) == SR_ERR_OK) {
 470             char *ov = sr_val_to_str(old_value);
 471             char *nv = sr_val_to_str(new_value);
 472
 473             //get function type and index
 474             char *function_type_string = strdup(strstr(new_value->xpath, "function-type='") + 15);
 475             *strchr(function_type_string, '\'') = 0;
 476
 477             //if context is new
 478             if((new_context.function_type_string == 0) || (strcmp(new_context.function_type_string, function_type_string) != 0)) {
 479
 480                 if(new_context.function_type_string != 0) {
 481                     if(manager_process_change(index, &new_context) != NTS_ERR_OK) {
 482                         manager_context_free(&new_context);
 483                         return SR_ERR_VALIDATION_FAILED;
 484                     }
 485
 486                     manager_context_free(&new_context);
 487                 }
 488
 489                 //-1 means no change
 490                 new_context.function_type_string = function_type_string;
 491                 new_context.started_instances = -1;
 492                 new_context.mounted_instances = -1;
 493                 new_context.mount_point_addressing_method = 0;
 494                 new_context.docker_instance_name = 0;
 495                 new_context.docker_version_tag = 0;
 496                 new_context.docker_repository = 0;
 497
 498                 new_context.data_changed = false;
 499
 500                 //find intex in manager_context[]
 501                 for(int i = 0; i < manager_installed_function_types_count; i++) {
 502                     if(strcmp(function_type_string, manager_context[i].function_type_string) == 0) {
 503                         index = i;
 504                         break;
 505                     }
 506                 }
 507             }
 508
 509             char *leaf_path  = strdup(strstr(new_value->xpath, "']/") + 3);
 510             if(strcmp(leaf_path, "started-instances") == 0) {
 511                 new_context.started_instances = new_value->data.uint16_val;
 512             }
 513             else if(strcmp(leaf_path, "mounted-instances") == 0) {
 514                 new_context.mounted_instances = new_value->data.uint16_val;
 515             }
 516             else if(strcmp(leaf_path, "mount-point-addressing-method") == 0) {
 517                 new_context.mount_point_addressing_method = strdup(nv);
 518             }
 519             else if(strcmp(leaf_path, "docker-instance-name") == 0) {
 520                 new_context.docker_instance_name = strdup(nv);
 521             }
 522             else if(strcmp(leaf_path, "docker-version-tag") == 0) {
 523                 new_context.docker_version_tag = strdup(nv);
 524             }
 525             else if(strcmp(leaf_path, "docker-repository") == 0) {
 526                 new_context.docker_repository = strdup(nv);
 527             }
 528             else {
 529                 new_context.data_changed = true;
 530             }
 531
 532             free(leaf_path);
 533             free(ov);
 534             free(nv);
 535             sr_free_val(old_value);
 536             sr_free_val(new_value);
 537         }
 538
 539         sr_free_change_iter(it);
 540
 541         if(index != -1) {
 542             if(manager_process_change(index, &new_context) != NTS_ERR_OK) {
 543                 manager_context_free(&new_context);
 544                 return SR_ERR_VALIDATION_FAILED;
 545             }
 546
 547             manager_context_free(&new_context);
 548         }
 549     }
 550     else if(event == SR_EV_DONE) {
 551         bool global_change = true;
 552
 553         rc = sr_get_changes_iter(session, NTS_SIMULATION_SCHEMA_XPATH"//.", &it);
 554         if(rc != SR_ERR_OK) {
 555             log_error("sr_get_changes_iter failed");
 556             return SR_ERR_VALIDATION_FAILED;
 557         }
 558
 559         while((rc = sr_get_change_next(session, it, &oper, &old_value, &new_value)) == SR_ERR_OK) {
 560             if(strstr(new_value->xpath, NTS_FUNCTION_LIST_SCHEMA_XPATH) == new_value->xpath) {
 561                 global_change = false;
 562                 sr_free_val(old_value);
 563                 sr_free_val(new_value);
 564                 break;
 565             }
 566
 567             sr_free_val(old_value);
 568             sr_free_val(new_value);
 569         }
 570
 571         sr_free_change_iter(it);
 572
 573         // commit all updates
 574         for(int i = 0; i < manager_installed_function_types_count; i++) {
 575             for(int j = 0; j < manager_context[i].started_instances; j++) {
 576                 if(global_change || manager_context[i].data_changed || (manager_context[i].instance[j].is_configured == false)) {
 577                     log_message(2, "configuring instance %d of type %s\n", j, manager_context[i].function_type_string);
 578                     rc = manager_config_instance(&manager_context[i], &manager_context[i].instance[j]);
 579                     if(rc != NTS_ERR_OK) {
 580                         log_error("manager_config_instance failed");
 581                     }
 582                 }
 583             }
 584
 585             manager_context[i].data_changed = false;
 586         }
 587         global_change = false;
 588     }
 589
 590     return SR_ERR_OK;
 591 }
 592
 593 static int manager_instances_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) {
 594
 595     char value[100];
 596
 597     *parent = lyd_new_path(NULL, sr_get_context(sr_session_get_connection(session)), NTS_FUNCTION_LIST_SCHEMA_XPATH, 0, 0, 0);
 598     if(*parent == 0) {
 599         return SR_ERR_OPERATION_FAILED;
 600     }
 601
 602     for(int i = 0; i < manager_installed_function_types_count; i++) {
 603         char *ftype_path = 0;
 604         asprintf(&ftype_path, "%s[function-type='%s']/instances/instance", NTS_FUNCTION_LIST_SCHEMA_XPATH, manager_context[i].function_type_string);
 605         for(int j = 0; j < manager_context[i].started_instances; j++) {
 606             char *instance_path = 0;
 607             asprintf(&instance_path, "%s[name='%s']", ftype_path, manager_context[i].instance[j].name);
 608
 609             char *full_path = 0;
 610
 611             asprintf(&full_path, "%s/mount-point-addressing-method", instance_path);
 612             if(lyd_new_path(*parent, NULL, full_path, manager_context[i].instance[j].mount_point_addressing_method, 0, 0) == 0) {
 613                 return SR_ERR_OPERATION_FAILED;
 614             }
 615             free(full_path);
 616
 617             asprintf(&full_path, "%s/networking/docker-ip", instance_path);
 618             if(lyd_new_path(*parent, NULL, full_path, manager_context[i].instance[j].docker_ip, 0, 0) == 0) {
 619                 return SR_ERR_OPERATION_FAILED;
 620             }
 621             free(full_path);
 622
 623             asprintf(&full_path, "%s/networking/docker-port", instance_path);
 624             sprintf(value, "%d", manager_context[i].instance[j].docker_port);
 625             if(lyd_new_path(*parent, NULL, full_path, value, 0, 0) == 0) {
 626                 return SR_ERR_OPERATION_FAILED;
 627             }
 628             free(full_path);
 629
 630             asprintf(&full_path, "%s/networking/host-ip", instance_path);
 631             if(lyd_new_path(*parent, NULL, full_path, manager_context[i].instance[j].host_ip, 0, 0) == 0) {
 632                 return SR_ERR_OPERATION_FAILED;
 633             }
 634             free(full_path);
 635
 636             asprintf(&full_path, "%s/networking/host-port", instance_path);
 637             sprintf(value, "%d", manager_context[i].instance[j].host_port);
 638             if(lyd_new_path(*parent, NULL, full_path, value, 0, 0) == 0) {
 639                 return SR_ERR_OPERATION_FAILED;
 640             }
 641             free(full_path);
 642
 643             free(instance_path);
 644         }
 645         free(ftype_path);
 646     }
 647
 648     return SR_ERR_OK;
 649 }
 650
 651 static int manager_stats_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) {
 652
 653     char value[128];
 654
 655     *parent = lyd_new_path(NULL, sr_get_context(sr_session_get_connection(session)), NTS_SIMULATION_SCHEMA_XPATH, 0, 0, 0);
 656     if(*parent == 0) {
 657         return SR_ERR_OPERATION_FAILED;
 658     }
 659
 660     docker_usage_t usage = docker_usage_get(manager_context, manager_installed_function_types_count);
 661
 662     sprintf(value, "%.2f", usage.cpu);
 663     if(lyd_new_path(*parent, NULL, NTS_SIMULATION_SCHEMA_XPATH"/cpu-usage", value, 0, 0) == 0) {
 664         return SR_ERR_OPERATION_FAILED;
 665     }
 666
 667     sprintf(value, "%.0f", usage.mem);
 668     if(lyd_new_path(*parent, NULL, NTS_SIMULATION_SCHEMA_XPATH"/mem-usage", value, 0, 0) == 0) {
 669         return SR_ERR_OPERATION_FAILED;
 670     }
 671
 672     return SR_ERR_OK;
 673 }