Class and Description |
---|
OdlLispSbService
Interface for implementing the following YANG RPCs defined in module odl-lisp-sb
rpc send-map-reply {
input {
container MapReply {
leaf probe {
type boolean;
}
leaf nonce {
type int64;
}
leaf echoNonceEnabled {
type boolean;
}
leaf securityEnabled {
type boolean;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapReply;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
}
output {
}
}
rpc send-map-request {
input {
container 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 {
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses eid-container;
}
list itrRloc {
key "itr-rloc-id";
leaf itr-rloc-id {
type string;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
container MapReply {
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
leaf source-rloc {
type ip-address-binary;
}
list eid-item {
key "eid-item-id";
leaf eid-item-id {
type string;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses eid-container;
}
uses MapRequest;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
}
output {
}
}
rpc reset-stats {
input {
}
output {
}
}
rpc send-map-notify {
input {
container MapNotify {
leaf xtrSiteIdPresent {
type boolean;
}
leaf nonce {
type int64;
}
leaf keyId {
type int16;
}
leaf authenticationData {
type binary;
}
leaf mergeEnabled {
type boolean;
}
leaf xtrId {
type xtr-id;
}
leaf siteId {
type site-id;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapNotify;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
}
output {
}
}
rpc get-stats {
input {
}
output {
container control-message-stats {
leaf rx-unknown {
type int64;
}
leaf tx-errors {
type int64;
}
list control-message {
leaf msg-type {
type message-type;
}
leaf rx-count {
type int64;
}
leaf tx-count {
type int64;
}
}
uses ctrl-msg-stats;
}
container map-register-cache-stats {
leaf hits {
type int64;
}
leaf misses {
type int64;
}
uses cache-stats;
}
}
}
rpc send-map-register {
input {
container 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;
}
leaf xtrId {
type xtr-id;
}
leaf siteId {
type site-id;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapRegister;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
}
output {
}
}
|
Class and Description |
---|
GetStatsOutput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container output {
container control-message-stats {
leaf rx-unknown {
type int64;
}
leaf tx-errors {
type int64;
}
list control-message {
leaf msg-type {
type message-type;
}
leaf rx-count {
type int64;
}
leaf tx-count {
type int64;
}
}
uses ctrl-msg-stats;
}
container map-register-cache-stats {
leaf hits {
type int64;
}
leaf misses {
type int64;
}
uses cache-stats;
}
}
The schema path to identify an instance is
odl-lisp-sb/get-stats/output
To create instances of this class use
GetStatsOutputBuilder . |
OdlLispSbService
Interface for implementing the following YANG RPCs defined in module odl-lisp-sb
rpc send-map-reply {
input {
container MapReply {
leaf probe {
type boolean;
}
leaf nonce {
type int64;
}
leaf echoNonceEnabled {
type boolean;
}
leaf securityEnabled {
type boolean;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapReply;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
}
output {
}
}
rpc send-map-request {
input {
container 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 {
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses eid-container;
}
list itrRloc {
key "itr-rloc-id";
leaf itr-rloc-id {
type string;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
container MapReply {
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
leaf source-rloc {
type ip-address-binary;
}
list eid-item {
key "eid-item-id";
leaf eid-item-id {
type string;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses eid-container;
}
uses MapRequest;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
}
output {
}
}
rpc reset-stats {
input {
}
output {
}
}
rpc send-map-notify {
input {
container MapNotify {
leaf xtrSiteIdPresent {
type boolean;
}
leaf nonce {
type int64;
}
leaf keyId {
type int16;
}
leaf authenticationData {
type binary;
}
leaf mergeEnabled {
type boolean;
}
leaf xtrId {
type xtr-id;
}
leaf siteId {
type site-id;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapNotify;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
}
output {
}
}
rpc get-stats {
input {
}
output {
container control-message-stats {
leaf rx-unknown {
type int64;
}
leaf tx-errors {
type int64;
}
list control-message {
leaf msg-type {
type message-type;
}
leaf rx-count {
type int64;
}
leaf tx-count {
type int64;
}
}
uses ctrl-msg-stats;
}
container map-register-cache-stats {
leaf hits {
type int64;
}
leaf misses {
type int64;
}
uses cache-stats;
}
}
}
rpc send-map-register {
input {
container 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;
}
leaf xtrId {
type xtr-id;
}
leaf siteId {
type site-id;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapRegister;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
}
output {
}
}
|
SendMapNotifyInput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container input {
container MapNotify {
leaf xtrSiteIdPresent {
type boolean;
}
leaf nonce {
type int64;
}
leaf keyId {
type int16;
}
leaf authenticationData {
type binary;
}
leaf mergeEnabled {
type boolean;
}
leaf xtrId {
type xtr-id;
}
leaf siteId {
type site-id;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapNotify;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
uses MapNotifyMessage;
}
The schema path to identify an instance is
odl-lisp-sb/send-map-notify/input
To create instances of this class use
SendMapNotifyInputBuilder . |
SendMapRegisterInput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container input {
container 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;
}
leaf xtrId {
type xtr-id;
}
leaf siteId {
type site-id;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapRegister;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
uses MapRegisterMessage;
}
The schema path to identify an instance is
odl-lisp-sb/send-map-register/input
To create instances of this class use
SendMapRegisterInputBuilder . |
SendMapReplyInput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container input {
container MapReply {
leaf probe {
type boolean;
}
leaf nonce {
type int64;
}
leaf echoNonceEnabled {
type boolean;
}
leaf securityEnabled {
type boolean;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapReply;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
uses MapReplyMessage;
}
The schema path to identify an instance is
odl-lisp-sb/send-map-reply/input
To create instances of this class use
SendMapReplyInputBuilder . |
SendMapRequestInput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container input {
container 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 {
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses eid-container;
}
list itrRloc {
key "itr-rloc-id";
leaf itr-rloc-id {
type string;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
container MapReply {
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
leaf source-rloc {
type ip-address-binary;
}
list eid-item {
key "eid-item-id";
leaf eid-item-id {
type string;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses eid-container;
}
uses MapRequest;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
uses MapRequestMessage;
}
The schema path to identify an instance is
odl-lisp-sb/send-map-request/input
To create instances of this class use
SendMapRequestInputBuilder . |
Class and Description |
---|
GetStatsOutput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container output {
container control-message-stats {
leaf rx-unknown {
type int64;
}
leaf tx-errors {
type int64;
}
list control-message {
leaf msg-type {
type message-type;
}
leaf rx-count {
type int64;
}
leaf tx-count {
type int64;
}
}
uses ctrl-msg-stats;
}
container map-register-cache-stats {
leaf hits {
type int64;
}
leaf misses {
type int64;
}
uses cache-stats;
}
}
The schema path to identify an instance is
odl-lisp-sb/get-stats/output
To create instances of this class use
GetStatsOutputBuilder . |
GetStatsOutputBuilder
Class that builds
GetStatsOutput instances. |
SendMapNotifyInput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container input {
container MapNotify {
leaf xtrSiteIdPresent {
type boolean;
}
leaf nonce {
type int64;
}
leaf keyId {
type int16;
}
leaf authenticationData {
type binary;
}
leaf mergeEnabled {
type boolean;
}
leaf xtrId {
type xtr-id;
}
leaf siteId {
type site-id;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapNotify;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
uses MapNotifyMessage;
}
The schema path to identify an instance is
odl-lisp-sb/send-map-notify/input
To create instances of this class use
SendMapNotifyInputBuilder . |
SendMapNotifyInputBuilder
Class that builds
SendMapNotifyInput instances. |
SendMapRegisterInput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container input {
container 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;
}
leaf xtrId {
type xtr-id;
}
leaf siteId {
type site-id;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapRegister;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
uses MapRegisterMessage;
}
The schema path to identify an instance is
odl-lisp-sb/send-map-register/input
To create instances of this class use
SendMapRegisterInputBuilder . |
SendMapRegisterInputBuilder
Class that builds
SendMapRegisterInput instances. |
SendMapReplyInput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container input {
container MapReply {
leaf probe {
type boolean;
}
leaf nonce {
type int64;
}
leaf echoNonceEnabled {
type boolean;
}
leaf securityEnabled {
type boolean;
}
list mapping-record-item {
key "mapping-record-item-id";
leaf mapping-record-item-id {
type string;
}
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
uses MapReply;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
uses MapReplyMessage;
}
The schema path to identify an instance is
odl-lisp-sb/send-map-reply/input
To create instances of this class use
SendMapReplyInputBuilder . |
SendMapReplyInputBuilder
Class that builds
SendMapReplyInput instances. |
SendMapRequestInput
This class represents the following YANG schema fragment defined in module odl-lisp-sb
container input {
container 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 {
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses eid-container;
}
list itrRloc {
key "itr-rloc-id";
leaf itr-rloc-id {
type string;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
container MapReply {
container mapping-record {
leaf recordTtl {
type int32;
}
leaf mapVersion {
type int16;
}
leaf action {
type enumeration;
}
leaf authoritative {
type boolean;
}
leaf xtr-id {
type xtr-id;
}
leaf site-id {
type site-id;
}
leaf source-rloc {
type ip-address-binary;
}
leaf timestamp {
type int64;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
list LocatorRecord {
key "locator-id";
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;
}
container rloc {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses rloc-container;
}
uses eid-container;
uses mapping-record-metadata;
uses LocatorRecords;
}
uses mapping-record-container;
}
leaf source-rloc {
type ip-address-binary;
}
list eid-item {
key "eid-item-id";
leaf eid-item-id {
type string;
}
container eid {
leaf address-type {
type lisp-address-family-ref;
}
leaf virtual-network-id {
type instance-id-type;
}
choice address {
case afi-list {
container afi-list {
leaf-list address-list {
type simple-address;
}
}
}
case application-data {
container application-data {
leaf address {
type simple-address;
}
leaf protocol {
type uint8;
}
leaf ip-tos {
type int32;
}
leaf local-port-low {
type port-number;
}
leaf local-port-high {
type port-number;
}
leaf remote-port-low {
type port-number;
}
leaf remote-port-high {
type port-number;
}
}
}
case as-number {
leaf as-number {
type as-number;
}
}
case as-number-lcaf {
container as-number-lcaf {
leaf as {
type as-number;
}
leaf address {
type simple-address;
}
}
}
case distinguished-name {
leaf distinguished-name {
type distinguished-name-type;
}
}
case explicit-locator-path {
container explicit-locator-path {
list hop {
key "hop-id";
leaf hop-id {
type string;
}
leaf address {
type simple-address;
}
leaf lrs-bits {
type bits;
}
}
}
}
case geo-coordinates {
container geo-coordinates {
leaf latitude {
type bits;
}
leaf latitude-degrees {
type uint8;
}
leaf latitude-minutes {
type uint8;
}
leaf latitude-seconds {
type uint8;
}
leaf longitude {
type bits;
}
leaf longitude-degrees {
type uint16;
}
leaf longitude-minutes {
type uint8;
}
leaf longitude-seconds {
type uint8;
}
leaf altitude {
type int32;
}
leaf address {
type simple-address;
}
}
}
case instance-id {
container instance-id {
leaf iid {
type instance-id-type;
}
leaf mask-length {
type uint8;
}
leaf address {
type simple-address;
}
}
}
case ipv4 {
leaf ipv4 {
type ipv4-address;
}
}
case ipv4-binary {
leaf ipv4-binary {
type ipv4-address-binary;
}
}
case ipv4-prefix {
leaf ipv4-prefix {
type ipv4-prefix;
}
}
case ipv4-prefix-binary {
leaf ipv4-address-binary {
type ipv4-address-binary;
}
leaf ipv4-mask-length {
type uint8;
}
}
case ipv6 {
leaf ipv6 {
type ipv6-address;
}
}
case ipv6-binary {
leaf ipv6-binary {
type ipv6-address-binary;
}
}
case ipv6-prefix {
leaf ipv6-prefix {
type ipv6-prefix;
}
}
case ipv6-prefix-binary {
leaf ipv6-address-binary {
type ipv6-address-binary;
}
leaf ipv6-mask-length {
type uint8;
}
}
case key-value-address {
container key-value-address {
leaf key {
type simple-address;
}
leaf value {
type simple-address;
}
}
}
case mac {
leaf mac {
type mac-address;
}
}
case nat-traversal {
container nat-traversal {
leaf ms-udp-port {
type uint16;
}
leaf etr-udp-port {
type uint16;
}
leaf global-etr-rloc {
type simple-address;
}
leaf ms-rloc {
type simple-address;
}
leaf private-etr-rloc {
type simple-address;
}
leaf-list rtr-rlocs {
type simple-address;
}
}
}
case no-address {
leaf no-address {
type empty;
}
}
case null-address {
container null-address {
leaf address {
type empty;
}
}
}
case service-path {
container service-path {
leaf service-path-id {
type service-path-id-type;
}
leaf service-index {
type uint8;
}
}
}
case source-dest-key {
container source-dest-key {
leaf source {
type simple-address;
}
leaf dest {
type simple-address;
}
}
}
}
uses augmented-lisp-address;
}
uses eid-container;
}
uses MapRequest;
}
container transport-address {
leaf ipAddress {
type ip-address-binary;
}
leaf port {
type port-number;
}
}
uses MapRequestMessage;
}
The schema path to identify an instance is
odl-lisp-sb/send-map-request/input
To create instances of this class use
SendMapRequestInputBuilder . |
SendMapRequestInputBuilder
Class that builds
SendMapRequestInput instances. |
Class and Description |
---|
CacheStats
This class represents the following YANG schema fragment defined in module odl-lisp-sb
grouping cache-stats {
leaf hits {
type int64;
}
leaf misses {
type int64;
}
}
The schema path to identify an instance is
odl-lisp-sb/cache-stats
|
CtrlMsgStats
This class represents the following YANG schema fragment defined in module odl-lisp-sb
grouping ctrl-msg-stats {
leaf rx-unknown {
type int64;
}
leaf tx-errors {
type int64;
}
list control-message {
leaf msg-type {
type message-type;
}
leaf rx-count {
type int64;
}
leaf tx-count {
type int64;
}
}
}
The schema path to identify an instance is
odl-lisp-sb/ctrl-msg-stats
|
Copyright © 2019 OpenDaylight. All rights reserved.