HONEYCOMB-75 - Lisp API

Change-Id: I9999bd2c10fb8731aaabc2a0875eac43647d9e08
Signed-off-by: Jan Srnicek <jsrnicek@cisco.com> 

6 files changed, 1146 insertions, 0 deletions

diff --git a/lisp/api/src/main/java/lisp/Ipv4Matcher.java b/lisp/api/src/main/java/lisp/Ipv4Matcher.java
new file mode 100755
index 000000000..546d40460
--- /dev/null
+++ b/lisp/api/src/main/java/lisp/Ipv4Matcher.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package lisp;
+
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+
+
+/**
+ * Class that checks whether {@link String} can represent Ipv4Address
+ */
+public final class Ipv4Matcher {
+
+    private static final List<Pattern> PATTERNS =
+            Ipv4Address.PATTERN_CONSTANTS.stream().map(a -> Pattern.compile(a)).collect(Collectors.toList());
+
+    public static boolean matches(String candidate) {
+        return PATTERNS.stream().anyMatch(pattern -> pattern.matcher(candidate).matches());
+    }
+}
diff --git a/lisp/api/src/main/java/lisp/Ipv6Matcher.java b/lisp/api/src/main/java/lisp/Ipv6Matcher.java
new file mode 100755
index 000000000..209868ec8
--- /dev/null
+++ b/lisp/api/src/main/java/lisp/Ipv6Matcher.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package lisp;
+
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
+
+/**
+ * Class that checks whether {@link String} can represent Ipv6Address
+ */
+public final class Ipv6Matcher {
+
+    private static final List<Pattern> PATTERNS =
+            Ipv6Address.PATTERN_CONSTANTS.stream().map(a -> Pattern.compile(a)).collect(Collectors.toList());
+
+    public static boolean matches(String candidate) {
+        return PATTERNS.stream().anyMatch(pattern -> pattern.matcher(candidate).matches());
+    }
+}
diff --git a/lisp/api/src/main/java/lisp/MacMatcher.java b/lisp/api/src/main/java/lisp/MacMatcher.java
new file mode 100755
index 000000000..611c92e1e
--- /dev/null
+++ b/lisp/api/src/main/java/lisp/MacMatcher.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package lisp;
+
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+
+/**
+ * Class that checks whether {@link String} can represent MacAddress
+ */
+public class MacMatcher {
+
+    private static final List<Pattern> PATTERNS =
+            MacAddress.PATTERN_CONSTANTS.stream().map(a -> Pattern.compile(a)).collect(Collectors.toList());
+
+    public static boolean matches(String candidate) {
+        return PATTERNS.stream().anyMatch(pattern -> pattern.matcher(candidate).matches());
+    }
+}
diff --git a/lisp/api/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/lisp/address/types/rev151105/SimpleAddressBuilder.java b/lisp/api/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/lisp/address/types/rev151105/SimpleAddressBuilder.java
new file mode 100644
index 000000000..3d340855e
--- /dev/null
+++ b/lisp/api/src/main/java/org/opendaylight/yang/gen/v1/urn/ietf/params/xml/ns/yang/ietf/lisp/address/types/rev151105/SimpleAddressBuilder.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105;
+
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import lisp.Ipv4Matcher;
+import lisp.Ipv6Matcher;
+import lisp.MacMatcher;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+
+/**
+ * The purpose of generated class in src/main/java for Union types is to create new instances of unions from a string representation.
+ * In some cases it is very difficult to automate it since there can be unions such as (uint32 - uint16), or (string - uint32).
+ *
+ * The reason behind putting it under src/main/java is:
+ * This class is generated in form of a stub and needs to be finished by the user. This class is generated only once to prevent
+ * loss of user code.
+ *
+ */
+public class SimpleAddressBuilder {
+
+    public static SimpleAddress getDefaultInstance(String defaultValue) {
+        checkNotNull(defaultValue, "Cannot convert null address");
+
+        if (Ipv4Matcher.matches(defaultValue)) {
+            return new SimpleAddress(new IpAddress(new Ipv4Address(defaultValue)));
+        } else if (Ipv6Matcher.matches(defaultValue)) {
+            return new SimpleAddress(new IpAddress(new Ipv6Address(defaultValue)));
+        } else if (MacMatcher.matches(defaultValue)) {
+            return new SimpleAddress(new MacAddress(defaultValue));
+        } else {
+            //TODO - implement other conversions
+            throw new IllegalArgumentException("Unknown type");
+        }
+    }
+
+}
diff --git a/lisp/api/src/main/yang/ietf-lisp-address-types.yang b/lisp/api/src/main/yang/ietf-lisp-address-types.yang
new file mode 100755
index 000000000..2a3a1d31d
--- /dev/null
+++ b/lisp/api/src/main/yang/ietf-lisp-address-types.yang
@@ -0,0 +1,677 @@
+module ietf-lisp-address-types {
+  namespace "urn:ietf:params:xml:ns:yang:ietf-lisp-address-types";
+  prefix laddr;
+  import ietf-inet-types {
+    prefix inet;
+    revision-date 2013-07-15;
+  }
+  import ietf-yang-types {
+    prefix yang;
+    revision-date 2013-07-15;
+  }
+  organization
+    "IETF LISP (Locator/ID Separation Protocol) Working Group";
+  contact
+    "lisp@ietf.org";
+  description
+    "This YANG module defines the LISP Canonical Address Formats
+     (LCAF) for LISP. The module can be extended by vendors to
+     define vendor-specific parameters.
+
+     Copyright (c) 2014 IETF Trust and the persons identified as
+     authors of the code.  All rights reserved.
+
+     Redistribution and use in source and binary forms, with or
+     without modification, is permitted pursuant to, and subject
+     to the license terms contained in, the Simplified BSD License
+     set forth in Section 4.c of the IETF Trust's Legal Provisions
+     Relating to IETF Documents
+     (http://trustee.ietf.org/license-info).
+
+     This version of this YANG module is part of RFC 6338; see
+     the RFC itself for full legal notices.
+
+    ";
+  revision 2015-11-05 {
+    description
+      "Initial revision.";
+    reference
+      "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10";
+  }
+  identity lisp-address-family {
+    description
+      "Base identity from which identities describing LISP address
+       families are derived.";
+  }
+  identity no-address-afi {
+    base lisp-address-family;
+    description
+      "IANA Reserved.";
+    }
+  identity ipv4-afi {
+    base lisp-address-family;
+    description
+      "IANA IPv4 address family.";
+  }
+  identity ipv4-prefix-afi {
+    base lisp-address-family;
+    description
+      "IANA IPv4 address family prefix.";
+  }
+  identity ipv6-afi {
+    base lisp-address-family;
+    description
+      "IANA IPv6 address family.";
+  }
+  identity ipv6-prefix-afi {
+    base lisp-address-family;
+    description
+      "IANA IPv6 address family prefix.";
+  }
+  identity mac-afi {
+    base lisp-address-family;
+    description
+      "IANA MAC address family.";
+  }
+  identity distinguished-name-afi {
+    base lisp-address-family;
+    description
+      "IANA Distinguished Name address family.";
+  }
+  identity as-number-afi {
+      base lisp-address-family;
+      description
+        "IANA AS Number address family.";
+  }
+  identity lcaf {
+    base lisp-address-family;
+    description
+      "IANA LISP Canonical Address Format address family.";
+  }
+  identity null-address-lcaf {
+    base lcaf;
+    description
+      "Null body LCAF type.";
+  }
+  identity afi-list-lcaf {
+    base lcaf;
+    description
+      "AFI-List LCAF type.";
+  }
+  identity instance-id-lcaf {
+    base lcaf;
+    description
+      "Instance-ID LCAF type.";
+  }
+  identity as-number-lcaf {
+    base lcaf;
+    description
+      "AS Number LCAF type.";
+  }
+  identity application-data-lcaf {
+    base lcaf;
+    description
+      "Application Data LCAF type.";
+  }
+  identity geo-coordinates-lcaf {
+    base lcaf;
+    description
+      "Geo-coordinates LCAF type.";
+  }
+  identity opaque-key-lcaf {
+    base lcaf;
+    description
+      "Opaque Key LCAF type.";
+  }
+  identity nat-traversal-lcaf {
+    base lcaf;
+    description
+      "NAT-Traversal LCAF type.";
+  }
+  identity nonce-locator-lcaf {
+    base lcaf;
+    description
+      "Nonce-Locator LCAF type.";
+  }
+  identity multicast-info-lcaf {
+    base lcaf;
+    description
+      "Multicast Info LCAF type.";
+  }
+  identity explicit-locator-path-lcaf {
+    base lcaf;
+    description
+      "Explicit Locator Path LCAF type.";
+  }
+  identity security-key-lcaf {
+    base lcaf;
+    description
+      "Security Key LCAF type.";
+  }
+  identity source-dest-key-lcaf {
+    base lcaf;
+    description
+      "Source/Dest LCAF type.";
+  }
+  identity replication-list-lcaf {
+    base lcaf;
+    description
+      "Replication-List LCAF type.";
+  }
+  identity json-data-model-lcaf {
+    base lcaf;
+    description
+      "JSON Data Model LCAF type.";
+  }
+  identity key-value-address-lcaf {
+    base lcaf;
+    description
+      "Key/Value Address LCAF type.";
+  }
+  identity encapsulation-format-lcaf {
+    base lcaf;
+    description
+      "Encapsulation Format LCAF type.";
+  }
+  identity service-path-lcaf {
+    base lcaf;
+    description
+      "Service Path LCAF type.";
+  }
+  typedef instance-id-type {
+    type uint32 {
+      range "0..16777215";
+    }
+    description
+      "Defines the range of values for an Instance ID.";
+  }
+  typedef service-path-id-type {
+    type uint32 {
+      range "0..16777215";
+    }
+    description
+      "Defines the range of values for a Service Path ID.";
+  }
+   typedef distinguished-name-type {
+    type string;
+    description
+      "Distinguished Name address.";
+    reference
+      "http://www.iana.org/assignments/address-family-numbers/
+       address-family-numbers.xhtml";
+  }
+  typedef simple-address {
+    type union {
+      type inet:ip-address;
+      type inet:ip-prefix;
+      type yang:mac-address;
+      type distinguished-name-type;
+      type inet:as-number;
+    }
+    description
+      "Union of address types that can be part of LCAFs.";
+  }
+
+  typedef lisp-address-family-ref {
+    type identityref {
+      base lisp-address-family;
+    }
+    description
+      "LISP address family reference.";
+  }
+  typedef lcaf-ref {
+    type identityref {
+      base lcaf;
+    }
+    description
+      "LCAF types reference.";
+  }
+
+  grouping lisp-address {
+    description
+      "Generic LISP address.";
+    leaf address-type {
+      type lisp-address-family-ref;
+      mandatory true;
+      description
+        "Type of the LISP address.";
+    }
+    leaf virtual-network-id {
+      type instance-id-type;
+      description
+        "Virtual Network Identifier (instance-id) of the address.";
+    }
+    choice address {
+      description
+        "Various LISP address types, including IP, MAC, and LCAF.";
+  
+      leaf no-address {
+        when "../address-type = 'laddr:no-addr-afi'" {
+          description
+            "When AFI is 0.";
+        }
+        type empty;
+        description
+          "No address.";
+      }
+      leaf ipv4 {
+        when "../address-type = 'laddr:ipv4-afi'" {
+          description
+            "When AFI is IPv4.";
+        }
+        type inet:ipv4-address;
+        description
+          "IPv4 address.";
+      }
+      leaf ipv4-prefix {
+        when "../address-type = 'laddr:ipv4-prefix-afi'" {
+          description
+            "When AFI is IPv4.";
+        }
+        type inet:ipv4-prefix;
+        description
+          "IPv4 prefix.";
+      }
+      leaf ipv6 {
+        when "../address-type = 'laddr:ipv6-afi'" {
+          description
+            "When AFI is IPv6.";
+        }
+        type inet:ipv6-address;
+        description
+          "IPv6 address.";
+      }
+      leaf ipv6-prefix {
+        when "../address-type = 'laddr:ipv6-prefix-afi'" {
+          description
+            "When AFI is IPv6.";
+        }
+        type inet:ipv6-prefix;
+        description
+          "IPv6 address.";
+      }
+      leaf mac {
+        when "../address-type = 'laddr:mac-afi'" {
+          description
+            "When AFI is MAC.";
+        }
+        type yang:mac-address;
+        description
+          "MAC address.";
+      }
+      leaf distinguished-name {
+        when "../address-type = 'laddr:distinguished-name-afi'" {
+          description
+            "When AFI is distinguished-name.";
+        }
+        type distinguished-name-type;
+        description
+          "Distinguished Name address.";
+      }
+      leaf as-number {
+        when "../address-type = 'laddr:as-number-afi'" {
+          description
+            "When AFI is as-number.";
+        }
+        type inet:as-number;
+        description
+          "AS Number.";
+      }
+      container null-address {
+        when "../address-type = 'laddr:null-address-lcaf'" {
+          description
+            "When LCAF type is null.";
+        }
+        description
+          "Null body LCAF type";
+        leaf address {
+          type empty;
+          description
+            "AFI address.";
+        }
+      }
+      container afi-list {
+        when "../address-type = 'laddr:afi-list-lcaf'" {
+          description
+            "When LCAF type is AFI-List.";
+        }
+        description
+          "AFI-List LCAF type.";
+        reference
+          "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10
+           #section-4.16.1";
+        leaf-list address-list {
+          type simple-address;
+          description
+            "List of AFI addresses.";
+        }
+      }
+      container instance-id {
+        when "../address-type = 'laddr:instance-id-lcaf'" {
+          description
+            "When LCAF type is Instance-ID";
+        }
+        description
+          "Instance ID LCAF type.";
+        reference
+          "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10
+           #section-4.2";
+        leaf iid {
+          type instance-id-type;
+          description
+            "Instance ID value.";
+        }
+        leaf mask-length {
+            type uint8;
+            description
+              "Mask length.";
+        }
+        leaf address {
+          type simple-address;
+          description
+            "AFI address.";
+        }
+      }
+      container as-number-lcaf {
+        when "../address-type = 'laddr:as-number-lcaf'" {
+          description
+            "When LCAF type is AS-Number.";
+        }
+        description
+          "AS Number LCAF type.";
+        reference
+          "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10
+           #section-4.3";
+        leaf as {
+          type inet:as-number;
+          description
+            "AS number.";
+        }
+        leaf address {
+          type simple-address;
+          description
+            "AFI address.";
+        }
+      }
+      container application-data {
+        when "../address-type = 'laddr:application-data-lcaf'" {
+          description
+            "When LCAF type is Application Data.";
+        }
+        description
+          "Application Data LCAF type.";
+        reference
+          "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10
+           #section-4.4";
+        leaf address {
+            type simple-address;
+            description
+              "AFI address.";
+        }
+        leaf protocol {
+            type uint8;
+            description
+              "Protocol number.";
+        }
+        leaf ip-tos {
+            type int32;
+            description
+              "Type of service field.";
+        }
+        leaf local-port-low {
+            type inet:port-number;
+            description
+              "Low end of local port range.";
+        }
+        leaf local-port-high {
+            type inet:port-number;
+            description
+              "High end of local port range.";
+        }
+        leaf remote-port-low {
+            type inet:port-number;
+            description
+              "Low end of remote port range.";
+        }
+        leaf remote-port-high {
+            type inet:port-number;
+            description
+              "High end of remote port range.";
+        }
+      }
+      container geo-coordinates {
+        when "../address-type = 'laddr:geo-coordinates-lcaf'" {
+          description
+            "When LCAF type is Geo-coordinates.";
+        }
+        description
+          "Geo-coordinates LCAF type.";
+        reference
+          "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10
+           #section-4.5";
+        leaf latitude {
+          type bits {
+            bit N {
+              description
+                "Latitude bit.";
+            }
+          }
+          description
+            "Bit that selects between North and South latitude.";
+        }
+        leaf latitude-degrees {
+          type uint8 {
+            range "0 .. 90";
+          }
+          description
+            "Degrees of latitude.";
+        }
+        leaf latitude-minutes {
+          type uint8 {
+            range "0..59";
+          }
+          description
+            "Minutes of latitude.";
+        }
+        leaf latitude-seconds {
+          type uint8 {
+            range "0..59";
+          }
+          description
+            "Seconds of latitude.";
+        }
+        leaf longitude {
+          type bits {
+            bit E {
+              description
+                "Longitude bit.";
+            }
+          }
+          description
+            "Bit that selects between East and West longitude.";
+        }
+        leaf longitude-degrees {
+          type uint16 {
+            range "0 .. 180";
+          }
+          description
+            "Degrees of longitude.";
+        }
+        leaf longitude-minutes {
+          type uint8 {
+            range "0..59";
+          }
+          description
+            "Minutes of longitude.";
+        }
+        leaf longitude-seconds {
+          type uint8 {
+            range "0..59";
+          }
+          description
+            "Seconds of longitude.";
+        }
+        leaf altitude {
+          type int32;
+          description
+            "Height relative to sea level in meters.";
+        }
+        leaf address {
+          type simple-address;
+          description
+            "AFI address.";
+        }
+      }
+      container nat-traversal {
+        when "../address-type = 'laddr:nat-traversal-lcaf'" {
+          description
+            "When LCAF type is NAT-Traversal.";
+        }
+        description
+          "NAT-Traversal LCAF type.";
+        reference
+          "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10
+           #section-4.6";
+        leaf ms-udp-port {
+          type uint16;
+          description
+            "Map-Server UDP port (set to 4342).";
+        }
+        leaf etr-udp-port {
+          type uint16;
+          description
+            "ETR UDP port.";
+        }
+        leaf global-etr-rloc {
+          type simple-address;
+          description
+            "Global ETR RLOC address.";
+        }
+        leaf ms-rloc {
+          type simple-address;
+          description
+            "Map-Server RLOC address.";
+        }
+        leaf private-etr-rloc {
+          type simple-address;
+          description
+            "Private ETR RLOC address.";
+        }
+        leaf-list rtr-rlocs {
+          type simple-address;
+          description
+            "List of RTR RLOC addresses.";
+        }
+      }
+      container explicit-locator-path {
+        when "../address-type = 'laddr:explicit-locator-path-lcaf'" {
+          description
+            "When LCAF type type is Explicit Locator Path.";
+        }
+        description
+          "Explicit Locator Path LCAF type.";
+        reference
+          "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10
+           #section-4.9";
+        list hop {
+          key "hop-id";
+          ordered-by user;
+          description
+            "List of locator hops forming the explicit path.";
+          leaf hop-id {
+            type string {
+              length "1..64";
+            }
+            description
+              "Unique identifier for the hop.";
+          }
+          leaf address {
+            type simple-address;
+            description
+              "AFI address.";
+          }
+          leaf lrs-bits {
+            type bits{
+              bit lookup {
+                description
+                  "Lookup bit.";
+              }
+              bit rloc-probe {
+                description
+                  "RLOC-probe bit.";
+              }
+              bit strict {
+                description
+                  "Strict bit.";
+              }
+            }
+            description
+              "Flag bits per hop.";
+          }
+        }
+      }
+      container source-dest-key {
+        when "../address-type = 'laddr:source-dest-key-lcaf'" {
+          description
+            "When LCAF type type is Source/Dest.";
+        }
+        description
+          "Source/Dest LCAF type.";
+        reference
+            "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10
+            #section-4.11";
+        leaf source {
+          type simple-address;
+          description
+            "Source address.";
+        }
+        leaf dest {
+          type simple-address;
+          description
+            "Destination address.";
+        }
+      }
+      container key-value-address {
+        when "../address-type = 'laddr:key-value-address-lcaf'" {
+          description
+            "When LCAF type type is Key/Value Address.";
+        }
+        description
+          "Key/Value Address LCAF type.";
+        reference
+          "http://tools.ietf.org/html/draft-ietf-lisp-lcaf-10
+           #section-4.11";
+        leaf key {
+          type simple-address;
+          description
+            "Address as Key.";
+        }
+        leaf value {
+          type simple-address;
+          description
+            "Address as Value.";
+        }
+      }
+      container service-path {
+        when "../address-type = 'laddr:service-path-lcaf'" {
+        description
+          "When LCAF type service path identifier.";
+            }
+        description
+          "Service Path LCAF type.";
+        reference
+          "http://tools.ietf.org/html/draft-ermagan-lisp-nsh-00";
+        leaf service-path-id {
+          type service-path-id-type;
+          description
+            "Service path identifier for the path for NSH header";
+        }
+        leaf service-index {
+          type uint8;
+          description
+            "Service path index for NSH header";
+        }
+      }
+    }
+  }
+}
diff --git a/lisp/api/src/main/yang/lisp.yang b/lisp/api/src/main/yang/lisp.yang
new file mode 100755
index 000000000..4f64ca28a
--- /dev/null
+++ b/lisp/api/src/main/yang/lisp.yang
@@ -0,0 +1,311 @@
+//TODO mandatory statements
+module lisp {
+  yang-version 1;
+  namespace "urn:opendaylight:params:xml:ns:yang:lisp";
+  prefix "lisp";
+  import ietf-interfaces {
+    prefix "if";
+  }
+  import ietf-inet-types {
+    prefix "inet";
+  }
+  import ietf-lisp-address-types {
+    prefix "lisp-types";
+  }
+  organization
+    "FD.io Overlay Forwarding Engine (ONE) project";
+  contact
+    "Florin Coras <fcoras@cisco.com>
+     Vina Ermagan <vermagan@cisco.com>
+     ONE list <one@lists.fd.io>";
+
+  description
+    "This YANG module defines the generic configuration and
+    operational data for LISP in VPP";
+  revision "2016-05-20" {
+    description
+      "Initial revision of LISP model";
+    reference
+      "https://tools.ietf.org/html/rfc6830";
+  }
+
+  typedef locator-set-ref {
+    type leafref {
+      path "/lisp/locator-sets/locator-set/name";
+    }
+    description "Locator-set reference";
+  }
+
+  typedef mapping-id {
+    type string;
+    description "Mapping ID";
+  }
+
+  typedef map-reply-action {
+    type enumeration {
+      enum no-action {
+        value 0;
+        description
+          "Mapping is kept alive and no encapsulation occurs.";
+      }
+      enum natively-forward {
+        value 1;
+        description
+          "Matching packets are not encapsulated or dropped but
+           natively forwarded.";
+      }
+      enum send-map-request {
+        value 2;
+        description
+          "Matching packets invoke Map-Requests.";
+      }
+      enum drop {
+        value 3;
+        description
+          "Matching packets are dropped.";
+      }
+    }
+    description
+      "Defines the lisp map-cache ACT type";
+    reference
+      "https://tools.ietf.org/html/rfc6830#section-6.1.4";
+  }
+  grouping locator-properties-grouping {
+    description
+      "Properties of a RLOC";
+    leaf priority {
+      type uint8;
+      description
+        "Locator priority.";
+    }
+    leaf weight {
+      type uint8;
+      description
+        "Locator weight.";
+    }
+  }
+
+  grouping locator-sets-grouping {
+    // NOTE: to be used only for local locators
+    // lisp_add_del_locator_set locator-set <ls_name> [del]
+    // lisp_add_del_locator locator-set <ls_name> iface <iface_name>
+    //                                  p <val> w <val> [del]
+    container locator-sets {
+      when "../lisp:enable = 'true'";
+      list locator-set {
+        key "name";
+        leaf name {
+          type string;
+          description "Locator-set name";
+        }
+        list interface {
+          key "interface-ref";
+          leaf interface-ref {
+            type if:interface-ref;
+            description "Interface reference";
+          }
+          uses locator-properties-grouping;
+          description "List of interfaces part of the locator-set";
+        }
+        description "Locator-set";
+      }
+      description "Locator-sets";
+    }
+    description "Grouping for locator-sets";
+  }
+
+  grouping eid-table-grouping {
+    container eid-table {
+      when "../lisp:enable = 'true'";
+      list vni-table {
+        key "virtual-network-identifier";
+        leaf virtual-network-identifier {
+            type uint32;
+            description "vni";
+        }
+        leaf table-id {
+            type uint32;
+            description "table-id/vrf";
+        }
+        // Once both vni and table-id are set:
+        // lisp_eid_table_add_del_map <vni> <vrf>
+        container local-mappings {
+          list local-mapping {
+            key "id";
+            leaf id {
+              type mapping-id;
+              description "Id that uniquely identifies a mapping";
+            }
+            container eid {
+              uses lisp-types:lisp-address;
+              description "EID address";
+            }
+            leaf locator-set {
+              type locator-set-ref;
+              description "Locator-set";
+            }
+            description "Local mapping";
+          }
+          description "Local EID to locator-set mappings";
+        }
+    // lisp_add_del_local_eid eid <ip-address/mask> locator-set
+    //                            <ls-name> [del]
+    // lisp_add_del_remote_mapping vni <vni> eid <ip-pref> seid
+    //                             <ip-pref> [action <action>] rloc
+    //                             <ip-addr> [rloc <ip-addr> ..]
+    // NOTE: 1.lisp_add_del_remote_mapping needs updating, right now
+    //         it expects both seid and deid, but this will be
+    //         simplified to just eid
+    //       2.priority/weight not yet part of API, patch under
+    //         review
+        container remote-mappings {
+          list remote-mapping {
+            key "id";
+            leaf id {
+              type mapping-id;
+              description "Id that uniquely identifies a mapping";
+            }
+            container eid {
+                description "Remote EID address";
+                uses lisp-types:lisp-address;
+            }
+            leaf ttl {
+              type uint32;
+              description "Mapping validity period.";
+            }
+            leaf authoritative {
+              type bits {
+                bit A {
+                  description "Authoritative bit.";
+                }
+              }
+              description
+                "Bit that indicates if mapping comes from an
+                 authoritative source.";
+            }
+            choice locator-list {
+              description
+                "list of locators are either negative, or positive.";
+              case negative-mapping {
+                //NOTE if this is enclosed in container,there can be a dedicated writer/reader
+                //for setting/reading this node
+                leaf map-reply-action {
+                  type map-reply-action;
+                  description
+                    "Forwarding action for a negative mapping.";
+                }
+              }
+              case positive-mapping {
+                container rlocs {
+                  list locator {
+                     key "address";
+                     leaf address {
+                       type inet:ip-address;
+                       description "Locator address";
+                     }
+                     uses locator-properties-grouping;
+                     description "Remote locator";
+                  }
+                  description
+                    "List of locators for a positive mapping.";
+                }
+              }
+            }
+            description "List of remote mappings";
+          }
+          description "Map-cache/remote mappings cache";
+        }
+
+        container adjacencies {
+          list adjacency {
+            key "id";
+            leaf id {
+              type string;
+              description "Adjacency id";
+            }
+            container local-eid {
+              uses lisp-types:lisp-address;
+              description "Local EID that must have a local mapping";
+            }
+            container remote-eid {
+              uses lisp-types:lisp-address;
+              description "Remote EID that must have a remote mapping";
+            }
+            description "List of adjacencies";
+          }
+          description "Adjacencies programmed into the data plane";
+        }
+        description "VNI tables";
+      }
+      description "EID table";
+    }
+    description "EID table grouping";
+  }
+  grouping map-resolvers-grouping {
+    container map-resolvers {
+      // lisp_add_del_map_resolver <ip>
+      when "../lisp:enable = 'true'";
+      list map-resolver {
+        key ip-address;
+        leaf ip-address {
+          type inet:ip-address;
+          description "Map-resolver IP address";
+        }
+        description "List of map-resolvers";
+      }
+      description "Map-resolvers configured";
+    }
+    description "Map-Resolver grouping";
+  }
+  grouping pitr-cfg-grouping {
+    // lisp_pitr_set_locator_set <ip>
+    container pitr-cfg {
+      when "../lisp:enable = 'true'";
+      leaf locator-set {
+        type locator-set-ref;
+        description "Locator-set reference";
+      }
+      description "Proxy-ITR configuration";
+    }
+    description "";
+  }
+
+  // ref https://wiki.fd.io/view/ONE/Command-line_Interface_CLI_Guide
+  container lisp {
+    // lisp_enable_disable / lisp_enable_disable_status_dump
+    leaf enable {
+      type boolean;
+      description "Enable/disable LISP feature";
+    }
+    // lisp_add_del_map_request_itr_rlocs add/del <ls_name>
+    leaf itr-rlocs {
+      type locator-set-ref;
+      description "Locators to be used in map-requests";
+    }
+    uses locator-sets-grouping;
+    uses eid-table-grouping;
+    uses map-resolvers-grouping;
+    uses pitr-cfg-grouping;
+
+    // lisp_pitr_set_locator_set <ip>
+    description "LISP configuration";
+  }
+
+  container lisp-state {
+    config false;
+    leaf enable {
+      type boolean;
+      description "LISP status";
+    }
+    leaf itr-rlocs {
+      type locator-set-ref;
+      description "Locators to be used in map-requests";
+    }
+    uses locator-sets-grouping;
+    uses eid-table-grouping;
+    uses map-resolvers-grouping;
+    uses pitr-cfg-grouping;
+
+    description "LISP state";
+  }
+}
\ No newline at end of file