cps_api_return_code_t cps_api_process_get_request(cps_api_get_params_t *param, size_t ix) {
cps_api_return_code_t rc = cps_api_ret_code_ERR;
char buff[SCRATCH_LOG_BUFF];
cps_api_channel_t handle;
cps_api_key_t *key = cps_api_object_key(cps_api_object_list_get(param->filters,ix));
if (!cps_api_get_handle(*key,handle)) {
EV_LOG(ERR,DSAPI,0,"NS","Failed to find owner for %s",
cps_api_key_print(key,buff,sizeof(buff)-1));
return cps_api_ret_code_NO_SERVICE;
}
do {
cps_api_object_t o = cps_api_object_list_get(param->filters,ix);
if (o==NULL) {
EV_LOG(ERR,DSAPI,0,"NS","Missing filters... %s",
cps_api_key_print(key,buff,sizeof(buff)-1));
break;
}
if (!cps_api_send_one_object(handle,cps_api_msg_o_GET,o)) {
EV_LOG(ERR,DSAPI,0,"NS","Failed to send request %s",
cps_api_key_print(key,buff,sizeof(buff)-1));
break;
}
uint32_t op;
do {
if (param->timeout > 0) {
fd_set rset;
FD_ZERO(&rset);
FD_SET(handle,&rset);
if ((rc=cps_api_timeout_wait(handle,&rset,param->timeout,"CPS-OP-GET"))!=cps_api_ret_code_OK) {
EV_LOG(ERR,DSAPI,0,"CPS-OP-GET","Send request %s timed out",
cps_api_key_print(key,buff,sizeof(buff)-1));
break;
}
}
size_t len;
if (!cps_api_receive_header(handle,op,len)) break;
if (op!=cps_api_msg_o_GET_RESP) break;
cps_api_object_guard og (cps_api_receive_object(handle,len));
if (og.valid() && cps_api_object_list_append(param->list,og.get())) {
og.release();
} else break;
} while (op == cps_api_msg_o_GET_RESP);
if (op!=cps_api_msg_o_GET_DONE) break; //leave an error code
rc = cps_api_ret_code_OK;
} while (0);
cps_api_disconnect_owner(handle);
return rc;
}
static cps_api_return_code_t _write_function(void * context, cps_api_transaction_params_t * param,size_t ix) {
GILLock gil;
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
if (obj==NULL) return cps_api_ret_code_ERR;
cps_api_object_t prev = cps_api_object_list_get(param->prev,ix);
if(prev==NULL) {
prev = cps_api_object_list_create_obj_and_append(param->prev);
}
if (prev==NULL) return cps_api_ret_code_ERR;
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
PyObject *p = PyDict_New();
PyRef dict(p);
py_cps_util_set_item_to_dict(p,"change",cps_obj_to_dict(obj));
py_cps_util_set_item_to_dict(p,"previous",cps_obj_to_dict(prev));
static const std::map<int,std::string> trans = {
{cps_api_oper_DELETE,"delete" },
{cps_api_oper_CREATE,"create"},
{cps_api_oper_SET, "set"},
{cps_api_oper_ACTION,"rpc"}
};
py_cps_util_set_item_to_dict(p,"operation",PyString_FromString(trans.at(op).c_str()));
py_callbacks_t *cb = (py_callbacks_t*)context;
PyObject *res = cb->execute("transaction",p);
if (res==NULL || !PyBool_Check(res) || (Py_False==(res))) {
return cps_api_ret_code_ERR;
}
PyRef ret(res);
PyObject *ch = PyDict_GetItemString(p,"change");
if (ch==NULL) return cps_api_ret_code_ERR;
cps_api_object_t o = dict_to_cps_obj(ch);
cps_api_object_guard og(o);
if(og.valid()) {
cps_api_object_clone(obj,og.get());
}
PyObject *pr = PyDict_GetItemString(p,"previous");
if (pr==NULL) return cps_api_ret_code_ERR;
og.set(dict_to_cps_obj(pr));
if (og.valid()) {
cps_api_object_clone(prev,og.get());
}
return cps_api_ret_code_OK;
}
TEST(std_nas_route_test, nas_route_arp_get) {
cps_api_get_params_t gp;
cps_api_get_request_init(&gp);
cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters);
cps_api_key_from_attr_with_qual(cps_api_object_key(obj),BASE_ROUTE_OBJ_NBR,
cps_api_qualifier_TARGET);
unsigned short af = 2;
cps_api_set_key_data(obj,BASE_ROUTE_OBJ_NBR_AF,cps_api_object_ATTR_T_U16,
&af,sizeof(af));
if (cps_api_get(&gp)==cps_api_ret_code_OK) {
size_t mx = cps_api_object_list_size(gp.list);
for ( size_t ix = 0 ; ix < mx ; ++ix ) {
obj = cps_api_object_list_get(gp.list,ix);
std::cout<<"ARP ENTRY "<<std::endl;
std::cout<<"================================="<<std::endl;
nas_route_dump_arp_object_content(obj);
std::cout<<std::endl;
}
}
cps_api_get_request_close(&gp);
}
bool cps_api_nodes::load_aliases() {
cps_db::connection_request b(cps_db::ProcessDBCache(),DEFAULT_REDIS_ADDR);
if (!b.valid()) {
return false;
}
alias_map_t _cpy;
cps_api_object_guard og(cps_api_object_create());
if (!cps_api_key_from_attr_with_qual(cps_api_object_key(og.get()),CPS_NODE_DETAILS, cps_api_qualifier_TARGET)) {
return false;
}
cps_api_object_list_guard lg(cps_api_object_list_create());
if (!cps_db::get_objects(b.get(),og.get(),lg.get())) return false;
for ( size_t ix = 0, mx = cps_api_object_list_size(lg.get()); ix < mx ; ++ix ) {
cps_api_object_t o = cps_api_object_list_get(lg.get(),ix);
const char *name = (const char*) cps_api_object_get_data(o,CPS_NODE_DETAILS_NAME);
const char *alias = (const char*) cps_api_object_get_data(o,CPS_NODE_DETAILS_ALIAS);
_cpy[name] = alias;
}
std::swap(_cpy,_alias_map);
return true;
}
/**
* This function provides NAS-QoS priority_group CPS API read function
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_priority_group_read (void * context,
cps_api_get_params_t * param,
size_t ix)
{
cps_api_object_t obj = cps_api_object_list_get(param->filters, ix);
cps_api_object_attr_t port_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_PORT_ID);
cps_api_object_attr_t local_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_LOCAL_ID);
uint_t switch_id = 0;
if (port_id_attr == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Port Id must be specified\n");
return NAS_QOS_E_MISSING_KEY;
}
uint_t port_id = cps_api_object_attr_data_u32(port_id_attr);
bool local_id_specified = false;
uint8_t local_id;
if (local_id_attr) {
local_id = *(uint8_t *)cps_api_object_attr_data_bin(local_id_attr);
local_id_specified = true;
}
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Read switch id %u, port_id id %u\n",
switch_id, port_id);
std_mutex_simple_lock_guard p_m(&priority_group_mutex);
// If the port priority group is not initialized yet, initialize it in NAS
nas_qos_port_priority_group_init(port_id);
return nas_qos_cps_get_priority_group_info(param, switch_id, port_id,
local_id_specified, local_id);
}
t_std_error nas_get_lag_if_index (uint64_t ndi_port, hal_ifindex_t *lag_if_index)
{
cps_api_get_params_t gp;
cps_api_get_request_init(&gp);
cps_api_get_request_guard rg(&gp);
EV_LOG_TRACE(ev_log_t_INTERFACE, 2, "INTF-C", "querying for ifindex of ndi lag id 0x%x ", ndi_port);
cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters);
cps_api_key_from_attr_with_qual(cps_api_object_key(obj), DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_OBJ,
cps_api_qualifier_TARGET);
cps_api_object_attr_add_u64(obj,BASE_IF_LAG_IF_INTERFACES_INTERFACE_LAG_OPAQUE_DATA, ndi_port);
cps_api_object_attr_add(obj,IF_INTERFACES_INTERFACE_TYPE,
(const char *)IF_INTERFACE_TYPE_IANAIFT_IANA_INTERFACE_TYPE_IANAIFT_IEEE8023ADLAG,
sizeof(IF_INTERFACE_TYPE_IANAIFT_IANA_INTERFACE_TYPE_IANAIFT_IEEE8023ADLAG));
if (cps_api_get(&gp)==cps_api_ret_code_OK) {
size_t mx = cps_api_object_list_size(gp.list);
for (size_t ix = 0 ; ix < mx ; ++ix ) {
cps_api_object_t obj = cps_api_object_list_get(gp.list,ix);
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
cps_api_object_attr_t attr = cps_api_object_it_find(&it, DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_IF_INDEX);
if (!attr) {
return STD_ERR(INTERFACE, FAIL, 0);
}
*lag_if_index = cps_api_object_attr_data_u32(attr);
}
}
return(STD_ERR_OK);
}
static t_std_error dn_nas_get_phy_media_default_setting(PLATFORM_MEDIA_TYPE_t media_type, cps_api_object_t obj)
{
cps_api_get_params_t gp;
cps_api_get_request_init(&gp);
cps_api_get_request_guard rg(&gp);
cps_api_object_t media_obj = cps_api_object_list_create_obj_and_append(gp.filters);
t_std_error rc = STD_ERR_MK(e_std_err_INTERFACE, e_std_err_code_FAIL, 0);
do {
if (!cps_api_key_from_attr_with_qual(cps_api_object_key(media_obj),
BASE_MEDIA_MEDIA_INFO_OBJ, cps_api_qualifier_OBSERVED)) {
break;
}
cps_api_set_key_data_uint(media_obj, BASE_MEDIA_MEDIA_INFO_MEDIA_TYPE, &media_type, sizeof(media_type));
cps_api_object_attr_add_u32(media_obj, BASE_MEDIA_MEDIA_INFO_MEDIA_TYPE, media_type);
if (cps_api_get(&gp) != cps_api_ret_code_OK)
break;
if (0 == cps_api_object_list_size(gp.list))
break;
media_obj = cps_api_object_list_get(gp.list,0);
if (!cps_api_object_clone(obj, media_obj)) {
break;
}
rc = STD_ERR_OK;
} while(0);
return rc;
}
cps_api_return_code_t ds_api_linux_interface_set_function(void * context, cps_api_transaction_params_t * param, size_t ix) {
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
if (op!=cps_api_oper_SET) return cps_api_ret_code_ERR;
return execute_set_function(param->prev,obj);
}
cps_api_return_code_t cps_api_process_rollback_request(cps_api_transaction_params_t *param,
size_t ix) {
cps_api_return_code_t rc = cps_api_ret_code_ERR;
cps_api_object_t obj = cps_api_object_list_get(param->prev,ix);
if (obj==NULL) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","No Revert Object");
return rc;
}
cps_api_channel_t handle;
cps_api_key_t *key = cps_api_object_key(obj);
char buff[CPS_API_KEY_STR_MAX];
EV_LOG(TRACE,DSAPI,0, "CPS IPC", "Object for rollback request: %s ",
cps_api_key_name_print(key, buff, sizeof(buff)));
if (!cps_api_get_handle(*key,handle)) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","No Service");
return cps_api_ret_code_NO_SERVICE;
}
cps_api_channel_handle_guard hg(handle);
rc = cps_api_ret_code_ERR;
do {
if (!cps_api_send_one_object(handle,cps_api_msg_o_REVERT,obj)) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Could not send REVERT header");
break;
}
uint32_t op;
size_t len;
if (!cps_api_receive_header(handle,op,len)) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Failed to read the receive header for revert object");
break;
}
if (op == cps_api_msg_o_RETURN_CODE) {
if (!cps_api_receive_data(handle,&rc,sizeof(rc))) break;
}
} while (0);
cps_api_disconnect_owner(handle);
return rc;
}
/**
* This function provides NAS-QoS priority_group CPS API rollback function
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_priority_group_rollback(void * context,
cps_api_transaction_params_t * param,
size_t ix)
{
cps_api_object_t obj = cps_api_object_list_get(param->prev,ix);
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
std_mutex_simple_lock_guard p_m(&priority_group_mutex);
if (op == cps_api_oper_SET) {
nas_qos_cps_api_priority_group_set(obj, NULL);
}
return cps_api_ret_code_OK;
}
extern "C" t_std_error nas_os_get_interface_obj(hal_ifindex_t ifix,cps_api_object_t obj) {
cps_api_object_list_guard lg(cps_api_object_list_create());
if (lg.get()==NULL) return STD_ERR(NAS_OS,FAIL,0);
if (_get_interfaces(lg.get(),ifix,false)!=cps_api_ret_code_OK) {
return STD_ERR(NAS_OS,FAIL,0);
}
cps_api_object_t ret = cps_api_object_list_get(lg.get(),0);
if (ret==nullptr) {
return STD_ERR(NAS_OS,FAIL,0);
}
cps_api_object_clone(obj,ret);
return STD_ERR_OK;
}
static cps_api_return_code_t _phy_int_set(void * context, cps_api_transaction_params_t * param,size_t ix) {
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
if (obj==NULL) return cps_api_ret_code_ERR;
cps_api_object_t prev = cps_api_object_list_create_obj_and_append(param->prev);
if (prev==nullptr) return cps_api_ret_code_ERR;
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
if (op==cps_api_oper_SET) return _phy_set(obj,prev);
EV_LOG(ERR,INTERFACE,0,"NAS-PHY","Invalid operation");
return cps_api_ret_code_ERR;
}
extern "C" t_std_error dn_hal_get_interface_mac(hal_ifindex_t if_index, hal_mac_addr_t mac_addr)
{
if(mac_addr == NULL) {
EV_LOG_TRACE(ev_log_t_INTERFACE, 2, "INTF-C","mac_addr_ptr NULL");
return(STD_ERR_MK(e_std_err_INTERFACE, e_std_err_code_PARAM, 0));
}
cps_api_get_params_t gp;
cps_api_get_request_init(&gp);
cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters);
t_std_error rc = STD_ERR_MK(e_std_err_INTERFACE, e_std_err_code_FAIL, 0);
do {
if (!cps_api_key_from_attr_with_qual(cps_api_object_key(obj),
DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_OBJ, cps_api_qualifier_TARGET)) {
break;
}
cps_api_object_attr_add_u32(obj,DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_IF_INDEX, if_index);
if (cps_api_get(&gp) != cps_api_ret_code_OK)
break;
if (0 == cps_api_object_list_size(gp.list))
break;
obj = cps_api_object_list_get(gp.list,0);
cps_api_object_attr_t attr = cps_api_object_attr_get(obj,DELL_IF_IF_INTERFACES_INTERFACE_PHYS_ADDRESS);
if (attr != NULL) {
void *_mac_str = cps_api_object_attr_data_bin(attr);
size_t addr_len = strlen(static_cast<char *>(_mac_str));
EV_LOG_TRACE(ev_log_t_INTERFACE, 2, "INTF-C","mac_addr %s, len %d",
_mac_str, addr_len);
if (std_string_to_mac((hal_mac_addr_t *)mac_addr, static_cast<const char *>(_mac_str), addr_len)) {
rc = STD_ERR_OK;
}
}
} while (0);
cps_api_get_request_close(&gp);
return rc;
}
t_std_error dn_nas_lag_get_ndi_ids (hal_ifindex_t if_index, nas_ndi_obj_id_table_handle_t ndi_id_data)
{
if(ndi_id_data == NULL) {
EV_LOG_ERR(ev_log_t_INTERFACE, 2, "INTF-C","Input ndi_data is NULL");
return(STD_ERR(INTERFACE, PARAM, 0));
}
cps_api_get_params_t gp;
cps_api_get_request_init(&gp);
cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters);
t_std_error rc = STD_ERR(INTERFACE, FAIL, 0);
do {
if (!cps_api_key_from_attr_with_qual(cps_api_object_key(obj),
DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_OBJ, cps_api_qualifier_TARGET)) {
break;
}
cps_api_object_attr_add_u32(obj,DELL_BASE_IF_CMN_IF_INTERFACES_INTERFACE_IF_INDEX, if_index);
cps_api_object_attr_add(obj,IF_INTERFACES_INTERFACE_TYPE,
(const char *)IF_INTERFACE_TYPE_IANAIFT_IANA_INTERFACE_TYPE_IANAIFT_IEEE8023ADLAG,
sizeof(IF_INTERFACE_TYPE_IANAIFT_IANA_INTERFACE_TYPE_IANAIFT_IEEE8023ADLAG));
if (cps_api_get(&gp) != cps_api_ret_code_OK)
break;
if (0 == cps_api_object_list_size(gp.list))
break;
obj = cps_api_object_list_get(gp.list,0);
cps_api_attr_id_t attr_list[] = {BASE_IF_LAG_IF_INTERFACES_INTERFACE_LAG_OPAQUE_DATA};
if (!nas_ndi_obj_id_table_cps_unserialize (ndi_id_data, obj, attr_list,
sizeof (attr_list)/sizeof (cps_api_attr_id_t)))
{
EV_LOG_ERR(ev_log_t_INTERFACE, 2, "INTF-C","Failed to get LAG opaque data");
break;
}
rc = STD_ERR_OK;
} while (0);
cps_api_get_request_close(&gp);
return rc;
}
t_std_error nas_switch_get_sys_mac_base(hal_mac_addr_t *mac_base)
{
if(mac_base == NULL) {
EV_LOG(ERR,NAS_L2,0,"NAS-L2-SWITCH","invalid parameter");
return(STD_ERR_MK(e_std_err_BOARD, e_std_err_code_PARAM, 0));
}
cps_api_get_params_t gp;
cps_api_get_request_init(&gp);
cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters);
t_std_error rc = STD_ERR_MK(e_std_err_BOARD, e_std_err_code_FAIL, 0);
do {
if (!cps_api_key_from_attr_with_qual(cps_api_object_key(obj),
BASE_SWITCH_SWITCHING_ENTITIES_SWITCHING_ENTITY, cps_api_qualifier_TARGET)) {
break;
}
uint32_t switch_id = 0; /* default switch ID. @TODO add switch id */
cps_api_set_key_data_uint(obj, BASE_SWITCH_SWITCHING_ENTITIES_SWITCHING_ENTITY_SWITCH_ID, &switch_id, sizeof(switch_id));
if (cps_api_get(&gp) != cps_api_ret_code_OK)
break;
if (0 == cps_api_object_list_size(gp.list))
break;
obj = cps_api_object_list_get(gp.list,0);
cps_api_object_attr_t attr = cps_api_object_attr_get(obj, BASE_SWITCH_SWITCHING_ENTITIES_SWITCHING_ENTITY_DEFAULT_MAC_ADDRESS);
if (attr != NULL) {
memcpy(*mac_base,cps_api_object_attr_data_bin(attr),sizeof(*mac_base));
rc = STD_ERR_OK;
}
} while (0);
cps_api_get_request_close(&gp);
return rc;
}
static cps_api_return_code_t _write_function(void * context, cps_api_transaction_params_t * param,size_t ix) {
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
if (obj==NULL) return cps_api_ret_code_ERR;
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
cps_api_object_t prev = cps_api_object_create();
if (prev==NULL) return cps_api_ret_code_ERR;
if (!cps_api_object_list_append(param->prev,prev)) {
cps_api_object_delete(prev);
return cps_api_ret_code_ERR;
}
cps_api_key_t _local_key;
cps_api_key_init(&_local_key,cps_api_qualifier_TARGET,cps_api_obj_cat_ROUTE,cps_api_route_obj_EVENT,0);
if (cps_api_key_matches(&_local_key,cps_api_object_key(obj),true)) {
os_send_refresh(nas_nl_sock_T_ROUTE);
} else {
return _op(op,context,obj,prev);
}
return cps_api_ret_code_OK;
}
/**
* This function provides NAS-QoS priority_group CPS API write function
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_priority_group_write(void * context,
cps_api_transaction_params_t * param,
size_t ix)
{
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
std_mutex_simple_lock_guard p_m(&priority_group_mutex);
switch (op) {
case cps_api_oper_CREATE:
case cps_api_oper_DELETE:
return NAS_QOS_E_FAIL; //not supported
case cps_api_oper_SET:
return nas_qos_cps_api_priority_group_set(obj, param->prev);
default:
return NAS_QOS_E_UNSUPPORTED;
}
}
static cps_api_return_code_t cps_nas_switch_log_set_function(void * context,
cps_api_transaction_params_t * param, size_t ix){
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
if (op != cps_api_oper_ACTION) {
EV_LOG(ERR,SYSTEM,0,"NAS-DIAG","Invalid operation %d for setting switch log",op);
return cps_api_ret_code_ERR;
}
BASE_SWITCH_SUBSYSTEM_t switch_system_id;
cps_api_object_attr_t switch_system_id_attr;
if ((switch_system_id_attr = cps_api_get_key_data(obj,BASE_SWITCH_SET_LOG_INPUT_SUBSYSTEM_ID)) == NULL) {
EV_LOG(ERR,SYSTEM,0,"NAS-DIAG","No Module id passed for Updating sai log level");
return cps_api_ret_code_ERR;
}
switch_system_id = (BASE_SWITCH_SUBSYSTEM_t) cps_api_object_attr_data_u32(switch_system_id_attr);
cps_api_attr_id_t log_level_attr_id = BASE_SWITCH_SET_LOG_INPUT_LEVEL;
cps_api_object_attr_t log_level_attr = cps_api_object_e_get (obj, &log_level_attr_id, 1);
if(log_level_attr == NULL){
EV_LOG(ERR,SYSTEM,0,"NAS-DIAG","No log level passed for Updating sai log level"
"for module %d",switch_system_id);
return cps_api_ret_code_ERR;
}
BASE_SWITCH_LOG_LEVEL_t log_level = (BASE_SWITCH_LOG_LEVEL_t)
cps_api_object_attr_data_u32(log_level_attr);
t_std_error rc;
if( (rc =ndi_switch_set_sai_log_level(switch_system_id,log_level)) != STD_ERR_OK ){
EV_LOG(ERR,SYSTEM,0,"NAS-DIAG","Failed to set log_level to %d for sai module %d "
"got the return code %d ",log_level,switch_system_id,rc);
return cps_api_ret_code_ERR;
}
return cps_api_ret_code_OK;
}
/**
* This function provides NAS-QoS Map CPS API write function
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_map_write_type(void * context,
cps_api_transaction_params_t * param,
size_t ix,
nas_qos_map_type_t map_type)
{
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
switch (op) {
case cps_api_oper_CREATE:
return nas_qos_cps_api_map_create(obj, param->prev, map_type);
case cps_api_oper_SET:
return nas_qos_cps_api_map_set(obj, param->prev, map_type);
case cps_api_oper_DELETE:
return nas_qos_cps_api_map_delete(obj, param->prev, map_type);
default:
return NAS_QOS_E_UNSUPPORTED;
}
}
static cps_api_return_code_t _phy_int_get (void * context, cps_api_get_params_t * param,
size_t key_ix) {
cps_api_object_t filt = cps_api_object_list_get(param->filters,key_ix);
npu_id_t npu = 0;
npu_id_t npu_max = (npu_id_t)nas_switch_get_max_npus();
cps_api_object_attr_t _npu = cps_api_get_key_data(filt,BASE_IF_PHY_PHYSICAL_NPU_ID);
cps_api_object_attr_t _port = cps_api_get_key_data(filt,BASE_IF_PHY_PHYSICAL_PORT_ID);
cps_api_object_attr_t _hw_port = cps_api_get_key_data(filt,BASE_IF_PHY_PHYSICAL_HARDWARE_PORT_ID);
for ( npu = 0; npu< npu_max ; ++npu){
if (_npu!=NULL && cps_api_object_attr_data_u32(_npu)!=(uint32_t)npu) continue;
unsigned int intf_max_ports = ndi_max_npu_port_get(npu);
for (port_t port = 0; port < intf_max_ports ; ++port ) {
if (_port!=NULL && cps_api_object_attr_data_u32(_port)!=port) continue;
if (_hw_port!=NULL) {
uint32_t hwport;
if (get_hw_port(npu,port,hwport)) {
if (cps_api_object_attr_data_u32(_hw_port)!=hwport) continue;
}
}
// skip invalid port or cpu port
if (!ndi_port_is_valid(npu, port) || _is_cpu_port(npu, port)) {
continue;
}
cps_api_object_t o = cps_api_object_list_create_obj_and_append(param->list);
if (o==NULL) return cps_api_ret_code_ERR;
make_phy_port_details(npu,port,o);
}
}
return cps_api_ret_code_OK;
}
/**
* This function provides NAS-QoS Map CPS API rollback function
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_map_rollback_type(void * context,
cps_api_transaction_params_t * param,
size_t ix,
nas_qos_map_type_t map_type)
{
cps_api_object_t obj = cps_api_object_list_get(param->prev,ix);
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
if (op == cps_api_oper_CREATE) {
nas_qos_cps_api_map_delete(obj, NULL, map_type);
}
if (op == cps_api_oper_SET) {
nas_qos_cps_api_map_set(obj, NULL, map_type);
}
if (op == cps_api_oper_DELETE) {
nas_qos_cps_api_map_create(obj, NULL, map_type);
}
return cps_api_ret_code_OK;
}
t_std_error dn_pas_psu_get(cps_api_get_params_t * param, size_t key_idx)
{
t_std_error result = STD_ERR_OK, ret;
cps_api_object_t req_obj = cps_api_object_list_get(param->filters, key_idx);
cps_api_qualifier_t qual;
bool slot_valid;
uint_t slot, slot_start, slot_limit;
dn_pas_obj_key_psu_get(req_obj, &qual, &slot_valid, &slot);
if (slot_valid) {
slot_start = slot_limit = slot;
} else {
struct pas_config_entity *e;
e = dn_pas_config_entity_get_type(PLATFORM_ENTITY_TYPE_PSU);
if (e == 0) return (STD_ERR(PAS, FAIL, 0));
slot_start = 1;
slot_limit = e->num_slots;
}
for (slot = slot_start; slot <= slot_limit; ++slot) {
ret = dn_pas_psu_get1(param, qual, slot);
if (ret == STD_ERR(PAS, NEXIST, 0)) {
if (slot_valid) {
result = STD_ERR(PAS, NEXIST, 0);
}
break;
} else if (STD_IS_ERR(ret)) {
result = STD_ERR(PAS, FAIL, 0);
}
}
return (result);
}
TEST(std_nas_route_test, nas_peer_routing_config_get) {
cps_api_get_params_t gp;
cps_api_get_request_init(&gp);
cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters);
cps_api_key_from_attr_with_qual(cps_api_object_key(obj),BASE_ROUTE_PEER_ROUTING_CONFIG_OBJ,
cps_api_qualifier_TARGET);
if (cps_api_get(&gp)==cps_api_ret_code_OK) {
size_t mx = cps_api_object_list_size(gp.list);
for ( size_t ix = 0 ; ix < mx ; ++ix ) {
obj = cps_api_object_list_get(gp.list,ix);
std::cout<<"Peer Routing Status "<<std::endl;
std::cout<<"================================="<<std::endl;
nas_route_dump_peer_routing_object_content(obj);
std::cout<<std::endl;
}
}
cps_api_get_request_close(&gp);
}
static cps_api_return_code_t _read_function (void * context, cps_api_get_params_t * param,
size_t key_ix) {
py_callbacks_t *cb = (py_callbacks_t*)context;
GILLock gil;
PyObject *p = PyDict_New();
PyRef dict(p);
py_cps_util_set_item_to_dict(p,"filter",cps_obj_to_dict(cps_api_object_list_get(
param->filters,key_ix)));
py_cps_util_set_item_to_dict(p,"list",PyList_New(0));
PyObject * res = cb->execute("get",p);
PyRef ret(res);
if (res==NULL || !PyBool_Check(res) || (Py_False == (res))) {
return cps_api_ret_code_ERR;
}
PyObject *d = PyDict_GetItemString(p,"list");
if (d!=NULL && PyList_Check(d)) {
size_t ix = 0;
size_t mx = PyList_Size(d);
for ( ; ix < mx ; ++ix ) {
PyObject *o = PyList_GetItem(d,ix);
if (o==NULL || !PyDict_Check(o)) continue;
cps_api_object_guard og(dict_to_cps_obj(o));
if (og.valid() && cps_api_object_list_append(param->list,og.get())) {
og.release();
continue;
}
return cps_api_ret_code_ERR;
}
}
return cps_api_ret_code_OK;
}
TEST(std_nas_route_test, nas_route_ipv6_get) {
cps_api_get_params_t gp;
cps_api_get_request_init(&gp);
cps_api_object_t obj = cps_api_object_list_create_obj_and_append(gp.filters);
cps_api_key_from_attr_with_qual(cps_api_object_key(obj),BASE_ROUTE_OBJ_ENTRY,
cps_api_qualifier_TARGET);
unsigned int af = AF_INET6;
cps_api_set_key_data(obj,BASE_ROUTE_OBJ_ENTRY_AF,cps_api_object_ATTR_T_U32,
&af,sizeof(af));
if (cps_api_get(&gp)==cps_api_ret_code_OK) {
size_t mx = cps_api_object_list_size(gp.list);
std::cout<<"IPv6 FIB Entries"<<std::endl;
std::cout<<"================================="<<std::endl;
for ( size_t ix = 0 ; ix < mx ; ++ix ) {
obj = cps_api_object_list_get(gp.list,ix);
nas_route_dump_route_object_content(obj);
std::cout<<std::endl;
}
}
cps_api_get_request_close(&gp);
}
/**
* This function provides NAS-QoS priority_group stats CPS API read function
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_priority_group_stat_read (void * context,
cps_api_get_params_t * param,
size_t ix)
{
cps_api_object_t obj = cps_api_object_list_get(param->filters, ix);
cps_api_object_attr_t port_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID);
cps_api_object_attr_t local_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID);
if (port_id_attr == NULL ||
local_id_attr == NULL ) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Incomplete key: port-id, priority_group local id must be specified\n");
return NAS_QOS_E_MISSING_KEY;
}
uint32_t switch_id = 0;
nas_qos_priority_group_key_t key;
key.port_id = cps_api_object_attr_data_u32(port_id_attr);
key.local_id = *(uint8_t *)cps_api_object_attr_data_bin(local_id_attr);
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Read switch id %u, port_id %u priority_group local id %u stat\n",
switch_id, key.port_id, key.local_id);
std_mutex_simple_lock_guard p_m(&priority_group_mutex);
// If the port is not be initialized yet, initialize it in NAS
nas_qos_port_priority_group_init(key.port_id);
nas_qos_switch *switch_p = nas_qos_get_switch(switch_id);
if (switch_p == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "switch_id %u not found", switch_id);
return NAS_QOS_E_FAIL;
}
nas_qos_priority_group * priority_group_p = switch_p->get_priority_group(key);
if (priority_group_p == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Priority Group not found");
return NAS_QOS_E_FAIL;
}
nas_qos_priority_group_stat_counter_t stats = {0};
std::vector<BASE_QOS_PRIORITY_GROUP_STAT_t> counter_ids;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
cps_api_attr_id_t id = cps_api_object_attr_id(it.attr);
switch (id) {
case BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID:
case BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID:
break;
case BASE_QOS_PRIORITY_GROUP_STAT_PACKETS:
case BASE_QOS_PRIORITY_GROUP_STAT_BYTES:
case BASE_QOS_PRIORITY_GROUP_STAT_CURRENT_OCCUPANCY_BYTES:
case BASE_QOS_PRIORITY_GROUP_STAT_WATERMARK_BYTES:
counter_ids.push_back((BASE_QOS_PRIORITY_GROUP_STAT_t)id);
break;
default:
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Unknown priority_group STAT flag: %u, ignored", id);
break;
}
}
if (ndi_qos_get_priority_group_stats(priority_group_p->get_ndi_port_id(),
priority_group_p->ndi_obj_id(),
&counter_ids[0],
counter_ids.size(),
&stats) != STD_ERR_OK) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Priority Group stats get failed");
return NAS_QOS_E_FAIL;
}
// return stats objects to cps-app
cps_api_object_t ret_obj = cps_api_object_list_create_obj_and_append(param->list);
if (ret_obj == NULL) {
return cps_api_ret_code_ERR;
}
cps_api_key_from_attr_with_qual(cps_api_object_key(ret_obj),
BASE_QOS_PRIORITY_GROUP_STAT_OBJ,
cps_api_qualifier_TARGET);
cps_api_set_key_data(ret_obj, BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID,
cps_api_object_ATTR_T_U32,
&(key.port_id), sizeof(uint32_t));
cps_api_set_key_data(ret_obj, BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID,
cps_api_object_ATTR_T_BIN,
&(key.local_id), sizeof(uint8_t));
uint64_t val64;
for (uint_t i=0; i< counter_ids.size(); i++) {
BASE_QOS_PRIORITY_GROUP_STAT_t id = counter_ids[i];
val64 = get_stats_by_type(&stats, id);
cps_api_object_attr_add_u64(ret_obj, id, val64);
}
return cps_api_ret_code_OK;
}
PyObject * py_cps_get(PyObject *self, PyObject *args) {
PyObject * param_list;
cps_api_get_params_t gr;
if (cps_api_get_request_init (&gr)==cps_api_ret_code_ERR) {
py_set_error_string("Failed to initialize the get req");
return nullptr;
}
cps_api_get_request_guard rg(&gr);
PyObject *res_obj;
if (! PyArg_ParseTuple( args, "O!O", &PyList_Type, ¶m_list,&res_obj)) {
py_set_error_string("Failed to parse input args.");
return nullptr;
}
PyObject * lst = NULL;
if (PyDict_Check(res_obj)) {
PyObject *l = PyList_New(0);
PyRef _l(l);
if (l==NULL) {
py_set_error_string("Can not create a list.");
return nullptr;
}
PyObject *_prev = PyDict_GetItemString(res_obj,"list");
if (_prev!=NULL) {
PyDict_DelItemString(res_obj,"list");
}
if (!py_cps_util_set_item_to_dict(res_obj,"list",l)) {
py_set_error_string("Can not create a list.");
return nullptr;
}
lst = l;
}
if (PyList_Check(res_obj)) {
lst = res_obj;
}
if (lst==NULL) {
py_set_error_string("The return args are invalid.");
return nullptr;
}
Py_ssize_t str_keys = PyList_Size(param_list);
{
Py_ssize_t ix = 0;
for ( ;ix < str_keys ; ++ix ) {
PyObject *strObj = PyList_GetItem(param_list, ix);
if (PyString_Check(strObj)) {
//
cps_api_object_t o = cps_api_object_list_create_obj_and_append(gr.filters);
if (o==NULL) {
py_set_error_string("Memory allocation error.");
return nullptr;
}
if (!cps_api_key_from_string(cps_api_object_key(o),PyString_AsString(strObj))) {
py_set_error_string("Memory allocation error.");
return nullptr;
}
}
if (PyDict_Check(strObj)) {
cps_api_object_t o = dict_to_cps_obj(strObj);
if (o==NULL) {
py_set_error_string("Can't convert from a python to internal object");
return nullptr;
}
if (!cps_api_object_list_append(gr.filters,o)) {
cps_api_object_delete(o);
py_set_error_string("Memory allocation error.");
return nullptr;
}
}
}
}
gr.keys = NULL;
gr.key_count = 0;
cps_api_return_code_t rc;
{
NonBlockingPythonContext l;
rc = cps_api_get(&gr);
}
if (rc!=cps_api_ret_code_OK) {
Py_RETURN_FALSE;
}
size_t ix = 0;
size_t mx = cps_api_object_list_size(gr.list);
for ( ; ix < mx ; ++ix) {
cps_api_object_t obj = cps_api_object_list_get(gr.list,ix);
PyObject *d = cps_obj_to_dict(obj);
PyRef r(d);
if (d==NULL) {
py_set_error_string("Memory allocation error.");
return nullptr;
}
if (PyList_Append(lst,d)) {
py_set_error_string("Memory allocation error.");
return nullptr;
}
}
Py_RETURN_TRUE;
}
PyObject * py_cps_trans(PyObject *self, PyObject *args) {
PyObject *list;
if (! PyArg_ParseTuple( args, "O!", &PyList_Type, &list)) return NULL;
cps_api_transaction_params_t tr;
if (cps_api_transaction_init(&tr)!=cps_api_ret_code_OK) {
py_set_error_string("Memory allocation error.");
return nullptr;
}
cps_api_transaction_guard pg(&tr);
size_t ix = 0;
size_t mx = PyList_Size(list);
for ( ; ix < mx ; ++ix ) {
PyObject *dict = PyList_GetItem(list,ix);
if (!py_add_object_to_trans(&tr,dict)) {
py_set_error_string("Could not translate the request to a transaction");
return nullptr;
}
}
cps_api_return_code_t rc;
{
NonBlockingPythonContext l;
rc = cps_api_commit(&tr);
}
if (rc!=cps_api_ret_code_OK) {
Py_RETURN_FALSE;
}
ix = 0;
mx = PyList_Size(list);
for ( ; ix < mx ; ++ix ) {
PyObject *dict = PyList_GetItem(list,ix);
if (dict==NULL || !PyDict_Check(dict)) {
py_set_error_string("Failed to convert the transaction response.");
return nullptr;
}
PyObject *_req = PyDict_GetItemString(dict,"change");
if (_req==NULL || !PyDict_Check(_req)) {
py_set_error_string("Failed to convert the transaction response.");
return nullptr;
}
cps_api_object_t obj = cps_api_object_list_get(tr.change_list,ix);
if (obj==NULL) {
py_set_error_string("Failed to convert the transaction response.");
return nullptr;
}
py_cps_util_set_item_to_dict(_req,"key",
PyString_FromString(cps_key_to_string(cps_api_object_key(obj)).c_str()));
if (PyDict_GetItemString(dict,"change")!=NULL)
PyDict_DelItemString(dict,"change");
py_cps_util_set_item_to_dict(dict,"change",cps_obj_to_dict(obj));
}
cps_api_transaction_close(&tr);
Py_RETURN_TRUE;
}
cps_api_return_code_t cps_api_process_commit_request(cps_api_transaction_params_t *param, size_t ix) {
cps_api_return_code_t rc = cps_api_ret_code_ERR;
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
cps_api_object_t pre = cps_api_object_list_get(param->prev,ix);
if (obj==NULL) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","No Commit Object");
return rc;
}
cps_api_channel_t handle;
cps_api_key_t *key = cps_api_object_key(obj);
char buff[CPS_API_KEY_STR_MAX];
EV_LOG(TRACE,DSAPI,0, "CPS IPC", "Object for commit request: %s ",
cps_api_key_name_print(key, buff, sizeof(buff)));
if (!cps_api_get_handle(*key,handle)) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","No Service");
return cps_api_ret_code_NO_SERVICE;
}
rc = cps_api_ret_code_ERR;
fd_set rset;
FD_ZERO(&rset);
FD_SET(handle,&rset);
do {
if (!cps_api_send_one_object(handle,cps_api_msg_o_COMMIT_CHANGE,obj)) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Could not send COMMIT CHANGE ");
break;
}
if (!cps_api_send_one_object(handle,cps_api_msg_o_COMMIT_PREV,pre)) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Could not send COMMIT PREV ");
break;
}
uint32_t op;
size_t len;
if (param->timeout > 0) {
if ((rc=cps_api_timeout_wait(handle,&rset,param->timeout,"CPS-OP-TR"))!=cps_api_ret_code_OK) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Transaction Response timed out ");
break;
}
}
rc = cps_api_ret_code_ERR;
if (!cps_api_receive_header(handle,op,len)) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Failed to read the receive header ");
break;
}
if (op == cps_api_msg_o_COMMIT_OBJECT) {
cps_api_object_guard og(cps_api_receive_object(handle,len));
if (!og.valid()) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Transaction response missing cur object..");
break;
}
cps_api_object_clone(obj,og.get());
if (!cps_api_receive_header(handle,op,len)) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Failed to read the receive header for prev object ");
break;
}
if (op!=cps_api_msg_o_COMMIT_OBJECT) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Transaction response header incorrect for prev object" );
break;
}
if (len>0) {
cps_api_object_guard og(cps_api_receive_object(handle,len));
if (!og.valid()) {
EV_LOG(ERR,DSAPI,0,"CPS IPC","Transaction response missing resp object..");
break;
}
obj = cps_api_object_list_get(param->prev,ix);
if (obj==NULL) { //if there was no previous object passed by client override
if (cps_api_object_list_append(param->prev,og.get())) {
og.release();
rc = cps_api_ret_code_OK;
}
} else {
//take the previous provided by the client if the key is valid
//assume that the data is valid too
if (cps_api_key_get_len(cps_api_object_key(og.get()))>0) {
cps_api_object_clone(obj,og.get());
}
rc = cps_api_ret_code_OK;
}
}
}
if (op == cps_api_msg_o_RETURN_CODE) {
if (!cps_api_receive_data(handle,&rc,sizeof(rc))) break;
}
} while (0);
cps_api_disconnect_owner(handle);
return rc;
}
/**
* This function provides NAS-QoS priority_group stats CPS API clear function
* To clear the priority_group stats, set relevant counters to zero
* @Param Standard CPS API params
* @Return Standard Error Code
*/
cps_api_return_code_t nas_qos_cps_api_priority_group_stat_clear (void * context,
cps_api_transaction_params_t * param,
size_t ix)
{
cps_api_object_t obj = cps_api_object_list_get(param->change_list,ix);
cps_api_operation_types_t op = cps_api_object_type_operation(cps_api_object_key(obj));
if (op != cps_api_oper_SET)
return NAS_QOS_E_UNSUPPORTED;
cps_api_object_attr_t port_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID);
cps_api_object_attr_t local_id_attr = cps_api_get_key_data(obj, BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID);
if (port_id_attr == NULL ||
local_id_attr == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Incomplete key: port-id, priority_group local id must be specified\n");
return NAS_QOS_E_MISSING_KEY;
}
uint32_t switch_id = 0;
nas_qos_priority_group_key_t key;
key.port_id = cps_api_object_attr_data_u32(port_id_attr);
key.local_id = *(uint8_t *)cps_api_object_attr_data_bin(local_id_attr);
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Read switch id %u, port_id %u priority_group local_id %u stat\n",
switch_id, key.port_id, key.local_id);
std_mutex_simple_lock_guard p_m(&priority_group_mutex);
// If the port is not be initialized yet, initialize it in NAS
nas_qos_port_priority_group_init(key.port_id);
nas_qos_switch *switch_p = nas_qos_get_switch(switch_id);
if (switch_p == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "switch_id %u not found", switch_id);
return NAS_QOS_E_FAIL;
}
nas_qos_priority_group * priority_group_p = switch_p->get_priority_group(key);
if (priority_group_p == NULL) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Priority Group not found");
return NAS_QOS_E_FAIL;
}
std::vector<BASE_QOS_PRIORITY_GROUP_STAT_t> counter_ids;
cps_api_object_it_t it;
cps_api_object_it_begin(obj,&it);
for ( ; cps_api_object_it_valid(&it) ; cps_api_object_it_next(&it) ) {
cps_api_attr_id_t id = cps_api_object_attr_id(it.attr);
switch (id) {
case BASE_QOS_PRIORITY_GROUP_STAT_PORT_ID:
case BASE_QOS_PRIORITY_GROUP_STAT_LOCAL_ID:
break;
case BASE_QOS_PRIORITY_GROUP_STAT_PACKETS:
case BASE_QOS_PRIORITY_GROUP_STAT_BYTES:
case BASE_QOS_PRIORITY_GROUP_STAT_WATERMARK_BYTES:
counter_ids.push_back((BASE_QOS_PRIORITY_GROUP_STAT_t)id);
break;
case BASE_QOS_PRIORITY_GROUP_STAT_CURRENT_OCCUPANCY_BYTES:
// READ-only
break;
default:
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS",
"Unknown priority_group STAT flag: %u, ignored", id);
break;
}
}
if (ndi_qos_clear_priority_group_stats(priority_group_p->get_ndi_port_id(),
priority_group_p->ndi_obj_id(),
&counter_ids[0],
counter_ids.size()) != STD_ERR_OK) {
EV_LOG_TRACE(ev_log_t_QOS, 3, "NAS-QOS", "Priority Group stats clear failed");
return NAS_QOS_E_FAIL;
}
return cps_api_ret_code_OK;
}
