#include "populate_dm_startup.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <amxc/amxc_macros.h>
#include <amxc/amxc.h>
#include <amxp/amxp_timer.h>
#include "data_model.h"
#include "dm_info.h"
#include "pon_ctrl.h"
#include "xpon_mgr_constants.h"
#include "xpon_trace.h"

Data Structures
struct	_task

Macros
#define	QUERY_ONUS_INTERVAL_MS 10000

#define	QUERY_ONUS_NR_TIMES 30

Typedefs
typedef enum _task_type	task_type_t

typedef struct _task	task_t

Enumerations
enum	_task_type { task_none , task_query_indexes , task_query_content , task_type_nr }

Functions
static const char *	task_type_to_string (task_type_t type)

static void	task_init (task_t const task, const char const path, uint32_t index, task_type_t type)

static void	task_clean (task_t *const task)

static task_t *	task_create (const char *const path, uint32_t index, task_type_t type)

static void	task_delete (amxc_llist_it_t *hit)

static bool	check_return_values (int rc, const amxc_var_t const ret, const char func, const char *const path, uint32_t index)

static void	query_children (const char *const path, uint32_t index, object_id_t id, bool templates)

static void	query_content (const task_t *task)

static void	query_indexes (const task_t *task)

static void	schedule_remaining_tasks (void)

static void	handle_task (UNUSED amxp_timer_t timer, UNUSED void priv)

static void	query_onu_instances (amxp_timer_t timer, UNUSED void priv)

bool	pplt_dm_init (void)

void	pplt_dm_cleanup (void)

Variables
static amxp_timer_t *	s_timer_query_onus = NULL

static uint32_t	s_cntr_query_onus = 0

static amxc_llist_t	s_tasks = { 0 }

static amxp_timer_t *	s_timer_handle_tasks = NULL

static bool	s_onu_initialised [MAX_NR_OF_ONUS] = { 0 }

Macro Definition Documentation

◆ QUERY_ONUS_INTERVAL_MS

#define QUERY_ONUS_INTERVAL_MS 10000

Query ONU instances every 10 s during the first 5 minutes after startup.

30 intervals of 10 s corresponds to 5 minutes.

Definition at line 104 of file populate_dm_startup.c.

◆ QUERY_ONUS_NR_TIMES

#define QUERY_ONUS_NR_TIMES 30

Definition at line 105 of file populate_dm_startup.c.

Typedef Documentation

◆ task_t

typedef struct _task task_t

A task to help in populating the XPON DM after startup.

path object path, e.g. "XPON.ONU"
index index instance for a template object. 0 if not applicable.
type task type. See task_type_t.
it to put a task in the list 's_tasks'

If 'path' refers to a template object, then:

'index' is 0 (not applicable) if 'type' is 'task_query_indexes': the task will query the instances of the template object. The task is not for a specific instance of the template object.
'index' is an actual instance index if type is 'task_query_content'.

◆ task_type_t

typedef enum _task_type task_type_t

Task type.

When populating the XPON DM at startup, the plugin schedules 2 types of tasks:

tasks to find out which instances it should create for a template object, e.g., for an object such as "XPON.ONU". They have 'task_query_indexes' as type.
tasks to query the values to be assigned to the params of the object. They have 'task_query_content' as type.

Enumeration Type Documentation

◆ _task_type

enum _task_type

Task type.

When populating the XPON DM at startup, the plugin schedules 2 types of tasks:

tasks to find out which instances it should create for a template object, e.g., for an object such as "XPON.ONU". They have 'task_query_indexes' as type.
tasks to query the values to be assigned to the params of the object. They have 'task_query_content' as type.

Enumerator
task_none
task_query_indexes
task_query_content
task_type_nr

Definition at line 119 of file populate_dm_startup.c.

                         {
     task_none,
     task_query_indexes,
     task_query_content,
     task_type_nr
 } task_type_t;

Function Documentation

◆ check_return_values()

static bool check_return_values	(	int	rc,
		const amxc_var_t *const	ret,
		const char *	func,
		const char *const	path,
		uint32_t	index
	)

static

Do basic checks on the return values of a call towards the vendor module.

Parameters

[in]	rc	return code of the call towards the vendor module.
[in]	ret	result returned by vendor module
[in]	func	name of the function called in the vendor module. For logging only.
[in]	path	object path for which function was called. This can refer to a singleton or template object. For logging only.
[in]	index	if function was called for an instance, this parameter is the instance index. It must be 0 if the function was called for a singleton. For logging only.

The function returns false if:

rc is not 0
ret is not an htable

Returns: true if function call towards the vendor module is ok according to the 1st checks done by this function, else false

Definition at line 225 of file populate_dm_startup.c.

                                                 {
     bool rv = false;
  
     amxc_string_t buf; /* for logging only */
     amxc_string_init(&buf, 0);
  
     if(index) {
         amxc_string_setf(&buf, "%s(%s.%d)", func, path, index);
     } else {
         amxc_string_setf(&buf, "%s(%s)", func, path);
     }
     const char* const fc = amxc_string_get(&buf, 0); /*function call */
  
     if(rc) {
         SAH_TRACEZ_ERROR(ME, "%s failed: rc=%d", fc, rc);
         goto exit;
     }
  
     const uint32_t type = amxc_var_type_of(ret);
     if(type != AMXC_VAR_ID_HTABLE) {
         SAH_TRACEZ_ERROR(ME, "%s: type of 'ret'= %d != htable", fc, type);
         goto exit;
     }
     rv = true;
 exit:
     amxc_string_clean(&buf);
     return rv;
 }

Here is the caller graph for this function:

◆ handle_task()

static void handle_task	(	UNUSED amxp_timer_t *	timer,
		UNUSED void *	priv
	)

static

Handle the 1st task from s_tasks, remove it from the list, and delete it.

Subsequently reschedule the timer if there are remaining tasks.

Definition at line 536 of file populate_dm_startup.c.

                                                                        {
  
     if(amxc_llist_is_empty(&s_tasks)) {
         SAH_TRACEZ_WARNING(ME, "No tasks");
         return;
     }
  
     amxc_llist_it_t* const it = amxc_llist_get_first(&s_tasks);
  
     const task_t* const task = amxc_container_of(it, task_t, it);
  
     switch(task->type) {
     case task_query_indexes:
         query_indexes(task);
         break;
     case task_query_content:
         query_content(task);
         break;
     default:
         SAH_TRACEZ_WARNING(ME, "Unknown task type: %d", task->type);
         break;
     }
     /* Remove the 1st task from the list and delete it */
     amxc_llist_it_clean(it, task_delete);
  
     schedule_remaining_tasks();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pplt_dm_cleanup()

void pplt_dm_cleanup ( void )

Clean up the part responsible for populating the XPON DM at startup.

The plugin must call this function once when stopping.

Definition at line 648 of file populate_dm_startup.c.

                            {
     amxc_llist_clean(&s_tasks, task_delete);
     amxp_timer_delete(&s_timer_handle_tasks);
     amxp_timer_delete(&s_timer_query_onus);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pplt_dm_init()

bool pplt_dm_init ( void )

Initialize the part responsible for populating the XPON DM at startup.

To start the whole process of the populating the XPON DM, the function schedules a task to query the instances of XPON.ONU every 10 s. (The plugin will stop the timer when it has found MAX_NR_OF_ONUS ONUs, or when 5 minutes have passed since startup.)

The plugin must call this function once at startup.

Definition at line 619 of file populate_dm_startup.c.

                         {
     bool rv = false;
  
     amxc_llist_init(&s_tasks);
  
     if(amxp_timer_new(&s_timer_handle_tasks, handle_task, NULL)) {
         SAH_TRACEZ_ERROR(ME, "Failed to create timer to handle tasks");
         goto exit;
     }
  
     if(amxp_timer_new(&s_timer_query_onus, query_onu_instances, NULL)) {
         SAH_TRACEZ_ERROR(ME, "Failed to create timer to query ONUs");
         goto exit;
     }
     amxp_timer_set_interval(s_timer_query_onus, QUERY_ONUS_INTERVAL_MS);
  
     /* Start querying the DM on the southbound IF */
     amxp_timer_start(s_timer_query_onus, SHORT_TIMEOUT_MS);
  
     rv = true;
 exit:
     return rv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query_children()

static void query_children	(	const char *const	path,
		uint32_t	index,
		object_id_t	id,
		bool	templates
	)

static

Query the children of an object.

Parameters

[in]	path	object path of a singleton or template object
[in]	index	instance index for a template object. 0 (not applicable) for a singleton.
[in]	id	object ID (caller normally derived it from path)
[in]	templates	true if the function should query the children which are template objects, false if it should query the children which are singleton objects.

The function appends a task to 's_tasks' for each child. It does not do any updates to the XPON DM.

For a child which is a singleton, it adds a task of type 'task_query_content'. For a child which is a template, it adds a task of type 'task_query_indexes'.

Example: An instance of "XPON.ONU.x.ANI" has children which are singletons, and children which are templates:

singletons: TC.ONUActivation,TC.PerformanceThresholds,TC.Alarms
templates: TC.GEM.Port,Transceiver If this function is called for such an instance, e.g., for the instance with path = "XPON.ONU.1.ANI" and index = 1, then this function adds following tasks to 's_tasks':
3 tasks of type 'task_query_content', for TC.ONUActivation, TC.PerformanceThresholds and TC.Alarms respectively.
2 tasks of type 'task_query_indexes', for TC.GEM.Port and Transceiver respectively.

Definition at line 288 of file populate_dm_startup.c.

                                                            {
  
     const object_info_t* const info = dm_get_object_info(id);
     when_null(info, exit_no_cleanup);
  
     const char* const children_char = templates ? info->templates : info->singletons;
     if(NULL == children_char) {
         /* Nothing to do */
         return;
     }
  
     amxc_llist_t children;
     amxc_llist_init(&children);
  
     amxc_string_t str;
     amxc_string_init(&str, 0);
     amxc_string_set(&str, children_char);
  
     if(AMXC_STRING_SPLIT_OK != amxc_string_split_to_llist(&str, &children, ',')) {
         SAH_TRACEZ_ERROR(ME, "Failed to split '%s'", children_char);
         goto exit;
     }
  
     char child_path[256];
  
     amxc_llist_iterate(it, &children) {
         const amxc_string_t* const child = amxc_string_from_llist_it(it);
         const char* const child_cstr = amxc_string_get(child, 0);
         if(index) {
             snprintf(child_path, 256, "%s.%d.%s", path, index, child_cstr);
         } else {
             snprintf(child_path, 256, "%s.%s", path, child_cstr);
         }
         SAH_TRACEZ_DEBUG(ME, "Schedule query %s of %s",
                          templates ? "indexes" : "content", child_path);
  
         task_create(child_path, /*index=*/ 0,
                     templates ? task_query_indexes : task_query_content);
     }
  
 exit:
     amxc_llist_clean(&children, amxc_string_list_it_free);
     amxc_string_clean(&str);
 exit_no_cleanup:
     return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query_content()

static void query_content ( const task_t * task )

static

Ask vendor module for object content, update DM and add tasks to query children.

Parameters

[in] task has info about the object to query. If the field 'index' is 0, the task queries a singleton object, else it queries the instance with that index of a template object.

The object content consists of the values to be assigned to the params of the object.

The function calls the function get_object_content() in the pon_ctrl namespace of the vendor module. It adds the instance to the XPON DM if it queried the instance of a template object, or it updates the object if it queried a singleton object.

The function subsequently adds tasks to 's_tasks' to handle the children of the object. It adds a task of type 'task_query_content' for each child which is a singleton, and it adds a task of type 'task_query_indexes' for each child which is a template.

Definition at line 356 of file populate_dm_startup.c.

                                               {
  
     const char* path = amxc_string_get(&task->path, 0);
     if(!path) {
         SAH_TRACEZ_ERROR(ME, "Failed to get path");
         return;
     }
     SAH_TRACEZ_DEBUG(ME, "path='%s' index=%d", path, task->index);
  
     amxc_var_t ret;
     amxc_var_init(&ret);
  
     const int rc = pon_ctrl_get_object_content(path, task->index, &ret);
  
     if(!check_return_values(rc, &ret, "get_object_content", path, task->index)) {
         goto exit;
     }
     if(amxc_var_add_key(cstring_t, &ret, "path", path) == NULL) {
         SAH_TRACEZ_ERROR(ME, "Failed to add 'path' to 'ret'");
         goto exit;
     }
     if(task->index) {
         if(amxc_var_add_key(uint32_t, &ret, "index", task->index) == NULL) {
             SAH_TRACEZ_ERROR(ME, "Failed to add 'index' to 'ret'");
             goto exit;
         }
         if(dm_add_or_change_instance_impl(&ret)) {
             SAH_TRACEZ_ERROR(ME, "Failed to create %s.%d", path, task->index);
             goto exit;
         }
     } else {
         if(dm_change_object(&ret)) {
             SAH_TRACEZ_ERROR(ME, "Failed to update %s", path);
             /* Do not jump to 'exit'. Still attempt to update any sub-objects. */
         }
     }
  
     const object_id_t id = dm_get_object_id(path);
     if(obj_id_unknown == id) {
         SAH_TRACEZ_DEBUG(ME, "%s has no sub-objects", path);
         goto exit;
     }
  
     query_children(path, task->index, id, false);
     query_children(path, task->index, id, true);
  
     if(obj_id_onu == id) {
         if((task->index != 0) && (task->index <= MAX_NR_OF_ONUS)) {
             SAH_TRACEZ_INFO(ME, "XPON.ONU.%d is initialised", task->index);
             s_onu_initialised[task->index - 1] = 1;
         } else {
             SAH_TRACEZ_ERROR(ME, "XPON.ONU: invalid index: %d: not in [1, %d]",
                              task->index, MAX_NR_OF_ONUS);
         }
     }
  
 exit:
     amxc_var_clean(&ret);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query_indexes()

static void query_indexes ( const task_t * task )

static

Ask the vendor module which instances it should create for a template object.

Parameters

[in] task has info about the template object

The function calls the function get_list_of_instances() in the pon_ctrl namespace of the vendor module. It appends a task of type task_query_content to 's_tasks' for each instance which does not yet exist in the XPON DM.

The function does not change anything in the XPON DM.

If the get_list_of_instances() call fails, the function logs an error and immediately returns an error. It does not retry.

Example: if task->path is XPON.ONU, it asks the vendor module if there are any instances for this object. If the vendor module returns the indexes 1 and 2, XPON.ONU.1 already exists and XPON.ONU.2 not, the function appends a task to 's_tasks' to query the content of XPON.ONU.2.

Check instance exists.

For an XPON.ONU instance also check if it's already initialised.

Definition at line 436 of file populate_dm_startup.c.

                                               {
  
     const char* const path = amxc_string_get(&task->path, 0);
     if(!path) {
         SAH_TRACEZ_ERROR(ME, "Failed to get path");
         return;
     }
     SAH_TRACEZ_DEBUG(ME, "path='%s' index=%d", path, task->index);
  
     amxc_var_t ret;
     amxc_var_init(&ret);
  
     amxc_string_t indexes_str;
     amxc_string_init(&indexes_str, 0);
  
     amxc_llist_t indexes_list;
     amxc_llist_init(&indexes_list);
  
     const int rc = pon_ctrl_get_list_of_instances(path, &ret);
  
     if(!check_return_values(rc, &ret, "get_list_of_instances", path, task->index)) {
         goto exit;
     }
  
     const amxc_htable_t* const htable = amxc_var_constcast(amxc_htable_t, &ret);
     if(!amxc_htable_contains(htable, "indexes")) {
         SAH_TRACEZ_ERROR(ME, "htable 'ret' does not contain 'indexes'");
         goto exit;
     }
  
     const char* const indexes = GET_CHAR(&ret, "indexes");
     if(0 == strlen(indexes)) {
         SAH_TRACEZ_DEBUG(ME, "path='%s' index=%d: no instances", path, task->index);
         goto exit;
     }
     SAH_TRACEZ_DEBUG(ME, "indexes='%s'", indexes);
  
     amxc_string_set(&indexes_str, indexes);
  
     if(AMXC_STRING_SPLIT_OK != amxc_string_split_to_llist(&indexes_str, &indexes_list, ',')) {
         SAH_TRACEZ_ERROR(ME, "Failed to split '%s'", indexes);
         goto exit;
     }
  
     amxc_llist_iterate(it, &indexes_list) {
         const amxc_string_t* const index_str = amxc_string_from_llist_it(it);
         const char* const index_cstr = amxc_string_get(index_str, 0);
         if(!amxc_string_is_numeric(index_str)) {
             SAH_TRACEZ_ERROR(ME, "'%s' is not numeric", index_cstr);
             continue;
         }
         const uint32_t index = atoi(index_cstr);
  
         SAH_TRACEZ_DEBUG(ME, "check instance already exists path=%s, index=%d", path, index);
         if(strcmp(path, "XPON.ONU") == 0) {
             if((0 == index) || (index > MAX_NR_OF_ONUS)) {
                 SAH_TRACEZ_ERROR(ME, "Invalid index: %d: not in [1, %d]", index, MAX_NR_OF_ONUS);
                 continue;
             }
  
             if(dm_does_instance_exist(path, index) && s_onu_initialised[index - 1]) {
                 SAH_TRACEZ_DEBUG(ME, "%s.%d already exists", path, index);
                 continue;
             }
         } else {
             if(dm_does_instance_exist(path, index)) {
                 SAH_TRACEZ_DEBUG(ME, "%s.%d already exists", path, index);
                 continue;
             }
  
         }
  
         SAH_TRACEZ_DEBUG(ME, "Schedule query content of %s.%d", path, index);
  
         task_create(path, index, task_query_content);
     }
  
 exit:
     amxc_llist_clean(&indexes_list, amxc_string_list_it_free);
     amxc_string_clean(&indexes_str);
     amxc_var_clean(&ret);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query_onu_instances()

static void query_onu_instances	(	amxp_timer_t *	timer,
		UNUSED void *	priv
	)

static

Ask vendor module for instances of XPON.ONU.

Parameters

[in,out] timer timer to query the instances of XPON.ONU every 10 s

The function stops the timer if the number of instances of XPON.ONU is MAX_NR_OF_ONUS, or if 5 minutes passed since startup.

Otherwise the function calls query_indexes() for XPON.ONU.

Definition at line 574 of file populate_dm_startup.c.

                                                                         {
  
     task_t task;
     task_init(&task, "XPON.ONU", /*index=*/ 0, task_query_indexes);
  
     SAH_TRACEZ_DEBUG(ME, "s_cntr_query_onus=%d", s_cntr_query_onus);
  
     /* Check if all the ONU instances are initialised */
     bool all_onus_initialised = true;
     for(int i = 0; i < MAX_NR_OF_ONUS; i++) {
         if(!s_onu_initialised[i]) {
             all_onus_initialised = false;
             break;
         }
     }
     if(all_onus_initialised) {
         SAH_TRACEZ_INFO(ME, "All %d ONUs found and initialised", MAX_NR_OF_ONUS);
         amxp_timer_stop(timer);
         goto exit;
     }
  
     ++s_cntr_query_onus;
     if(s_cntr_query_onus > QUERY_ONUS_NR_TIMES) {
         SAH_TRACEZ_DEBUG(ME, "Stop querying ONU instances");
         amxp_timer_stop(timer);
         goto exit;
     }
  
     query_indexes(&task);
     schedule_remaining_tasks();
  
 exit:
     task_clean(&task);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule_remaining_tasks()

static void schedule_remaining_tasks ( void )

static

Definition at line 524 of file populate_dm_startup.c.

                                            {
  
     if(!amxc_llist_is_empty(&s_tasks)) {
         amxp_timer_start(s_timer_handle_tasks, SHORT_TIMEOUT_MS);
     }
 }

Here is the caller graph for this function:

◆ task_clean()

static void task_clean ( task_t *const task )

static

Definition at line 164 of file populate_dm_startup.c.

                                            {
     amxc_string_clean(&task->path);
 }

Here is the caller graph for this function:

◆ task_create()

static task_t* task_create	(	const char *const	path,
		uint32_t	index,
		task_type_t	type
	)

static

Create task and append it to 's_tasks'.

If it fails to create the task or to append the task to 's_tasks', the function is a no-op.

Returns: task created on success, else NULL

Definition at line 176 of file populate_dm_startup.c.

                                                                                      {
  
     task_t* task = (task_t*) calloc(1, sizeof(task_t));
     when_null_trace(task, exit, ERROR, "Failed to allocate memory for task_t");
  
     task_init(task, path, index, type);
  
     if(amxc_llist_append(&s_tasks, &task->it)) {
         SAH_TRACEZ_ERROR(ME, "Failed to append task to 's_tasks'");
         SAH_TRACEZ_ERROR(ME, "  path='%s' index=%d type=%s", path, index,
                          task_type_to_string(type));
         task_clean(task);
         free(task);
         task = NULL;
     }
  
 exit:
     return task;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ task_delete()

static void task_delete ( amxc_llist_it_t * hit )

static

Definition at line 196 of file populate_dm_startup.c.

                                               {
     task_t* task = amxc_container_of(hit, task_t, it);
     const char* path = amxc_string_get(&task->path, 0);
     SAH_TRACEZ_DEBUG(ME, "path='%s' index=%d type=%s", path, task->index,
                      task_type_to_string(task->type));
     task_clean(task);
     free(task);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ task_init()

static void task_init	(	task_t *const	task,
		const char *const	path,
		uint32_t	index,
		task_type_t	type
	)

static

Definition at line 156 of file populate_dm_startup.c.

                                                         {
     amxc_string_init(&task->path, 0);
     amxc_string_set(&task->path, path);
     task->index = index;
     task->type = type;
 }

Here is the caller graph for this function:

◆ task_type_to_string()

static const char* task_type_to_string ( task_type_t type )

static

Definition at line 147 of file populate_dm_startup.c.

                                                          {
     switch(type) {
     case task_query_indexes: return "query_indexes";
     case task_query_content: return "query_content";
     default: break;
     }
     return "none";
 }

Here is the caller graph for this function:

Variable Documentation

◆ s_cntr_query_onus

uint32_t s_cntr_query_onus = 0

static

Counts the number of times the plugin has queried for the existence of ONUs since startup.

Definition at line 89 of file populate_dm_startup.c.

◆ s_onu_initialised

bool s_onu_initialised[MAX_NR_OF_ONUS] = { 0 }

static

Definition at line 96 of file populate_dm_startup.c.

◆ s_tasks

amxc_llist_t s_tasks = { 0 }

static

Definition at line 92 of file populate_dm_startup.c.

◆ s_timer_handle_tasks

amxp_timer_t* s_timer_handle_tasks = NULL

static

Definition at line 94 of file populate_dm_startup.c.

◆ s_timer_query_onus

amxp_timer_t* s_timer_query_onus = NULL

static

Definition at line 84 of file populate_dm_startup.c.

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ QUERY_ONUS_INTERVAL_MS

◆ QUERY_ONUS_NR_TIMES

Typedef Documentation

◆ task_t

◆ task_type_t

Enumeration Type Documentation

◆ _task_type

Function Documentation

◆ check_return_values()

◆ handle_task()

◆ pplt_dm_cleanup()

◆ pplt_dm_init()

◆ query_children()

◆ query_content()

◆ query_indexes()

◆ query_onu_instances()

◆ schedule_remaining_tasks()

◆ task_clean()

◆ task_create()

◆ task_delete()

◆ task_init()

◆ task_type_to_string()

Variable Documentation

◆ s_cntr_query_onus

◆ s_onu_initialised

◆ s_tasks

◆ s_timer_handle_tasks

◆ s_timer_query_onus