path: root/sdnr/wt/data-provider/model/src/main/yang/dataprovider.yang

module data-provider {

    yang-version 1;
    namespace "urn:opendaylight:params:xml:ns:yang:data-provider";
    prefix "odluxprovider";

    import ietf-yang-types { prefix "yang"; revision-date 2013-07-15; }
    import netconf-node-topology { prefix "nettop"; revision-date 2015-01-14; }
    description
        "data-provider api module";

    revision "2019-08-01" {
        description
                "Initial revision";
    }
    // --- typedef
    typedef Entity {
        description "Data type and alias for elasticsearch or table name for SQL database.";
        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";
            }
        }
    }
    typedef SortOrder {
        type enumeration {
            enum ascending {
            }
            enum descending {
            }
        }
        description "Entities for odlux clients";
    }
    typedef FilterProperty {
        type string;
    }

    typedef NotificationType {
        type enumeration {
            enum ProblemNotificationXml {
                description "";
            }
            enum AttributeValueChangedNotificationXml {
                description "";
            }
        }
    }

    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";
            }
        }
    }
    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";
            }
        }
    }
    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";
            }
        }
    }
    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";
        }
        leaf status {
            type ConnectionLogStatus;
            description "new state of the connection of the device";
        }
    }
    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;
        }
        leaf counter {
            type int32;
        }
        leaf timestamp {
            type yang:date-and-time;
        }
        leaf object-id {
            type string;
        }
    }
    grouping source-reference {
        description "Identify a source";
        leaf source-type {
            type source-type;
        }
    }
    grouping fault {
        description "Fault event of an object";
        leaf problem {
            type string;
        }
        leaf severity {
            type severity-type;
        }
    }
    grouping attribute-change {
        description "update change of an attribute";
        leaf attribute-name {
            type string;
        }
        leaf new-value {
            type string;
        }
    }
    grouping entity-id {
        description "Unique database id of entity";
        leaf id {
            type string;
        }
    }
    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";
        }
    }
    grouping maintenance-entity {
        description "Maintenance mode for a device. ";
        leaf id {
            mandatory true;
            type string;
            description "Key to get/set configuration entry in database. Normally Mountpoint-name
                        is used as key id of node.";
        }
        leaf node-id {
            mandatory true;
            type string;
            description "";
        }
        leaf active {
            type boolean;
            description "Configuration to activate or deactivate this entry";
        }
        uses filter;
    }
    container maintenance {
        description "builder";
        uses maintenance-entity;
    }
    grouping mediator-server-entity {
        leaf id {
            mandatory true;
            type string;
        }
        leaf url {
            type string;
        }
        leaf name {
            type string;
        }
    }
    grouping pmdata-base {
       description "Performance data base information";
        leaf node-name {
            type string;
        }
        leaf uuid-interface {
            type string;
        }
        leaf layer-protocol-name {
            type string;
        }
        leaf radio-signal-id {
            type string;
        }
        leaf time-stamp {
            type yang:date-and-time;
        }
        leaf suspect-interval-flag {
            type boolean;
        }
        leaf granularity-period {
            type granularity-period-type;
        }
        leaf scanner-id {
            type string;
        }
    }
    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.";
        }
    }
    container pmdata-entity {
        description "builder";
        uses pmdata-base;
        container performance-data {
            uses pmdata-microwave;
            uses pmdata-ethernet;
        }
    }
    grouping pmdata15m-entity {
        uses pmdata-base;
        container performance-data {
            uses pmdata-microwave;
            uses pmdata-ethernet;
        }
    }
    grouping pmdata24h-entity {
        uses pmdata-base;
        container performance-data {
            uses pmdata-microwave;
            uses pmdata-ethernet;
        }
    }
    grouping inventory-entity {
        description "One equipment entity in a list of a network element that could be rack, card, backplane, module";

        leaf id {
            description "Unique database id, node-id/uuid";
            mandatory true;
            type string;
        }
        leaf tree-level {
            description "Containment level, starting with 0..";
            type uint32;
        }
        leaf parent-uuid {
            description "Unique inventory id of holder";
            type string;
        }
        leaf node-id {
            description "Unique node id of network element";
            type string;
        }
        leaf uuid {
            description "Unique inventory id of this node for this equipement, provided by network element";
            type string;
        }
        leaf-list contained-holder {
            description "List of uuid of contained equipment";
            type string;
        }
        leaf manufacturer-name {
            description "manufactured-thing/manufacturer-properties/manufacturer-name";
            type string;
        }
        leaf manufacturer-identifier {
            description "manufactured-thing/manufacturer-properties/manufacturer-identifier";
            type string;
        }
        leaf serial {
            description "manufactured-thing/equipment-instance/serial";
            type string;
        }
        leaf date {
            description "manufactured-thing/equipment-instance/manufacture-date: Date information provided by manufacturer. No specific format. ()";
            type string;
        }
        leaf version {
            description "manufactured-thing/equipment-type/version";
            type string;
        }
        leaf description {
            description "manufactured-thing/equipment-type/description";
            type string;
        }
        leaf part-type-id {
            description "manufactured-thing/equipment-type/part-type-identifier";
            type string;
        }
        leaf model-identifier {
            description "manufactured-thing/equipment-type/model-identifier";
            type string;
        }
        leaf type-name {
            description "manufactured-thing/equipment-type/type-name";
            type string;
        }
    }
    container inventory {
        description "builder";
        uses inventory-entity;
    }
    grouping node-details-g {
        leaf-list available-capabilities {
            type string;
        }
        leaf-list unavailable-capabilities {
            type string;
        }
    }
    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 hostname or ip address of device";
        }
        leaf port {
            type uint32;
            description "netconf port of device";
        }
        leaf username {
            type string;
            description "netconf username";
        }
        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 "categoried type of ne 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";
        }
    }
    container network-element-connection {
        description "builder";
        uses network-element-connection-entity;
    }
    grouping status-entity {
        container faults {
            leaf criticals {
                type uint32;
            }
            leaf majors {
                type uint32;
            }
            leaf minors {
                type uint32;
            }
            leaf warnings {
                type uint32;
            }
        }
    }
    container status {
        description "builder";
         uses status-entity;
    }
    grouping entity-input {
        list filter {
            key property;
            leaf property {
                type string;
            }
            leaf filtervalue {
                type string;
            }
            description "List with filter criteria. Not listed means all.";
        }
        list sortorder {
            key property;
            leaf property {
                type string;
            }
            leaf sortorder {
                type SortOrder;
            }
            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";
            }
        }
    }
    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";
        }
    }
    container pagination-output {
        description "builder";
        uses pagination-output-g;
    }
    // --- rpc
    rpc read-faultcurrent-list {
        description
                "Get list of faultcurrent entries according to filter";
        input {
            uses entity-input;
        }
        output {
            container pagination {
                uses pagination-output-g;
            }
            list data {
                uses faultcurrent-entity;
            }
        }
    }
    rpc read-faultlog-list {
        description
                "Get list of faultlog entries according to filter";
        input {
            uses entity-input;
        }
        output {
            container pagination {
                uses pagination-output-g;
            }
            list data {
                uses faultlog-entity;
            }
        }
    }

    rpc read-eventlog-list {
        description
                "Get list of eventlog entities according to filter";
        input {
            uses entity-input;
        }
        output {
            container pagination {
                uses pagination-output-g;
            }
            list data {
                uses eventlog-entity;
            }
        }
    }
    rpc read-connectionlog-list {
        description
                "Get list of eventlog entities according to filter";
        input {
            uses entity-input;
        }
        output {
            container pagination {
                uses pagination-output-g;
            }
            list data {
                uses connectionlog-entity;
            }
        }
    }
    rpc read-maintenance-list {
        description
                "Get list of maintenance entries according to filter";
        input {
            uses entity-input;
        }
        output {
            container pagination {
                uses pagination-output-g;
            }
            list data {
                uses maintenance-entity;
            }
        }
    }
    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;
        }
        output {
        }
    }

    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;
            }
            list data {
                uses mediator-server-entity;
            }
        }
    }
    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;
        }
        output {
        }
    }
    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;
            }
            list data {
                uses network-element-connection-entity;
            }
        }
    }
    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;
        }
        output {
        }
    }

    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;
            }
            leaf-list data {
                type string;
            }
        }
    }
    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;
            }
            leaf-list data {
                type string;
            }
        }
    }
    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;
            }
            leaf-list data {
                type string;
            }
        }
    }
    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;
            }
            leaf-list data {
                type string;
            }
        }
    }

    rpc read-pmdata-15m-list {
        description
                "Get list of entities according to filter";
        input {
            uses entity-input;
        }
        output {
            container pagination {
                uses pagination-output-g;
            }
            list data {
                uses pmdata15m-entity;
            }
        }
    }
    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;
            }
            list data {
                uses pmdata24h-entity;
            }
        }
    }
    rpc read-inventory-list {
        description
                "Get list of inventory according to filter";
        input {
            uses entity-input;
        }
        output {
            container pagination {
                uses pagination-output-g;
            }
            list data {
                uses inventory-entity;
            }
        }
    }
    rpc read-status {
        description
                "Read status information of controller";
        output {
            list data {
                uses status-entity;
            }
        }
    }
}