HC2VPP-30 - Lisp control plane impl

Add new nodes
- rloc-probe/ing
- map-server/s
- map-request-mode
- petr-cfg use

Also adds new nodes to local-mapping
- key
- key type

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

18 files changed, 982 insertions, 13 deletions

diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/LispModule.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/LispModule.java
index 90ca83343..5e674f52b 100644
--- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/LispModule.java
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/LispModule.java
@@ -35,10 +35,12 @@ import io.fd.hc2vpp.lisp.translate.read.factory.EidTableReaderFactory;
 import io.fd.hc2vpp.lisp.translate.read.factory.LispStateReaderFactory;
 import io.fd.hc2vpp.lisp.translate.read.factory.LocatorSetReaderFactory;
 import io.fd.hc2vpp.lisp.translate.read.factory.MapResolverReaderFactory;
+import io.fd.hc2vpp.lisp.translate.read.factory.MapServerReaderFactory;
 import io.fd.hc2vpp.lisp.translate.write.factory.EidTableWriterFactory;
 import io.fd.hc2vpp.lisp.translate.write.factory.LispWriterFactory;
 import io.fd.hc2vpp.lisp.translate.write.factory.LocatorSetWriterFactory;
 import io.fd.hc2vpp.lisp.translate.write.factory.MapResolverWriterFactory;
+import io.fd.hc2vpp.lisp.translate.write.factory.MapServerWriterFactory;
 import io.fd.honeycomb.translate.read.ReaderFactory;
 import io.fd.honeycomb.translate.write.WriterFactory;
 import net.jmob.guice.conf.core.ConfigurationModule;
@@ -81,6 +83,7 @@ public class LispModule extends AbstractModule {
         readerFactoryBinder.addBinding().to(EidTableReaderFactory.class);
         readerFactoryBinder.addBinding().to(LocatorSetReaderFactory.class);
         readerFactoryBinder.addBinding().to(MapResolverReaderFactory.class);
+        readerFactoryBinder.addBinding().to(MapServerReaderFactory.class);
         LOG.info("Reader factories binded");
 
         LOG.info("Binding writer factories");
@@ -89,6 +92,7 @@ public class LispModule extends AbstractModule {
         writerFactoryBinder.addBinding().to(EidTableWriterFactory.class);
         writerFactoryBinder.addBinding().to(LocatorSetWriterFactory.class);
         writerFactoryBinder.addBinding().to(MapResolverWriterFactory.class);
+        writerFactoryBinder.addBinding().to(MapServerWriterFactory.class);
         LOG.info("Writer factories binded");
 
         final Multibinder<ReaderFactory> readerBinder = Multibinder.newSetBinder(binder(), ReaderFactory.class);
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/AbstractLispInfraFactoryBase.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/AbstractLispInfraFactoryBase.java
index eeda656bc..022ea19ed 100644
--- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/AbstractLispInfraFactoryBase.java
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/AbstractLispInfraFactoryBase.java
@@ -27,11 +27,16 @@ import com.google.inject.name.Named;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
 import io.fd.hc2vpp.lisp.context.util.AdjacenciesMappingContext;
 import io.fd.hc2vpp.lisp.context.util.EidMappingContext;
+import io.fd.honeycomb.translate.impl.write.GenericWriter;
+import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.LispState;
+import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
+import javax.annotation.Nonnull;
+
 
 /**
  * Basic attributes for lisp writer factories
@@ -68,4 +73,10 @@ public abstract class AbstractLispInfraFactoryBase {
     @Inject
     @Named(ADJACENCIES_IDENTIFICATION_CONTEXT)
     protected AdjacenciesMappingContext adjacenciesMappingContext;
+
+    @Nonnull
+    protected <D extends DataObject> GenericWriter<D> writer(@Nonnull final InstanceIdentifier<D> type,
+                                                             @Nonnull final WriterCustomizer<D> customizer) {
+        return new GenericWriter<>(type, customizer);
+    }
 }
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizer.java
index 44f5f2dd2..69df09c80 100755
--- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizer.java
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizer.java
@@ -35,6 +35,7 @@ import io.fd.vpp.jvpp.core.dto.LispEidTableDetailsReplyDump;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.eid.mapping.context.rev160801.contexts.eid.mapping.context.mappings.mapping.Eid;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.HmacKeyType;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MappingId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.LocalMappings;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.LocalMappingsBuilder;
@@ -42,6 +43,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.LocalMappingBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.LocalMappingKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.hmac.key.grouping.HmacKeyBuilder;
 import org.opendaylight.yangtools.concepts.Builder;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
@@ -133,6 +135,16 @@ public class LocalMappingCustomizer
         builder.setLocatorSet(locatorSetContext.getName(details.locatorSetIndex, ctx.getMappingContext()));
         builder.setKey(new LocalMappingKey(new MappingId(id.firstKeyOf(LocalMapping.class).getId())));
         builder.setEid(getArrayAsEidLocal(valueOf(details.eidType), details.eid, details.vni));
+
+        if (details.key != null) {
+            builder.setHmacKey(
+                    new HmacKeyBuilder()
+                            .setKey(toString(details.key))
+                            .setKeyType(HmacKeyType.forValue(details.keyId))
+                            .build());
+        } else {
+            builder.setHmacKey(new HmacKeyBuilder().setKeyType(HmacKeyType.NoKey).build());
+        }
     }
 
     private Address getAddressFromDumpDetail(final LispEidTableDetails detail) {
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRegisterCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRegisterCustomizer.java
new file mode 100644
index 000000000..e94bb92f0
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRegisterCustomizer.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.read;
+
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.Initialized;
+import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer;
+import io.fd.vpp.jvpp.core.dto.ShowLispMapRegisterState;
+import io.fd.vpp.jvpp.core.dto.ShowLispMapRegisterStateReply;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegisterBuilder;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class MapRegisterCustomizer extends FutureJVppCustomizer
+        implements InitializingReaderCustomizer<MapRegister, MapRegisterBuilder>, ByteDataTranslator,
+        JvppReplyConsumer, LispInitPathsMapper {
+
+    public MapRegisterCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+    }
+
+    @Nonnull
+    @Override
+    public MapRegisterBuilder getBuilder(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier) {
+        return new MapRegisterBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
+                                      @Nonnull MapRegisterBuilder mapRegisterBuilder,
+                                      @Nonnull ReadContext readContext) throws ReadFailedException {
+        final ShowLispMapRegisterStateReply read = getReplyForRead(getFutureJVpp()
+                .showLispMapRegisterState(new ShowLispMapRegisterState()).toCompletableFuture(), instanceIdentifier);
+
+        if (read != null) {
+            mapRegisterBuilder.setEnabled(byteToBoolean(read.isEnabled));
+        }
+    }
+
+    @Override
+    public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull MapRegister mapRegister) {
+        LispFeatureDataBuilder.class.cast(builder).setMapRegister(mapRegister);
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<MapRegister> instanceIdentifier,
+                                                  @Nonnull final MapRegister mapRegister,
+                                                  @Nonnull final ReadContext readContext) {
+        return Initialized.create(lispFeaturesBasePath().child(MapRegister.class), mapRegister);
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRequestModeCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRequestModeCustomizer.java
new file mode 100644
index 000000000..9de5b5c68
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRequestModeCustomizer.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.read;
+
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.Initialized;
+import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer;
+import io.fd.vpp.jvpp.core.dto.ShowLispMapRequestMode;
+import io.fd.vpp.jvpp.core.dto.ShowLispMapRequestModeReply;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestModeBuilder;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class MapRequestModeCustomizer extends FutureJVppCustomizer
+        implements InitializingReaderCustomizer<MapRequestMode, MapRequestModeBuilder>,
+        JvppReplyConsumer, LispInitPathsMapper {
+
+    public MapRequestModeCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+    }
+
+    @Nonnull
+    @Override
+    public MapRequestModeBuilder getBuilder(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier) {
+        return new MapRequestModeBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
+                                      @Nonnull MapRequestModeBuilder mapRequestModeBuilder,
+                                      @Nonnull ReadContext readContext) throws ReadFailedException {
+        final ShowLispMapRequestModeReply reply = getReplyForRead(
+                getFutureJVpp().showLispMapRequestMode(new ShowLispMapRequestMode()).toCompletableFuture(),
+                instanceIdentifier);
+
+        if (reply != null) {
+            mapRequestModeBuilder.setMode(
+                    org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MapRequestMode
+                            .forValue(reply.mode));
+        }
+    }
+
+    @Override
+    public void merge(@Nonnull Builder<? extends DataObject> builder,
+                      @Nonnull MapRequestMode mapRequestMode) {
+        LispFeatureDataBuilder.class.cast(builder).setMapRequestMode(mapRequestMode);
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
+                                                  @Nonnull MapRequestMode mapRequestMode,
+                                                  @Nonnull ReadContext readContext) {
+        return Initialized.create(lispFeaturesBasePath().child(MapRequestMode.class), mapRequestMode);
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapServerCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapServerCustomizer.java
new file mode 100644
index 000000000..8e53f265d
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapServerCustomizer.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.read;
+
+import static io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor.NO_PARAMS;
+
+import com.google.common.base.Optional;
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.Initialized;
+import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
+import io.fd.honeycomb.translate.util.RWUtils;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager.DumpCacheManagerBuilder;
+import io.fd.vpp.jvpp.core.dto.LispMapServerDetails;
+import io.fd.vpp.jvpp.core.dto.LispMapServerDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.LispMapServerDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServersBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerKey;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class MapServerCustomizer extends FutureJVppCustomizer
+        implements InitializingListReaderCustomizer<MapServer, MapServerKey, MapServerBuilder>, JvppReplyConsumer,
+        AddressTranslator {
+
+    private final DumpCacheManager<LispMapServerDetailsReplyDump, Void> dumpManager;
+
+    public MapServerCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+        dumpManager = new DumpCacheManagerBuilder<LispMapServerDetailsReplyDump, Void>()
+                .acceptOnly(LispMapServerDetailsReplyDump.class)
+                .withExecutor((instanceIdentifier, aVoid) ->
+                        getReplyForRead(getFutureJVpp()
+                                .lispMapServerDump(new LispMapServerDump()).toCompletableFuture(), instanceIdentifier))
+                .build();
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
+                                                  @Nonnull MapServer mapServer,
+                                                  @Nonnull ReadContext readContext) {
+        final InstanceIdentifier<MapServer> configId = InstanceIdentifier.create(Lisp.class)
+                .child(LispFeatureData.class)
+                .child(MapServers.class)
+                .child(MapServer.class, instanceIdentifier.firstKeyOf(MapServer.class));
+
+        return Initialized.create(configId, mapServer);
+    }
+
+    @Nonnull
+    @Override
+    public List<MapServerKey> getAllIds(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
+                                        @Nonnull ReadContext readContext) throws ReadFailedException {
+
+        final Optional<LispMapServerDetailsReplyDump> dump =
+                dumpManager.getDump(instanceIdentifier, readContext.getModificationCache(), NO_PARAMS);
+
+        if (dump.isPresent() && dump.get().lispMapServerDetails != null) {
+            return dump.get().lispMapServerDetails.stream()
+                    .map(detail -> arrayToIpAddress(byteToBoolean(detail.isIpv6), detail.ipAddress))
+                    .map(MapServerKey::new)
+                    .collect(Collectors.toList());
+        }
+
+        return Collections.emptyList();
+    }
+
+    @Override
+    public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<MapServer> list) {
+        MapServersBuilder.class.cast(builder).setMapServer(list);
+    }
+
+    @Nonnull
+    @Override
+    public MapServerBuilder getBuilder(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier) {
+        return new MapServerBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
+                                      @Nonnull MapServerBuilder mapServerBuilder, @Nonnull ReadContext readContext)
+            throws ReadFailedException {
+        final Optional<LispMapServerDetailsReplyDump> dump =
+                dumpManager.getDump(instanceIdentifier, readContext.getModificationCache(), NO_PARAMS);
+
+        if (dump.isPresent() && dump.get().lispMapServerDetails != null) {
+            final IpAddress currentAddress = instanceIdentifier.firstKeyOf(MapServer.class).getIpAddress();
+
+            final LispMapServerDetails currentDetail = dump.get().lispMapServerDetails.stream()
+                    .filter(detail -> Arrays.equals(currentAddress.getValue(),
+                            arrayToIpAddress(byteToBoolean(detail.isIpv6), detail.ipAddress).getValue()))
+                    .collect(RWUtils.singleItemCollector());
+
+            mapServerBuilder
+                    .setIpAddress(arrayToIpAddress(byteToBoolean(currentDetail.isIpv6), currentDetail.ipAddress));
+
+        }
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/PetrCfgCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/PetrCfgCustomizer.java
new file mode 100644
index 000000000..0e27a0ee8
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/PetrCfgCustomizer.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.read;
+
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.Initialized;
+import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer;
+import io.fd.vpp.jvpp.core.dto.ShowLispUsePetr;
+import io.fd.vpp.jvpp.core.dto.ShowLispUsePetrReply;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfg;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfgBuilder;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class PetrCfgCustomizer extends FutureJVppCustomizer
+        implements InitializingReaderCustomizer<PetrCfg, PetrCfgBuilder>, JvppReplyConsumer,
+        AddressTranslator, LispInitPathsMapper {
+
+    public PetrCfgCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
+                                                  @Nonnull PetrCfg petrCfg,
+                                                  @Nonnull ReadContext readContext) {
+        return Initialized.create(lispFeaturesBasePath().child(PetrCfg.class), petrCfg);
+    }
+
+    @Nonnull
+    @Override
+    public PetrCfgBuilder getBuilder(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier) {
+        return new PetrCfgBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
+                                      @Nonnull PetrCfgBuilder petrCfgBuilder,
+                                      @Nonnull ReadContext readContext) throws ReadFailedException {
+        final ShowLispUsePetrReply read = getReplyForRead(getFutureJVpp().showLispUsePetr(new ShowLispUsePetr())
+                .toCompletableFuture(), instanceIdentifier);
+
+        if (read != null && read.status != 0) {
+            // TODO - https://jira.fd.io/browse/VPP-660 - returns address back in bad form
+            petrCfgBuilder.setPetrAddress(arrayToIpAddress(!byteToBoolean(read.isIp4), read.address));
+        }
+    }
+
+    @Override
+    public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull PetrCfg petrCfg) {
+        LispFeatureDataBuilder.class.cast(builder).setPetrCfg(petrCfg);
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/RlocProbeCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/RlocProbeCustomizer.java
new file mode 100644
index 000000000..bd0070141
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/RlocProbeCustomizer.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.read;
+
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.Initialized;
+import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer;
+import io.fd.vpp.jvpp.core.dto.ShowLispRlocProbeState;
+import io.fd.vpp.jvpp.core.dto.ShowLispRlocProbeStateReply;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbeBuilder;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class RlocProbeCustomizer extends FutureJVppCustomizer
+        implements InitializingReaderCustomizer<RlocProbe, RlocProbeBuilder>, JvppReplyConsumer, ByteDataTranslator,
+        LispInitPathsMapper {
+
+    public RlocProbeCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+    }
+
+    @Nonnull
+    @Override
+    public RlocProbeBuilder getBuilder(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier) {
+        return new RlocProbeBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
+                                      @Nonnull RlocProbeBuilder rlocProbeBuilder,
+                                      @Nonnull ReadContext readContext) throws ReadFailedException {
+        final ShowLispRlocProbeStateReply read = getReplyForRead(getFutureJVpp()
+                .showLispRlocProbeState(new ShowLispRlocProbeState()).toCompletableFuture(), instanceIdentifier);
+
+        if (read != null) {
+            rlocProbeBuilder.setEnabled(byteToBoolean(read.isEnabled));
+        }
+    }
+
+    @Override
+    public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull RlocProbe rlocProbe) {
+        LispFeatureDataBuilder.class.cast(builder).setRlocProbe(rlocProbe);
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
+                                                  @Nonnull RlocProbe rlocProbe,
+                                                  @Nonnull ReadContext readContext) {
+        return Initialized.create(lispFeaturesBasePath().child(RlocProbe.class), rlocProbe);
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/LispStateReaderFactory.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/LispStateReaderFactory.java
index 345fe46ad..b7bd37588 100755
--- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/LispStateReaderFactory.java
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/LispStateReaderFactory.java
@@ -18,18 +18,25 @@ package io.fd.hc2vpp.lisp.translate.read.factory;
 
 import io.fd.hc2vpp.lisp.translate.AbstractLispInfraFactoryBase;
 import io.fd.hc2vpp.lisp.translate.read.LispStateCustomizer;
+import io.fd.hc2vpp.lisp.translate.read.MapRegisterCustomizer;
+import io.fd.hc2vpp.lisp.translate.read.MapRequestModeCustomizer;
+import io.fd.hc2vpp.lisp.translate.read.PetrCfgCustomizer;
 import io.fd.hc2vpp.lisp.translate.read.PitrCfgCustomizer;
+import io.fd.hc2vpp.lisp.translate.read.RlocProbeCustomizer;
 import io.fd.honeycomb.translate.impl.read.GenericInitReader;
 import io.fd.honeycomb.translate.read.ReaderFactory;
 import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
+import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.LispState;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.pitr.cfg.grouping.PitrCfg;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfg;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
-import javax.annotation.Nonnull;
-
 
 /**
  * Initialize readers for {@link LispState}
@@ -37,6 +44,8 @@ import javax.annotation.Nonnull;
 public class LispStateReaderFactory extends AbstractLispInfraFactoryBase implements ReaderFactory {
 
     private static final InstanceIdentifier<LispState> lispStateId = InstanceIdentifier.create(LispState.class);
+    static final InstanceIdentifier<LispFeatureData>
+            LISP_FEATURE_ID = lispStateId.child(LispFeatureData.class);
 
     @Override
     public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) {
@@ -44,7 +53,19 @@ public class LispStateReaderFactory extends AbstractLispInfraFactoryBase impleme
         registry.add(new GenericInitReader<>(lispStateId, new LispStateCustomizer(vppApi)));
         registry.addStructuralReader(lispStateId.child(LispFeatureData.class), LispFeatureDataBuilder.class);
 
-        registry.add(new GenericInitReader<>(lispStateId.child(LispFeatureData.class).child(PitrCfg.class),
+        registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(PitrCfg.class),
                 new PitrCfgCustomizer(vppApi)));
+
+        registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(RlocProbe.class),
+                new RlocProbeCustomizer(vppApi)));
+
+        registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(PetrCfg.class),
+                new PetrCfgCustomizer(vppApi)));
+
+        registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(MapRegister.class),
+                new MapRegisterCustomizer(vppApi)));
+
+        registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(MapRequestMode.class),
+                new MapRequestModeCustomizer(vppApi)));
     }
 }
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/MapServerReaderFactory.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/MapServerReaderFactory.java
new file mode 100644
index 000000000..1af8f939f
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/MapServerReaderFactory.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.read.factory;
+
+
+import static io.fd.hc2vpp.lisp.translate.read.factory.LispStateReaderFactory.LISP_FEATURE_ID;
+
+import io.fd.hc2vpp.lisp.translate.AbstractLispInfraFactoryBase;
+import io.fd.hc2vpp.lisp.translate.read.MapServerCustomizer;
+import io.fd.honeycomb.translate.impl.read.GenericInitListReader;
+import io.fd.honeycomb.translate.read.ReaderFactory;
+import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServersBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class MapServerReaderFactory extends AbstractLispInfraFactoryBase implements ReaderFactory {
+
+    private static final InstanceIdentifier<MapServers> MAP_SERVERS_ID = LISP_FEATURE_ID.child(MapServers.class);
+
+    @Override
+    public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) {
+        registry.addStructuralReader(MAP_SERVERS_ID, MapServersBuilder.class);
+        registry.add(new GenericInitListReader<>(MAP_SERVERS_ID.child(MapServer.class),
+                new MapServerCustomizer(vppApi)));
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizer.java
index e2943c670..494afd3cb 100755
--- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizer.java
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizer.java
@@ -22,26 +22,28 @@ import static io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDump
 import static io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDumpParams.EidType.IPV6;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
 import io.fd.hc2vpp.lisp.context.util.EidMappingContext;
 import io.fd.hc2vpp.lisp.translate.read.trait.MappingProducer;
 import io.fd.hc2vpp.lisp.translate.util.EidTranslator;
 import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
-import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
-import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
-import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
 import io.fd.honeycomb.translate.write.WriteContext;
 import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.VppBaseCallException;
+import io.fd.vpp.jvpp.core.dto.LispAddDelLocalEid;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
 import java.util.concurrent.TimeoutException;
 import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MappingId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.LocalMapping;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.LocalMappingKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.hmac.key.grouping.HmacKey;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import io.fd.vpp.jvpp.VppBaseCallException;
-import io.fd.vpp.jvpp.core.dto.LispAddDelLocalEid;
-import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 
 
 /**
@@ -129,6 +131,14 @@ public class LocalMappingCustomizer extends FutureJVppCustomizer
             request.prefixLen = (byte) 128;
         }
 
+        final HmacKey hmacKey = data.getHmacKey();
+        if (hmacKey != null) {
+            request.key = checkNotNull(hmacKey.getKey(), "HMAC key not specified")
+                    .getBytes(StandardCharsets.UTF_8);
+            request.keyId = (byte) checkNotNull(hmacKey.getKeyType(),
+                    "HMAC key type not specified").getIntValue();
+        }
+
         getReply(getFutureJVpp().lispAddDelLocalEid(request).toCompletableFuture());
     }
 
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRegisterCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRegisterCustomizer.java
new file mode 100644
index 000000000..1dac298a3
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRegisterCustomizer.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.write;
+
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.core.dto.LispMapRegisterEnableDisable;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import javax.annotation.Nonnull;
+
+public class MapRegisterCustomizer extends FutureJVppCustomizer
+        implements WriterCustomizer<MapRegister>, ByteDataTranslator, JvppReplyConsumer {
+
+    public MapRegisterCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+    }
+
+    @Override
+    public void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
+                                       @Nonnull MapRegister mapRegister,
+                                       @Nonnull WriteContext writeContext) throws WriteFailedException {
+        enableDisableMapRegister(mapRegister.isEnabled(), instanceIdentifier);
+    }
+
+    @Override
+    public void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
+                                        @Nonnull MapRegister mapRegisterBefore,
+                                        @Nonnull MapRegister mapRegisterAfter, @Nonnull
+                                                WriteContext writeContext) throws WriteFailedException {
+        enableDisableMapRegister(mapRegisterAfter.isEnabled(), instanceIdentifier);
+    }
+
+    @Override
+    public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier,
+                                        @Nonnull MapRegister mapRegister,
+                                        @Nonnull WriteContext writeContext) throws WriteFailedException {
+        enableDisableMapRegister(false, instanceIdentifier);
+    }
+
+    private void enableDisableMapRegister(final boolean enable, @Nonnull final InstanceIdentifier<MapRegister> id) throws WriteFailedException {
+        LispMapRegisterEnableDisable request = new LispMapRegisterEnableDisable();
+        request.isEnabled = booleanToByte(enable);
+        getReplyForWrite(getFutureJVpp().lispMapRegisterEnableDisable(request).toCompletableFuture(), id);
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRequestModeCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRequestModeCustomizer.java
new file mode 100644
index 000000000..0e069504d
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRequestModeCustomizer.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.write;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.core.dto.LispMapRequestMode;
+import io.fd.vpp.jvpp.core.dto.LispMapRequestModeReply;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import java.util.concurrent.CompletableFuture;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MapRequestModeCustomizer extends FutureJVppCustomizer
+        implements WriterCustomizer<MapRequestMode>, JvppReplyConsumer {
+
+    private static final Logger LOG = LoggerFactory.getLogger(MapRequestModeCustomizer.class);
+
+    public MapRequestModeCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+    }
+
+    @Override
+    public void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
+                                       @Nonnull MapRequestMode mapRequestMode,
+                                       @Nonnull WriteContext writeContext) throws WriteFailedException {
+        getReplyForWrite(mapRequestModeRequestFuture(mapRequestMode), instanceIdentifier);
+    }
+
+    @Override
+    public void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
+                                        @Nonnull MapRequestMode mapRequestModeBefore,
+                                        @Nonnull MapRequestMode mapRequestModeAfter, @Nonnull WriteContext writeContext)
+            throws WriteFailedException {
+        getReplyForUpdate(mapRequestModeRequestFuture(mapRequestModeAfter), instanceIdentifier,
+                mapRequestModeBefore, mapRequestModeAfter);
+    }
+
+    @Override
+    public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier,
+                                        @Nonnull MapRequestMode mapRequestMode,
+                                        @Nonnull WriteContext writeContext) throws WriteFailedException {
+        //TODO - after HC2VPP-115 - change to throw UnsupportedOperationException
+        LOG.error("Map request mode cannot be deleted, ignoring");
+    }
+
+    private CompletableFuture<LispMapRequestModeReply> mapRequestModeRequestFuture(
+            @Nonnull final MapRequestMode mapRequestMode) {
+        LispMapRequestMode request = new LispMapRequestMode();
+        request.mode = (byte) checkNotNull(mapRequestMode.getMode(),
+                "Mode not specified").getIntValue();
+        return getFutureJVpp().lispMapRequestMode(request).toCompletableFuture();
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapServerCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapServerCustomizer.java
new file mode 100644
index 000000000..9697e16bc
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapServerCustomizer.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.write;
+
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.core.dto.LispAddDelMapServer;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import javax.annotation.Nonnull;
+
+public class MapServerCustomizer extends FutureJVppCustomizer
+        implements ListWriterCustomizer<MapServer, MapServerKey>, AddressTranslator,
+        JvppReplyConsumer {
+
+    public MapServerCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+    }
+
+    @Override
+    public void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
+                                       @Nonnull MapServer mapServer,
+                                       @Nonnull WriteContext writeContext) throws WriteFailedException {
+        addDelMapServer(true, instanceIdentifier, mapServer);
+    }
+
+    @Override
+    public void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier,
+                                        @Nonnull MapServer mapServerBefore,
+                                        @Nonnull MapServer mapServerAfter,
+                                        @Nonnull WriteContext writeContext) throws WriteFailedException {
+        throw new WriteFailedException.UpdateFailedException(instanceIdentifier, mapServerBefore, mapServerAfter,
+                new UnsupportedOperationException("Not supported"));
+    }
+
+    @Override
+    public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServer mapServer, @Nonnull WriteContext writeContext) throws WriteFailedException {
+        addDelMapServer(false, instanceIdentifier, mapServer);
+    }
+
+    private void addDelMapServer(final boolean add,
+                                 @Nonnull final InstanceIdentifier<MapServer> id,
+                                 @Nonnull final MapServer data) throws WriteFailedException {
+        LispAddDelMapServer request = new LispAddDelMapServer();
+
+        final IpAddress ipAddress = data.getIpAddress();
+
+        request.isAdd = booleanToByte(add);
+        request.isIpv6 = booleanToByte(isIpv6(ipAddress));
+        request.ipAddress = ipAddressToArray(ipAddress);
+
+        getReplyForWrite(getFutureJVpp().lispAddDelMapServer(request).toCompletableFuture(), id);
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/PetrCfgCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/PetrCfgCustomizer.java
new file mode 100644
index 000000000..d3a381490
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/PetrCfgCustomizer.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.write;
+
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.core.dto.LispUsePetr;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfg;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import javax.annotation.Nonnull;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+public class PetrCfgCustomizer extends FutureJVppCustomizer
+        implements WriterCustomizer<PetrCfg>, AddressTranslator, JvppReplyConsumer {
+
+    public PetrCfgCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+    }
+
+    @Override
+    public void writeCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
+                                       @Nonnull PetrCfg petrCfg,
+                                       @Nonnull WriteContext writeContext) throws WriteFailedException {
+        enablePetrCfg(instanceIdentifier, petrCfg);
+    }
+
+    @Override
+    public void updateCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier,
+                                        @Nonnull PetrCfg petrCfgBefore,
+                                        @Nonnull PetrCfg petrCfgAfter,
+                                        @Nonnull WriteContext writeContext) throws WriteFailedException {
+        if (petrCfgAfter.getPetrAddress() != null) {
+            enablePetrCfg(instanceIdentifier, petrCfgAfter);
+        } else {
+            disablePetrCfg(instanceIdentifier);
+        }
+    }
+
+    @Override
+    public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfg, @Nonnull WriteContext writeContext) throws WriteFailedException {
+        disablePetrCfg(instanceIdentifier);
+    }
+
+    private void enablePetrCfg(@Nonnull final InstanceIdentifier<PetrCfg> id, @Nonnull final PetrCfg data) throws WriteFailedException {
+        LispUsePetr request = new LispUsePetr();
+
+        final IpAddress petrAddress = checkNotNull(data.getPetrAddress(), "PETR address not defined");
+        request.isAdd = 1;
+        request.address = ipAddressToArray(petrAddress);
+        request.isIp4 = booleanToByte(!isIpv6(petrAddress));
+        getReplyForWrite(getFutureJVpp().lispUsePetr(request).toCompletableFuture(), id);
+    }
+
+    private void disablePetrCfg(@Nonnull final InstanceIdentifier<PetrCfg> id) throws WriteFailedException {
+        LispUsePetr request = new LispUsePetr();
+        request.isAdd = 0;
+        getReplyForDelete(getFutureJVpp().lispUsePetr(request).toCompletableFuture(), id);
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/RlocProbeCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/RlocProbeCustomizer.java
new file mode 100644
index 000000000..b240d1d2e
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/RlocProbeCustomizer.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.write;
+
+import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.honeycomb.translate.spi.write.WriterCustomizer;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import io.fd.vpp.jvpp.core.dto.LispRlocProbeEnableDisable;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import javax.annotation.Nonnull;
+
+public class RlocProbeCustomizer extends FutureJVppCustomizer
+        implements WriterCustomizer<RlocProbe>, ByteDataTranslator, JvppReplyConsumer {
+
+    public RlocProbeCustomizer(@Nonnull FutureJVppCore futureJVppCore) {
+        super(futureJVppCore);
+    }
+
+    @Override
+    public void writeCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
+                                       @Nonnull RlocProbe rlocProbe,
+                                       @Nonnull WriteContext writeContext) throws WriteFailedException {
+        enableDisableRlocProbe(rlocProbe.isEnabled(), instanceIdentifier);
+    }
+
+    @Override
+    public void updateCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
+                                        @Nonnull RlocProbe rlocProbeBefore,
+                                        @Nonnull RlocProbe rlocProbeAfter,
+                                        @Nonnull WriteContext writeContext) throws WriteFailedException {
+        enableDisableRlocProbe(rlocProbeAfter.isEnabled(), instanceIdentifier);
+    }
+
+    @Override
+    public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier,
+                                        @Nonnull RlocProbe rlocProbe,
+                                        @Nonnull WriteContext writeContext) throws WriteFailedException {
+        enableDisableRlocProbe(false, instanceIdentifier);
+    }
+
+    private void enableDisableRlocProbe(final boolean enable, @Nonnull final InstanceIdentifier<RlocProbe> id) throws WriteFailedException {
+        LispRlocProbeEnableDisable request = new LispRlocProbeEnableDisable();
+
+        request.isEnabled = booleanToByte(enable);
+
+        getReplyForWrite(getFutureJVpp().lispRlocProbeEnableDisable(request).toCompletableFuture(), id);
+    }
+}
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/LispWriterFactory.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/LispWriterFactory.java
index b2ce44e82..ed7d2122a 100755
--- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/LispWriterFactory.java
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/LispWriterFactory.java
@@ -21,14 +21,22 @@ import static io.fd.hc2vpp.lisp.translate.write.factory.LocatorSetWriterFactory.
 
 import io.fd.hc2vpp.lisp.translate.AbstractLispInfraFactoryBase;
 import io.fd.hc2vpp.lisp.translate.write.LispCustomizer;
+import io.fd.hc2vpp.lisp.translate.write.MapRegisterCustomizer;
+import io.fd.hc2vpp.lisp.translate.write.MapRequestModeCustomizer;
+import io.fd.hc2vpp.lisp.translate.write.PetrCfgCustomizer;
 import io.fd.hc2vpp.lisp.translate.write.PitrCfgCustomizer;
+import io.fd.hc2vpp.lisp.translate.write.RlocProbeCustomizer;
 import io.fd.honeycomb.translate.impl.write.GenericWriter;
 import io.fd.honeycomb.translate.write.WriterFactory;
 import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
 import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.pitr.cfg.grouping.PitrCfg;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfg;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 
@@ -36,13 +44,27 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  * Initialize writers for {@link Lisp}
  */
 public final class LispWriterFactory extends AbstractLispInfraFactoryBase implements WriterFactory {
-    private final InstanceIdentifier<Lisp> lispInstanceIdentifier = InstanceIdentifier.create(Lisp.class);
+    private static final InstanceIdentifier<Lisp> LISP_INSTANCE_IDENTIFIER = InstanceIdentifier.create(Lisp.class);
+    private static final InstanceIdentifier<LispFeatureData> LISP_FEATURE_IDENTIFIER =
+            LISP_INSTANCE_IDENTIFIER.child(LispFeatureData.class);
 
     @Override
     public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) {
-        registry.add(new GenericWriter<>(lispInstanceIdentifier, new LispCustomizer(vppApi)));
+        registry.add(new GenericWriter<>(LISP_INSTANCE_IDENTIFIER, new LispCustomizer(vppApi)));
 
-        registry.addAfter(new GenericWriter<>(lispInstanceIdentifier.child(LispFeatureData.class).child(PitrCfg.class),
-                new PitrCfgCustomizer(vppApi)),LOCATOR_SET_ID);
+        registry.addAfter(writer(LISP_FEATURE_IDENTIFIER.child(PitrCfg.class),
+                new PitrCfgCustomizer(vppApi)), LOCATOR_SET_ID);
+
+        registry.add(writer(LISP_FEATURE_IDENTIFIER.child(MapRegister.class),
+                new MapRegisterCustomizer(vppApi)));
+
+        registry.add(writer(LISP_FEATURE_IDENTIFIER.child(MapRequestMode.class),
+                new MapRequestModeCustomizer(vppApi)));
+
+        registry.add(writer(LISP_FEATURE_IDENTIFIER.child(PetrCfg.class),
+                new PetrCfgCustomizer(vppApi)));
+
+        registry.add(writer(LISP_FEATURE_IDENTIFIER.child(RlocProbe.class),
+                new RlocProbeCustomizer(vppApi)));
     }
 }
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/MapServerWriterFactory.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/MapServerWriterFactory.java
new file mode 100644
index 000000000..fc0cc4d10
--- /dev/null
+++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/MapServerWriterFactory.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2017 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 io.fd.hc2vpp.lisp.translate.write.factory;
+
+import io.fd.hc2vpp.lisp.translate.AbstractLispInfraFactoryBase;
+import io.fd.hc2vpp.lisp.translate.write.MapServerCustomizer;
+import io.fd.honeycomb.translate.impl.write.GenericListWriter;
+import io.fd.honeycomb.translate.write.WriterFactory;
+import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer;
+
+public class MapServerWriterFactory extends AbstractLispInfraFactoryBase implements WriterFactory {
+
+    @Override
+    public void init(@Nonnull ModifiableWriterRegistryBuilder registry) {
+        registry.add(new GenericListWriter<>(
+                LISP_CONFIG_IDENTIFIER.child(LispFeatureData.class).child(MapServers.class).child(MapServer.class),
+                new MapServerCustomizer(vppApi)));
+    }
+}