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; }