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"
28 #include "core/xpath.h"
30 static int manager_context_sync = 0;
32 int manager_sr_get_context_sync(void) {
33 return manager_context_sync;
36 int manager_sr_update_context(manager_context_t *ctx) {
43 //setup sdn-controller defaults
44 sprintf(xpath, NTS_MANAGER_FUNCTION_LIST_SCHEMA_XPATH"[function-type='%s']/started-instances", ctx->function_type);
45 sprintf(int_to_str, "%d", ctx->started_instances);
46 int rc = sr_set_item_str(session_running, xpath, (const char*)int_to_str, 0, 0);
48 log_error("sr_set_item_str failed\n");
49 return NTS_ERR_FAILED;
52 sprintf(xpath, NTS_MANAGER_FUNCTION_LIST_SCHEMA_XPATH"[function-type='%s']/mounted-instances", ctx->function_type);
53 sprintf(int_to_str, "%d", ctx->mounted_instances);
54 rc = sr_set_item_str(session_running, xpath, (const char*)int_to_str, 0, 0);
56 log_error("sr_set_item_str failed\n");
57 return NTS_ERR_FAILED;
60 manager_context_sync = 1;
63 rc = sr_apply_changes(session_running, 0, 0);
65 log_error("sr_apply_changes failed\n");
66 return NTS_ERR_FAILED;
69 manager_context_sync = 0;
74 int manager_sr_on_last_operation_status(const char *status, const char *errmsg) {
77 int rc = sr_set_item_str(session_operational, NTS_MANAGER_SIMULATION_SCHEMA_XPATH"/last-operation-status", status, 0, 0);
79 log_error("sr_set_item_str failed\n");
80 return NTS_ERR_FAILED;
84 rc = sr_apply_changes(session_operational, 0, 0);
86 log_error("sr_apply_changes failed\n");
87 return NTS_ERR_FAILED;
91 const struct lys_module *manager_module = ly_ctx_get_module(session_context, NTS_MANAGER_MODULE, 0, 0);
92 if(manager_module == 0) {
93 log_error("ly_ctx_get_module failed\n");
94 return NTS_ERR_FAILED;
97 struct lyd_node *notif = lyd_new(0, manager_module, "operation-status-changed");
99 log_error("lyd_new failed\n");
100 return NTS_ERR_FAILED;
103 lyd_new_leaf(notif, manager_module, "operation-status", status);
104 if(errmsg && errmsg[0]) {
105 lyd_new_leaf(notif, manager_module, "error-message", errmsg);
108 rc = sr_event_notif_send_tree(session_running, notif);
109 if(rc != SR_ERR_OK) {
110 log_error("sr_event_notif_send_tree failed\n");
111 return NTS_ERR_FAILED;
117 int manager_sr_notif_send_instance_changed(const char *status, const char *function_type, const char *name, const manager_network_function_instance_t* instance) {
119 assert(function_type);
123 const struct lys_module *manager_module = ly_ctx_get_module(session_context, NTS_MANAGER_MODULE, 0, 0);
124 if(manager_module == 0) {
125 log_error("ly_ctx_get_module failed\n");
126 return NTS_ERR_FAILED;
129 struct lyd_node *notif = lyd_new(0, manager_module, "instance-changed");
131 log_error("lyd_new failed\n");
132 return NTS_ERR_FAILED;
135 if(lyd_new_leaf(notif, manager_module, "change-status", status) == 0) {
136 log_error("lyd_new_leaf error\n");
137 return NTS_ERR_FAILED;
140 if(lyd_new_leaf(notif, manager_module, "function-type", function_type) == 0) {
141 log_error("lyd_new_leaf error\n");
142 return NTS_ERR_FAILED;
145 if(lyd_new_leaf(notif, manager_module, "name", name) == 0) {
146 log_error("lyd_new_leaf error\n");
147 return NTS_ERR_FAILED;
151 if(manager_sr_populate_networking(notif, instance) != NTS_ERR_OK) {
152 log_error("manager_sr_populate_networking error\n");
153 return NTS_ERR_FAILED;
157 int rc = sr_event_notif_send_tree(session_running, notif);
158 if(rc != SR_ERR_OK) {
159 log_error("sr_event_notif_send_tree failed\n");
160 return NTS_ERR_FAILED;
167 int manager_sr_update_static_stats(void) {
172 sprintf(int_to_str, "%d", framework_environment.host.ssh_base_port);
173 rc = sr_set_item_str(session_operational, NTS_MANAGER_SIMULATION_SCHEMA_XPATH"/ports/netconf-ssh-port", (const char*)int_to_str, 0, 0);
174 if(rc != SR_ERR_OK) {
175 log_error("sr_set_item_str failed\n");
176 return NTS_ERR_FAILED;
179 sprintf(int_to_str, "%d", framework_environment.host.tls_base_port);
180 rc = sr_set_item_str(session_operational, NTS_MANAGER_SIMULATION_SCHEMA_XPATH"/ports/netconf-tls-port", (const char*)int_to_str, 0, 0);
181 if(rc != SR_ERR_OK) {
182 log_error("sr_set_item_str failed\n");
183 return NTS_ERR_FAILED;
186 sprintf(int_to_str, "%d", framework_environment.host.ftp_base_port);
187 rc = sr_set_item_str(session_operational, NTS_MANAGER_SIMULATION_SCHEMA_XPATH"/ports/transport-ftp-port", (const char*)int_to_str, 0, 0);
188 if(rc != SR_ERR_OK) {
189 log_error("sr_set_item_str failed\n");
190 return NTS_ERR_FAILED;
193 sprintf(int_to_str, "%d", framework_environment.host.sftp_base_port);
194 rc = sr_set_item_str(session_operational, NTS_MANAGER_SIMULATION_SCHEMA_XPATH"/ports/transport-sftp-port", (const char*)int_to_str, 0, 0);
195 if(rc != SR_ERR_OK) {
196 log_error("sr_set_item_str failed\n");
197 return NTS_ERR_FAILED;
200 sprintf(int_to_str, "%d", framework_environment.settings.ssh_connections);
201 rc = sr_set_item_str(session_operational, NTS_MANAGER_SIMULATION_SCHEMA_XPATH"/ssh-connections", (const char*)int_to_str, 0, 0);
202 if(rc != SR_ERR_OK) {
203 log_error("sr_set_item_str failed\n");
204 return NTS_ERR_FAILED;
207 sprintf(int_to_str, "%d", framework_environment.settings.tls_connections);
208 rc = sr_set_item_str(session_operational, NTS_MANAGER_SIMULATION_SCHEMA_XPATH"/tls-connections", (const char*)int_to_str, 0, 0);
209 if(rc != SR_ERR_OK) {
210 log_error("sr_set_item_str failed\n");
211 return NTS_ERR_FAILED;
215 rc = sr_apply_changes(session_operational, 0, 0);
216 if(rc != SR_ERR_OK) {
217 log_error("sr_apply_changes failed: %s\n", sr_strerror(rc));
218 return NTS_ERR_FAILED;
224 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) {
227 *parent = lyd_new_path(NULL, sr_get_context(sr_session_get_connection(session)), NTS_MANAGER_SIMULATION_SCHEMA_XPATH, 0, 0, 0);
229 log_error("lyd_new_path failed\n");
230 return SR_ERR_OPERATION_FAILED;
233 int docker_instances_count = 0;
234 for(int i = 0; i < docker_context_count; i++) {
235 docker_instances_count += manager_context[i].started_instances;
238 const char **instances_id = malloc(sizeof(char *) * docker_instances_count);
239 if(instances_id == 0) {
240 log_error("malloc failed\n");
241 return SR_ERR_OPERATION_FAILED;
245 for(int i = 0; i < docker_context_count; i++) {
246 for(int j = 0; j < manager_context[i].started_instances; j++) {
247 instances_id[k] = manager_context[i].instance[j].container.id;
252 docker_usage_t usage;
253 int rc = docker_usage_get(instances_id, docker_instances_count, &usage);
255 if(rc != NTS_ERR_OK) {
256 log_error("docker_usage_get failed\n");
257 return SR_ERR_OPERATION_FAILED;
260 sprintf(value, "%.2f", usage.cpu);
261 if(lyd_new_path(*parent, NULL, NTS_MANAGER_SIMULATION_SCHEMA_XPATH"/cpu-usage", value, 0, 0) == 0) {
262 log_error("lyd_new_path failed\n");
263 return SR_ERR_OPERATION_FAILED;
266 sprintf(value, "%.0f", usage.mem);
267 if(lyd_new_path(*parent, NULL, NTS_MANAGER_SIMULATION_SCHEMA_XPATH"/mem-usage", value, 0, 0) == 0) {
268 log_error("lyd_new_path failed\n");
269 return SR_ERR_OPERATION_FAILED;
275 int manager_sr_populate_networking(struct lyd_node *parent, const manager_network_function_instance_t* instance) {
280 struct lyd_node *networking = lyd_new(parent, parent->schema->module, "networking");
281 if(networking == 0) {
282 log_error("lyd_new failed\n");
283 return NTS_ERR_FAILED;
286 if(lyd_new_leaf(networking, parent->schema->module, "docker-ip", instance->container.docker_ip) == 0) {
287 log_error("lyd_new_leaf failed\n");
288 return NTS_ERR_FAILED;
291 if(lyd_new_leaf(networking, parent->schema->module, "host-ip", instance->container.host_ip) == 0) {
292 log_error("lyd_new_leaf failed\n");
293 return NTS_ERR_FAILED;
297 for(int k = 0; k < framework_environment.settings.ssh_connections; k++) {
300 struct lyd_node *ports = lyd_new(networking, parent->schema->module, "docker-ports");
302 log_error("lyd_new failed\n");
303 return NTS_ERR_FAILED;
306 sprintf(value, "%d", instance->container.docker_netconf_ssh_port + k);
307 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
308 log_error("lyd_new_leaf failed\n");
309 return NTS_ERR_FAILED;
312 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "nts-common:NTS_PROTOCOL_TYPE_NETCONF_SSH") == 0) {
313 log_error("lyd_new_leaf failed\n");
314 return NTS_ERR_FAILED;
318 ports = lyd_new(networking, parent->schema->module, "host-ports");
320 log_error("lyd_new failed\n");
321 return NTS_ERR_FAILED;
324 sprintf(value, "%d", instance->container.host_netconf_ssh_port + k);
325 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
326 log_error("lyd_new_leaf failed\n");
327 return NTS_ERR_FAILED;
330 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "nts-common:NTS_PROTOCOL_TYPE_NETCONF_SSH") == 0) {
331 log_error("lyd_new_leaf failed\n");
332 return NTS_ERR_FAILED;
337 for(int k = 0; k < framework_environment.settings.tls_connections; k++) {
340 struct lyd_node *ports = lyd_new(networking, parent->schema->module, "docker-ports");
342 log_error("lyd_new failed\n");
343 return NTS_ERR_FAILED;
346 sprintf(value, "%d", instance->container.docker_netconf_tls_port + k);
347 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
348 log_error("lyd_new_leaf failed\n");
349 return NTS_ERR_FAILED;
352 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "nts-common:NTS_PROTOCOL_TYPE_NETCONF_TLS") == 0) {
353 log_error("lyd_new_leaf failed\n");
354 return NTS_ERR_FAILED;
358 ports = lyd_new(networking, parent->schema->module, "host-ports");
360 log_error("lyd_new failed\n");
361 return NTS_ERR_FAILED;
364 sprintf(value, "%d", instance->container.host_netconf_tls_port + k);
365 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
366 log_error("lyd_new_leaf failed\n");
367 return NTS_ERR_FAILED;
370 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "nts-common:NTS_PROTOCOL_TYPE_NETCONF_TLS") == 0) {
371 log_error("lyd_new_leaf failed\n");
372 return NTS_ERR_FAILED;
377 for(int k = 0; k < framework_environment.settings.ftp_connections; k++) {
380 struct lyd_node *ports = lyd_new(networking, parent->schema->module, "docker-ports");
382 log_error("lyd_new failed\n");
383 return NTS_ERR_FAILED;
386 sprintf(value, "%d", instance->container.docker_ftp_port + k);
387 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
388 log_error("lyd_new_leaf failed\n");
389 return NTS_ERR_FAILED;
392 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "nts-common:NTS_PROTOCOL_TYPE_FTP") == 0) {
393 log_error("lyd_new_leaf failed\n");
394 return NTS_ERR_FAILED;
398 ports = lyd_new(networking, parent->schema->module, "host-ports");
400 log_error("lyd_new failed\n");
401 return NTS_ERR_FAILED;
404 sprintf(value, "%d", instance->container.host_ftp_port + k);
405 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
406 log_error("lyd_new_leaf failed\n");
407 return NTS_ERR_FAILED;
410 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "nts-common:NTS_PROTOCOL_TYPE_FTP") == 0) {
411 log_error("lyd_new_leaf failed\n");
412 return NTS_ERR_FAILED;
417 for(int k = 0; k < framework_environment.settings.sftp_connections; k++) {
420 struct lyd_node *ports = lyd_new(networking, parent->schema->module, "docker-ports");
422 log_error("lyd_new failed\n");
423 return NTS_ERR_FAILED;
426 sprintf(value, "%d", instance->container.docker_sftp_port + k);
427 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
428 log_error("lyd_new_leaf failed\n");
429 return NTS_ERR_FAILED;
432 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "nts-common:NTS_PROTOCOL_TYPE_SFTP") == 0) {
433 log_error("lyd_new_leaf failed\n");
434 return NTS_ERR_FAILED;
438 ports = lyd_new(networking, parent->schema->module, "host-ports");
440 log_error("lyd_new failed\n");
441 return NTS_ERR_FAILED;
444 sprintf(value, "%d", instance->container.host_sftp_port + k);
445 if(lyd_new_leaf(ports, ports->schema->module, "port", value) == 0) {
446 log_error("lyd_new_leaf failed\n");
447 return NTS_ERR_FAILED;
450 if(lyd_new_leaf(ports, ports->schema->module, "protocol", "nts-common:NTS_PROTOCOL_TYPE_SFTP") == 0) {
451 log_error("lyd_new_leaf failed\n");
452 return NTS_ERR_FAILED;