matthieu/frr
1
0
Fork 0
forked from Mirror/frr
Code Pull requests Activity

pceplib: add json string option to subgroup counter

Browse source 
The created counters in pceplib library are structures with
a string attribute which is used for further display. This
string information is not formatted for json output.

Add a second option in the create_subgroup_counter() creation
API to provide the json attribute output.

Create a json naming compatible with caml format for each
subgroup counter used.

Signed-off-by: Philippe Guibert <philippe.guibert@6wind.com>
This commit is contained in:
Philippe Guibert 2024-01-10 15:26:05 +01:00
parent 94178edac3
commit 09047d2bf6
4 changed files with 141 additions and 113 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

193
pceplib/pcep_session_logic_counters.c
View file

@ -36,30 +36,30 @@ void create_session_counters(pcep_session *session)
struct counters_subgroup *rx_msg_subgroup = create_counters_subgroup( struct counters_subgroup *rx_msg_subgroup = create_counters_subgroup(
"RX Message counters", COUNTER_SUBGROUP_ID_RX_MSG, "RX Message counters", COUNTER_SUBGROUP_ID_RX_MSG,
PCEP_TYPE_MAX + 1); PCEP_TYPE_MAX + 1);
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_OPEN, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_OPEN, "Message Open",
"Message Open"); "messageOpen");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_KEEPALIVE, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_KEEPALIVE,
"Message KeepAlive"); "Message KeepAlive", "messageKeepalive");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_PCREQ, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_PCREQ,
"Message PcReq"); "Message PcReq", "messagePcReq");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_PCREP, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_PCREP,
"Message PcRep"); "Message PcRep", "messagePcRep");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_PCNOTF, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_PCNOTF,
"Message Notify"); "Message Notify", "messageNotify");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_ERROR, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_ERROR,
"Message Error"); "Message Error", "messageError");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_CLOSE, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_CLOSE,
"Message Close"); "Message Close", "messageClose");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_REPORT, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_REPORT,
"Message Report"); "Message Report", "messageReport");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_UPDATE, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_UPDATE,
"Message Update"); "Message Update", "messageUpdate");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_INITIATE, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_INITIATE,
"Message Initiate"); "Message Initiate", "messageInitiate");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_START_TLS, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_START_TLS,
"Message StartTls"); "Message StartTls", "messageStartTls");
create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_MAX, create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_MAX,
"Message Erroneous"); "Message Erroneous", "messageErroneous");
struct counters_subgroup *tx_msg_subgroup = struct counters_subgroup *tx_msg_subgroup =
clone_counters_subgroup(rx_msg_subgroup, "TX Message counters", clone_counters_subgroup(rx_msg_subgroup, "TX Message counters",
@ -74,59 +74,61 @@ void create_session_counters(pcep_session *session)
struct counters_subgroup *rx_obj_subgroup = create_counters_subgroup( struct counters_subgroup *rx_obj_subgroup = create_counters_subgroup(
"RX Object counters", COUNTER_SUBGROUP_ID_RX_OBJ, 100); "RX Object counters", COUNTER_SUBGROUP_ID_RX_OBJ, 100);
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_OPEN, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_OPEN,
"Object Open"); "Object Open", "objectOpen");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_RP, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_RP, "Object RP",
"Object RP"); "objectRP");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_NOPATH, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_NOPATH,
"Object Nopath"); "Object Nopath", "objectNopath");
create_subgroup_counter( create_subgroup_counter(rx_obj_subgroup,
rx_obj_subgroup, ((PCEP_OBJ_CLASS_ENDPOINTS << 4) |
((PCEP_OBJ_CLASS_ENDPOINTS << 4) | PCEP_OBJ_TYPE_ENDPOINT_IPV4), PCEP_OBJ_TYPE_ENDPOINT_IPV4),
"Object Endpoint IPv4"); "Object Endpoint IPv4", "objectEndpointIPv4");
create_subgroup_counter( create_subgroup_counter(rx_obj_subgroup,
rx_obj_subgroup, ((PCEP_OBJ_CLASS_ENDPOINTS << 4) |
((PCEP_OBJ_CLASS_ENDPOINTS << 4) | PCEP_OBJ_TYPE_ENDPOINT_IPV6), PCEP_OBJ_TYPE_ENDPOINT_IPV6),
"Object Endpoint IPv6"); "Object Endpoint IPv6", "objectEndpointIPv6");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_BANDWIDTH, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_BANDWIDTH,
"Object Bandwidth"); "Object Bandwidth", "objectBandwidth");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_METRIC, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_METRIC,
"Object Metric"); "Object Metric", "objectMetric");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_ERO, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_ERO,
"Object ERO"); "Object ERO", "objectERO");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_RRO, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_RRO,
"Object RRO"); "Object RRO", "objectRRO");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_LSPA, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_LSPA,
"Object LSPA"); "Object LSPA", "objectLSPA");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_IRO, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_IRO,
"Object IRO"); "Object IRO", "objectIRO");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_SVEC, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_SVEC,
"Object SVEC"); "Object SVEC", "objectSVEC");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_NOTF, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_NOTF,
"Object Notify"); "Object Notify", "objectNotify");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_ERROR, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_ERROR,
"Object Error"); "Object Error", "objectError");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_CLOSE, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_CLOSE,
"Object Close"); "Object Close", "objectClose");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_LSP, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_LSP,
"Object LSP"); "Object LSP", "objectLSP");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_SRP, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_SRP,
"Object SRP"); "Object SRP", "objectSRP");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_VENDOR_INFO, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_VENDOR_INFO,
"Object Vendor Info"); "Object Vendor Info", "objectVendorInfo");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_INTER_LAYER, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_INTER_LAYER,
"Object Inter-Layer"); "Object Inter-Layer", "objectInterLayer");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_SWITCH_LAYER, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_SWITCH_LAYER,
"Object Switch-Layer"); "Object Switch-Layer", "objectSwitchLayer");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_REQ_ADAP_CAP, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_REQ_ADAP_CAP,
"Object Requested Adap-Cap"); "Object Requested Adap-Cap",
"objectRequestedAdapCap");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_SERVER_IND, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_SERVER_IND,
"Object Server-Indication"); "Object Server-Indication",
"objectServerIndication");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_ASSOCIATION, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_ASSOCIATION,
"Object Association"); "Object Association", "objectAssociation");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_MAX, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_MAX,
"Object Unknown"); "Object Unknown", "objectUnknown");
create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_MAX + 1, create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_MAX + 1,
"Object Erroneous"); "Object Erroneous", "objectErroneous");
struct counters_subgroup *tx_obj_subgroup = struct counters_subgroup *tx_obj_subgroup =
clone_counters_subgroup(rx_obj_subgroup, "TX Object counters", clone_counters_subgroup(rx_obj_subgroup, "TX Object counters",
@ -139,21 +141,22 @@ void create_session_counters(pcep_session *session)
"RX RO Sub-Object counters", COUNTER_SUBGROUP_ID_RX_SUBOBJ, "RX RO Sub-Object counters", COUNTER_SUBGROUP_ID_RX_SUBOBJ,
RO_SUBOBJ_UNKNOWN + 2); RO_SUBOBJ_UNKNOWN + 2);
create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_IPV4, create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_IPV4,
"RO Sub-Object IPv4"); "RO Sub-Object IPv4", "ROSubObjectIPv4");
create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_IPV6, create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_IPV6,
"RO Sub-Object IPv6"); "RO Sub-Object IPv6", "ROSubObjectIPv6");
create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_LABEL, create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_LABEL,
"RO Sub-Object Label"); "RO Sub-Object Label", "ROSubObjectLabel");
create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_UNNUM, create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_UNNUM,
"RO Sub-Object Unnum"); "RO Sub-Object Unnum", "ROSubObjectUnnum");
create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_ASN, create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_ASN,
"RO Sub-Object ASN"); "RO Sub-Object ASN", "ROSubObjectASN");
create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_SR, create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_TYPE_SR,
"RO Sub-Object SR"); "RO Sub-Object SR", "ROSubObjectSR");
create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_UNKNOWN, create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_UNKNOWN,
"RO Sub-Object Unknown"); "RO Sub-Object Unknown", "ROSubObjectUnknown");
create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_UNKNOWN + 1, create_subgroup_counter(rx_subobj_subgroup, RO_SUBOBJ_UNKNOWN + 1,
"RO Sub-Object Erroneous"); "RO Sub-Object Erroneous",
"ROSubObjectErroneous");
struct counters_subgroup *tx_subobj_subgroup = clone_counters_subgroup( struct counters_subgroup *tx_subobj_subgroup = clone_counters_subgroup(
rx_subobj_subgroup, "TX RO Sub-Object counters", rx_subobj_subgroup, "TX RO Sub-Object counters",
@ -168,28 +171,36 @@ void create_session_counters(pcep_session *session)
PCEP_SR_SUBOBJ_NAI_UNKNOWN + 1); PCEP_SR_SUBOBJ_NAI_UNKNOWN + 1);
create_subgroup_counter(rx_subobj_sr_nai_subgroup, create_subgroup_counter(rx_subobj_sr_nai_subgroup,
PCEP_SR_SUBOBJ_NAI_ABSENT, PCEP_SR_SUBOBJ_NAI_ABSENT,
"RO Sub-Object SR NAI absent"); "RO Sub-Object SR NAI absent",
"ROSubObjectSRNAIAbsent");
create_subgroup_counter(rx_subobj_sr_nai_subgroup, create_subgroup_counter(rx_subobj_sr_nai_subgroup,
PCEP_SR_SUBOBJ_NAI_IPV4_NODE, PCEP_SR_SUBOBJ_NAI_IPV4_NODE,
"RO Sub-Object SR NAI IPv4 Node"); "RO Sub-Object SR NAI IPv4 Node",
"ROSubObjectSRNAIIPv4Node");
create_subgroup_counter(rx_subobj_sr_nai_subgroup, create_subgroup_counter(rx_subobj_sr_nai_subgroup,
PCEP_SR_SUBOBJ_NAI_IPV6_NODE, PCEP_SR_SUBOBJ_NAI_IPV6_NODE,
"RO Sub-Object SR NAI IPv6 Node"); "RO Sub-Object SR NAI IPv6 Node",
"ROSubObjectSRNAIIPv6Node");
create_subgroup_counter(rx_subobj_sr_nai_subgroup, create_subgroup_counter(rx_subobj_sr_nai_subgroup,
PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY, PCEP_SR_SUBOBJ_NAI_IPV4_ADJACENCY,
"RO Sub-Object SR NAI IPv4 Adj"); "RO Sub-Object SR NAI IPv4 Adj",
"ROSubObjectSRNAIIPv4Adj");
create_subgroup_counter(rx_subobj_sr_nai_subgroup, create_subgroup_counter(rx_subobj_sr_nai_subgroup,
PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY, PCEP_SR_SUBOBJ_NAI_IPV6_ADJACENCY,
"RO Sub-Object SR NAI IPv6 Adj"); "RO Sub-Object SR NAI IPv6 Adj",
"ROSubObjectSRNAIIPv6Adj");
create_subgroup_counter(rx_subobj_sr_nai_subgroup, create_subgroup_counter(rx_subobj_sr_nai_subgroup,
PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY, PCEP_SR_SUBOBJ_NAI_UNNUMBERED_IPV4_ADJACENCY,
"RO Sub-Object SR NAI Unnumbered IPv4 Adj"); "RO Sub-Object SR NAI Unnumbered IPv4 Adj",
"ROSubObjectSRNAIUnnumberedIPv4Adj");
create_subgroup_counter(rx_subobj_sr_nai_subgroup, create_subgroup_counter(rx_subobj_sr_nai_subgroup,
PCEP_SR_SUBOBJ_NAI_LINK_LOCAL_IPV6_ADJACENCY, PCEP_SR_SUBOBJ_NAI_LINK_LOCAL_IPV6_ADJACENCY,
"RO Sub-Object SR NAI Link Local IPv6 Adj"); "RO Sub-Object SR NAI Link Local IPv6 Adj",
"ROSubObjectSRNAILinkLocalIPv6Adj");
create_subgroup_counter(rx_subobj_sr_nai_subgroup, create_subgroup_counter(rx_subobj_sr_nai_subgroup,
PCEP_SR_SUBOBJ_NAI_UNKNOWN, PCEP_SR_SUBOBJ_NAI_UNKNOWN,
"RO Sub-Object SR NAI Unknown"); "RO Sub-Object SR NAI Unknown",
"ROSubObjectSRNAIUnknown");
struct counters_subgroup *tx_subobj_sr_nai_subgroup = struct counters_subgroup *tx_subobj_sr_nai_subgroup =
clone_counters_subgroup(rx_subobj_sr_nai_subgroup, clone_counters_subgroup(rx_subobj_sr_nai_subgroup,
@ -204,56 +215,60 @@ void create_session_counters(pcep_session *session)
PCEP_OBJ_TLV_TYPE_UNKNOWN + 1); PCEP_OBJ_TLV_TYPE_UNKNOWN + 1);
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_NO_PATH_VECTOR, PCEP_OBJ_TLV_TYPE_NO_PATH_VECTOR,
"TLV No Path Vector"); "TLV No Path Vector", "TLVNoPathVector");
create_subgroup_counter(rx_tlv_subgroup, PCEP_OBJ_TLV_TYPE_VENDOR_INFO, create_subgroup_counter(rx_tlv_subgroup, PCEP_OBJ_TLV_TYPE_VENDOR_INFO,
"TLV Vendor Info"); "TLV Vendor Info", "TLVVendorInfo");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY, PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY,
"TLV Stateful PCE Capability"); "TLV Stateful PCE Capability",
"TLVStatefulPCCapability");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME, PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME,
"TLV Symbolic Path Name"); "TLV Symbolic Path Name", "TLVSymbolicPathName");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS, PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS,
"TLV IPv4 LSP Identifier"); "TLV IPv4 LSP Identifier",
"TLVIPv4LSPIdentifier");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_IPV6_LSP_IDENTIFIERS, PCEP_OBJ_TLV_TYPE_IPV6_LSP_IDENTIFIERS,
"TLV IPv6 LSP Identifier"); "TLV IPv6 LSP Identifier",
"TLVIPv6LSPIdentifier");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_LSP_ERROR_CODE, PCEP_OBJ_TLV_TYPE_LSP_ERROR_CODE,
"TLV LSP Error Code"); "TLV LSP Error Code", "TLVLSPErrorCode");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_RSVP_ERROR_SPEC, PCEP_OBJ_TLV_TYPE_RSVP_ERROR_SPEC,
"TLV RSVP Error Spec"); "TLV RSVP Error Spec", "TLVRSVPErrorSpec");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_LSP_DB_VERSION, PCEP_OBJ_TLV_TYPE_LSP_DB_VERSION,
"TLV LSP DB Version"); "TLV LSP DB Version", "TLVLSPDBVersion");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_SPEAKER_ENTITY_ID, PCEP_OBJ_TLV_TYPE_SPEAKER_ENTITY_ID,
"TLV Speaker Entity ID"); "TLV Speaker Entity ID", "TLVSpeakerEntityId");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY, PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY,
"TLV SR PCE Capability"); "TLV SR PCE Capability", "TLVSRPCECapability");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE, PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE,
"TLV Path Setup Type"); "TLV Path Setup Type", "TLVPathSetupType");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE_CAPABILITY, PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE_CAPABILITY,
"TLV Path Setup Type Capability"); "TLV Path Setup Type Capability",
"TLVPathSetupTypeCapability");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_ID, PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_ID,
"TLV SR Policy PolId"); "TLV SR Policy PolId", "TLVSRPolicyPolId");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_NAME, PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_NAME,
"TLV SR Policy PolName"); "TLV SR Policy PolName", "TLVSRPolicyPolName");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_ID, PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_ID,
"TLV SR Policy CpathId"); "TLV SR Policy CpathId", "TLVSRPolicyCpathId");
create_subgroup_counter(rx_tlv_subgroup, create_subgroup_counter(rx_tlv_subgroup,
PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_PREFERENCE, PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_PREFERENCE,
"TLV SR Policy CpathRef"); "TLV SR Policy CpathRef", "TLVSRPolicyCpathRef");
create_subgroup_counter(rx_tlv_subgroup, PCEP_OBJ_TLV_TYPE_UNKNOWN, create_subgroup_counter(rx_tlv_subgroup, PCEP_OBJ_TLV_TYPE_UNKNOWN,
"TLV Unknown"); "TLV Unknown", "TLVUnknown");
struct counters_subgroup *tx_tlv_subgroup = clone_counters_subgroup( struct counters_subgroup *tx_tlv_subgroup = clone_counters_subgroup(
rx_tlv_subgroup, "TX TLV counters", COUNTER_SUBGROUP_ID_TX_TLV); rx_tlv_subgroup, "TX TLV counters", COUNTER_SUBGROUP_ID_TX_TLV);
@ -265,28 +280,32 @@ void create_session_counters(pcep_session *session)
"Events counters", COUNTER_SUBGROUP_ID_EVENT, MAX_COUNTERS); "Events counters", COUNTER_SUBGROUP_ID_EVENT, MAX_COUNTERS);
create_subgroup_counter(events_subgroup, create_subgroup_counter(events_subgroup,
PCEP_EVENT_COUNTER_ID_PCC_CONNECT, PCEP_EVENT_COUNTER_ID_PCC_CONNECT,
"PCC connect"); "PCC connect", "PCCConnect");
create_subgroup_counter(events_subgroup, create_subgroup_counter(events_subgroup,
PCEP_EVENT_COUNTER_ID_PCE_CONNECT, PCEP_EVENT_COUNTER_ID_PCE_CONNECT,
"PCE connect"); "PCE connect", "PCEConnect");
create_subgroup_counter(events_subgroup, create_subgroup_counter(events_subgroup,
PCEP_EVENT_COUNTER_ID_PCC_DISCONNECT, PCEP_EVENT_COUNTER_ID_PCC_DISCONNECT,
"PCC disconnect"); "PCC disconnect", "PCCDisconnect");
create_subgroup_counter(events_subgroup, create_subgroup_counter(events_subgroup,
PCEP_EVENT_COUNTER_ID_PCE_DISCONNECT, PCEP_EVENT_COUNTER_ID_PCE_DISCONNECT,
"PCE disconnect"); "PCE disconnect", "PCEDisconnect");
create_subgroup_counter(events_subgroup, create_subgroup_counter(events_subgroup,
PCEP_EVENT_COUNTER_ID_TIMER_KEEPALIVE, PCEP_EVENT_COUNTER_ID_TIMER_KEEPALIVE,
"Timer KeepAlive expired"); "Timer KeepAlive expired",
"timerKeepAliveExpired");
create_subgroup_counter(events_subgroup, create_subgroup_counter(events_subgroup,
PCEP_EVENT_COUNTER_ID_TIMER_DEADTIMER, PCEP_EVENT_COUNTER_ID_TIMER_DEADTIMER,
"Timer DeadTimer expired"); "Timer DeadTimer expired",
"timerDeadTimerExpired");
create_subgroup_counter(events_subgroup, create_subgroup_counter(events_subgroup,
PCEP_EVENT_COUNTER_ID_TIMER_OPENKEEPWAIT, PCEP_EVENT_COUNTER_ID_TIMER_OPENKEEPWAIT,
"Timer OpenKeepWait expired"); "Timer OpenKeepWait expired",
"timerOpenKeepWaitExpired");
create_subgroup_counter(events_subgroup, create_subgroup_counter(events_subgroup,
PCEP_EVENT_COUNTER_ID_TIMER_OPENKEEPALIVE, PCEP_EVENT_COUNTER_ID_TIMER_OPENKEEPALIVE,
"Timer OpenKeepAlive expired"); "Timer OpenKeepAlive expired",
"timerOpenKeepAliveExpired");
/* /*
* Create the parent counters group * Create the parent counters group

10
pceplib/pcep_utils_counters.c
View file

@ -139,7 +139,8 @@ clone_counters_subgroup(struct counters_subgroup *subgroup,
if (counter != NULL) { if (counter != NULL) {
create_subgroup_counter(cloned_subgroup, create_subgroup_counter(cloned_subgroup,
counter->counter_id, counter->counter_id,
counter->counter_name); counter->counter_name,
counter->counter_name_json);
} }
} }
@ -180,7 +181,8 @@ bool add_counters_subgroup(struct counters_group *group,
} }
bool create_subgroup_counter(struct counters_subgroup *subgroup, bool create_subgroup_counter(struct counters_subgroup *subgroup,
uint32_t counter_id, const char *counter_name) uint32_t counter_id, const char *counter_name,
const char *counter_name_json)
{ {
if (subgroup == NULL) { if (subgroup == NULL) {
pcep_log( pcep_log(
@ -212,7 +214,9 @@ bool create_subgroup_counter(struct counters_subgroup *subgroup,
counter->counter_id = counter_id; counter->counter_id = counter_id;
strlcpy(counter->counter_name, counter_name, strlcpy(counter->counter_name, counter_name,
sizeof(counter->counter_name)); sizeof(counter->counter_name));
if (counter_name_json)
strlcpy(counter->counter_name_json, counter_name_json,
sizeof(counter->counter_name_json));
subgroup->num_counters++; subgroup->num_counters++;
subgroup->counters[counter->counter_id] = counter; subgroup->counters[counter->counter_id] = counter;

27
pceplib/pcep_utils_counters.h
View file

@ -55,18 +55,18 @@ extern "C" {
* *events_subgroup = create_counters_subgroup("events counters", 4); * *events_subgroup = create_counters_subgroup("events counters", 4);
* *
* Use message_id: PCEP_TYPE_OPEN=1 * Use message_id: PCEP_TYPE_OPEN=1
* create_subgroup_counter(rx_subgroup, 1, "Message Open"); * create_subgroup_counter(rx_subgroup, 1, "Message Open", "messageOpen");
* create_subgroup_counter(rx_subgroup, 2, "Message KeepAlive"); * create_subgroup_counter(rx_subgroup, 2, "Message KeepAlive", "messageKeepAlive");
* create_subgroup_counter(rx_subgroup, 3, "Message PcReq"); * create_subgroup_counter(rx_subgroup, 3, "Message PcReq", "messagePcReq");
* *
* create_subgroup_counter(tx_subgroup, 1, "Message Open"); * create_subgroup_counter(tx_subgroup, 1, "Message Open", "messageOpen");
* create_subgroup_counter(tx_subgroup, 2, "Message KeepAlive"); * create_subgroup_counter(tx_subgroup, 2, "Message KeepAlive", "messageKeepAlive");
* create_subgroup_counter(tx_subgroup, 3, "Message PcReq"); * create_subgroup_counter(tx_subgroup, 3, "Message PcReq", "messagePcReq");
* *
* create_subgroup_counter(events_subgroup, 1, "PCC Connect"); * create_subgroup_counter(events_subgroup, 1, "PCC Connect", "PCConnect");
* create_subgroup_counter(events_subgroup, 2, "PCE Connect"); * create_subgroup_counter(events_subgroup, 2, "PCE Connect", "PCEConnect");
* create_subgroup_counter(events_subgroup, 3, "PCC Disconnect"); * create_subgroup_counter(events_subgroup, 3, "PCC Disconnect", "PCCDisconnect");
* create_subgroup_counter(events_subgroup, 4, "PCE Disconnect"); * create_subgroup_counter(events_subgroup, 4, "PCE Disconnect", "PCEDisconnect");
* *
* struct counters_group *cntrs_group = create_counters_group("PCEP Counters", * struct counters_group *cntrs_group = create_counters_group("PCEP Counters",
* 3); add_counters_subgroup(cntrs_group, rx_subgroup); * 3); add_counters_subgroup(cntrs_group, rx_subgroup);
@ -81,6 +81,7 @@ extern "C" {
struct counter { struct counter {
uint16_t counter_id; uint16_t counter_id;
char counter_name[MAX_COUNTER_STR_LENGTH]; char counter_name[MAX_COUNTER_STR_LENGTH];
char counter_name_json[MAX_COUNTER_STR_LENGTH];
uint32_t counter_value; uint32_t counter_value;
}; };
@ -142,13 +143,15 @@ clone_counters_subgroup(struct counters_subgroup *subgroup,
const char *subgroup_name, uint16_t subgroup_id); const char *subgroup_name, uint16_t subgroup_id);
/* /*
* Create a counter in a subgroup with the given counter_id and counter_name. * Create a counter in a subgroup with the given counter_id and counter_name
* and counter_name_json.
* The counter_id is 0-based. * The counter_id is 0-based.
* Return true on success or false if subgroup is NULL, counter_id >= * Return true on success or false if subgroup is NULL, counter_id >=
* MAX_COUNTERS, or if counter_name is NULL. * MAX_COUNTERS, or if counter_name is NULL.
*/ */
bool create_subgroup_counter(struct counters_subgroup *subgroup, bool create_subgroup_counter(struct counters_subgroup *subgroup,
uint32_t counter_id, const char *counter_name); uint32_t counter_id, const char *counter_name,
const char *couter_name_json);
/* /*
* Delete the counters_group and recursively delete all subgroups and their * Delete the counters_group and recursively delete all subgroups and their

24
pceplib/test/pcep_utils_counters_test.c
View file

@ -106,17 +106,19 @@ void test_create_subgroup_counter()
{ {
uint16_t counter_id = 1; uint16_t counter_id = 1;
char counter_name[] = "my counter"; char counter_name[] = "my counter";
char counter_name_json[] = "myCounter";
struct counters_subgroup *subgroup = struct counters_subgroup *subgroup =
create_counters_subgroup("subgroup", 1, 2); create_counters_subgroup("subgroup", 1, 2);
CU_ASSERT_FALSE( CU_ASSERT_FALSE(create_subgroup_counter(NULL, counter_id, counter_name,
create_subgroup_counter(NULL, counter_id, counter_name)); counter_name_json));
CU_ASSERT_FALSE(create_subgroup_counter(subgroup, counter_id + 1, CU_ASSERT_FALSE(create_subgroup_counter(subgroup, counter_id + 1,
counter_name)); counter_name));
CU_ASSERT_FALSE(create_subgroup_counter(subgroup, counter_id, NULL)); CU_ASSERT_FALSE(
create_subgroup_counter(subgroup, counter_id, NULL, NULL));
CU_ASSERT_EQUAL(subgroup->num_counters, 0); CU_ASSERT_EQUAL(subgroup->num_counters, 0);
CU_ASSERT_TRUE( CU_ASSERT_TRUE(create_subgroup_counter(subgroup, counter_id,
create_subgroup_counter(subgroup, counter_id, counter_name)); counter_name, counter_name_json));
CU_ASSERT_EQUAL(subgroup->num_counters, 1); CU_ASSERT_EQUAL(subgroup->num_counters, 1);
delete_counters_subgroup(subgroup); delete_counters_subgroup(subgroup);
@ -146,7 +148,7 @@ void test_reset_group_counters()
struct counters_group *group = create_counters_group("group", 10); struct counters_group *group = create_counters_group("group", 10);
struct counters_subgroup *subgroup = struct counters_subgroup *subgroup =
create_counters_subgroup("subgroup", subgroup_id, 10); create_counters_subgroup("subgroup", subgroup_id, 10);
create_subgroup_counter(subgroup, counter_id, "counter"); create_subgroup_counter(subgroup, counter_id, "counter", "counter");
add_counters_subgroup(group, subgroup); add_counters_subgroup(group, subgroup);
struct counter *counter = subgroup->counters[counter_id]; struct counter *counter = subgroup->counters[counter_id];
@ -164,7 +166,7 @@ void test_reset_subgroup_counters()
uint16_t counter_id = 1; uint16_t counter_id = 1;
struct counters_subgroup *subgroup = struct counters_subgroup *subgroup =
create_counters_subgroup("subgroup", 1, 10); create_counters_subgroup("subgroup", 1, 10);
create_subgroup_counter(subgroup, counter_id, "counter"); create_subgroup_counter(subgroup, counter_id, "counter", "counter");
struct counter *counter = subgroup->counters[counter_id]; struct counter *counter = subgroup->counters[counter_id];
counter->counter_value = 100; counter->counter_value = 100;
@ -183,7 +185,7 @@ void test_increment_counter()
struct counters_group *group = create_counters_group("group", 10); struct counters_group *group = create_counters_group("group", 10);
struct counters_subgroup *subgroup = struct counters_subgroup *subgroup =
create_counters_subgroup("subgroup", subgroup_id, 10); create_counters_subgroup("subgroup", subgroup_id, 10);
create_subgroup_counter(subgroup, counter_id, "counter"); create_subgroup_counter(subgroup, counter_id, "counter", "counter");
add_counters_subgroup(group, subgroup); add_counters_subgroup(group, subgroup);
struct counter *counter = subgroup->counters[counter_id]; struct counter *counter = subgroup->counters[counter_id];
@ -205,7 +207,7 @@ void test_increment_subgroup_counter()
uint32_t counter_value = 100; uint32_t counter_value = 100;
struct counters_subgroup *subgroup = struct counters_subgroup *subgroup =
create_counters_subgroup("subgroup", 1, 10); create_counters_subgroup("subgroup", 1, 10);
create_subgroup_counter(subgroup, counter_id, "counter"); create_subgroup_counter(subgroup, counter_id, "counter", "counter");
struct counter *counter = subgroup->counters[counter_id]; struct counter *counter = subgroup->counters[counter_id];
counter->counter_value = counter_value; counter->counter_value = counter_value;
@ -225,7 +227,7 @@ void test_dump_counters_group_to_log()
struct counters_group *group = create_counters_group("group", 10); struct counters_group *group = create_counters_group("group", 10);
struct counters_subgroup *subgroup = struct counters_subgroup *subgroup =
create_counters_subgroup("subgroup", subgroup_id, 10); create_counters_subgroup("subgroup", subgroup_id, 10);
create_subgroup_counter(subgroup, counter_id, "counter"); create_subgroup_counter(subgroup, counter_id, "counter", "counter");
add_counters_subgroup(group, subgroup); add_counters_subgroup(group, subgroup);
CU_ASSERT_FALSE(dump_counters_group_to_log(NULL)); CU_ASSERT_FALSE(dump_counters_group_to_log(NULL));
@ -240,7 +242,7 @@ void test_dump_counters_subgroup_to_log()
uint16_t counter_id = 1; uint16_t counter_id = 1;
struct counters_subgroup *subgroup = struct counters_subgroup *subgroup =
create_counters_subgroup("subgroup", subgroup_id, 10); create_counters_subgroup("subgroup", subgroup_id, 10);
create_subgroup_counter(subgroup, counter_id, "counter"); create_subgroup_counter(subgroup, counter_id, "counter", "counter");
CU_ASSERT_FALSE(dump_counters_subgroup_to_log(NULL)); CU_ASSERT_FALSE(dump_counters_subgroup_to_log(NULL));
CU_ASSERT_TRUE(dump_counters_subgroup_to_log(subgroup)); CU_ASSERT_TRUE(dump_counters_subgroup_to_log(subgroup));