diff --git a/Collection Models/ONU Information Collection/ONU local information/an-epon-pm-onu-local-info.proto b/Collection Models/ONU Information Collection/ONU local information/an-epon-pm-onu-local-info.proto new file mode 100644 index 0000000000000000000000000000000000000000..6db59733338662183012cecdf24e46702674b39b --- /dev/null +++ b/Collection Models/ONU Information Collection/ONU local information/an-epon-pm-onu-local-info.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; +package an_epon_pm_onu_local_info; + +message EponPmOnuLocalInfos { + message EponPmOnuLocalInfo { + ///The name of ONU. + string name = 1; + + //The optical power received by the OLT transceiver.The unit is 0.01dBm. + int32 olt_rx_power = 2; + + //The ONU online time.The unit is second. + uint32 online_duration = 3; + + //The last offline time of ONU.It is timestamp format. + uint32 last_down_time = 4; + + //The reason for last offline of ONU. + uint32 last_down_cause = 5; + + //The ONU status.(1-online，2-offline，255-invalid). + uint32 onu_status = 6; + } + repeated EponPmOnuLocalInfo epon_pm_onu_local_info = 1; +} diff --git a/Collection Models/ONU Information Collection/ONU local information/an-gpon-pm-onu-line-quality.proto b/Collection Models/ONU Information Collection/ONU local information/an-gpon-pm-onu-line-quality.proto new file mode 100644 index 0000000000000000000000000000000000000000..1af9f92f3a1d2c638f67ea58ae02ae73a3bbd9a5 --- /dev/null +++ b/Collection Models/ONU Information Collection/ONU local information/an-gpon-pm-onu-line-quality.proto @@ -0,0 +1,49 @@ +syntax = "proto3"; +package an_gpon_pm_onu_line_quality; + +message GponPmOnuLineQualitys { + message GponPmOnuLineQuality { + //The name of ONU. + string name = 1; + + //The number of Loss of Frame of ONU indication (LOFi, Loss of Frame of ONU indication) alarms of the OLT for the ONU. GPON ONU is valid, XGPON ONU does not support. + uint32 lofi_alarm_count = 2; + + //The number of drift window (DOWi, Drift of Window of ONU) alarms after the ONU is started by the OLT. GPON/XGPON ONU valid. + uint32 dowi_alarm_count = 3; + + //The number of uplink frame delimitation errors after the ONU goes online. GPON ONU is valid, XGPON ONU does not support. + uint32 upstream_delimiter_error_count = 4; + + //After the ONU is started, the number of Bit-interleaved parity errors in the upstream frame. GPON/XGPON ONU is valid. + uint64 upstream_bip_error_count = 5; + + //After the ONU is started, the number of Bit-interleaved parity errors in the downstream frame. GPON ONU is valid, XGPON ONU does not support. + uint64 downstream_bip_error_count = 6; + + //Number of corrected blocks in upstream FEC (forward error correction) decoding. + uint64 upstream_fec_block = 7; + + // Number of uncorrected blocks in upstream FEC (forward error correction) decoding. + uint64 upstream_fec_error_block = 8; + + //The total number of corrected blocks in upstream FEC (forward error correction) decoding. + uint64 upstream_fec_total_block = 9; + + //Upstream FEC correction bytes. GPON/XGPON ONU is valid. + uint64 upstream_fec_byte = 10; + + //Upstream HEC (Header Error Code) error times. GPON/XGPON ONU is valid. + uint64 upstream_hec_error_count = 11; + + //Number of upstream GEM frames. + uint64 upstream_gem_count = 12; + + //Number of ONU LOSi (loss of signal) alarms. + uint32 losi_alarm_count = 13; + + //Number of ONU DGi (Dying Gasp) alarms. + uint32 dgi_alarm_count = 14; + } + repeated GponPmOnuLineQuality gpon_pm_onu_line_quality = 1; +} diff --git a/Collection Models/ONU Information Collection/ONU local information/an-gpon-pm-onu-local-info.proto b/Collection Models/ONU Information Collection/ONU local information/an-gpon-pm-onu-local-info.proto new file mode 100644 index 0000000000000000000000000000000000000000..dd70f8fe0dad9ecfeb6355dd08f8abe584438958 --- /dev/null +++ b/Collection Models/ONU Information Collection/ONU local information/an-gpon-pm-onu-local-info.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; +package an_gpon_pm_onu_local_info; + +message GponPmOnuLocalInfos { + message GponPmOnuLocalInfo { + //The name of ONU. + string name = 1; + + //The optical power received by the OLT transceiver.The unit is 0.01dBm. + int32 olt_rx_power = 2; + + //The ONU online time.The unit is second. + uint32 online_duration = 3; + + //The last offline time of ONU.It is timestamp format. + uint32 last_down_time = 4; + + //The reason for last offline of ONU. + uint32 last_down_cause = 5; + + //The ONU status.(1-online，2-offline，255-invalid). + uint32 onu_status = 6; + } + repeated GponPmOnuLocalInfo gpon_pm_onu_local_info = 1; +} diff --git a/Collection Models/ONU Information Collection/ONU remote information/an-epon-onu-transceivers.proto b/Collection Models/ONU Information Collection/ONU remote information/an-epon-onu-transceivers.proto new file mode 100644 index 0000000000000000000000000000000000000000..52479a6819efecd96ca5207bf90d0d97a6a0b5de --- /dev/null +++ b/Collection Models/ONU Information Collection/ONU remote information/an-epon-onu-transceivers.proto @@ -0,0 +1,31 @@ +syntax = "proto3"; +package an_epon_onu_transceivers; + +message EponOnuTransceivers { + message EponOnuTransceiver { + //The name of ONU. + string name = 1; + + //Received optical power.The unit is 0.01dBm. + int32 optical_unit_rx_power = 2; + + //Transmit optical power.The unit is 0.01dBm. + int32 optical_unit_tx_power = 3; + + //The current bias of the port.The unit is 0.01mA. + int32 optical_unit_laser_bias_current = 4; + + //The current temperature of the optical module.The unit is 0.01℃. + int32 optical_unit_temperature = 5; + + //The current voltage of the optical module.The unit is 0.01V. + int32 optical_unit_voltage = 6; + + // Optical module type.(0:unknown,1:gpon,2:xg-pon,3:xgs-pon,4:gpon-and-xgpon,5:gpon-and-xgspon,-1:invalid) + int32 module_type = 7; + + //Optical module subtype. + string module_sub_type = 8; + } + repeated EponOnuTransceiver epon_onu_transceiver = 1; +} diff --git a/Collection Models/ONU Information Collection/ONU remote information/an-epon-pm-onu-remote-info.proto b/Collection Models/ONU Information Collection/ONU remote information/an-epon-pm-onu-remote-info.proto new file mode 100644 index 0000000000000000000000000000000000000000..c0411b55212aeb5787b3af50fe8e69e8be40dacc --- /dev/null +++ b/Collection Models/ONU Information Collection/ONU remote information/an-epon-pm-onu-remote-info.proto @@ -0,0 +1,28 @@ +syntax = "proto3"; +package an_epon_pm_onu_remote_info; + +message EponPmOnuRemoteInfos { + message EponPmOnuRemoteInfo { + //The name of ONU. + string name = 1; + + //Memory utilization of ONU.The unit is %. + uint32 mem_occup = 2; + + //CPU utilization of ONU.The unit is %. + uint32 cpu_occup = 3; + + //CPU temperature of ONU.The unit is ℃. + int32 cpu_temp = 4; + + //Number of packets sent by the ONU PON port. + uint64 onu_pon_send_packets = 5; + + //Number of packets received by the ONU PON port. + uint64 onu_pon_recv_packets = 6; + + //Number of error packets received by the ONU PON port. + uint64 onu_pon_recv_errors_packets = 7; + } + repeated EponPmOnuRemoteInfo epon_pm_onu_remote_info = 1; +} diff --git a/Collection Models/ONU Information Collection/ONU remote information/an-gpon-onu-transceivers.proto b/Collection Models/ONU Information Collection/ONU remote information/an-gpon-onu-transceivers.proto new file mode 100644 index 0000000000000000000000000000000000000000..395d0a8146fd42c128c195e2db41c3dbd31cfc62 --- /dev/null +++ b/Collection Models/ONU Information Collection/ONU remote information/an-gpon-onu-transceivers.proto @@ -0,0 +1,31 @@ +syntax = "proto3"; +package an_gpon_onu_transceivers; + +message GponOnuTransceivers { + message GponOnuTransceiver { + //The name of ONU. + string name = 1; + + //Received optical power.The unit is 0.01dBm. + int32 optical_unit_rx_power = 2; + + //Transmit optical power.The unit is 0.01dBm. + int32 optical_unit_tx_power = 3; + + //The current bias of the port.The unit is 0.01mA. + int32 optical_unit_laser_bias_current = 4; + + //The current temperature of the optical module.The unit is 0.01℃. + int32 optical_unit_temperature = 5; + + //The current voltage of the optical module.The unit is 0.01V. + int32 optical_unit_voltage = 6; + + // Optical module type.(0:unknown,1:gpon,2:xg-pon,3:xgs-pon,4:gpon-and-xgpon,5:gpon-and-xgspon,-1:invalid) + int32 module_type = 7; + + //Optical module subtype. + string module_sub_type = 8; + } + repeated GponOnuTransceiver gpon_onu_transceiver = 1; +} diff --git a/Collection Models/ONU Information Collection/ONU remote information/an-gpon-pm-onu-remote-info.proto b/Collection Models/ONU Information Collection/ONU remote information/an-gpon-pm-onu-remote-info.proto new file mode 100644 index 0000000000000000000000000000000000000000..1c48ff6bf2f2c57c4fcc26b1b8a4353a9b67b8b8 --- /dev/null +++ b/Collection Models/ONU Information Collection/ONU remote information/an-gpon-pm-onu-remote-info.proto @@ -0,0 +1,55 @@ +syntax = "proto3"; +package an_gpon_pm_onu_remote_info; + +message GponPmOnuRemoteInfos { + message GponPmOnuRemoteInfo { + //The name of ONU. + string name = 1; + + //Number of downstream FEC (forward error correction) corrected bytes. + uint64 ds_fec_corrected_bytes = 2; + + //Number of downstream FEC corrected words. + uint64 ds_fec_corrected_words = 3; + + //Number of downstream FEC uncorrected words. + uint64 ds_fec_uncorrected_words = 4; + + //The total number of downstream received code words. + uint64 ds_total_rx_code_words = 5; + + //Downstream FEC correction time. + uint32 ds_fec_seconds = 6; + + //Number of GEM HEC errors received by ONU. + uint64 xgpon_gem_hec_error_count = 7; + + //Number of discarded XG-PON GEM frames + uint64 xgpon_gem_key_error_count = 8; + + //Memory utilization of ONU.The unit is %. + uint32 mem_occup = 9; + + //CPU utilization of ONU.The unit is %. + uint32 cpu_occup = 10; + + //CPU temperature of ONU.The unit is ℃. + int32 cpu_temp = 11; + + //Number of packets sent by the ONU PON port. + uint64 onu_pon_send_packets = 12; + + //Number of packets received by the ONU PON port. + uint64 onu_pon_recv_packets = 13; + + //Number of error packets received by the ONU PON port. + uint64 onu_pon_recv_errors_packets = 14; + + //Number of packets discarded in all TCONT queues of the ONU. + uint64 tcont_queue_dropped_packets = 15; + + //Number of packets forwarded in all TCONT queues of the ONU. + uint64 tcont_queue_passing_packets = 16; + } + repeated GponPmOnuRemoteInfo gpon_pm_onu_remote_info = 1; +} diff --git a/Collection Models/Optical Link Information Collection/an-epon-pm-olt-transceivers.proto b/Collection Models/Optical Link Information Collection/an-epon-pm-olt-transceivers.proto new file mode 100644 index 0000000000000000000000000000000000000000..4d1c35351381fd12ff22c429b29b0db9fac3a085 --- /dev/null +++ b/Collection Models/Optical Link Information Collection/an-epon-pm-olt-transceivers.proto @@ -0,0 +1,46 @@ +syntax = "proto3"; +package an_epon_pm_olt_transceivers; + +message EponPmOltTransceivers { + message EponPmOltTransceiver { + //The name of EPON port. + string name = 1; + + //Optical module temperature.The uint is 0.01℃. + int32 temperature = 2; + + //Type of channel 1. The unit is 0.01V. + int32 supply_voltage = 3; + + //Type of channel 1. + int32 channel_1_type = 4; + + //Current transmit bias of channel 1.The unit is 0.01mA. + int32 channel_1_tx_bias = 5; + + //Transmit power of channel 1.The unit is 0.01dBm. + int32 channel_1_tx_power = 6; + + //Optical power at idle time of channel 1.The unit is 0.01dBm. + int32 channel_1_idle_rssi = 7; + + //Type of channel 2. + int32 channel_2_type = 8; + + //Current transmit bias of channel 2.The unit is 0.01mA. + int32 channel_2_tx_bias = 9; + + //Transmit power of channel 2.The unit is 0.01dBm. + int32 channel_2_tx_power = 10; + + //Optical power at idle time of channel 2.The unit is 0.01dBm. + int32 channel_2_idle_rssi = 11; + + //Optical module type.(0:unknown,1:gpon,2:xg-pon,3:xgs-pon,4:gpon-and-xgpon,5:gpon-and-xgspon,-1:invalid） + int32 module_type = 12; + + //Optical module subtype + string module_sub_type = 13; + } + repeated EponPmOltTransceiver epon_pm_olt_transceiver = 1; +} diff --git a/Collection Models/Optical Link Information Collection/an-gpon-pm-olt-transceivers.proto b/Collection Models/Optical Link Information Collection/an-gpon-pm-olt-transceivers.proto new file mode 100644 index 0000000000000000000000000000000000000000..11267b74ac6b0c950d196017b4f599e6147ed44c --- /dev/null +++ b/Collection Models/Optical Link Information Collection/an-gpon-pm-olt-transceivers.proto @@ -0,0 +1,46 @@ +syntax = "proto3"; +package an_gpon_olt_transceivers; + +message GponOltTransceivers { + message GponOltTransceiver { + //The name of GPON port. + string name = 1; + + //Optical module temperature.The uint is 0.01℃. + int32 temperature = 2; + + //Type of channel 1. The unit is 0.01V. + int32 supply_voltage = 3; + + //Type of channel 1. + int32 channel_1_type = 4; + + //Current transmit bias of channel 1.The unit is 0.01mA. + int32 channel_1_tx_bias = 5; + + //Transmit power of channel 1.The unit is 0.01dBm. + int32 channel_1_tx_power = 6; + + //Optical power at idle time of channel 1.The unit is 0.01dBm. + int32 channel_1_idle_rssi = 7; + + //Type of channel 2. + int32 channel_2_type = 8; + + //Current transmit bias of channel 2.The unit is 0.01mA. + int32 channel_2_tx_bias = 9; + + //Transmit power of channel 2.The unit is 0.01dBm. + int32 channel_2_tx_power = 10; + + //Optical power at idle time of channel 2.The unit is 0.01dBm. + int32 channel_2_idle_rssi = 11; + + //Optical module type.(0:unknown,1:gpon,2:xg-pon,3:xgs-pon,4:gpon-and-xgpon,5:gpon-and-xgspon,-1:invalid） + int32 module_type = 12; + + //Optical module subtype + string module_sub_type = 13; + } + repeated GponOltTransceiver gpon_olt_transceiver = 1; +} diff --git a/Collection Models/Traffic Collection/an-bb-queue-kpi.proto b/Collection Models/Traffic Collection/an-bb-queue-kpi.proto new file mode 100644 index 0000000000000000000000000000000000000000..ee7af22aed69af993284abae9d7137f75577d54f --- /dev/null +++ b/Collection Models/Traffic Collection/an-bb-queue-kpi.proto @@ -0,0 +1,43 @@ +syntax = "proto3"; +package an_bb_queue_kpi; + +message QueueKpiRecords { + message QueueKpiRecord { + //Port name + string name = 1; + + //Channel number of the port + string channel = 2; + + //The index of the queue,which range is from 0 to 7. + uint32 index = 3; + + //Number of bytes forwarded by the queue. + uint64 pass_bytes = 4; + + //Number of packets forwarded by the queue. + uint64 pass_packets = 5; + + //Number of packets discarded (red traffic) by the queue. + uint64 drop_packets = 6; + + //Number of bytes of green traffic forwarded by the queue. + uint64 pass_green_bytes = 7; + + //Number of packets of green traffic forwarded by the queue. + uint64 pass_green_packets = 8; + + //Number of packets of green traffic discarded by the queue. + uint64 drop_green_packets = 9; + + //Number of bytes of yellow traffic forwarded by the queue. + uint64 pass_yellow_bytes = 10; + + //Number of packets of yellow traffic forwarded by the queue. + uint64 pass_yellow_packets = 11; + + //Number of packets of yellow traffic discarded by the queue. + uint64 drop_yellow_packets = 12; + } + repeated QueueKpiRecord queue_kpi_record = 1; +} diff --git a/Collection Models/Traffic Collection/an-bb-service-flow-kpi.proto b/Collection Models/Traffic Collection/an-bb-service-flow-kpi.proto new file mode 100644 index 0000000000000000000000000000000000000000..933ee4a1a9492f14c6cda5a9c294b51cf5e7b280 --- /dev/null +++ b/Collection Models/Traffic Collection/an-bb-service-flow-kpi.proto @@ -0,0 +1,46 @@ +syntax = "proto3"; +package an_bb_service_flow_kpi; + +message ServiceFlowKpiRecords { + message ServiceFlowKpiRecord { + //The name of service flow which means a flow identified by a VLAN ID + string name = 1; + + //The total number of packets dropped by the queue in the downstream direction. + uint64 downstream_flow_drop_cnt = 2; + + //The total number of packets passed through the queue in the downstream direction. + uint64 downstream_flow_pass_cnt = 3; + + //The maximum number of packets drop in a second-level queue in the downstream direction. + uint32 downstream_flow_drop_max = 4; + + //The minimum number of packets drop in a second-level queue in the downstream direction. + uint32 downstream_flow_drop_min = 5; + + //The maximum packet loss rate in seconds in the downstream queue.The unit is 10^-5. + uint32 downstream_flow_drop_rate_max = 6; + + //The minimum packet loss rate in seconds in the downstream queue.The unit is 10^-5. + uint32 downstream_flow_drop_rate_min = 7; + + //The minimum packet loss rate of the queue in the downstream direction in seconds. + uint32 downstream_flow_drop_seconds_cnt = 8; + + //The average rate in the downlink direction. + uint64 downstream_flow_pass_bytes = 9; + + //The average rate in the downlink direction. + uint32 downstream_mfr_avg = 10; + + //Bytes passed by the queue in the upstream direction. + uint64 upstream_pass_bytes = 11; + + //The total number of packets passed by the queue in the upstream direction. + uint64 upstream_pass_cnt = 12; + + //The total number of packets dropped by the queue in the upstream direction. + uint64 upstream_drop_cnt = 13; + } + repeated ServiceFlowKpiRecord service_flow_kpi_record = 1; +} diff --git a/Collection Models/Traffic Collection/an-epon-pm-olt-traffic.proto b/Collection Models/Traffic Collection/an-epon-pm-olt-traffic.proto new file mode 100644 index 0000000000000000000000000000000000000000..3dc17a0e4f7a83f79167413740ef3a682ac403f5 --- /dev/null +++ b/Collection Models/Traffic Collection/an-epon-pm-olt-traffic.proto @@ -0,0 +1,104 @@ +syntax = "proto3"; +package an_epon_pm_olt_traffic; + +message EponPmOltTraffics { + message EponPmOltTraffic { + //The name of EPON port. + string name = 1; + + //Ethernet frame bytes sent by the EPON port. + uint64 port_tx_bytes = 2; + + //Ethernet frame bytes received by the EPON port. + uint64 port_rx_bytes = 3; + + //Number of Ethernet packets sent by the EPON port. + uint64 port_tx_pkt = 4; + + //Number of Ethernet packets received by the EPON port. + uint64 port_rx_pkt = 5; + + //Packet loss statistics in the downlink queue of the EPON port. + uint64 port_tx_discard_pkt = 6; + + //Number of Ethernet packets (usually packets with errors in the MAC layer) discarded in the receiving direction of the EPON port. + uint64 port_rx_discard_pkt = 7; + + //Number of packets with CRC errors of Ethernet in the receiving direction of the EPON port. + uint64 port_rx_crc_error_pkt = 8; + + //Number of oversized Ethernet packets discarded in the receiving direction of the EPON port. + uint64 port_rx_oversized_discard_pkt = 9; + + //Number of undersized Ethernet packets (packet size is smaller than 64bytes and contains correct CRC) discarded in the receiving direction of the EPON port. + uint64 port_rx_undersized_discard_pkt = 10; + + //Number of Ethernet error packets received by the EPON port. + uint64 port_rx_error_pkt = 11; + + //Average transmit rate of the EPON port. The unit is kbps. + uint32 port_tx_rate = 12; + + //Average receive rate of the EPON port.The unit is kbps. + uint32 port_rx_rate = 13; + + //Peak transmit rate of the EPON port in seconds.The unit is kbps. + uint32 port_tx_peak_rate = 14; + + //Peak receive rate of the EPON port in seconds.The unit is kbps. + uint32 port_rx_peak_rate = 15; + } + repeated EponPmOltTraffic pm_olt_traffic = 1; +} +message EponPmOltChannelTraffics { + message EponPmOltChannelTraffic { + //The name of EPON port. + string name = 1; + + //The number of EPON port channel. + uint32 channel = 2; + + //Ethernet frame bytes sent by the EPON port. + uint64 port_tx_bytes = 3; + + //Ethernet frame bytes received by the EPON port. + uint64 port_rx_bytes = 4; + + //Number of Ethernet packets sent by the EPON port. + uint64 port_tx_pkt = 5; + + //Number of Ethernet packets received by the EPON port. + uint64 port_rx_pkt = 6; + + //Packet loss statistics in the downlink queue of the EPON port. + uint64 port_tx_discard_pkt = 7; + + //Number of Ethernet packets (usually packets with errors in the MAC layer) discarded in the receiving direction of the EPON port. + uint64 port_rx_discard_pkt = 8; + + //Number of packets with CRC errors of Ethernet in the receiving direction of the EPON port. + uint64 port_rx_crc_error_pkt = 9; + + //Number of oversized Ethernet packets discarded in the receiving direction of the EPON port. + uint64 port_rx_oversized_discard_pkt = 10; + + //Number of undersized Ethernet packets (packet size is smaller than 64bytes and contains correct CRC) discarded in the receiving direction of the EPON port. + uint64 port_rx_undersized_discard_pkt = 11; + + //Number of Ethernet error packets received by the EPON port. + uint64 port_rx_error_pkt = 12; + + //Average transmit rate of the EPON port. The unit is kbps. + uint32 port_tx_rate = 13; + + //Average receive rate of the EPON port.The unit is kbps. + uint32 port_rx_rate = 14; + + //Peak transmit rate of the EPON port in seconds.The unit is kbps. + uint32 port_tx_peak_rate = 15; + + //Peak receive rate of the EPON port in seconds.The unit is kbps. + uint32 port_rx_peak_rate = 16; + } + repeated EponPmOltChannelTraffic pm_olt_channel_traffic =1; +} diff --git a/Collection Models/Traffic Collection/an-epon-pm-onu-traffic.proto b/Collection Models/Traffic Collection/an-epon-pm-onu-traffic.proto new file mode 100644 index 0000000000000000000000000000000000000000..85a89b0141cf5a16e7f122567855b3e5b2f1fbd1 --- /dev/null +++ b/Collection Models/Traffic Collection/an-epon-pm-onu-traffic.proto @@ -0,0 +1,22 @@ +syntax = "proto3"; +package an_epon_pm_onu_traffic; + +message EponPmOnuTraffics { + message EponPmOnuTraffic { + //The name of ONU. + string name = 1; + + //Average transmit rate of the ONU.The unit is kbps. + uint32 tx_rate = 2; + + //Average receive rate of the ONU.The unit is kbps. + uint32 rx_rate = 3; + + //Peak transmit rate of the ONU in seconds，The unit is kbps + uint32 tx_peak_rate = 4; + + //Peak receive rate of the port in seconds.The unit is kbps + uint32 rx_peak_rate = 5; + } + repeated EponPmOnuTraffic epon_pm_onu_traffic = 1; +} diff --git a/Collection Models/Traffic Collection/an-ethernet-kpi.proto b/Collection Models/Traffic Collection/an-ethernet-kpi.proto new file mode 100644 index 0000000000000000000000000000000000000000..dec4a9ab6ac8c8dd640c41a8c31fc08db49b6d1f --- /dev/null +++ b/Collection Models/Traffic Collection/an-ethernet-kpi.proto @@ -0,0 +1,79 @@ +syntax = "proto3"; +package an_ethernet_kpi; + +message EthernetPortKpiRecords { + message EthernetPortKpiRecord { + //The name pf Ethernet port. + string name = 1; + + //Ethernet frame bytes sent by the Ethernet port. + uint64 port_tx_bytes = 2; + + //Ethernet frame bytes received by the Ethernet port. + uint64 port_rx_bytes = 3; + + //Number of Ethernet packets sent by the Ethernet port. + uint64 port_tx_packets = 4; + + //Number of Ethernet packets received by the Ethernet port. + uint64 port_rx_packets = 5; + + //Packet loss statistics in the downlink queue of the Ethernet port. + uint64 port_tx_discard_packets = 6; + + //Number of Ethernet packets (usually packets with errors in the MAC layer) discarded in the receiving direction of the Ethernet port. + uint64 port_rx_discard_packets = 7; + + //Number of Ethernet packets with misalignment (packet size is between 64bytes and 1518bytes and contains wrong CRC and misalignment). + uint64 port_rx_alignment_error_packets = 8; + + //Number of packets with CRC errors of Ethernet in the sending direction of the Ethernet port. + uint64 port_tx_crc_error_packets = 9; + + //Number of packets with CRC errors of Ethernet in the receiving direction of the Ethernet port. + uint64 port_rx_crc_error_packets = 10; + + //Number of packets with CRC errors of Ethernet in the sending direction of the Ethernet port. + uint64 port_tx_oversized_packets = 11; + + //Number of oversized Ethernet packets discarded in the receiving direction of the Ethernet port. + uint64 port_rx_oversized_packets = 12; + + //Number of undersized Ethernet packets (packet size is smaller than 64bytes and contains correct CRC) discarded in the sending direction of the Ethernet port. + uint64 port_tx_undersized_packets = 13; + + //Number of undersized Ethernet packets (packet size is smaller than 64bytes and contains correct CRC) discarded in the receiving direction of the Ethernet port. + uint64 port_rx_undersized_packets = 14; + + //Number of fragment packets (packet size is smaller than 64bytes and contains wrong CRC) sent by the Ethernet port. + uint64 port_tx_fragment_packets = 15; + + //Number of fragment packets (packet size is smaller than 64bytes and contains wrong CRC) received by the Ethernet port. + uint64 port_rx_fragment_packets = 16; + + //Number of jabber packets (packet size is bigger than 9396bytes and contains wrong CRC) received by the Ethernet port. + uint64 port_tx_jabber_packets = 17; + + // Number of jabber packets (packet size is bigger than 9396bytes and contains wrong CRC) received by the Ethernet port. + uint64 port_rx_jabber_packets = 18; + + //Number of Ethernet error packets sent by the Ethernet port. + uint64 port_tx_error_packets = 19; + + //Number of Ethernet error packets received by the Ethernet port. + uint64 port_rx_error_packets = 20; + + //Average transmit rate of the Ethernet port. The unit is kbps. + uint64 port_tx_rate = 21; + + //Average receive rate of the Ethernet port.The unit is kbps. + uint64 port_rx_rate = 22; + + //Peak transmit rate of the Ethernet port in seconds.The unit is kbps. + uint64 port_tx_peak_rate = 23; + + //Peak receive rate of the Ethernet port in seconds.The unit is kbps. + uint64 port_rx_peak_rate = 24; + } + repeated EthernetPortKpiRecord ethernet_port_kpi_record = 1; +} diff --git a/Collection Models/Traffic Collection/an-gpon-pm-olt-traffic.proto b/Collection Models/Traffic Collection/an-gpon-pm-olt-traffic.proto new file mode 100644 index 0000000000000000000000000000000000000000..3ca8fcd0367c24f9a1e69be80ef111e96ad54b47 --- /dev/null +++ b/Collection Models/Traffic Collection/an-gpon-pm-olt-traffic.proto @@ -0,0 +1,105 @@ +syntax = "proto3"; +package an_gpon_pm_olt_traffic; + +message GponPmOltTraffics { + message GponPmOltTraffic { + //The name of GPON port. + string name = 1; + + //Ethernet frame bytes sent by the GPON port. + uint64 port_tx_bytes = 2; + + //Ethernet frame bytes received by the GPON port. + uint64 port_rx_bytes = 3; + + //Number of Ethernet packets sent by the GPON port. + uint64 port_tx_pkt = 4; + + //Number of Ethernet packets received by the GPON port. + uint64 port_rx_pkt = 5; + + //Packet loss statistics in the downlink queue of the GPON port. + uint64 port_tx_discard_pkt = 6; + + //Number of Ethernet packets (usually packets with errors in the MAC layer) discarded in the receiving direction of the GPON port. + uint64 port_rx_discard_pkt = 7; + + //Number of packets with CRC errors of Ethernet in the receiving direction of the GPON port. + uint64 port_rx_crc_error_pkt = 8; + + //Number of oversized Ethernet packets discarded in the receiving direction of the GPON port. + uint64 port_rx_oversized_discard_pkt = 9; + + //Number of undersized Ethernet packets (packet size is smaller than 64bytes and contains correct CRC) discarded in the receiving direction of the GPON port. + uint64 port_rx_undersized_discard_pkt = 10; + + //Number of Ethernet error packets received by the GPON port. + uint64 port_rx_error_pkt = 11; + + //Average transmit rate of the GPON port. The unit is kbps. + uint32 port_tx_rate = 12; + + //Average receive rate of the GPON port.The unit is kbps. + uint32 port_rx_rate = 13; + + //Peak transmit rate of the GPON port in seconds.The unit is kbps. + uint32 port_tx_peak_rate = 14; + + //Peak receive rate of the GPON port in seconds.The unit is kbps. + uint32 port_rx_peak_rate = 15; + } + + repeated gponPmOltTraffic pm_olt_traffic = 1; +} +message GponPmOltChannelTraffics { + message GponPmOltChannelTraffic { + //The name of GPON port. + string name = 1; + + //The number of GPON port channel. + uint32 channel = 2; + + //Ethernet frame bytes sent by the GPON port. + uint64 port_tx_bytes = 3; + + //Ethernet frame bytes received by the GPON port. + uint64 port_rx_bytes = 4; + + //Number of Ethernet packets sent by the GPON port. + uint64 port_tx_pkt = 5; + + //Number of Ethernet packets received by the GPON port. + uint64 port_rx_pkt = 6; + + //Packet loss statistics in the downlink queue of the GPON port. + uint64 port_tx_discard_pkt = 7; + + //Number of Ethernet packets (usually packets with errors in the MAC layer) discarded in the receiving direction of the GPON port. + uint64 port_rx_discard_pkt = 8; + + //Number of packets with CRC errors of Ethernet in the receiving direction of the GPON port. + uint64 port_rx_crc_error_pkt = 9; + + //Number of oversized Ethernet packets discarded in the receiving direction of the GPON port. + uint64 port_rx_oversized_discard_pkt = 10; + + //Number of undersized Ethernet packets (packet size is smaller than 64bytes and contains correct CRC) discarded in the receiving direction of the GPON port. + uint64 port_rx_undersized_discard_pkt = 11; + + //Number of Ethernet error packets received by the GPON port. + uint64 port_rx_error_pkt = 12; + + //Average transmit rate of the GPON port. The unit is kbps. + uint32 port_tx_rate = 13; + + //Average receive rate of the GPON port.The unit is kbps. + uint32 port_rx_rate = 14; + + //Peak transmit rate of the GPON port in seconds.The unit is kbps. + uint32 port_tx_peak_rate = 15; + + //Peak receive rate of the GPON port in seconds.The unit is kbps. + uint32 port_rx_peak_rate = 16; + } + repeated GponPmOltChannelTraffic pm_olt_channel_traffic =1; +} diff --git a/Collection Models/Traffic Collection/an-gpon-pm-onu-traffic.proto b/Collection Models/Traffic Collection/an-gpon-pm-onu-traffic.proto new file mode 100644 index 0000000000000000000000000000000000000000..f9395aba9c5ea9f76c757ec00db372e930f78a4a --- /dev/null +++ b/Collection Models/Traffic Collection/an-gpon-pm-onu-traffic.proto @@ -0,0 +1,22 @@ +syntax = "proto3"; +package an_gpon_pm_onu_traffic; + +message GponPmOnuTraffics { + message GponPmOnuTraffic { + //The name of ONU. + string name = 1; + + //Average transmit rate of the ONU.The unit is kbps. + uint32 tx_rate = 2; + + //Average receive rate of the ONU.The unit is kbps. + uint32 rx_rate = 3; + + //Peak transmit rate of the ONU in seconds，The unit is kbps + uint32 tx_peak_rate = 4; + + //Peak receive rate of the port in seconds.The unit is kbps + uint32 rx_peak_rate = 5; + } + repeated GponPmOnuTraffic gpon_pm_onu_traffic = 1; +} \ No newline at end of file diff --git a/Configuration Models/an-inet-types.yang b/Configuration Models/an-inet-types.yang new file mode 100644 index 0000000000000000000000000000000000000000..165a501f0f1d58f7a6a1ce7cde4488b6d6a03da7 --- /dev/null +++ b/Configuration Models/an-inet-types.yang @@ -0,0 +1,284 @@ +module an-inet-types { + yang-version "1.1"; + namespace "urn:an:yang:an-inet-types"; + prefix "an-inet"; + + description + "This module contains a set of Internet address related + types for use in access network modules. + + Portions of this code were derived from IETF RFC 6021. + + This file is modified from openconfig-telemetry.yang, the original author of openconfig-telemetry.yang is OpenConfig, + OpenConfig holds the copyright of the original work. openconfig-telemetry.yang is licensed under the Apache License 2.0, + For details, please refer to https://www.openconfig.net/ and https://github.com/openconfig/public/blob/master/LICENSE"; + + revision "2020-09-22"; + + // IPv4 and IPv6 types. + + typedef ipv4-address { + type string { + pattern '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|' + + '25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4]' + + '[0-9]|25[0-5])'; + } + description + "An IPv4 address in dotted quad notation using the default + zone."; + } + + typedef ipv4-address-zoned { + type string { + pattern '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|' + + '25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4]' + + '[0-9]|25[0-5])(%[a-zA-Z0-9_]+)'; + } + description + "An IPv4 address in dotted quad notation. This type allows + specification of a zone index to disambiguate identical + address values. For link-local addresses, the index is + typically the interface index or interface name."; + } + + typedef ipv6-address { + type string { + pattern + // Must support compression through different lengths + // therefore this regexp is complex. + '(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|' + + '([0-9a-fA-F]{1,4}:){1,7}:|' + + '([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|' + + '([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|' + + '([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|' + + '([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|' + + '([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|' + + '[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|' + + ':((:[0-9a-fA-F]{1,4}){1,7}|:)' + + ')'; + } + description + "An IPv6 address represented as either a full address; shortened + or mixed-shortened formats, using the default zone."; + } + + typedef ipv6-address-zoned { + type string { + pattern + // Must support compression through different lengths + // therefore this regexp is complex. + '(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|' + + '([0-9a-fA-F]{1,4}:){1,7}:|' + + '([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|' + + '([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|' + + '([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|' + + '([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|' + + '([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|' + + '[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|' + + ':((:[0-9a-fA-F]{1,4}){1,7}|:)' + + ')(%[a-zA-Z0-9_]+)'; + } + description + "An IPv6 address represented as either a full address; shortened + or mixed-shortened formats. This type allows specification of + a zone index to disambiguate identical address values. For + link-local addresses, the index is typically the interface + index or interface name."; + } + + typedef ipv4-prefix { + type string { + pattern '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|' + + '25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4]' + + '[0-9]|25[0-5])/(([0-9])|([1-2][0-9])|(3[0-2]))'; + } + description + "An IPv4 prefix represented in dotted quad notation followed by + a slash and a CIDR mask (0 <= mask <= 32)."; + } + + typedef ipv6-prefix { + type string { + pattern + '(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|' + + '([0-9a-fA-F]{1,4}:){1,7}:|' + + '([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|' + + '([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|' + + '([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|' + + '([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|' + + '([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|' + + '[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|' + + ':((:[0-9a-fA-F]{1,4}){1,7}|:)' + + ')/(12[0-8]|1[0-1][0-9]|[1-9][0-9]|[0-9])'; + } + description + "An IPv6 prefix represented in full, shortened, or mixed + shortened format followed by a slash and CIDR mask + (0 <= mask <= 128)."; + } + + typedef ip-address { + type union { + type ipv4-address; + type ipv6-address; + } + description + "An IPv4 or IPv6 address with no prefix specified."; + } + + typedef ip-prefix { + type union { + type ipv4-prefix; + type ipv6-prefix; + } + description + "An IPv4 or IPv6 prefix."; + } + + typedef ip-version { + type enumeration { + enum UNKNOWN { + value 0; + description + "An unknown or unspecified version of the Internet + protocol."; + } + enum IPV4 { + value 4; + description + "The IPv4 protocol as defined in RFC 791."; + } + enum IPV6 { + value 6; + description + "The IPv6 protocol as defined in RFC 2460."; + } + } + description + "This value represents the version of the IP protocol. + Note that integer representation of the enumerated values + are not specified, and are not required to follow the + InetVersion textual convention in SMIv2."; + reference + "RFC 791: Internet Protocol + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification + RFC 4001: Textual Conventions for Internet Network Addresses"; + } + + typedef domain-name { + type string { + length "1..253"; + pattern + '((([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.)*' + + '([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.?)' + + '|\.'; + } + description + "The domain-name type represents a DNS domain name. + Fully quallified left to the models which utilize this type. + + Internet domain names are only loosely specified. Section + 3.5 of RFC 1034 recommends a syntax (modified in Section + 2.1 of RFC 1123). The pattern above is intended to allow + for current practice in domain name use, and some possible + future expansion. It is designed to hold various types of + domain names, including names used for A or AAAA records + (host names) and other records, such as SRV records. Note + that Internet host names have a stricter syntax (described + in RFC 952) than the DNS recommendations in RFCs 1034 and + 1123, and that systems that want to store host names in + schema nodes using the domain-name type are recommended to + adhere to this stricter standard to ensure interoperability. + + The encoding of DNS names in the DNS protocol is limited + to 255 characters. Since the encoding consists of labels + prefixed by a length bytes and there is a trailing NULL + byte, only 253 characters can appear in the textual dotted + notation. + + Domain-name values use the US-ASCII encoding. Their canonical + format uses lowercase US-ASCII characters. Internationalized + domain names MUST be encoded in punycode as described in RFC + 3492"; + } + + typedef host { + type union { + type ip-address; + type domain-name; + } + description + "The host type represents either an unzoned IP address or a DNS + domain name."; + } + + typedef as-number { + type uint32; + description + "A numeric identifier for an autonomous system (AS). An AS is a + single domain, under common administrative control, which forms + a unit of routing policy. Autonomous systems can be assigned a + 2-byte identifier, or a 4-byte identifier which may have public + or private scope. Private ASNs are assigned from dedicated + ranges. Public ASNs are assigned from ranges allocated by IANA + to the regional internet registries (RIRs)."; + reference + "RFC 1930 Guidelines for creation, selection, and registration + of an Autonomous System (AS) + RFC 4271 A Border Gateway Protocol 4 (BGP-4)"; + } + + typedef dscp { + type uint8 { + range "0..63"; + } + description + "A differentiated services code point (DSCP) marking within the + IP header."; + reference + "RFC 2474 Definition of the Differentiated Services Field + (DS Field) in the IPv4 and IPv6 Headers"; + } + + typedef ipv6-flow-label { + type uint32 { + range "0..1048575"; + } + description + "The IPv6 flow-label is a 20-bit value within the IPv6 header + which is optionally used by the source of the IPv6 packet to + label sets of packets for which special handling may be + required."; + reference + "RFC 2460 Internet Protocol, Version 6 (IPv6) Specification"; + } + + typedef port-number { + type uint16; + description + "A 16-bit port number used by a transport protocol such as TCP + or UDP."; + reference + "RFC 768 User Datagram Protocol + RFC 793 Transmission Control Protocol"; + } + + typedef uri { + type string; + description + "An ASCII-encoded Uniform Resource Identifier (URI) as defined + in RFC 3986."; + reference + "RFC 3986 Uniform Resource Identifier (URI): Generic Syntax"; + } + + typedef url { + type string; + description + "An ASCII-encoded Uniform Resource Locator (URL) as defined + in RFC 3986, section 1.1.3"; + reference + "RFC 3986, paragraph 1.1.3"; + } + +} diff --git a/Configuration Models/an-telemetry-ext.yang b/Configuration Models/an-telemetry-ext.yang new file mode 100644 index 0000000000000000000000000000000000000000..813ecf88b13c6adffdc8fc6fde45f9bc7c624825 --- /dev/null +++ b/Configuration Models/an-telemetry-ext.yang @@ -0,0 +1,199 @@ +module an-telemetry-ext { + // namespace + namespace "urn:an:yang:an-telemetry-ext"; + + prefix "an-telemetry-ext"; + + import an-telemetry { + prefix an-telemetry; + } + + description "Data model which creates the condition for the telemetry."; + + revision 2020-11-05; + + grouping telemetry-sensor-path-condition-op-config { + description + "Parameters for a filter criterion."; + + leaf op-field{ + type string { + length "1..63"; + } + description + "Reference field in the filter criterion. Different paths support different reference fields."; + } + + leaf op-type{ + type enumeration { + enum eq { + value 0; + description + "Equal."; + } + enum gt { + value 1; + description + "Greater than."; + } + enum ge { + value 2; + description + "Greater than or equal."; + } + enum lt { + value 3; + description + "Less than."; + } + enum le { + value 4; + description + "Less than or equal."; + } + } + description + "Reference to the op-type of the filter criterion."; + } + + leaf op-value{ + type string { + length "1..63"; + } + description + "Comparison value of the filter criterion.For the actual value range, see the definition of op-field in the YANG model."; + } + + } + + grouping telemetry-sensor-path-filter-condition-config { + description + "Parameters for filter criteria."; + + container conditions { + description + "Top level container for filter criteria, including the filter information such as op-field, op-type, and op-value."; + + list condition { + key "op-field op-type op-value"; + max-elements "2"; + description + "List of filter criteria."; + + leaf "op-field" { + type leafref { + path "../config/op-field"; + } + description + "Reference to the op-field of the filter criterion."; + } + + leaf "op-type" { + type leafref { + path "../config/op-type"; + } + description + "Reference to the op-type of the filter criterion."; + } + + leaf "op-value" { + type leafref { + path "../config/op-value"; + } + description + "Comparison value of the filter criterion. Op-value must be an integer and the maximum value range is [0, 4294967295]. For the actual value range, see the definition of op-field in the YANG model."; + } + + container config { + description + "Configuration parameters for a filter criterion."; + uses telemetry-sensor-path-condition-op-config; + } + container state { + config false; + description + "State information for a filter criterion."; + uses telemetry-sensor-path-condition-op-config; + } + } + } + } + + grouping telemetry-sensor-path-filter-attribute-config { + description + "Configuration parameters relating to the configured name of the telemetry sensor path filter."; + + leaf name { + type string { + length "1..8"; + pattern "[A-Za-z0-9]+"; + } + description "Filter name for the telemetry sensor path filter."; + } + + leaf condition-relation{ + type enumeration { + enum and { + value 1; + description + "The relationship between filter criteria in a filter of a sampling path is and."; + } + enum or { + value 2; + description + "The relationship between filter criteria in a filter of a sampling path is or."; + } + } + default "and"; + description + "Relationship between filter criteria in a filter of a sampling path."; + } + } + + grouping telemetry-sensor-path-filter-config { + description + "Condition-based filtering's parameter of the sampling path. If the conditions are met, the data is reported."; + + container filters { + description + "Top level container for filters. If the filter criteria are met, sampled data is sent to a collector. A filter and heartbeat interval or redundancy suppression cannot be configured at the same time."; + + list filter { + key "name"; + max-elements "1"; + description + "Filter list of a sampling path."; + + leaf name { + type leafref { + path "../config/name"; + } + description + "Filter name of a sampling path."; + } + + container config { + description + "Configuration parameters for a filter in a sampling path."; + uses telemetry-sensor-path-filter-attribute-config; + } + + container state { + config false; + description + "State information for a filter in a sampling path."; + uses telemetry-sensor-path-filter-attribute-config; + } + + uses telemetry-sensor-path-filter-condition-config; + } + } + } + + augment "/an-telemetry:telemetry-system/an-telemetry:sensor-groups/an-telemetry:sensor-group/an-telemetry:sensor-paths/an-telemetry:sensor-path"{ + description + "List of paths in the model which together comprise a sensor grouping. Filters for each path to exclude items are also provided."; + + uses telemetry-sensor-path-filter-config; + } +} diff --git a/Configuration Models/an-telemetry-types.yang b/Configuration Models/an-telemetry-types.yang new file mode 100644 index 0000000000000000000000000000000000000000..34bf60de0366477d13e85f6b6550deacbcad10e8 --- /dev/null +++ b/Configuration Models/an-telemetry-types.yang @@ -0,0 +1,85 @@ +module an-telemetry-types { + yang-version "1.1"; + namespace "urn:an:yang:an-telemetry-types"; + + prefix "an-telemetry-types"; + + description + "This module defines type and identities used by the access network + telemetry model. + + This file is modified from openconfig-telemetry.yang, the original author of openconfig-telemetry.yang is OpenConfig, + OpenConfig holds the copyright of the original work. openconfig-telemetry.yang is licensed under the Apache License 2.0, + For details, please refer to https://www.openconfig.net/ and https://github.com/openconfig/public/blob/master/LICENSE"; + + revision "2020-09-22"; + + identity DATA_ENCODING_METHOD { + description + "Base identity for supported encoding for configuration and + operational state data"; + } + + identity ENC_XML { + base DATA_ENCODING_METHOD; + description + "XML encoding"; + } + + identity ENC_JSON_IETF { + base DATA_ENCODING_METHOD; + description + "JSON encoded based on IETF draft standard"; + reference + "draft-ietf-netmod-yang-json"; + } + + identity ENC_PROTO3 { + base DATA_ENCODING_METHOD; + description + "Protocol buffers v3"; + reference + "https://developers.google.com/protocol-buffers/docs/overview"; + } + + identity STREAM_PROTOCOL { + description "Base identity for a telemetry stream protocol"; + } + + identity STREAM_SSH { + base "STREAM_PROTOCOL"; + description + "Telemetry stream is carried over a SSH connection"; + } + + identity STREAM_GRPC { + base "STREAM_PROTOCOL"; + description + "Telemetry stream is carried over via the gRPC framework"; + } + + identity STREAM_UDP { + base "STREAM_PROTOCOL"; + description + "Telemetry stream is carried over via the UDP framework"; + } + + identity STREAM_JSON_RPC { + base "STREAM_PROTOCOL"; + description + "Telemetry stream is carried via the JSON-RPC framework"; + } + + identity STREAM_THRIFT_RPC { + base "STREAM_PROTOCOL"; + description + "Telemetry stream is carried via the Apache Thrift framework"; + } + + identity STREAM_WEBSOCKET_RPC { + base "STREAM_PROTOCOL"; + description + "Telemetry stream is carried by the WebSocket framework"; + } + // typedef statements +} diff --git a/Configuration Models/an-telemetry.yang b/Configuration Models/an-telemetry.yang new file mode 100644 index 0000000000000000000000000000000000000000..ba185d3be17c7727f9b259e6ff067221f76a4bec --- /dev/null +++ b/Configuration Models/an-telemetry.yang @@ -0,0 +1,728 @@ +module an-telemetry { + yang-version "1.1"; + namespace "urn:an:yang:an-telemetry"; + + prefix "an-telemetry"; + + import an-inet-types { + prefix an-inet; + } + import an-telemetry-types { + prefix an-telemetry-types; + } + + description + "Data model which creates the configuration for the telemetry + systems and functions on the device. + + This file is modified from openconfig-telemetry.yang, the original author of openconfig-telemetry.yang is OpenConfig, + OpenConfig holds the copyright of the original work. openconfig-telemetry.yang is licensed under the Apache License 2.0, + For details, please refer to https://www.openconfig.net/ and https://github.com/openconfig/public/blob/master/LICENSE"; + + revision "2020-09-22"; + + grouping telemetry-top { + description + "Top level grouping for telemetry configuration and operational + state data"; + + container telemetry-system { + description + "Top level configuration and state for the + device's telemetry system."; + + container sensor-groups { + description + "Top level container for sensor-groups."; + + list sensor-group { + key "sensor-group-id"; + description + "List of telemetry sensory groups on the local + system, where a sensor grouping represents a resuable + grouping of multiple paths and exclude filters."; + + leaf sensor-group-id { + type leafref { + path "../config/sensor-group-id"; + } + description + "Reference to the name or identifier of the + sensor grouping"; + } + + container config { + description + "Configuration parameters relating to the + telemetry sensor grouping"; + uses telemetry-sensor-group-config; + } + + container state { + config false; + description + "State information relating to the telemetry + sensor group"; + uses telemetry-sensor-group-config; + } + + container sensor-paths { + description + "Top level container to hold a set of sensor + paths grouped together"; + + list sensor-path { + key "path"; + description + "List of paths in the model which together + comprise a sensor grouping. Filters for each path + to exclude items are also provided."; + + leaf path { + type leafref { + path "../config/path"; + } + description + "Reference to the path of interest"; + } + + container config { + description + "Configuration parameters to configure a set + of data model paths as a sensor grouping"; + uses telemetry-sensor-path-config; + } + + container state { + config false; + description + "Configuration parameters to configure a set + of data model paths as a sensor grouping"; + uses telemetry-sensor-path-config; + } + } + } + } + } + + container destination-groups { + description + "Top level container for destination group configuration + and state."; + + list destination-group { + key "group-id"; + description + "List of destination-groups. Destination groups allow the + reuse of common telemetry destinations across the + telemetry configuration. An operator references a + set of destinations via the configurable + destination-group-identifier. + + A destination group may contain one or more telemetry + destinations"; + + leaf group-id { + type leafref { + path "../config/group-id"; + } + description + "Unique identifier for the destination group"; + } + + container config { + description + "Top level config container for destination groups"; + leaf group-id { + type string; + description + "Unique identifier for the destination group"; + } + } + + container state { + config false; + description + "Top level state container for destination groups"; + + leaf group-id { + type string; + description + "Unique identifier for destination group"; + } + } + + container destinations { + description + "The destination container lists the destination + information such as IP address and port of the + telemetry messages from the network element."; + list destination { + key "destination-address destination-port"; + description + "List of telemetry stream destinations"; + + leaf destination-address { + type leafref { + path "../config/destination-address"; + } + description + "Reference to the destination address of the + telemetry stream"; + } + + leaf destination-port { + type leafref { + path "../config/destination-port"; + } + description + "Reference to the port number of the stream + destination"; + } + + container config { + description + "Configuration parameters relating to + telemetry destinations"; + uses telemetry-stream-destination-config; + } + + container state { + config false; + description + "State information associated with + telemetry destinations"; + uses telemetry-stream-destination-config; + } + } + } + } + } + + container subscriptions { + description + "This container holds information for both persistent + and dynamic telemetry subscriptions."; + + container persistent-subscriptions { + description + "This container holds information relating to persistent + telemetry subscriptions. A persistent telemetry + subscription is configued locally on the device through + configuration, and is persistent across device restarts or + other redundancy changes."; + + list persistent-subscription { + key "name"; + description + "List of telemetry subscriptions. A telemetry + subscription consists of a set of collection + destinations, stream attributes, and associated paths to + state information in the model (sensor data)"; + + leaf name { + type leafref { + path "../config/name"; + } + description + "Reference to the identifier of the subscription + itself. The id will be the handle to refer to the + subscription once created"; + } + + container config { + description + "Config parameters relating to the telemetry + subscriptions on the local device"; + + uses telemetry-subscription-name-config; + uses telemetry-local-source-address-config; + uses telemetry-qos-marking-config; + uses telemetry-stream-protocol-config; + uses telemetry-stream-encoding-config; + } + + container state { + config false; + description + "State parameters relating to the telemetry + subscriptions on the local device"; + + uses telemetry-subscription-name-config; + uses telemetry-subscription-config; + uses telemetry-subscription-state; + uses telemetry-local-source-address-config; + uses telemetry-qos-marking-config; + uses telemetry-stream-protocol-config; + uses telemetry-stream-encoding-config; + } + + container sensor-profiles { + description + "A sensor profile is a set of sensor groups or + individual sensor paths which are associated with a + telemetry subscription. This is the source of the + telemetry data for the subscription to send to the + defined collectors."; + list sensor-profile { + key "sensor-group"; + description + "List of telemetry sensor groups used + in the subscription"; + + leaf sensor-group { + type leafref { + path "../config/sensor-group"; + } + description + "Reference to the telemetry sensor group name"; + } + + container config { + description + "Configuration parameters related to the sensor + profile for a subscription"; + uses telemetry-sensor-profile-config; + } + + container state { + config false; + description + "State information relating to the sensor profile + for a subscription"; + uses telemetry-sensor-profile-config; + } + } + } + + container destination-groups { + description + "A subscription may specify destination addresses. + If the subscription supplies destination addresses, + the network element will be the initiator of the + telemetry streaming, sending it to the destination(s) + specified. + + If the destination set is omitted, the subscription + preconfigures certain elements such as paths and + sample intervals under a specified subscription ID. + In this case, the network element will NOT initiate an + outbound connection for telemetry, but will wait for + an inbound connection from a network management + system. + + It is expected that the network management system + connecting to the network element will reference + the preconfigured subscription ID when initiating + a subscription."; + + list destination-group { + key "group-id"; + description + "Identifier of the previously defined destination + group"; + + leaf group-id { + type leafref { + path "../config/group-id"; + } + description + "The destination group id references a configured + group of destinations for the telemetry stream."; + } + + container config { + description + "Configuration parameters related to telemetry + destinations."; + + leaf group-id { + type leafref { + path "../../../../../../../destination-groups" + + "/destination-group/group-id"; + } + description + "The destination group id references a reusable + group of destination addresses and ports for + the telemetry stream."; + } + } + + container state { + config false; + description + "State information related to telemetry + destinations"; + + leaf group-id { + type leafref { + path "../../../../../../../destination-groups" + + "/destination-group/group-id"; + } + description + "The destination group id references a reusable + group of destination addresses and ports for + the telemetry stream."; + } + } + } + } + } + } + + container dynamic-subscriptions { + description + "This container holds information relating to dynamic + telemetry subscriptions. A dynamic subscription is + typically configured through an RPC channel, and does not + persist across device restarts, or if the RPC channel is + reset or otherwise torn down."; + + + list dynamic-subscription { + key "id"; + + config false; + description + "List representation of telemetry subscriptions that + are configured via an inline RPC, otherwise known + as dynamic telemetry subscriptions."; + + leaf id { + type leafref { + path "../state/id"; + } + + description + "Reference to the identifier of the subscription + itself. The id will be the handle to refer to the + subscription once created"; + } + + container state { + config false; + description + "State information relating to dynamic telemetry + subscriptions."; + + uses telemetry-subscription-config; + uses telemetry-stream-destination-config; + uses telemetry-stream-frequency-config; + uses telemetry-heartbeat-config; + uses telemetry-suppress-redundant-config; + uses telemetry-qos-marking-config; + uses telemetry-stream-protocol-config; + uses telemetry-stream-encoding-config; + } + + container sensor-paths { + description + "Top level container to hold a set of sensor + paths grouped together"; + + list sensor-path { + key "path"; + description + "List of paths in the model which together + comprise a sensor grouping. Filters for each path + to exclude items are also provided."; + + leaf path { + type leafref { + path "../state/path"; + } + description + "Reference to the path of interest"; + } + + container state { + config false; + description + "State information for a dynamic subscription's + paths of interest"; + uses telemetry-sensor-path-config; + } + } + } + } + } + } + } + } + + // identity statements + + // typedef statements + + // grouping statements + + grouping telemetry-sensor-path-config { + description + "Configuration parameters relating to the + grouping of data model paths comprising a + sensor grouping"; + leaf path { + type string; + description + "Path to a section of operational state of interest + (the sensor)."; + } + + leaf exclude-filter { + type string; + description + "Filter to exclude certain values out of the state + values"; + //May not be necessary. Could remove. + } + } + + grouping telemetry-heartbeat-config { + description + "Configuration parameters relating to the + heartbeat of the telemetry subscription"; + leaf heartbeat-interval { + type uint64; + description + "Maximum time interval in seconds that may pass + between updates from a device to a telemetry collector. + If this interval expires, but there is no updated data to + send (such as if suppress_updates has been configured), the + device must send a telemetry message to the collector."; + } + } + + grouping telemetry-suppress-redundant-config { + description + "Configuration parameters relating to suppression of + redundant upstream updates"; + leaf suppress-redundant { + type boolean; + description + "Boolean flag to control suppression of redundant + telemetry updates to the collector platform. If this flag is + set to TRUE, then the collector will only send an update at + the configured interval if a subscribed data value has + changed. Otherwise, the device will not send an update to + the collector until expiration of the heartbeat interval."; + } + } + + grouping telemetry-sensor-profile-config { + description + "Configuration parameters relating to the sensor groups + used in the sensor profile"; + leaf sensor-group { + type leafref { + path "../../../../../../../sensor-groups/sensor-group" + + "/config/sensor-group-id"; + } + description + "Reference to the sensor group which is used in the profile"; + } + uses telemetry-stream-subscription-config; + } + + grouping telemetry-stream-subscription-config { + description + "Configuration used when the sensor is a stream based sensor."; + + uses telemetry-stream-frequency-config; + uses telemetry-heartbeat-config; + uses telemetry-suppress-redundant-config; + + } + + grouping telemetry-qos-marking-config { + description + "Config parameters relating to the quality of service + marking on device generated telemetry packets"; + + leaf originated-qos-marking { + type an-inet:dscp; + description + "DSCP marking of packets generated by the telemetry + subsystem on the network device."; + } + } + + + grouping telemetry-sensor-group-config { + description + "Config parameters related to the sensor groups + on the device"; + leaf sensor-group-id { + type string; + description + "Name or identifier for the sensor group itself. + Will be referenced by other configuration specifying a + sensor group"; + } + } + + grouping telemetry-subscription-config { + description + "Configuration parameters relating to the telemetry + subscription"; + + leaf id { + type uint64; + description + "System generated identifer of the telemetry + subscription."; + } + } + + grouping telemetry-subscription-name-config { + description + "Configuration parameters relating to the configured + name of the telemetry subscription. The name is a user + configured string value which uniquely identifies the + subscription in the configuration database."; + + leaf name { + type string; + description + "User configured identifier of the telemetry + subscription. This value is used primarily for + subscriptions configured locally on the network + element."; + } + } + + grouping telemetry-subscription-state { + description + "State values for the telemetry subscription"; + //TODO add values + } + + grouping telemetry-stream-protocol-config { + description + "Configuration parameters relating to the + transport protocol carrying telemetry + data."; + + leaf protocol { + type identityref { + base an-telemetry-types:STREAM_PROTOCOL; + } + description + "Selection of the transport protocol for the telemetry + stream."; + } + } + + grouping telemetry-stream-encoding-config { + description + "Configuration parameters relating to the + encoding of telemetry data to and from the + network element. The encoding method controls + specifically the wire format of the telemetry + data, and also controls which RPC framework + may be in use to exchange telemetry data."; + + leaf encoding { + type identityref { + base an-telemetry-types:DATA_ENCODING_METHOD; + } + description + "Selection of the specific encoding or RPC framework + for telemetry messages to and from the network element."; + } + } + + grouping telemetry-stream-destination-config { + description + "Configuration parameters for the stream destinations"; + leaf destination-address { + type an-inet:ip-address; + description + "IP address of the telemetry stream destination"; + } + leaf destination-port { + type uint16; + description + "Protocol (udp or tcp) port number for the telemetry + stream destination"; + } + } + + grouping telemetry-stream-frequency-config { + description + "Config parameters for the frequency of updates to + the collector"; + leaf sample-interval { + type uint64; + description + " The accuracy of the collected data reported by the device +to the collector"; + } + } + + grouping telemetry-sensor-specification { + description + "Config related to creating telemetry sensor groups. A sensor + group is a related set of sensor paths and/or filters to + exclude items. A group is assigned a reusable identifer, so + it can be used in multiple telemetry subscriptions."; + list telemetry-sensor-group { + key "telemetry-sensor-group-id"; + description + "List of telemetry sensor groups"; + + leaf telemetry-sensor-group-id { + type string; + description + "The sensor group identifer is a reusable handle which + identifies a single sensor group. It is referenced from + the subscription configuration."; + } + uses telemetry-sensor-paths; + } + } + + grouping telemetry-sensor-paths { + description + "This grouping contains these paths to leaves or containers + in the data model which are the sources of telemetry + information."; + + list telemetry-sensor-paths { + key "telemetry-sensor-path"; + description + "A list of sensor paths and exclude filters which comprise + a sensor grouping"; + + leaf telemetry-sensor-path { + type string; + description + "The sensor path is a path to a portion of operational + state of interest in the data model"; + } + } + } + + + grouping telemetry-local-source-address-config { + description + "Config relating to the local source address for telemetry + messages"; + // TODO: Make this a reference to an interface. + leaf local-source-address { + type an-inet:ip-address; + description + "The IP address which will be the source of packets from + the device to a telemetry collector destination."; + } + } + + // data definition statements + + uses telemetry-top; + + // augment statements + + // rpc statements + + // notification statements +}