diff options
Diffstat (limited to 'sdnr/wt/data-provider/model')
6 files changed, 3272 insertions, 0 deletions
diff --git a/sdnr/wt/data-provider/model/src/main/java/org/opendaylight/yang/gen/v1/http/org/openroadm/pm/types/rev200327/PmDataTypeBuilder.java b/sdnr/wt/data-provider/model/src/main/java/org/opendaylight/yang/gen/v1/http/org/openroadm/pm/types/rev200327/PmDataTypeBuilder.java new file mode 100644 index 000000000..f470fb6ba --- /dev/null +++ b/sdnr/wt/data-provider/model/src/main/java/org/opendaylight/yang/gen/v1/http/org/openroadm/pm/types/rev200327/PmDataTypeBuilder.java @@ -0,0 +1,23 @@ +package org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev200327; +import java.lang.String; +import java.lang.UnsupportedOperationException; + +/** + * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation. + * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32). + * + * The reason behind putting it under src/main/java is: + * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent + * loss of user code. + * + */ +public class PmDataTypeBuilder { + private PmDataTypeBuilder() { + //Exists only to defeat instantiation. + } + + public static PmDataType getDefaultInstance(String defaultValue) { + throw new UnsupportedOperationException("Not yet implemented"); + } + +} diff --git a/sdnr/wt/data-provider/model/src/main/yang/data-provider-g826-pm-types.yang b/sdnr/wt/data-provider/model/src/main/yang/data-provider-g826-pm-types.yang new file mode 100644 index 000000000..ae9410ce4 --- /dev/null +++ b/sdnr/wt/data-provider/model/src/main/yang/data-provider-g826-pm-types.yang @@ -0,0 +1,97 @@ +module data-provider-g826-pm-types { + + yang-version 1.1; + namespace "urn:opendaylight:params:xml:ns:yang:data-provider-g836-pm-types"; + prefix pmt; + + import data-provider-v2 { + prefix uxp; + } + + organization + "highstreet technologies GmbH"; + contact + "Web: <https://highstreet-technologies.com> + ONAP: <https://wiki.onap.org/display/DW/ODLUX+DB+API>"; + + description + "This module defines the perfromance measurement name identities + for SDN controller northbound APIs. + + Copyright 2020 highstreet technologies GmbH Intellectual Property. + All rights reserved. + + Licensed under the Apache License, Version 2.0 (the 'License'); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an 'AS IS' BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License."; + + revision 2020-04-13 { + description + "Initial revision"; + reference + "ITU T-REC-G.826 2002-12"; + } + + // --- typedef + identity performance-measurement-type-id { + base uxp:performance-measurement-type-id; + description + "An abstract base performance measurement type which must not be + used as reference in data objects."; + } + + identity errored-block { + base performance-measurement-type-id; + description + "errored block (EB): + A block in which one or more bits are in error."; + } + + identity errored-second { + base performance-measurement-type-id; + description + "errored second (ES): + A one-second period with one or more errored blocks or at least + one defect."; + } + + identity severely-errored-second { + base performance-measurement-type-id; + description + "severely errored second (SES): + A one-second period which contains ≥30% errored blocks or at least + one defect. SES is a subset of ES."; + } + + identity errored-second-ratio { + base performance-measurement-type-id; + description + "errored second ratio (ESR): + The ratio of ES to total seconds in available time during a fixed + measurement interval. "; + } + + identity severely-errored-second-ratio { + base performance-measurement-type-id; + description + "severely errored second ratio (SESR): + The ratio of SES to total seconds in available time during a fixed + measurement interval."; + } + + identity background-block-error-ratio { + base performance-measurement-type-id; + description + "background block error ratio (BBER): + The ratio of Background Block Errors (BBE) to total blocks in + available time during a fixed measurement interval."; + } +} diff --git a/sdnr/wt/data-provider/model/src/main/yang/data-provider-openroadm-pm-types.yang b/sdnr/wt/data-provider/model/src/main/yang/data-provider-openroadm-pm-types.yang new file mode 100644 index 000000000..2a3fb17a8 --- /dev/null +++ b/sdnr/wt/data-provider/model/src/main/yang/data-provider-openroadm-pm-types.yang @@ -0,0 +1,609 @@ +module data-provider-openroadm-pm-types { + + yang-version 1.1; + namespace "urn:opendaylight:params:xml:ns:yang:data-provider-openroadm-pm-types"; + prefix pmt; + + import data-provider-v2 { + prefix uxp; + } + + organization + "highstreet technologies GmbH"; + contact + "Web: <https://highstreet-technologies.com> + ONAP: <https://wiki.onap.org/display/DW/ODLUX+DB+API>"; + + description + "This module defines the perfromance measurement name identities + for SDN controller northbound APIs. + + Copyright 2020 highstreet technologies GmbH Intellectual Property. + All rights reserved. + + Licensed under the Apache License, Version 2.0 (the 'License'); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an 'AS IS' BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License."; + + revision 2020-04-13 { + description + "Initial revision"; + reference + "https://jira.onap.org/browse/SDNC-???"; + } + + // --- typedef + identity performance-measurement-type-id { + base uxp:performance-measurement-type-id; + description + "An abstract base performance measurement type which must not be used as + reference in data objects."; + } + + // [sko] no need to define vendor extension - yang augment should be used + // SDN Conroller will ignor such values. + // identity vendorExtension { + // base performance-measurement-type-id; + // description + // "vendor extension"; + // } + + identity bitErrorRate { + base performance-measurement-type-id; + description + "Bit error rate (BER)"; + } + identity opticalPowerOutput { + base performance-measurement-type-id; + description + "Optical Power Output (OPOUT-OTS, OPOUT-OMS, OPT-OCH). Total optical power includes Variable Optical Attenuator (VOA) attenuation"; + } + identity opticalReturnLoss { + base performance-measurement-type-id; + description + "Optical Return Loss (ORL-OTS) - at MW port(s) B"; + } + identity opticalPowerInput { + base performance-measurement-type-id; + description + "Optical Power Input (OPIN-OTS, OPIN-OMS, OPR-OCH). Total optical power"; + } + identity codeViolations { + base performance-measurement-type-id; + description + "Code Violations (CV)"; + } + + // [sko] exists already in G826 + // identity erroredSeconds { + // base performance-measurement-type-id; + // description + // "Errored Seconds (ES)"; + // } + + // [sko] exists already in G826 + // identity severelyErroredSeconds { + // base performance-measurement-type-id; + // description + // "Severely Errored Seconds (SES)"; + // } + + identity unavailableSeconds { + base performance-measurement-type-id; + description + "Unavailable Seconds (UAS)"; + } + identity inFrames { + base performance-measurement-type-id; + description + "In frames (INFRAMES-E)"; + } + identity inFramesErrored { + base performance-measurement-type-id; + description + "In frames errored (INFRAMESERR-E)"; + } + identity outFrames { + base performance-measurement-type-id; + description + "Out frames (OUTFRAMES-E)"; + } + identity erroredSecondsEthernet { + base performance-measurement-type-id; + description + "Errored Seconds Ethernet (ES-E)"; + } + identity severelyErroredSecondsEthernet { + base performance-measurement-type-id; + description + "Severely Errored Seconds, Ethernet (SES-E)"; + } + identity unavailableSecondsEthernet { + base performance-measurement-type-id; + description + "Unavailable Seconds, Ethernet (UAS-E)"; + } + identity erroredBlockCount { + base performance-measurement-type-id; + description + "Errored block count"; + } + identity delay { + base performance-measurement-type-id; + description + "Number of frames between a DMValue toggle event and the received DMp signal value toggle event"; + } + identity defectSeconds { + base performance-measurement-type-id; + description + "Defect Seconds (DS)"; + } + identity backwardIncomingAlignmentError { + base performance-measurement-type-id; + description + "Backward Incoming Alignment Error (BIAE)"; + } + identity incomingAlignmentError { + base performance-measurement-type-id; + description + "Incoming Alignment Error (IAE)"; + } + identity opticalPowerOutputMin { + base performance-measurement-type-id; + description + "Minimum Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation"; + } + identity opticalPowerOutputMax { + base performance-measurement-type-id; + description + "Maximum Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation"; + } + identity opticalPowerOutputAvg { + base performance-measurement-type-id; + description + "Average Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation"; + } + identity opticalPowerInputMin { + base performance-measurement-type-id; + description + "Minimum Optical Power Input (OPIN-OTS). Total optical power"; + } + identity opticalPowerInputMax { + base performance-measurement-type-id; + description + "Maximum Optical Power Input (OPIN-OTS). Total optical power"; + } + identity opticalPowerInputAvg { + base performance-measurement-type-id; + description + "Average Optical Power Input (OPIN-OTS). Total optical power"; + } + identity opticalPowerOutputOSC { + base performance-measurement-type-id; + description + "OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port"; + } + identity opticalPowerOutputOSCMin { + base performance-measurement-type-id; + description + "Minimum OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port"; + } + identity opticalPowerOutputOSCMax { + base performance-measurement-type-id; + description + "Maximum OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port"; + } + identity opticalPowerOutputOSCAvg { + base performance-measurement-type-id; + description + "Average OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port"; + } + identity opticalPowerInputOSC { + base performance-measurement-type-id; + description + "OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port"; + } + identity opticalPowerInputOSCMin { + base performance-measurement-type-id; + description + "Minimum OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port"; + } + identity opticalPowerInputOSCMax { + base performance-measurement-type-id; + description + "Maximum OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port"; + } + identity opticalPowerInputOSCAvg { + base performance-measurement-type-id; + description + "Average OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port"; + } + identity preFECCorrectedErrors { + base performance-measurement-type-id; + description + "pFEC corrected Errors"; + } + identity totalOpticalPowerInput { + base performance-measurement-type-id; + description + "Total Optical Power Input."; + } + identity totalOpticalPowerInputMin { + base performance-measurement-type-id; + description + "Minimum Total Optical Power Input."; + } + identity totalOpticalPowerInputMax { + base performance-measurement-type-id; + description + "Maximum Total Optical Power Input."; + } + identity totalOpticalPowerInputAvg { + base performance-measurement-type-id; + description + "Average Total Optical Power Input."; + } + identity FECCorrectableBlocks { + base performance-measurement-type-id; + description + "FEC Correctable Blocks."; + } + identity FECUncorrectableBlocks { + base performance-measurement-type-id; + description + "FEC Uncorrectable Blocks."; + } + identity BIPErrorCounter { + base performance-measurement-type-id; + description + "BIP Error Counter"; + } + identity protectionSwitchingCount { + base performance-measurement-type-id; + description + "Protection Switching Count (PSC)"; + } + identity protectionSwitchingDuration { + base performance-measurement-type-id; + description + "Protection Switching Duration in seconds (PSD)"; + } + identity erroredBlockCountTCM1-up { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM1 up direction."; + } + identity erroredBlockCountTCM2-up { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM2 up direction."; + } + identity erroredBlockCountTCM3-up { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM3 up direction."; + } + identity erroredBlockCountTCM4-up { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM4 up direction."; + } + identity erroredBlockCountTCM5-up { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM5 up direction."; + } + identity erroredBlockCountTCM6-up { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM6 up direction."; + } + identity delayTCM1-up { + base performance-measurement-type-id; + description + "Delay on TCM1 up direction."; + } + identity delayTCM2-up { + base performance-measurement-type-id; + description + "Delay on TCM2 up direction."; + } + identity delayTCM3-up { + base performance-measurement-type-id; + description + "Delay on TCM3 up direction."; + } + identity delayTCM4-up { + base performance-measurement-type-id; + description + "Delay on TCM4 up direction."; + } + identity delayTCM5-up { + base performance-measurement-type-id; + description + "Delay on TCM5 up direction."; + } + identity delayTCM6-up { + base performance-measurement-type-id; + description + "Delay on TCM6 up direction."; + } + identity erroredBlockCountTCM1-down { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM1 down direction."; + } + identity erroredBlockCountTCM2-down { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM2 down direction."; + } + identity erroredBlockCountTCM3-down { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM3 down direction."; + } + identity erroredBlockCountTCM4-down { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM4 down direction."; + } + identity erroredBlockCountTCM5-down { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM5 down direction."; + } + identity erroredBlockCountTCM6-down { + base performance-measurement-type-id; + description + "errored Blocks Count on TCM6 down direction."; + } + identity delayTCM1-down { + base performance-measurement-type-id; + description + "Delay on TCM1 down direction."; + } + identity delayTCM2-down { + base performance-measurement-type-id; + description + "Delay on TCM2 down direction."; + } + identity delayTCM3-down { + base performance-measurement-type-id; + description + "Delay on TCM3 down direction."; + } + identity delayTCM4-down { + base performance-measurement-type-id; + description + "Delay on TCM4 down direction."; + } + identity delayTCM5-down { + base performance-measurement-type-id; + description + "Delay on TCM5 down direction."; + } + identity delayTCM6-down { + base performance-measurement-type-id; + description + "Delay on TCM6 down direction."; + } + identity partialRateDiscard { + base performance-measurement-type-id; + description + "Discarded packet as a result of policing or rate limiting for subrate ethernet."; + } + identity erroredSecondsTCM1-up { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM1 up direction."; + } + identity erroredSecondsTCM2-up { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM2 up direction."; + } + identity erroredSecondsTCM3-up { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM3 up direction."; + } + identity erroredSecondsTCM4-up { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM4 up direction."; + } + identity erroredSecondsTCM5-up { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM5 up direction."; + } + identity erroredSecondsTCM6-up { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM6 up direction."; + } + identity severelyErroredSecondsTCM1-up { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM1 up direction."; + } + identity severelyErroredSecondsTCM2-up { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM2 up direction."; + } + identity severelyErroredSecondsTCM3-up { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM3 up direction."; + } + identity severelyErroredSecondsTCM4-up { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM4 up direction."; + } + identity severelyErroredSecondsTCM5-up { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM5 up direction."; + } + identity severelyErroredSecondsTCM6-up { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM6 up direction."; + } + identity unavailableSecondsTCM1-up { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM1 up direction."; + } + identity unavailableSecondsTCM2-up { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM2 up direction."; + } + identity unavailableSecondsTCM3-up { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM3 up direction."; + } + identity unavailableSecondsTCM4-up { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM4 up direction."; + } + identity unavailableSecondsTCM5-up { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM5 up direction."; + } + identity unavailableSecondsTCM6-up { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM6 up direction."; + } + identity erroredSecondsTCM1-down { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM1 down direction."; + } + identity erroredSecondsTCM2-down { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM2 down direction."; + } + identity erroredSecondsTCM3-down { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM3 down direction."; + } + identity erroredSecondsTCM4-down { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM4 down direction."; + } + identity erroredSecondsTCM5-down { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM5 down direction."; + } + identity erroredSecondsTCM6-down { + base performance-measurement-type-id; + description + "errored Seconds Count on TCM6 down direction."; + } + identity severelyErroredSecondsTCM1-down { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM1 down direction."; + } + identity severelyErroredSecondsTCM2-down { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM2 down direction."; + } + identity severelyErroredSecondsTCM3-down { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM3 down direction."; + } + identity severelyErroredSecondsTCM4-down { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM4 down direction."; + } + identity severelyErroredSecondsTCM5-down { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM5 down direction."; + } + identity severelyErroredSecondsTCM6-down { + base performance-measurement-type-id; + description + "severely Errored Seconds Count on TCM6 down direction."; + } + identity unavailableSecondsTCM1-down { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM1 down direction."; + } + identity unavailableSecondsTCM2-down { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM2 down direction."; + } + identity unavailableSecondsTCM3-down { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM3 down direction."; + } + identity unavailableSecondsTCM4-down { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM4 down direction."; + } + identity unavailableSecondsTCM5-down { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM5 down direction."; + } + identity unavailableSecondsTCM6-down { + base performance-measurement-type-id; + description + "unavailable Seconds Count on TCM6 down direction."; + } + identity fecCorrectedCodewords { + base performance-measurement-type-id; + description + "FEC Corrected Codewords Counter"; + } + identity fecUncorrectedCodewords { + base performance-measurement-type-id; + description + "FEC Uncorrected Codewords Counter"; + } + identity fecSymbolErrors { + base performance-measurement-type-id; + description + "FEC Symbol Error Counter"; + } + identity localFaultSeconds { + base performance-measurement-type-id; + description + "Local Fault Seconds"; + } + identity remoteFaultSeconds { + base performance-measurement-type-id; + description + "Remote Fault Seconds"; + } +} diff --git a/sdnr/wt/data-provider/model/src/main/yang/data-provider-units.yang b/sdnr/wt/data-provider/model/src/main/yang/data-provider-units.yang new file mode 100644 index 000000000..e8979396f --- /dev/null +++ b/sdnr/wt/data-provider/model/src/main/yang/data-provider-units.yang @@ -0,0 +1,86 @@ +module data-provider-units { + + yang-version 1.1; + namespace "urn:opendaylight:params:xml:ns:yang:data-provider-units"; + prefix unit; + + import data-provider-v2 { + prefix uxp; + } + + organization + "highstreet technologies GmbH"; + contact + "Web: <https://highstreet-technologies.com> + ONAP: <https://wiki.onap.org/display/DW/ODLUX+DB+API>"; + + description + "This module defines the unit names. + + Copyright 2020 highstreet technologies GmbH Intellectual Property. + All rights reserved. + + Licensed under the Apache License, Version 2.0 (the 'License'); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an 'AS IS' BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License."; + + revision 2020-04-13 { + description + "Initial revision"; + reference + "ITU T-REC-G.826 2002-12"; + } + + // --- typedef + identity performance-measurement-unit-id { + base uxp:performance-measurement-unit-id; + description + "An abstract base performance measurement type which must not be + used as reference in data objects."; + } + + identity celsius { + base "performance-measurement-unit-id"; + description + "°C: Grad Felsius"; + } + + identity dBm { + base "performance-measurement-unit-id"; + description + "dBm is unit of level used to indicate that a power ratio is expressed in + decibels (dB) with reference to one milliwatt (mW)."; + } + + identity dB { + base "performance-measurement-unit-id"; + description + "dB: decibels"; + } + + identity fahrenheit { + base "performance-measurement-unit-id"; + description + "°F: Grad Fahrenheit"; + } + + identity mW { + base "performance-measurement-unit-id"; + description + "mW: milliwatt"; + } + + identity kHz { + base "performance-measurement-unit-id"; + description + "kHz: kiloherz"; + } +} diff --git a/sdnr/wt/data-provider/model/src/main/yang/data-provider-v2@2020-07-02.yang b/sdnr/wt/data-provider/model/src/main/yang/data-provider-v2@2020-07-02.yang new file mode 100644 index 000000000..358e30c8b --- /dev/null +++ b/sdnr/wt/data-provider/model/src/main/yang/data-provider-v2@2020-07-02.yang @@ -0,0 +1,1748 @@ +module data-provider-v2 { + + yang-version 1.1; + namespace "urn:opendaylight:params:xml:ns:yang:data-provider-v2"; + prefix odluxprovider; + + import org-openroadm-pm-types { + prefix org-openroadm-pm-types; + reference + "OpenROADM: YANG definitions of performance management types"; + } + + import ietf-yang-types { + prefix yang; + reference + "RFC 6991: Common YANG Data Types."; + } + + organization + "highstreet technologies GmbH"; + contact + "Web: <https://highstreet-technologies.com> + ONAP: <https://wiki.onap.org/display/DW/ODLUX+DB+API>"; + + description + "This module defines the API for the data-provider component. + + Copyright 2019 highstreet technologies GmbH Intellectual Property. + All rights reserved. + + Licensed under the Apache License, Version 2.0 (the 'License'); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an 'AS IS' BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License."; + + revision 2020-07-02 { + description + "Initial revision"; + reference + "https://jira.onap.org/browse/SDNC-xxx"; + } + + // --- typedef + + typedef Entity { + type enumeration { + enum connectionlog { + description + "logs mountpoint connection state changes"; + } + enum faultcurrent { + description + "current faults"; + } + enum eventlog { + description + "logs for all notifications e.g. NetConf, ves and internal events"; + } + enum faultlog { + description + "faultlog information"; + } + enum historicalperformance15min { + description + "performance data"; + } + enum historicalperformance24h { + description + "performance data"; + } + enum mediator-server { + description + "list of mediator servers"; + } + enum networkelement-connection { + description + "list of mountpoints for NetConf devices (joint required-network-element+mdsal + state"; + } + enum inventoryequipment { + description + "list of equipment inventory"; + } + enum maintenancemode { + description + "list of maintenance setting"; + } + } + description + "Data type and alias for elasticsearch or table name for SQL database."; + } + + typedef SortOrder { + type enumeration { + enum ascending { + description + "Self explaining."; + } + enum descending { + description + "Self explaining."; + } + } + description + "Entities for odlux clients"; + } + + typedef FilterProperty { + type string; + description + "A string type describing a property (attribute, column, parameter) + filter"; + } + + typedef NotificationType { + type enumeration { + enum ProblemNotificationXml { + description + "A fault (alarm, problem) notification type in XML format."; + } + enum AttributeValueChangedNotificationXml { + description + "An attribute value change notification type in XML format."; + } + } + description + "An enumeration describing the found notification type."; + } + + typedef ConnectionLogStatus { + type enumeration { + enum Mounted { + description + "Mountpoint created"; + } + enum Unmounted { + description + "Mountpoint removed"; + } + enum Connecting { + description + "Mountpoint establishing connection"; + } + enum Connected { + description + "Mountpoint connection established"; + } + enum UnableToConnect { + description + "Mountpoint connection not possible"; + } + enum Disconnected { + description + "Required and mountpoint removed"; + } + enum Undefined { + description + "Status not available"; + } + } + description + "An enumeration describing connection states."; + } + + typedef NetworkElementDeviceType { + type enumeration { + enum Wireless { + description + "implements microwave-model.yang or air-interface.yang"; + } + enum RAN { + description + "implements sth. like o-ran*.yang"; + } + enum ORAN { + description + "implements RAN according to o-ran*.yang"; + } + enum RAN3GPP { + description + "implements RAN according to _3gpp-ran*.yang"; + } + enum Optical { + description + "implements tapi-*.yang or org-openroadm*.yang"; + } + enum Router { + description + "implements vlan-interface.yang"; + } + enum NtsManager { + description + "Simulation of device"; + } + enum Nonsupported { + description + "Device type known, but not support"; + } + enum Unknown { + description + "Device type at this point of time unknown"; + } + } + description + "An enumeration as identification of the device."; + } + + typedef severity-type { + type enumeration { + enum NonAlarmed { + description + "problem cleared indication"; + } + enum Warning { + description + "problem level"; + } + enum Minor { + description + "problem level"; + } + enum Major { + description + "problem level"; + } + enum Critical { + description + "problem level"; + } + } + description + "According to ITU-T M.3160"; + } + + typedef source-type { + type enumeration { + enum Ves { + description + "VES Interface"; + } + enum Netconf { + description + "NetConf Interface"; + } + enum Controller { + description + "SDN Controller"; + } + enum Unknown { + description + "Unknown source"; + } + } + description + "An enumeration for the information source of an event/notification."; + } + + typedef granularity-period-type { + type enumeration { + enum unknown { + description + "none"; + } + enum period-15-min { + description + "none"; + } + enum period-24-hours { + description + "none"; + } + } + description + "The enumeration with the options for granularity period of the + performance data similar to g.874.1-model"; + } + + // --- grouping and builder-container + + grouping connectionlog-entity { + leaf id { + type string; + description + "database id"; + } + leaf node-id { + type string; + description + "the node/mountpoint which connection state has changed"; + } + leaf timestamp { + type yang:date-and-time; + description + "timestamp when event happened, preferred in UTC time format."; + } + leaf status { + type ConnectionLogStatus; + description + "new state of the connection of the device"; + } + description + "An object class describing an entry in the connection status log."; + } + + container connectionlog { + description + "builder"; + uses connectionlog-entity; + } + + grouping object-change-reference { + description + "Reference of of object (e.g. Interface pack) owned by a node"; + leaf node-id { + type string; + description + "A network wide unique identifier of the NetConf server."; + } + leaf counter { + type int32; + description + "An arbitrary counter value."; + } + leaf timestamp { + type yang:date-and-time; + description + "The time of the reported change, preferred in UTC time format. "; + } + leaf object-id { + type string; + description + "The identifier of the reporting object (resource)."; + } + } + + grouping source-reference { + description + "Identify a source"; + leaf source-type { + type source-type; + description + "The source type."; + } + } + + grouping fault { + description + "Fault event of an object"; + leaf problem { + type string; + description + "The alarm type identifier."; + } + leaf severity { + type severity-type; + description + "The reported severity of the fault (alarm)."; + } + } + + grouping attribute-change { + description + "update change of an attribute"; + leaf attribute-name { + type string; + description + "The attribute name which was changed."; + } + leaf new-value { + type string; + description + "The new value of the attribute converted to a string format."; + } + } + + grouping entity-id { + description + "Unique database id of entity"; + leaf id { + type string; + description + "The unique identifier of the entity."; + } + } + + grouping faultcurrent-entity { + description + "Current fault status"; + uses object-change-reference; + uses fault; + uses entity-id; + } + + container faultcurrent { + description + "builder"; + uses faultcurrent-entity; + } + + grouping faultlog-entity { + description + "Changed fault indication"; + uses source-reference; + uses object-change-reference; + uses fault; + uses entity-id; + } + + container faultlog { + description + "builder"; + uses faultlog-entity; + } + + grouping eventlog-entity { + description + "One change event of devices"; + uses source-reference; + uses object-change-reference; + uses attribute-change; + uses entity-id; + } + + container eventlog { + description + "builder"; + uses eventlog-entity; + } + + grouping filter { + leaf description { + type string; + description + "Filter specific description"; + } + leaf start { + type yang:date-and-time; + description + "begin of maintenance-mode"; + } + leaf end { + type yang:date-and-time; + description + "end of maintenance-mode"; + } + leaf object-id-ref { + type string; + description + "object id to filter on, or empty for all"; + } + leaf problem { + type string; + description + "name of the problem to filter or empty for all"; + } + description + "An object class describing a generic filter of an interval for + faults (alarms)."; + } + + grouping maintenance-entity { + description + "Maintenance mode for a device. "; + leaf id { + type string; + mandatory true; + description + "Key to get/set configuration entry in database. Normally Mountpoint + name is used as key id of node."; + } + leaf node-id { + type string; + mandatory true; + description + "A network wide unique identifier of the NetConf server."; + } + leaf active { + type boolean; + description + "Configuration to activate or deactivate this entry"; + } + uses filter; + } + + container maintenance { + presence "false"; + description + "builder"; + uses maintenance-entity; + } + + grouping mediator-server-entity { + leaf id { + type string; + mandatory true; + description + "A network unique identifier of the mediator server."; + } + leaf url { + type string; + description + "The ULR to reach the REST interface of the mediator server."; + } + leaf name { + type string; + description + "A human readable name of the mediator server."; + } + description + "An object class describing a mediator server entity."; + } + + grouping pmdata-base { + description + "Performance data base information"; + leaf node-name { + type string; + description + "A network unique identifier of reporting NetConf server."; + } + leaf uuid-interface { + type string; + description + "A universal unique identifier of the performance monitoring point."; + } + leaf layer-protocol-name { + type string; + description + "The name of the measured transport layer."; + } + leaf radio-signal-id { + type string; + description + "The value exists only of wireless transport devices."; + } + leaf time-stamp { + type yang:date-and-time; + description + "The time-stamp of the measurement, preferred in UTC format."; + } + leaf suspect-interval-flag { + type boolean; + description + "If false, the measurement is not completed and should not be used + for performance analysis. "; + } + leaf granularity-period { + type granularity-period-type; + description + "The expected measurement interval."; + } + leaf scanner-id { + type string; + description + "See ITU-T X.739 chapter 8.1.1.2."; + } + } + + grouping pmdata-microwave { + description + "Consolidated performance information of all microwave model interface + PACs"; + leaf es { + type int32; + units "s"; + default "-1"; + config false; + description + "Number of errored seconds."; + } + leaf ses { + type int32; + units "s"; + default "-1"; + config false; + description + "Number of severely errored seconds."; + } + leaf cses { + type int32; + units "s"; + default "-1"; + config false; + description + "Number of consecutive severely errored seconds."; + } + leaf unavailability { + type int32; + units "s"; + default "-1"; + config false; + description + "Total time of unavailability in seconds."; + } + leaf tx-level-min { + type int8; + units "dBm"; + default "99"; + config false; + description + "Minimum transmit power. Signed integers are required."; + } + leaf tx-level-max { + type int8; + units "dBm"; + default "99"; + config false; + description + "Maximum transmit power. Signed integers are required."; + } + leaf tx-level-avg { + type int8; + units "dBm"; + default "99"; + config false; + description + "Averaged transmit power. Signed integers are required."; + } + leaf rx-level-min { + type int8; + units "dBm"; + default "99"; + config false; + description + "Minimum receive level. Signed integers are required."; + } + leaf rx-level-max { + type int8; + units "dBm"; + default "99"; + config false; + description + "Maximum receive level. Signed integers are required."; + } + leaf rx-level-avg { + type int8; + units "dBm"; + default "99"; + config false; + description + "Averaged receive level. Signed integers are required."; + } + leaf time2-states { + type int32; + units "s"; + default "-1"; + config false; + description + "Sum of all seconds the transmitter operated in e.g. BPSK."; + } + leaf time4-states-s { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time4-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time8-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time16-states-s { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time16-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time32-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time64-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time128-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time256-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time512-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time512-states-l { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time1024-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time1024-states-l { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time2048-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time2048-states-l { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time4096-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time4096-states-l { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time8192-states { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf time8192-states-l { + type int32; + units "s"; + default "-1"; + config false; + description + "none"; + } + leaf snir-min { + type int8; + units "dB"; + default "-99"; + config false; + description + "Minimum signal to (noise+interference) ratio."; + } + leaf snir-max { + type int8; + units "dB"; + default "-99"; + config false; + description + "Maximum signal to (noise+interference) ratio."; + } + leaf snir-avg { + type int8; + units "dB"; + default "-99"; + config false; + description + "Averaged signal to (noise+interference) ratio."; + } + leaf xpd-min { + type int8; + units "dB"; + default "-99"; + config false; + description + "Minimum cross polarization discrimination."; + } + leaf xpd-max { + type int8; + units "dB"; + default "-99"; + config false; + description + "Maximum cross polarization discrimination."; + } + leaf xpd-avg { + type int8; + units "dB"; + default "-99"; + config false; + description + "Averaged cross polarization discrimination."; + } + leaf rf-temp-min { + type int8; + units "C"; + default "-99"; + config false; + description + "Lowest temperature (in degree Celsius) of the radio module inside the + outdoor unit."; + } + leaf rf-temp-max { + type int8; + units "C"; + default "-99"; + config false; + description + "Highest temperature (in degree Celsius) of the radio module inside the + outdoor unit."; + } + leaf rf-temp-avg { + type int8; + units "C"; + default "-99"; + config false; + description + "Averaged temperature (in degree Celsius) of the radio module inside + the outdoor unit."; + } + leaf defect-blocks-sum { + type int16; + units "blocks"; + default "-1"; + config false; + description + "Total number of blocks that were defect after receiving and could not + be corrected by the FEC."; + } + leaf time-period { + type int32; + units "s"; + default "-1"; + config false; + description + "Total length of the measurement period."; + } + } + + grouping pmdata-ethernet { + description + "Consolidated performance information for Ethernet."; + leaf tx-ethernet-bytes-max-s { + type int32; + units "Bytes/s"; + default "-1"; + config false; + description + "Counts the number of Bytes of Ethernet traffic (before header + compression) transmitted within a second and keeps the highest value + within the measurement period. Field to be left blank for all types of + TDM containers."; + } + leaf tx-ethernet-bytes-max-m { + type int64; + units "Bytes/min"; + default "-1"; + config false; + description + "Counts the number of Bytes of Ethernet traffic (before header + compression) transmitted within a minute and keeps the highest value + with in the measurement period. Field to be left blank for all types + of TDM containers."; + } + leaf tx-ethernet-bytes-sum { + type int64; + units "Bytes"; + default "-1"; + config false; + description + "Total number of Bytes of Ethernet traffic (before header compression) + transmitted (in direction out of the device) during the measurement + period. Field to be left blank for all types of TDM containers."; + } + } + + identity performance-measurement-type-id { + description + "Base identity for perforamnce measurement types. A unique identification + of the performance measurment value, not including the resource. + Different resources can share performance measuement types. If the + resource reports the same performance measurment type, it is to be + considered to be the same performance measurment. + + This identity is abstract and MUST NOT be used for performence + mesurement."; + } + + identity performance-measurement-unit-id { + description + "Base identity for perforamnce measurement units. + + This identity is abstract and MUST NOT be used for performence + mesurement."; + } + + typedef performance-measurement-type-id { + type identityref { + base performance-measurement-type-id; + } + description + "Identifies an performance-measurement type. The description of the + performance measurement type id MUST indicate if the performance + measurement type is abstract or not. An abstract performance measurement + type is used as a base for other performance measurement type ids + and will not be used as a value for an performance measurement or be + present in the performance measurement inventory."; + } + + typedef performance-measurement-unit-id { + type identityref { + base performance-measurement-unit-id; + } + description + "Identifies an performance-measurement unit. The description of the + performance measurement unit id MUST indicate if the performance + measurement unit is abstract or not. An abstract performance measurement + unit is used as a base for other performance measurement unit ids + and will not be used as a value for an performance measurement or be + present in the performance measurement inventory."; + } + + grouping pm-measurement-grp { + leaf pm-key { + type performance-measurement-type-id; + description + "The local identifier of a pm-measurement object."; + } + leaf pm-value { + type org-openroadm-pm-types:pm-data-type; + mandatory true; + description + "The performance measurement value, measured in a certain interval."; + } + leaf pm-unit { + type performance-measurement-unit-id; + description + "A represention of the unit og the pm-value."; + } + description + "An abstract object class representing a key-value pair for + pm-measurement."; + } + grouping pmdata-grp { + list measurement { + key pm-key; + uses pm-measurement-grp; + description + "An abstract list of perfromance mesurement values."; + } + description + "An abstract object class containing a list of perfromance mesurement + values."; + } + + container pmdata-entity { + description + "builder"; + uses pmdata-base; + container performance-data { + uses pmdata-microwave; + uses pmdata-ethernet; + uses pmdata-grp; + description + "An object combining different performance monitoring data."; + } + } + + grouping pmdata15m-entity { + uses pmdata-base; + container performance-data { + uses pmdata-microwave; + uses pmdata-ethernet; + description + "An object combining different performance monitoring data."; + } + description + "An object class describing a 15 minute performance monitoring entity."; + } + + grouping pmdata24h-entity { + uses pmdata-base; + container performance-data { + uses pmdata-microwave; + uses pmdata-ethernet; + description + "An object combining different performance monitoring data."; + } + description + "An object class describing a 24 hour performance monitoring entity."; + } + + grouping inventory-entity { + description + "One equipment entity in a list of a network element that could be rack, + card, backplane, module"; + leaf id { + type string; + mandatory true; + description + "Unique database id, node-id/uuid"; + } + leaf tree-level { + type uint32; + description + "Containment level, starting with 0.."; + } + leaf parent-uuid { + type string; + description + "Unique inventory id of holder"; + } + leaf node-id { + type string; + description + "Unique node id of network element"; + } + leaf uuid { + type string; + description + "Unique inventory id of this node for this equipment, provided by + network element"; + } + leaf-list contained-holder { + type string; + description + "List of uuid of contained equipment"; + } + leaf manufacturer-name { + type string; + description + "manufactured-thing/manufacturer-properties/manufacturer-name"; + } + leaf manufacturer-identifier { + type string; + description + "manufactured-thing/manufacturer-properties/manufacturer-identifier"; + } + leaf serial { + type string; + description + "manufactured-thing/equipment-instance/serial"; + } + leaf date { + type string; + description + "manufactured-thing/equipment-instance/manufacture-date: Date + information provided by manufacturer. No specific format. ()"; + } + leaf version { + type string; + description + "manufactured-thing/equipment-type/version"; + } + leaf description { + type string; + description + "manufactured-thing/equipment-type/description"; + } + leaf part-type-id { + type string; + description + "manufactured-thing/equipment-type/part-type-identifier"; + } + leaf model-identifier { + type string; + description + "manufactured-thing/equipment-type/model-identifier"; + } + leaf type-name { + type string; + description + "manufactured-thing/equipment-type/type-name"; + } + } + + container inventory { + presence "false"; + description + "builder"; + uses inventory-entity; + } + + grouping node-details-g { + leaf-list available-capabilities { + type string; + description + "The list of available yang capabilities."; + } + leaf-list unavailable-capabilities { + type string; + description + "The list of unavailable yang capabilities."; + } + description + "An object class description the available and unavailable yang + capabilities."; + } + + grouping network-element-connection-entity { + leaf id { + type string; + description + "database id/key. here is equal to node-id"; + } + leaf node-id { + type string; + description + "mountpoint name of device in controller"; + } + leaf host { + type string; + description + "NetConf server host name or IP address of device"; + } + leaf port { + type uint32; + description + "NetConf port of device"; + } + leaf username { + type string; + description + "NetConf user name"; + } + leaf password { + type string; + description + "NetConf password. should be removed asap"; + } + leaf core-model-capability { + type string; + description + "revision of core-model capability"; + } + leaf device-type { + type NetworkElementDeviceType; + description + "categorized type of device based on implemented yang specs"; + } + leaf is-required { + type boolean; + description + "entry exists in db index required-networkelement"; + } + container node-details { + uses node-details-g; + description + "holder of available and unavailable capabilities"; + } + leaf status { + type ConnectionLogStatus; + description + "current connection status. default Disconnected"; + } + description + "An object class defining the NetConf connection towards a + NetConf server. "; + } + + container network-element-connection { + description + "builder"; + uses network-element-connection-entity; + } + + grouping status-entity { + container faults { + leaf criticals { + type uint32; + description + "The number of current faults (active alarms) with severity + 'critical'."; + } + leaf majors { + type uint32; + description + "The number of current faults (active alarms) with severity + 'major'."; + } + leaf minors { + type uint32; + description + "The number of current faults (active alarms) with severity + 'minor'."; + } + leaf warnings { + type uint32; + description + "The number of current faults (active alarms) with severity + 'warning'."; + } + description + "An object containing the number of current faults per its severity."; + } + description + "An object class defining an status entity for current faults + (also called active alarms)."; + } + + container status { + description + "builder"; + uses status-entity; + } + + grouping entity-input { + list filter { + key "property"; + leaf property { + type string; + description + "The property (parameter, column, field) identifier."; + } + leaf filtervalue { + type string; + description + "The filter information for the corresponding property."; + } + description + "List with filter criteria. Not listed means all."; + } + list sortorder { + key "property"; + leaf property { + type string; + description + "The property (parameter, column, field) identifier."; + } + leaf sortorder { + type SortOrder; + description + "The definition of the sort order for the corresponding property."; + } + description + "List with sort order. Not listed means default"; + } + container pagination { + leaf size { + type uint32 { + range "1..max"; + } + default "20"; + description + "Number of entries to be delivered"; + } + leaf page { + type uint64 { + range "1..max"; + } + default "1"; + description + "Number to be used to calculate starting entry to deliver"; + } + description + "An object defining the pagination details."; + } + description + "An object class defining a request input entity."; + } + + grouping pagination-output-g { + leaf size { + type uint32 { + range "1..max"; + } + default "20"; + description + "Number of entries to be delivered"; + } + leaf page { + type uint64 { + range "1..max"; + } + default "1"; + description + "Number to be used to calculate starting entry to deliver"; + } + leaf total { + type uint64 { + range "0..max"; + } + default "0"; + description + "Number to be used to calculate starting entry to deliver"; + } + description + "An object class defining the filter information for pagination."; + } + + container pagination-output { + description + "builder"; + uses pagination-output-g; + } + + // --- rpc + + rpc read-faultcurrent-list { + description + "Get list of current fault (active alarm) entries according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses faultcurrent-entity; + description + "The output data as list of current fault (or active alarm) + entities."; + } + } + } + + rpc read-faultlog-list { + description + "Get list of faultlog entries according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses faultlog-entity; + description + "The output data as list of fault entities."; + } + } + } + + rpc read-eventlog-list { + description + "Get list of event log entities according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses eventlog-entity; + description + "The output data as list of event log entities."; + } + } + } + + rpc read-connectionlog-list { + description + "Get list of event log entities according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses connectionlog-entity; + description + "The output data as list of connection log entities."; + } + } + } + + rpc read-maintenance-list { + description + "Get list of maintenance entries according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses maintenance-entity; + description + "The output data as list of maintenance entities."; + } + } + } + + rpc create-maintenance { + description + "insert new entry of maintenance"; + input { + uses maintenance-entity; + } + output { + uses maintenance-entity; + } + } + + rpc update-maintenance { + description + "update existing entity of maintenance"; + input { + uses maintenance-entity; + } + output { + uses maintenance-entity; + } + } + + rpc delete-maintenance { + description + "delete entity of maintenance"; + input { + uses maintenance-entity; + } + } + + rpc read-mediator-server-list { + description + "Get list of mediator-servers according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses mediator-server-entity; + description + "The list of found mediator server entities."; + } + } + } + + rpc create-mediator-server { + description + "create new entry of entity mediator-server"; + input { + uses mediator-server-entity; + } + output { + uses mediator-server-entity; + } + } + + rpc update-mediator-server { + description + "update entry of entity mediator-server"; + input { + uses mediator-server-entity; + } + output { + uses mediator-server-entity; + } + } + + rpc delete-mediator-server { + description + "delete entry of entity mediator-server"; + input { + uses mediator-server-entity; + } + } + + rpc read-network-element-connection-list { + description + "Get list of networkelement-connections according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses network-element-connection-entity; + description + "The output data as list of found network-element (or mountpoint, + or network functions) connection entities."; + } + } + } + + rpc create-network-element-connection { + description + "create entry in networkelement-connection"; + input { + uses network-element-connection-entity; + } + output { + uses network-element-connection-entity; + } + } + + rpc update-network-element-connection { + description + "Put an element to ne-entity"; + input { + uses network-element-connection-entity; + } + output { + uses network-element-connection-entity; + } + } + + rpc delete-network-element-connection { + description + "!ONLY FOR TESTING! Put an element to ne-entity"; + input { + uses network-element-connection-entity; + } + } + + rpc read-pmdata-15m-ltp-list { + description + "Get list of ltps for one mountpoint with historical pmdata"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + leaf-list data { + type string; + description + "The list of found mountpoint names."; + } + } + } + + rpc read-pmdata-24h-ltp-list { + description + "Get list of ltps for one mountpoint with historical pmdata"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + leaf-list data { + type string; + description + "The list of found logical-termination-point identifiers."; + } + } + } + + rpc read-pmdata-15m-device-list { + description + "Get list of mountpoints with historical pmdata"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + leaf-list data { + type string; + description + "The list of found mountpoint names."; + } + } + } + + rpc read-pmdata-24h-device-list { + description + "Get list of mountpoints with historical pmdata"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + leaf-list data { + type string; + description + "The list of found mountpoint names."; + } + } + } + + rpc read-pmdata-15m-list { + description + "Get list of entities according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses pmdata15m-entity; + description + "The output data as list of 15 minutes performance monitoring + entities."; + } + } + } + + rpc read-pmdata-24h-list { + description + "Get list of historical pmdata according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses pmdata24h-entity; + description + "The output data as list of 24 hours performance monitoring + entities."; + } + } + } + + rpc read-inventory-list { + description + "Get list of inventory according to filter"; + input { + uses entity-input; + } + output { + container pagination { + uses pagination-output-g; + description + "The pagination details used by the provider to filter the data."; + } + list data { + uses inventory-entity; + description + "The output data as list of inventory entities."; + } + } + } + + rpc read-status { + description + "Read status information of controller"; + output { + list data { + uses status-entity; + description + "The output data as list of status entities."; + } + } + } +} diff --git a/sdnr/wt/data-provider/model/src/main/yang/org-openroadm-pm-types@2020-03-27.yang b/sdnr/wt/data-provider/model/src/main/yang/org-openroadm-pm-types@2020-03-27.yang new file mode 100644 index 000000000..1fbd72e0f --- /dev/null +++ b/sdnr/wt/data-provider/model/src/main/yang/org-openroadm-pm-types@2020-03-27.yang @@ -0,0 +1,709 @@ +module org-openroadm-pm-types { + namespace "http://org/openroadm/pm-types"; + prefix org-openroadm-pm-types; + + organization + "Open ROADM MSA"; + contact + "OpenROADM.org"; + description + "YANG definitions of performance management types. + + Copyright of the Members of the Open ROADM MSA Agreement dated (c) 2016, + All other rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + * Neither the Members of the Open ROADM MSA Agreement nor the names of its + contributors may be used to endorse or promote products derived from this software + without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT ''AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT THE MEMBERS OF THE OPEN ROADM MSA AGREEMENT BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, + OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE"; + + revision 2020-03-27 { + description + "Version 7.0.0"; + } + revision 2019-11-29 { + description + "Version 6.1.0"; + } + revision 2019-03-29 { + description + "Version 5.0.0"; + } + revision 2018-11-30 { + description + "Version 4.1.0"; + } + revision 2017-12-15 { + description + "Version 2.2"; + } + revision 2017-09-29 { + description + "Version 2.1"; + } + revision 2017-06-26 { + description + "Version 2.0"; + } + revision 2016-10-14 { + description + "Version 1.2"; + } + + typedef pm-granularity { + type enumeration { + enum notApplicable { + value 1; + description + "This is for total statistic counters on devices that support + them."; + } + enum 15min { + value 2; + } + enum 24Hour { + value 3; + } + } + description + "Granularity of PM bin"; + } + + typedef pm-data-type { + type union { + type uint64; + type int64; + type decimal64 { + fraction-digits 2; + } + type decimal64 { + fraction-digits 17; + } + } + } + + typedef validity { + type enumeration { + enum complete { + value 1; + } + enum partial { + value 2; + } + enum suspect { + value 3; + } + } + description + "Validity of data"; + } + + typedef pm-names-enum { + type enumeration { + enum vendorExtension { + value 1; + description + "vendor extension"; + } + enum bitErrorRate { + value 2; + description + "Bit error rate (BER)"; + } + enum opticalPowerOutput { + value 3; + description + "Optical Power Output (OPOUT-OTS, OPOUT-OMS, OPT-OCH). Total optical power includes Variable Optical Attenuator (VOA) attenuation"; + } + enum opticalReturnLoss { + value 4; + description + "Optical Return Loss (ORL-OTS) - at MW port(s) B"; + } + enum opticalPowerInput { + value 5; + description + "Optical Power Input (OPIN-OTS, OPIN-OMS, OPR-OCH). Total optical power"; + } + enum codeViolations { + value 8; + description + "Code Violations (CV)"; + } + enum erroredSeconds { + value 9; + description + "Errored Seconds (ES)"; + } + enum severelyErroredSeconds { + value 10; + description + "Severely Errored Seconds (SES)"; + } + enum unavailableSeconds { + value 11; + description + "Unavailable Seconds (UAS)"; + } + enum inFrames { + value 12; + description + "In frames (INFRAMES-E)"; + } + enum inFramesErrored { + value 13; + description + "In frames errored (INFRAMESERR-E)"; + } + enum outFrames { + value 14; + description + "Out frames (OUTFRAMES-E)"; + } + enum erroredSecondsEthernet { + value 15; + description + "Errored Seconds Ethernet (ES-E)"; + } + enum severelyErroredSecondsEthernet { + value 16; + description + "Severely Errored Seconds, Ethernet (SES-E)"; + } + enum unavailableSecondsEthernet { + value 17; + description + "Unavailable Seconds, Ethernet (UAS-E)"; + } + enum erroredBlockCount { + value 18; + description + "Errored block count"; + } + enum delay { + value 19; + description + "Number of frames between a DMValue toggle event and the received DMp signal value toggle event"; + } + enum defectSeconds { + value 20; + description + "Defect Seconds (DS)"; + } + enum backwardIncomingAlignmentError { + value 21; + description + "Backward Incoming Alignment Error (BIAE)"; + } + enum incomingAlignmentError { + value 22; + description + "Incoming Alignment Error (IAE)"; + } + enum opticalPowerOutputMin { + value 23; + description + "Minimum Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation"; + } + enum opticalPowerOutputMax { + value 24; + description + "Maximum Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation"; + } + enum opticalPowerOutputAvg { + value 25; + description + "Average Optical Power Output (OPOUT-OTS). Total optical power includes Variable Optical Attenuator (VOA) attenuation"; + } + enum opticalPowerInputMin { + value 26; + description + "Minimum Optical Power Input (OPIN-OTS). Total optical power"; + } + enum opticalPowerInputMax { + value 27; + description + "Maximum Optical Power Input (OPIN-OTS). Total optical power"; + } + enum opticalPowerInputAvg { + value 28; + description + "Average Optical Power Input (OPIN-OTS). Total optical power"; + } + enum opticalPowerOutputOSC { + value 29; + description + "OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port"; + } + enum opticalPowerOutputOSCMin { + value 30; + description + "Minimum OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port"; + } + enum opticalPowerOutputOSCMax { + value 31; + description + "Maximum OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port"; + } + enum opticalPowerOutputOSCAvg { + value 32; + description + "Average OSC Optical Power Output (OPT-OSC). OSC Transmit power on MW port"; + } + enum opticalPowerInputOSC { + value 33; + description + "OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port"; + } + enum opticalPowerInputOSCMin { + value 34; + description + "Minimum OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port"; + } + enum opticalPowerInputOSCMax { + value 35; + description + "Maximum OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port"; + } + enum opticalPowerInputOSCAvg { + value 36; + description + "Average OSC Optical Power Input (OPR-OSC). OSC Receive power on MW port"; + } + enum preFECCorrectedErrors { + value 37; + description + "pFEC corrected Errors"; + } + enum totalOpticalPowerInput { + value 38; + description + "Total Optical Power Input."; + } + enum totalOpticalPowerInputMin { + value 39; + description + "Minimum Total Optical Power Input."; + } + enum totalOpticalPowerInputMax { + value 40; + description + "Maximum Total Optical Power Input."; + } + enum totalOpticalPowerInputAvg { + value 41; + description + "Average Total Optical Power Input."; + } + enum FECCorrectableBlocks { + value 42; + description + "FEC Correctable Blocks."; + } + enum FECUncorrectableBlocks { + value 43; + description + "FEC Uncorrectable Blocks."; + } + enum BIPErrorCounter { + value 56; + description + "BIP Error Counter"; + } + enum protectionSwitchingCount { + value 57; + description + "Protection Switching Count (PSC)"; + } + enum protectionSwitchingDuration { + value 58; + description + "Protection Switching Duration in seconds (PSD)"; + } + enum erroredBlockCountTCM1-up { + value 59; + description + "errored Blocks Count on TCM1 up direction."; + } + enum erroredBlockCountTCM2-up { + value 60; + description + "errored Blocks Count on TCM2 up direction."; + } + enum erroredBlockCountTCM3-up { + value 61; + description + "errored Blocks Count on TCM3 up direction."; + } + enum erroredBlockCountTCM4-up { + value 62; + description + "errored Blocks Count on TCM4 up direction."; + } + enum erroredBlockCountTCM5-up { + value 63; + description + "errored Blocks Count on TCM5 up direction."; + } + enum erroredBlockCountTCM6-up { + value 64; + description + "errored Blocks Count on TCM6 up direction."; + } + enum delayTCM1-up { + value 65; + description + "Delay on TCM1 up direction."; + } + enum delayTCM2-up { + value 66; + description + "Delay on TCM2 up direction."; + } + enum delayTCM3-up { + value 67; + description + "Delay on TCM3 up direction."; + } + enum delayTCM4-up { + value 68; + description + "Delay on TCM4 up direction."; + } + enum delayTCM5-up { + value 69; + description + "Delay on TCM5 up direction."; + } + enum delayTCM6-up { + value 70; + description + "Delay on TCM6 up direction."; + } + enum erroredBlockCountTCM1-down { + value 71; + description + "errored Blocks Count on TCM1 down direction."; + } + enum erroredBlockCountTCM2-down { + value 72; + description + "errored Blocks Count on TCM2 down direction."; + } + enum erroredBlockCountTCM3-down { + value 73; + description + "errored Blocks Count on TCM3 down direction."; + } + enum erroredBlockCountTCM4-down { + value 74; + description + "errored Blocks Count on TCM4 down direction."; + } + enum erroredBlockCountTCM5-down { + value 75; + description + "errored Blocks Count on TCM5 down direction."; + } + enum erroredBlockCountTCM6-down { + value 76; + description + "errored Blocks Count on TCM6 down direction."; + } + enum delayTCM1-down { + value 77; + description + "Delay on TCM1 down direction."; + } + enum delayTCM2-down { + value 78; + description + "Delay on TCM2 down direction."; + } + enum delayTCM3-down { + value 79; + description + "Delay on TCM3 down direction."; + } + enum delayTCM4-down { + value 80; + description + "Delay on TCM4 down direction."; + } + enum delayTCM5-down { + value 81; + description + "Delay on TCM5 down direction."; + } + enum delayTCM6-down { + value 82; + description + "Delay on TCM6 down direction."; + } + enum partialRateDiscard { + value 83; + description + "Discarded packet as a result of policing or rate limiting for subrate ethernet."; + } + enum erroredSecondsTCM1-up { + value 84; + description + "errored Seconds Count on TCM1 up direction."; + } + enum erroredSecondsTCM2-up { + value 85; + description + "errored Seconds Count on TCM2 up direction."; + } + enum erroredSecondsTCM3-up { + value 86; + description + "errored Seconds Count on TCM3 up direction."; + } + enum erroredSecondsTCM4-up { + value 87; + description + "errored Seconds Count on TCM4 up direction."; + } + enum erroredSecondsTCM5-up { + value 88; + description + "errored Seconds Count on TCM5 up direction."; + } + enum erroredSecondsTCM6-up { + value 89; + description + "errored Seconds Count on TCM6 up direction."; + } + enum severelyErroredSecondsTCM1-up { + value 90; + description + "severely Errored Seconds Count on TCM1 up direction."; + } + enum severelyErroredSecondsTCM2-up { + value 91; + description + "severely Errored Seconds Count on TCM2 up direction."; + } + enum severelyErroredSecondsTCM3-up { + value 92; + description + "severely Errored Seconds Count on TCM3 up direction."; + } + enum severelyErroredSecondsTCM4-up { + value 93; + description + "severely Errored Seconds Count on TCM4 up direction."; + } + enum severelyErroredSecondsTCM5-up { + value 94; + description + "severely Errored Seconds Count on TCM5 up direction."; + } + enum severelyErroredSecondsTCM6-up { + value 95; + description + "severely Errored Seconds Count on TCM6 up direction."; + } + enum unavailableSecondsTCM1-up { + value 96; + description + "unavailable Seconds Count on TCM1 up direction."; + } + enum unavailableSecondsTCM2-up { + value 97; + description + "unavailable Seconds Count on TCM2 up direction."; + } + enum unavailableSecondsTCM3-up { + value 98; + description + "unavailable Seconds Count on TCM3 up direction."; + } + enum unavailableSecondsTCM4-up { + value 99; + description + "unavailable Seconds Count on TCM4 up direction."; + } + enum unavailableSecondsTCM5-up { + value 100; + description + "unavailable Seconds Count on TCM5 up direction."; + } + enum unavailableSecondsTCM6-up { + value 101; + description + "unavailable Seconds Count on TCM6 up direction."; + } + enum erroredSecondsTCM1-down { + value 102; + description + "errored Seconds Count on TCM1 down direction."; + } + enum erroredSecondsTCM2-down { + value 103; + description + "errored Seconds Count on TCM2 down direction."; + } + enum erroredSecondsTCM3-down { + value 104; + description + "errored Seconds Count on TCM3 down direction."; + } + enum erroredSecondsTCM4-down { + value 105; + description + "errored Seconds Count on TCM4 down direction."; + } + enum erroredSecondsTCM5-down { + value 106; + description + "errored Seconds Count on TCM5 down direction."; + } + enum erroredSecondsTCM6-down { + value 107; + description + "errored Seconds Count on TCM6 down direction."; + } + enum severelyErroredSecondsTCM1-down { + value 108; + description + "severely Errored Seconds Count on TCM1 down direction."; + } + enum severelyErroredSecondsTCM2-down { + value 109; + description + "severely Errored Seconds Count on TCM2 down direction."; + } + enum severelyErroredSecondsTCM3-down { + value 110; + description + "severely Errored Seconds Count on TCM3 down direction."; + } + enum severelyErroredSecondsTCM4-down { + value 111; + description + "severely Errored Seconds Count on TCM4 down direction."; + } + enum severelyErroredSecondsTCM5-down { + value 112; + description + "severely Errored Seconds Count on TCM5 down direction."; + } + enum severelyErroredSecondsTCM6-down { + value 113; + description + "severely Errored Seconds Count on TCM6 down direction."; + } + enum unavailableSecondsTCM1-down { + value 114; + description + "unavailable Seconds Count on TCM1 down direction."; + } + enum unavailableSecondsTCM2-down { + value 115; + description + "unavailable Seconds Count on TCM2 down direction."; + } + enum unavailableSecondsTCM3-down { + value 116; + description + "unavailable Seconds Count on TCM3 down direction."; + } + enum unavailableSecondsTCM4-down { + value 117; + description + "unavailable Seconds Count on TCM4 down direction."; + } + enum unavailableSecondsTCM5-down { + value 118; + description + "unavailable Seconds Count on TCM5 down direction."; + } + enum unavailableSecondsTCM6-down { + value 119; + description + "unavailable Seconds Count on TCM6 down direction."; + } + enum fecCorrectedCodewords { + value 120; + description + "FEC Corrected Codewords Counter"; + } + enum fecUncorrectedCodewords { + value 121; + description + "FEC Uncorrected Codewords Counter"; + } + enum fecSymbolErrors { + value 122; + description + "FEC Symbol Error Counter"; + } + enum localFaultSeconds { + value 123; + description + "Local Fault Seconds"; + } + enum remoteFaultSeconds { + value 124; + description + "Remote Fault Seconds"; + } + } + } + + grouping pm-measurement { + description + "Set of parameters related to a PM Measurement"; + leaf pmParameterValue { + type pm-data-type; + config false; + mandatory true; + } + leaf pmParameterUnit { + type string; + mandatory false; + description + "Unit PM parameter has been measured - frames, packets, u, etc"; + } + leaf validity { + type validity; + mandatory false; + } + } + + grouping pm-names { + description + "Name of PM parameter. Consists of a set list of parameters, + plus an extension field to support addition parameters."; + leaf type { + type pm-names-enum; + mandatory true; + } + leaf extension { + type string; + description + "name of parameter, when enum value set to vendorExtension because + name not found in pm-names-enum"; + } + } +}
\ No newline at end of file |