All Superinterfaces:: org.opendaylight.yangtools.yang.binding.DataRoot

@Generated("mdsal-binding-generator")
public interface OdlLispProtoData
extends org.opendaylight.yangtools.yang.binding.DataRoot

YANG representation of LISP (RFC6830) protocol.

This class represents the following YANG schema fragment defined in module odl-lisp-proto

 module odl-lisp-proto {
   yang-version 1;
   namespace urn:opendaylight:lfm:lisp-proto;
   prefix lisp-proto;
   import ietf-inet-types {
     prefix inet;
     revision-date 2013-07-15;
   }
   import odl-inet-binary-types {
     prefix inet-bin;
     revision-date 2016-03-03;
   }
   import odl-lisp-address-types {
     prefix odl-lisp-address;
     revision-date 2016-05-04;
   }
   revision 2015-11-05 {
   }
   typedef xtr-id {
     type binary {
       length 16;
     }
   }
   typedef site-id {
     type binary {
       length 8;
     }
   }
   grouping transport-address {
     container transport-address {
       leaf ipAddress {
         type inet-bin:ip-address-binary;
       }
       leaf port {
         type inet:port-number;
       }
     }
   }
   grouping mapping-authkey-container {
     container mapping-authkey {
       leaf key-string {
         type string;
       }
       leaf key-type {
         type uint16;
       }
     }
   }
   grouping eid-container {
     container eid {
       uses odl-lisp-address:augmented-lisp-address;
     }
   }
   grouping rloc-container {
     container rloc {
       uses odl-lisp-address:augmented-lisp-address;
     }
   }
   grouping eid-list {
     list eid-item {
       key eid-item-id;
       ordered-by user;
       leaf eid-item-id {
         type string;
       }
       uses eid-container;
     }
   }
   grouping LocatorRecords {
     list LocatorRecord {
       key locator-id;
       ordered-by user;
       leaf locator-id {
         type string;
       }
       leaf priority {
         type uint8;
       }
       leaf weight {
         type uint8;
       }
       leaf multicastPriority {
         type uint8;
       }
       leaf multicastWeight {
         type uint8;
       }
       leaf localLocator {
         type boolean;
       }
       leaf rlocProbed {
         type boolean;
       }
       leaf routed {
         type boolean;
       }
       uses rloc-container;
     }
   }
   grouping map-request-metadata {
     leaf source-rloc {
       type inet-bin:ip-address-binary;
     }
   }
   grouping mapping-record-metadata {
     leaf xtr-id {
       type xtr-id;
     }
     leaf site-id {
       type site-id;
     }
     leaf source-rloc {
       type inet-bin:ip-address-binary;
     }
     leaf timestamp {
       type int64;
     }
   }
   grouping mapping-record-container {
     container mapping-record {
       leaf recordTtl {
         type int32;
       }
       leaf mapVersion {
         type int16;
       }
       leaf action {
         type enumeration {
           enum NoAction;
           enum NativelyForward;
           enum SendMapRequest;
           enum Drop;
         }
       }
       leaf authoritative {
         type boolean;
       }
       uses eid-container;
       uses LocatorRecords;
       uses mapping-record-metadata;
     }
   }
   grouping mapping-record-list {
     list mapping-record-item {
       key mapping-record-item-id;
       ordered-by user;
       leaf mapping-record-item-id {
         type string;
       }
       uses mapping-record-container;
     }
   }
   grouping xtrSiteId {
     leaf xtrId {
       type xtr-id;
     }
     leaf siteId {
       type site-id;
     }
   }
   grouping MapRegister {
     leaf proxyMapReply {
       type boolean;
     }
     leaf xtrSiteIdPresent {
       type boolean;
     }
     leaf wantMapNotify {
       type boolean;
     }
     leaf nonce {
       type int64;
     }
     leaf keyId {
       type int16;
     }
     leaf authenticationData {
       type binary;
     }
     leaf mergeEnabled {
       type boolean;
     }
     uses mapping-record-list;
     uses xtrSiteId;
   }
   grouping MapNotify {
     leaf xtrSiteIdPresent {
       type boolean;
     }
     leaf nonce {
       type int64;
     }
     leaf keyId {
       type int16;
     }
     leaf authenticationData {
       type binary;
     }
     leaf mergeEnabled {
       type boolean;
     }
     uses mapping-record-list;
     uses xtrSiteId;
   }
   grouping MapRequest {
     leaf authoritative {
       type boolean;
     }
     leaf mapDataPresent {
       type boolean;
     }
     leaf probe {
       type boolean;
     }
     leaf smr {
       type boolean;
     }
     leaf pitr {
       type boolean;
     }
     leaf smrInvoked {
       type boolean;
     }
     leaf nonce {
       type int64;
     }
     container SourceEid {
       uses eid-container;
     }
     list itrRloc {
       key itr-rloc-id;
       ordered-by user;
       leaf itr-rloc-id {
         type string;
       }
       uses rloc-container;
     }
     uses eid-list;
     container MapReply {
       uses mapping-record-container;
     }
     uses map-request-metadata;
   }
   grouping MapReply {
     leaf probe {
       type boolean;
     }
     leaf nonce {
       type int64;
     }
     leaf echoNonceEnabled {
       type boolean;
     }
     leaf securityEnabled {
       type boolean;
     }
     uses mapping-record-list;
   }
   grouping map-register-cache-key-container {
     container map-register-cache-key {
       leaf eid-prefix {
         type binary;
       }
       leaf xtr-id {
         type binary;
       }
       leaf site-id {
         type binary;
       }
     }
   }
   grouping map-register-cache-metadata-container {
     container map-register-cache-metadata {
       list eid-lisp-address {
         key eid-lisp-address-id;
         leaf eid-lisp-address-id {
           type string;
         }
         uses eid-container;
       }
       leaf xtr-id {
         type xtr-id;
       }
       leaf site-id {
         type site-id;
       }
       leaf timestamp {
         type int64;
       }
       leaf want-map-notify {
         type boolean;
       }
       leaf merge-enabled {
         type boolean;
       }
     }
   }
   grouping map-register-cache-value-grouping {
     container map-register-cache-value {
       uses map-register-cache-metadata-container;
       uses mapping-authkey-container;
       leaf packet-data {
         type binary;
       }
     }
   }
   grouping subscriber-data-grouping {
     container subscriber-data {
       uses rloc-container;
       uses eid-container;
       leaf ttl {
         type int32;
       }
     }
   }
   typedef message-type {
     type enumeration {
       enum reserved {
         value 0;
       }
       enum map-request {
         value 1;
       }
       enum map-reply {
         value 2;
       }
       enum map-register {
         value 3;
       }
       enum map-notify {
         value 4;
       }
       enum map-referral {
         value 6;
       }
       enum info {
         value 7;
       }
       enum encapsulated-control-message {
         value 8;
       }
     }
   }
   grouping MapRegisterMessage {
     container MapRegister {
       uses MapRegister;
     }
     uses transport-address;
   }
   grouping MapRegisterNotification {
     container MapRegister {
       uses MapRegister;
     }
     uses transport-address;
   }
   grouping MapNotifyMessage {
     container MapNotify {
       uses MapNotify;
     }
     uses transport-address;
   }
   grouping MapNotifyNotification {
     container MapNotify {
       uses MapNotify;
     }
     uses transport-address;
   }
   grouping MapRequestMessage {
     container MapRequest {
       uses MapRequest;
     }
     uses transport-address;
   }
   grouping MapRequestNotification {
     container MapRequest {
       uses MapRequest;
     }
     uses transport-address;
   }
   grouping MapReplyMessage {
     container MapReply {
       uses MapReply;
     }
     uses transport-address;
   }
   grouping MapReplyNotification {
     container MapReply {
       uses MapReply;
     }
     uses transport-address;
   }
   notification addMapping {
     uses MapRegisterNotification;
   }
   notification gotMapNotify {
     uses MapNotifyNotification;
   }
   notification requestMapping {
     uses MapRequestNotification;
   }
   notification gotMapReply {
     uses MapReplyNotification;
   }
   notification xtrRequestMapping {
     uses MapRequestNotification;
   }
   notification xtrReplyMapping {
     uses MapReplyNotification;
   }
   notification mappingKeepAlive {
     uses map-register-cache-metadata-container;
   }
 }

Interface OdlLispProtoData