pceplib: add json string option to subgroup counter

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>

diff --git a/pceplib/pcep_session_logic_counters.c b/pceplib/pcep_session_logic_counters.c
index 6f6f2a0df46532acdc880eb492b3f6420752a900..b12b8ab0e072bb431f4709b4617070577f7be347 100644 (file)
--- a/pceplib/pcep_session_logic_counters.c
+++ b/pceplib/pcep_session_logic_counters.c
@@ -36,30 +36,30 @@ void create_session_counters(pcep_session *session)
        struct counters_subgroup *rx_msg_subgroup = create_counters_subgroup(
                "RX Message counters", COUNTER_SUBGROUP_ID_RX_MSG,
                PCEP_TYPE_MAX + 1);
-       create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_OPEN,
-                               "Message Open");
+       create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_OPEN, "Message Open",
+                               "messageOpen");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_KEEPALIVE,
-                               "Message KeepAlive");
+                               "Message KeepAlive", "messageKeepalive");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_PCREQ,
-                               "Message PcReq");
+                               "Message PcReq", "messagePcReq");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_PCREP,
-                               "Message PcRep");
+                               "Message PcRep", "messagePcRep");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_PCNOTF,
-                               "Message Notify");
+                               "Message Notify", "messageNotify");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_ERROR,
-                               "Message Error");
+                               "Message Error", "messageError");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_CLOSE,
-                               "Message Close");
+                               "Message Close", "messageClose");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_REPORT,
-                               "Message Report");
+                               "Message Report", "messageReport");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_UPDATE,
-                               "Message Update");
+                               "Message Update", "messageUpdate");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_INITIATE,
-                               "Message Initiate");
+                               "Message Initiate", "messageInitiate");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_START_TLS,
-                               "Message StartTls");
+                               "Message StartTls", "messageStartTls");
        create_subgroup_counter(rx_msg_subgroup, PCEP_TYPE_MAX,
-                               "Message Erroneous");
+                               "Message Erroneous", "messageErroneous");
 
        struct counters_subgroup *tx_msg_subgroup =
                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(
                "RX Object counters", COUNTER_SUBGROUP_ID_RX_OBJ, 100);
        create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_OPEN,
-                               "Object Open");
-       create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_RP,
-                               "Object RP");
+                               "Object Open", "objectOpen");
+       create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_RP, "Object RP",
+                               "objectRP");
        create_subgroup_counter(rx_obj_subgroup, PCEP_OBJ_CLASS_NOPATH,
-                               "Object Nopath");
-       create_subgroup_counter(
-               rx_obj_subgroup,
-               ((PCEP_OBJ_CLASS_ENDPOINTS << 4) | PCEP_OBJ_TYPE_ENDPOINT_IPV4),
-               "Object Endpoint IPv4");
-       create_subgroup_counter(
-               rx_obj_subgroup,
-               ((PCEP_OBJ_CLASS_ENDPOINTS << 4) | PCEP_OBJ_TYPE_ENDPOINT_IPV6),
-               "Object Endpoint IPv6");
+                               "Object Nopath", "objectNopath");
+       create_subgroup_counter(rx_obj_subgroup,
+                               ((PCEP_OBJ_CLASS_ENDPOINTS << 4) |
+                                PCEP_OBJ_TYPE_ENDPOINT_IPV4),
+                               "Object Endpoint IPv4", "objectEndpointIPv4");
+       create_subgroup_counter(rx_obj_subgroup,
+                               ((PCEP_OBJ_CLASS_ENDPOINTS << 4) |
+                                PCEP_OBJ_TYPE_ENDPOINT_IPV6),
+                               "Object Endpoint IPv6", "objectEndpointIPv6");
        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,
-                               "Object Metric");
+                               "Object Metric", "objectMetric");
        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,
-                               "Object RRO");
+                               "Object RRO", "objectRRO");
        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,
-                               "Object IRO");
+                               "Object IRO", "objectIRO");
        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,
-                               "Object Notify");
+                               "Object Notify", "objectNotify");
        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,
-                               "Object Close");
+                               "Object Close", "objectClose");
        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,
-                               "Object SRP");
+                               "Object SRP", "objectSRP");
        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,
-                               "Object Inter-Layer");
+                               "Object Inter-Layer", "objectInterLayer");
        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,
-                               "Object Requested Adap-Cap");
+                               "Object Requested Adap-Cap",
+                               "objectRequestedAdapCap");
        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,
-                               "Object Association");
+                               "Object Association", "objectAssociation");
        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,
-                               "Object Erroneous");
+                               "Object Erroneous", "objectErroneous");
 
        struct counters_subgroup *tx_obj_subgroup =
                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,
                RO_SUBOBJ_UNKNOWN + 2);
        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,
-                               "RO Sub-Object IPv6");
+                               "RO Sub-Object IPv6", "ROSubObjectIPv6");
        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,
-                               "RO Sub-Object Unnum");
+                               "RO Sub-Object Unnum", "ROSubObjectUnnum");
        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,
-                               "RO Sub-Object SR");
+                               "RO Sub-Object SR", "ROSubObjectSR");
        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,
-                               "RO Sub-Object Erroneous");
+                               "RO Sub-Object Erroneous",
+                               "ROSubObjectErroneous");
 
        struct counters_subgroup *tx_subobj_subgroup = clone_counters_subgroup(
                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);
        create_subgroup_counter(rx_subobj_sr_nai_subgroup,
                                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,
                                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,
                                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,
                                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,
                                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,
                                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,
                                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,
                                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 =
                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);
        create_subgroup_counter(rx_tlv_subgroup,
                                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,
-                               "TLV Vendor Info");
+                               "TLV Vendor Info", "TLVVendorInfo");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_STATEFUL_PCE_CAPABILITY,
-                               "TLV Stateful PCE Capability");
+                               "TLV Stateful PCE Capability",
+                               "TLVStatefulPCCapability");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_SYMBOLIC_PATH_NAME,
-                               "TLV Symbolic Path Name");
+                               "TLV Symbolic Path Name", "TLVSymbolicPathName");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_IPV4_LSP_IDENTIFIERS,
-                               "TLV IPv4 LSP Identifier");
+                               "TLV IPv4 LSP Identifier",
+                               "TLVIPv4LSPIdentifier");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_IPV6_LSP_IDENTIFIERS,
-                               "TLV IPv6 LSP Identifier");
+                               "TLV IPv6 LSP Identifier",
+                               "TLVIPv6LSPIdentifier");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_LSP_ERROR_CODE,
-                               "TLV LSP Error Code");
+                               "TLV LSP Error Code", "TLVLSPErrorCode");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_RSVP_ERROR_SPEC,
-                               "TLV RSVP Error Spec");
+                               "TLV RSVP Error Spec", "TLVRSVPErrorSpec");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_LSP_DB_VERSION,
-                               "TLV LSP DB Version");
+                               "TLV LSP DB Version", "TLVLSPDBVersion");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_SPEAKER_ENTITY_ID,
-                               "TLV Speaker Entity ID");
+                               "TLV Speaker Entity ID", "TLVSpeakerEntityId");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_SR_PCE_CAPABILITY,
-                               "TLV SR PCE Capability");
+                               "TLV SR PCE Capability", "TLVSRPCECapability");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_PATH_SETUP_TYPE,
-                               "TLV Path Setup Type");
+                               "TLV Path Setup Type", "TLVPathSetupType");
        create_subgroup_counter(rx_tlv_subgroup,
                                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,
                                PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_ID,
-                               "TLV SR Policy PolId");
+                               "TLV SR Policy PolId", "TLVSRPolicyPolId");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_SRPOLICY_POL_NAME,
-                               "TLV SR Policy PolName");
+                               "TLV SR Policy PolName", "TLVSRPolicyPolName");
        create_subgroup_counter(rx_tlv_subgroup,
                                PCEP_OBJ_TLV_TYPE_SRPOLICY_CPATH_ID,
-                               "TLV SR Policy CpathId");
+                               "TLV SR Policy CpathId", "TLVSRPolicyCpathId");
        create_subgroup_counter(rx_tlv_subgroup,
                                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,
-                               "TLV Unknown");
+                               "TLV Unknown", "TLVUnknown");
 
        struct counters_subgroup *tx_tlv_subgroup = clone_counters_subgroup(
                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);
        create_subgroup_counter(events_subgroup,
                                PCEP_EVENT_COUNTER_ID_PCC_CONNECT,
-                               "PCC connect");
+                               "PCC connect", "PCCConnect");
        create_subgroup_counter(events_subgroup,
                                PCEP_EVENT_COUNTER_ID_PCE_CONNECT,
-                               "PCE connect");
+                               "PCE connect", "PCEConnect");
        create_subgroup_counter(events_subgroup,
                                PCEP_EVENT_COUNTER_ID_PCC_DISCONNECT,
-                               "PCC disconnect");
+                               "PCC disconnect", "PCCDisconnect");
        create_subgroup_counter(events_subgroup,
                                PCEP_EVENT_COUNTER_ID_PCE_DISCONNECT,
-                               "PCE disconnect");
+                               "PCE disconnect", "PCEDisconnect");
        create_subgroup_counter(events_subgroup,
                                PCEP_EVENT_COUNTER_ID_TIMER_KEEPALIVE,
-                               "Timer KeepAlive expired");
+                               "Timer KeepAlive expired",
+                               "timerKeepAliveExpired");
        create_subgroup_counter(events_subgroup,
                                PCEP_EVENT_COUNTER_ID_TIMER_DEADTIMER,
-                               "Timer DeadTimer expired");
+                               "Timer DeadTimer expired",
+                               "timerDeadTimerExpired");
        create_subgroup_counter(events_subgroup,
                                PCEP_EVENT_COUNTER_ID_TIMER_OPENKEEPWAIT,
-                               "Timer OpenKeepWait expired");
+                               "Timer OpenKeepWait expired",
+                               "timerOpenKeepWaitExpired");
        create_subgroup_counter(events_subgroup,
                                PCEP_EVENT_COUNTER_ID_TIMER_OPENKEEPALIVE,
-                               "Timer OpenKeepAlive expired");
+                               "Timer OpenKeepAlive expired",
+                               "timerOpenKeepAliveExpired");
 
        /*
         * Create the parent counters group

diff --git a/pceplib/pcep_utils_counters.c b/pceplib/pcep_utils_counters.c
index badef9351a759d61edd1b61c9b1d79a05d462cc0..1ab341c69c5197f86fc324baef6d5f58c97674c9 100644 (file)
--- a/pceplib/pcep_utils_counters.c
+++ b/pceplib/pcep_utils_counters.c
@@ -139,7 +139,8 @@ clone_counters_subgroup(struct counters_subgroup *subgroup,
                if (counter != NULL) {
                        create_subgroup_counter(cloned_subgroup,
                                                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,
-                            uint32_t counter_id, const char *counter_name)
+                            uint32_t counter_id, const char *counter_name,
+                            const char *counter_name_json)
 {
        if (subgroup == NULL) {
                pcep_log(
@@ -212,7 +214,9 @@ bool create_subgroup_counter(struct counters_subgroup *subgroup,
        counter->counter_id = counter_id;
        strlcpy(counter->counter_name, 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->counters[counter->counter_id] = counter;
 

diff --git a/pceplib/pcep_utils_counters.h b/pceplib/pcep_utils_counters.h
index 755c94eb0cd46ac175f7ffd048ce847246e935c9..dfae02fb2ea18dbee15fe58c79e5767d07dde4f1 100644 (file)
--- a/pceplib/pcep_utils_counters.h
+++ b/pceplib/pcep_utils_counters.h
@@ -55,18 +55,18 @@ extern "C" {
  * *events_subgroup = create_counters_subgroup("events counters", 4);
  *
  * Use message_id: PCEP_TYPE_OPEN=1
- * create_subgroup_counter(rx_subgroup, 1, "Message Open");
- * create_subgroup_counter(rx_subgroup, 2, "Message KeepAlive");
- * create_subgroup_counter(rx_subgroup, 3, "Message PcReq");
+ * create_subgroup_counter(rx_subgroup, 1, "Message Open", "messageOpen");
+ * create_subgroup_counter(rx_subgroup, 2, "Message KeepAlive", "messageKeepAlive");
+ * create_subgroup_counter(rx_subgroup, 3, "Message PcReq", "messagePcReq");
  *
- * create_subgroup_counter(tx_subgroup, 1, "Message Open");
- * create_subgroup_counter(tx_subgroup, 2, "Message KeepAlive");
- * create_subgroup_counter(tx_subgroup, 3, "Message PcReq");
+ * create_subgroup_counter(tx_subgroup, 1, "Message Open", "messageOpen");
+ * create_subgroup_counter(tx_subgroup, 2, "Message KeepAlive", "messageKeepAlive");
+ * create_subgroup_counter(tx_subgroup, 3, "Message PcReq", "messagePcReq");
  *
- * create_subgroup_counter(events_subgroup, 1, "PCC Connect");
- * create_subgroup_counter(events_subgroup, 2, "PCE Connect");
- * create_subgroup_counter(events_subgroup, 3, "PCC Disconnect");
- * create_subgroup_counter(events_subgroup, 4, "PCE Disconnect");
+ * create_subgroup_counter(events_subgroup, 1, "PCC Connect", "PCConnect");
+ * create_subgroup_counter(events_subgroup, 2, "PCE Connect", "PCEConnect");
+ * create_subgroup_counter(events_subgroup, 3, "PCC Disconnect", "PCCDisconnect");
+ * create_subgroup_counter(events_subgroup, 4, "PCE Disconnect", "PCEDisconnect");
  *
  * struct counters_group *cntrs_group = create_counters_group("PCEP Counters",
  * 3); add_counters_subgroup(cntrs_group, rx_subgroup);
@@ -81,6 +81,7 @@ extern "C" {
 struct counter {
        uint16_t counter_id;
        char counter_name[MAX_COUNTER_STR_LENGTH];
+       char counter_name_json[MAX_COUNTER_STR_LENGTH];
        uint32_t counter_value;
 };
 
@@ -142,13 +143,15 @@ clone_counters_subgroup(struct counters_subgroup *subgroup,
                        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.
  * Return true on success or false if subgroup is NULL, counter_id >=
  * MAX_COUNTERS, or if counter_name is NULL.
  */
 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

diff --git a/pceplib/test/pcep_utils_counters_test.c b/pceplib/test/pcep_utils_counters_test.c
index 2cad9a64438f21a905e32a10343f2ada7f6fcc31..d3d5197b53084b24c73e7447b20813a12785b69a 100644 (file)
--- a/pceplib/test/pcep_utils_counters_test.c
+++ b/pceplib/test/pcep_utils_counters_test.c
@@ -106,17 +106,19 @@ void test_create_subgroup_counter()
 {
        uint16_t counter_id = 1;
        char counter_name[] = "my counter";
+       char counter_name_json[] = "myCounter";
        struct counters_subgroup *subgroup =
                create_counters_subgroup("subgroup", 1, 2);
 
-       CU_ASSERT_FALSE(
-               create_subgroup_counter(NULL, counter_id, counter_name));
+       CU_ASSERT_FALSE(create_subgroup_counter(NULL, counter_id, counter_name,
+                                               counter_name_json));
        CU_ASSERT_FALSE(create_subgroup_counter(subgroup, counter_id + 1,
                                                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_TRUE(
-               create_subgroup_counter(subgroup, counter_id, counter_name));
+       CU_ASSERT_TRUE(create_subgroup_counter(subgroup, counter_id,
+                                              counter_name, counter_name_json));
        CU_ASSERT_EQUAL(subgroup->num_counters, 1);
 
        delete_counters_subgroup(subgroup);
@@ -146,7 +148,7 @@ void test_reset_group_counters()
        struct counters_group *group = create_counters_group("group", 10);
        struct counters_subgroup *subgroup =
                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);
 
        struct counter *counter = subgroup->counters[counter_id];
@@ -164,7 +166,7 @@ void test_reset_subgroup_counters()
        uint16_t counter_id = 1;
        struct counters_subgroup *subgroup =
                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];
        counter->counter_value = 100;
@@ -183,7 +185,7 @@ void test_increment_counter()
        struct counters_group *group = create_counters_group("group", 10);
        struct counters_subgroup *subgroup =
                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);
 
        struct counter *counter = subgroup->counters[counter_id];
@@ -205,7 +207,7 @@ void test_increment_subgroup_counter()
        uint32_t counter_value = 100;
        struct counters_subgroup *subgroup =
                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];
        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_subgroup *subgroup =
                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);
 
        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;
        struct counters_subgroup *subgroup =
                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_TRUE(dump_counters_subgroup_to_log(subgroup));