1 /*************************************************************************
3 * Copyright 2020 highstreet technologies GmbH and others
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
9 * http://www.apache.org/licenses/LICENSE-2.0
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 ***************************************************************************/
21 #include "utils/log_utils.h"
22 #include "utils/sys_utils.h"
26 #include "core/framework.h"
27 #include "core/session.h"
29 static int manager_context_sync = 0;
31 int manager_sr_get_context_sync(void) {
32 return manager_context_sync;
35 int manager_sr_update_context(manager_context_t *ctx) {
42 //setup sdn-controller defaults
43 sprintf(xpath, NTS_FUNCTION_LIST_SCHEMA_XPATH"[function-type='%s']/started-instances", ctx->function_type);
44 sprintf(int_to_str, "%d", ctx->started_instances);
45 int rc = sr_set_item_str(session_running, xpath, (const char*)int_to_str, 0, 0);
47 log_error("sr_set_item_str failed\n");
48 return NTS_ERR_FAILED;
51 sprintf(xpath, NTS_FUNCTION_LIST_SCHEMA_XPATH"[function-type='%s']/mounted-instances", ctx->function_type);
52 sprintf(int_to_str, "%d", ctx->mounted_instances);
53 rc = sr_set_item_str(session_running, xpath, (const char*)int_to_str, 0, 0);
55 log_error("sr_set_item_str failed\n");
56 return NTS_ERR_FAILED;
59 manager_context_sync = 1;
62 rc = sr_apply_changes(session_running, 0, 0);
64 log_error("sr_apply_changes failed\n");
65 return NTS_ERR_FAILED;
68 manager_context_sync = 0;
73 int manager_sr_on_last_operation_status(const char *status, const char *errmsg) {
76 int rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/last-operation-status", status, 0, 0);
78 log_error("sr_set_item_str failed\n");
79 return NTS_ERR_FAILED;
83 rc = sr_apply_changes(session_operational, 0, 0);
85 log_error("sr_apply_changes failed\n");
86 return NTS_ERR_FAILED;
90 const struct lys_module *manager_module = ly_ctx_get_module(session_context, NTS_MANAGER_MODULE, 0, 0);
91 if(manager_module == 0) {
92 log_error("ly_ctx_get_module failed\n");
93 return NTS_ERR_FAILED;
96 struct lyd_node *notif = lyd_new(0, manager_module, "operation-status-changed");
98 log_error("lyd_new failed\n");
99 return NTS_ERR_FAILED;
102 lyd_new_leaf(notif, manager_module, "operation-status", status);
103 if(errmsg && errmsg[0]) {
104 lyd_new_leaf(notif, manager_module, "error-message", errmsg);
107 rc = sr_event_notif_send_tree(session_running, notif);
108 if(rc != SR_ERR_OK) {
109 log_error("sr_event_notif_send_tree failed\n");
110 return NTS_ERR_FAILED;
116 int manager_sr_notif_send_instance_changed(const char *status, const char *function_type, const char *name, const manager_network_function_instance_t* instance) {
118 assert(function_type);
122 const struct lys_module *manager_module = ly_ctx_get_module(session_context, NTS_MANAGER_MODULE, 0, 0);
123 if(manager_module == 0) {
124 log_error("ly_ctx_get_module failed\n");
125 return NTS_ERR_FAILED;
128 struct lyd_node *notif = lyd_new(0, manager_module, "instance-changed");
130 log_error("lyd_new failed\n");
131 return NTS_ERR_FAILED;
134 if(lyd_new_leaf(notif, manager_module, "change-status", status) == 0) {
135 log_error("lyd_new_leaf error\n");
136 return NTS_ERR_FAILED;
139 if(lyd_new_leaf(notif, manager_module, "function-type", function_type) == 0) {
140 log_error("lyd_new_leaf error\n");
141 return NTS_ERR_FAILED;
144 if(lyd_new_leaf(notif, manager_module, "name", name) == 0) {
145 log_error("lyd_new_leaf error\n");
146 return NTS_ERR_FAILED;
150 if(manager_sr_populate_networking(notif, instance) != NTS_ERR_OK) {
151 log_error("manager_sr_populate_networking error\n");
152 return NTS_ERR_FAILED;
156 int rc = sr_event_notif_send_tree(session_running, notif);
157 if(rc != SR_ERR_OK) {
158 log_error("sr_event_notif_send_tree failed\n");
159 return NTS_ERR_FAILED;
166 int manager_sr_update_static_stats(void) {
171 sprintf(int_to_str, "%d", framework_environment.host.ssh_base_port);
172 rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/ports/netconf-ssh-port", (const char*)int_to_str, 0, 0);
173 if(rc != SR_ERR_OK) {
174 log_error("sr_set_item_str failed\n");
175 return NTS_ERR_FAILED;
178 sprintf(int_to_str, "%d", framework_environment.host.tls_base_port);
179 rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/ports/netconf-tls-port", (const char*)int_to_str, 0, 0);
180 if(rc != SR_ERR_OK) {
181 log_error("sr_set_item_str failed\n");
182 return NTS_ERR_FAILED;
185 sprintf(int_to_str, "%d", framework_environment.host.ftp_base_port);
186 rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/ports/transport-ftp-port", (const char*)int_to_str, 0, 0);
187 if(rc != SR_ERR_OK) {
188 log_error("sr_set_item_str failed\n");
189 return NTS_ERR_FAILED;
192 sprintf(int_to_str, "%d", framework_environment.host.sftp_base_port);
193 rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/ports/transport-sftp-port", (const char*)int_to_str, 0, 0);
194 if(rc != SR_ERR_OK) {
195 log_error("sr_set_item_str failed\n");
196 return NTS_ERR_FAILED;
199 sprintf(int_to_str, "%d", framework_environment.settings.ssh_connections);
200 rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/ssh-connections", (const char*)int_to_str, 0, 0);
201 if(rc != SR_ERR_OK) {
202 log_error("sr_set_item_str failed\n");
203 return NTS_ERR_FAILED;
206 sprintf(int_to_str, "%d", framework_environment.settings.tls_connections);
207 rc = sr_set_item_str(session_operational, NTS_SIMULATION_SCHEMA_XPATH"/tls-connections", (const char*)int_to_str, 0, 0);
208 if(rc != SR_ERR_OK) {
209 log_error("sr_set_item_str failed\n");
210 return NTS_ERR_FAILED;
214 rc = sr_apply_changes(session_operational, 0, 0);
215 if(rc != SR_ERR_OK) {
216 log_error("sr_apply_changes failed: %s\n", sr_strerror(rc));
217 return NTS_ERR_FAILED;
223 int manager_sr_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) {
226 *parent = lyd_new_path(NULL, sr_get_context(sr_session_get_connection(session)), NTS_SIMULATION_SCHEMA_XPATH, 0, 0, 0);
228 log_error("lyd_new_path failed\n");
229 return SR_ERR_OPERATION_FAILED;
232 int docker_instances_count = 0;
233 for(int i = 0; i < docker_context_count; i++) {
234 docker_instances_count += manager_context[i].started_instances;
237 const char **instances_id = malloc(sizeof(char *) * docker_instances_count);
238 if(instances_id == 0) {
239 log_error("malloc failed\n");
240 return SR_ERR_OPERATION_FAILED;
244 for(int i = 0; i < docker_context_count; i++) {
245 for(int j = 0; j < manager_context[i].started_instances; j++) {
246 instances_id[k] = manager_context[i].instance[j].container.id;
251 docker_usage_t usage;
252 int rc = docker_usage_get(instances_id, docker_instances_count, &usage);
254 if(rc != NTS_ERR_OK) {
255 log_error("docker_usage_get failed\n");
256 return SR_ERR_OPERATION_FAILED;
259 sprintf(value, "%.2f", usage.cpu);
260 if(lyd_new_path(*parent, NULL, NTS_SIMULATION_SCHEMA_XPATH"/cpu-usage", value, 0, 0) == 0) {
261 log_error("lyd_new_path failed\n");
262 return SR_ERR_OPERATION_FAILED;
265 sprintf(value, "%.0f", usage.mem);
266 if(lyd_new_path(*parent, NULL, NTS_SIMULATION_SCHEMA_XPATH"/mem-usage", value, 0, 0) == 0) {
267 log_error("lyd_new_path failed\n");
268 return SR_ERR_OPERATION_FAILED;
274 int manager_sr_populate_networking(struct lyd_node *parent, const manager_network_function_instance_t* instance) {
279 struct lyd_node *networking = lyd_new(parent, parent->schema->module, "networking");
280 if(networking == 0) {
281 log_error("lyd_new failed\n");
282 return NTS_ERR_FAILED;
285 if(lyd_new_leaf(networking, parent->schema->module, "docker-ip", instance->container.docker_ip) == 0) {
286 log_error("lyd_new_leaf failed\n");
287 return NTS_ERR_FAILED;
290 if(lyd_new_leaf(networking, parent->schema->module, "host-ip", instance->container.host_ip) == 0) {
291 log_error("lyd_new_leaf failed\n");
292 return NTS_ERR_FAILED;
296 for(int k = 0; k < framework_environment.settings.ssh_connections; k++) {
299 struct lyd_node *ports = lyd_new(networking, parent->schema->module, "docker-ports");
301 log_error("lyd_new failed\n");
302 return NTS_ERR_FAILED;
305 sprintf(value, "%d", instance->container.docker_netconf_ssh_port + k);
306 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
307 log_error("lyd_new_leaf failed\n");
308 return NTS_ERR_FAILED;
311 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "NTS_PROTOCOL_TYPE_NETCONF_SSH") == 0) {
312 log_error("lyd_new_leaf failed\n");
313 return NTS_ERR_FAILED;
317 ports = lyd_new(networking, parent->schema->module, "host-ports");
319 log_error("lyd_new failed\n");
320 return NTS_ERR_FAILED;
323 sprintf(value, "%d", instance->container.host_netconf_ssh_port + k);
324 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
325 log_error("lyd_new_leaf failed\n");
326 return NTS_ERR_FAILED;
329 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "NTS_PROTOCOL_TYPE_NETCONF_SSH") == 0) {
330 log_error("lyd_new_leaf failed\n");
331 return NTS_ERR_FAILED;
336 for(int k = 0; k < framework_environment.settings.tls_connections; k++) {
339 struct lyd_node *ports = lyd_new(networking, parent->schema->module, "docker-ports");
341 log_error("lyd_new failed\n");
342 return NTS_ERR_FAILED;
345 sprintf(value, "%d", instance->container.docker_netconf_tls_port + k);
346 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
347 log_error("lyd_new_leaf failed\n");
348 return NTS_ERR_FAILED;
351 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "NTS_PROTOCOL_TYPE_NETCONF_TLS") == 0) {
352 log_error("lyd_new_leaf failed\n");
353 return NTS_ERR_FAILED;
357 ports = lyd_new(networking, parent->schema->module, "host-ports");
359 log_error("lyd_new failed\n");
360 return NTS_ERR_FAILED;
363 sprintf(value, "%d", instance->container.host_netconf_tls_port + k);
364 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
365 log_error("lyd_new_leaf failed\n");
366 return NTS_ERR_FAILED;
369 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "NTS_PROTOCOL_TYPE_NETCONF_TLS") == 0) {
370 log_error("lyd_new_leaf failed\n");
371 return NTS_ERR_FAILED;
376 for(int k = 0; k < framework_environment.settings.ftp_connections; k++) {
379 struct lyd_node *ports = lyd_new(networking, parent->schema->module, "docker-ports");
381 log_error("lyd_new failed\n");
382 return NTS_ERR_FAILED;
385 sprintf(value, "%d", instance->container.docker_ftp_port + k);
386 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
387 log_error("lyd_new_leaf failed\n");
388 return NTS_ERR_FAILED;
391 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "NTS_PROTOCOL_TYPE_FTP") == 0) {
392 log_error("lyd_new_leaf failed\n");
393 return NTS_ERR_FAILED;
397 ports = lyd_new(networking, parent->schema->module, "host-ports");
399 log_error("lyd_new failed\n");
400 return NTS_ERR_FAILED;
403 sprintf(value, "%d", instance->container.host_ftp_port + k);
404 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
405 log_error("lyd_new_leaf failed\n");
406 return NTS_ERR_FAILED;
409 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "NTS_PROTOCOL_TYPE_FTP") == 0) {
410 log_error("lyd_new_leaf failed\n");
411 return NTS_ERR_FAILED;
416 for(int k = 0; k < framework_environment.settings.sftp_connections; k++) {
419 struct lyd_node *ports = lyd_new(networking, parent->schema->module, "docker-ports");
421 log_error("lyd_new failed\n");
422 return NTS_ERR_FAILED;
425 sprintf(value, "%d", instance->container.docker_sftp_port + k);
426 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
427 log_error("lyd_new_leaf failed\n");
428 return NTS_ERR_FAILED;
431 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "NTS_PROTOCOL_TYPE_SFTP") == 0) {
432 log_error("lyd_new_leaf failed\n");
433 return NTS_ERR_FAILED;
437 ports = lyd_new(networking, parent->schema->module, "host-ports");
439 log_error("lyd_new failed\n");
440 return NTS_ERR_FAILED;
443 sprintf(value, "%d", instance->container.host_sftp_port + k);
444 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
445 log_error("lyd_new_leaf failed\n");
446 return NTS_ERR_FAILED;
449 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "NTS_PROTOCOL_TYPE_SFTP") == 0) {
450 log_error("lyd_new_leaf failed\n");
451 return NTS_ERR_FAILED;