HC2VPP-288 - add readers for SRv6 module

Changes:
- add locator context to map locator name to locator IPv6Prefix
- add readers for SRv6 module
- implements reading of local sids and their end functions.
- implements support for FIB table management (HC2VPP-345)

Change-Id: Ib04402539a0b6666c5a1d0b4e1b5b5e08ccbf67b
Signed-off-by: Michal Cmarada <michal.cmarada@pantheon.tech>

39 files changed, 2101 insertions, 100 deletions

diff --git a/srv6/srv6-api/src/main/yang/locator-context@2018-06-05.yang b/srv6/srv6-api/src/main/yang/locator-context@2018-06-05.yang
new file mode 100644
index 000000000..0634be5ca
--- /dev/null
+++ b/srv6/srv6-api/src/main/yang/locator-context@2018-06-05.yang
@@ -0,0 +1,73 @@
+module locator-context {
+    yang-version 1;
+    namespace "urn:honeycomb:params:xml:ns:yang:locator:context";
+    prefix "locator-ctx";
+
+    import ietf-inet-types {
+       prefix "inet";
+    }
+
+    import naming-context {
+       prefix "nc";
+    }
+
+    import yang-ext {
+       prefix "ext";
+    }
+
+    organization
+        "FD.io - The Fast Data Project";
+
+    contact
+        "Hc2vpp Wiki <https://wiki.fd.io/view/Hc2vpp>
+         Mailing List <hc2vpp@lists.fd.io>";
+
+    description
+        "This module provides mapping between SRV6 locator identifiers
+         defined in the ietf-nat-srv6-base module
+         and identifiers used by the VPP SRV6 plugin.
+
+         The mapping is managed internally by the HC SRV6 plugin.
+         It is exposed as operational state data for debugging purposes.
+
+         Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.";
+
+    revision "2018-06-05" {
+        description "Initial revision.";
+    }
+
+    grouping srv6-locator-context-attributes {
+        container srv6-locator-mappings {
+            list srv6-locator-mapping {
+                key "name";
+
+                leaf name {
+                    type string;
+                    description "Srv6 locator name";
+                }
+
+                leaf prefix {
+                    type inet:ipv6-prefix;
+                    description "Locator represented by IPv6 address and locator length.";
+                }
+            }
+        }
+    }
+
+    augment /nc:contexts {
+        ext:augment-identifier "srv6-locator-context-augmentation";
+        uses srv6-locator-context-attributes;
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/Srv6Configuration.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/Srv6Configuration.java
index 8d23b1703..f11c730b1 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/Srv6Configuration.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/Srv6Configuration.java
@@ -19,17 +19,10 @@ package io.fd.hc2vpp.srv6;
 public class Srv6Configuration {
 
     /**
-     * Used to map Srv6 Sids to locator length values
+     * Provides default locator length value for locator context. Since local SID is represented as IPv6 address, which
+     * represents LOCATOR+FUNCTION. This address with total length of 128 bits is divided into these parts by defining
+     * locator length. Because ietf-srv6-types model defines local SIds OpCode (function) as uint32, it leaves 96 bits
+     * for the locator part. This way we can use full range of the IPv6 address without loosing any bits.
      */
-    public static final String LOCATOR_CONTEXT = "locator-context";
-
-    /**
-     * Locator length context child name for locator length
-     */
-    public static final String LOCATOR_LENGTH = "locator-length";
-
-    /**
-     * Locator length context child name for locator length
-     */
-    public static final String LOCATOR_IPV6_ADDRESS = "locator-ipv6-address";
+    public static final Integer DEFAULT_LOCATOR_LENGTH = 96;
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/Srv6Module.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/Srv6Module.java
index 5dd3e2097..ec91b2133 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/Srv6Module.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/Srv6Module.java
@@ -16,12 +16,20 @@
 
 package io.fd.hc2vpp.srv6;
 
+import static io.fd.hc2vpp.srv6.Srv6Configuration.DEFAULT_LOCATOR_LENGTH;
+
 import com.google.inject.AbstractModule;
 import com.google.inject.Singleton;
 import com.google.inject.multibindings.Multibinder;
+import io.fd.hc2vpp.srv6.read.Srv6ReaderFactory;
+import io.fd.hc2vpp.srv6.util.LocatorContextManager;
+import io.fd.hc2vpp.srv6.util.LocatorContextManagerImpl;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionReadBindingRegistry;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionReadBindingRegistryProvider;
 import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionWriteBindingRegistry;
 import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionWriteBindingRegistryProvider;
 import io.fd.hc2vpp.srv6.write.Srv6WriterFactory;
+import io.fd.honeycomb.translate.read.ReaderFactory;
 import io.fd.honeycomb.translate.write.WriterFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -36,6 +44,11 @@ public class Srv6Module extends AbstractModule {
         LOG.info("Reading SRv6 configuration");
         requestInjection(Srv6Configuration.class);
 
+        bind(LocatorContextManager.class).toInstance(new LocatorContextManagerImpl(DEFAULT_LOCATOR_LENGTH));
+
+        bind(LocalSidFunctionReadBindingRegistry.class).toProvider(LocalSidFunctionReadBindingRegistryProvider.class)
+                .in(Singleton.class);
+
         bind(LocalSidFunctionWriteBindingRegistry.class).toProvider(LocalSidFunctionWriteBindingRegistryProvider.class)
                 .in(Singleton.class);
 
@@ -43,6 +56,10 @@ public class Srv6Module extends AbstractModule {
         final Multibinder<WriterFactory> writeBinder = Multibinder.newSetBinder(binder(), WriterFactory.class);
         writeBinder.addBinding().to(Srv6WriterFactory.class);
 
+        LOG.info("Injecting SRv6 readers");
+        final Multibinder<ReaderFactory> readerBinder = Multibinder.newSetBinder(binder(), ReaderFactory.class);
+        readerBinder.addBinding().to(Srv6ReaderFactory.class);
+
         LOG.info("SRv6 module successfully configured");
     }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/ReadRequest.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/ReadRequest.java
new file mode 100644
index 000000000..1b366fd15
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/ReadRequest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read;
+
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import java.util.List;
+import javax.annotation.Nonnull;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
+import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Represents common interface for read requests
+ *
+ * @param <T> type class to be read
+ * @param <K> key class of read type
+ * @param <B> builder class for read type
+ */
+public interface ReadRequest<T extends DataObject & Identifiable<K>, K extends Identifier<T>, B extends Builder<T>> {
+
+    /**
+     * Provide list of keys for specified type
+     *
+     * @param identifier identifies path to DataObject class of specified type
+     * @param ctx        read context holds modification cache and mapping context
+     * @return list of keys for specified type
+     * @throws ReadFailedException when read error occurs
+     */
+    @Nonnull
+    List<K> readAllKeys(@Nonnull final InstanceIdentifier<T> identifier, @Nonnull final ReadContext ctx) throws
+            ReadFailedException;
+
+    /**
+     * Reads one specific value
+     *
+     * @param identifier identifies path to DataObject class of specified type
+     * @param ctx        read context holds modification cache and mapping context
+     * @param builder    builder for particular type which will hold actual data
+     * @throws ReadFailedException when read error occurs
+     */
+    void readSpecific(@Nonnull final InstanceIdentifier<T> identifier, @Nonnull final ReadContext ctx,
+                      @Nonnull B builder)
+            throws ReadFailedException;
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/Srv6ReaderFactory.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/Srv6ReaderFactory.java
new file mode 100644
index 000000000..312280dce
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/Srv6ReaderFactory.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read;
+
+import com.google.inject.Inject;
+import io.fd.hc2vpp.srv6.Srv6IIds;
+import io.fd.hc2vpp.srv6.read.sid.LocatorCustomizer;
+import io.fd.hc2vpp.srv6.read.sid.SidCustomizer;
+import io.fd.hc2vpp.srv6.util.LocatorContextManager;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionReadBindingRegistry;
+import io.fd.honeycomb.translate.impl.read.GenericInitListReader;
+import io.fd.honeycomb.translate.read.ReaderFactory;
+import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.Locator1Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.routing.srv6.locators.locator.StaticBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.routing.srv6.locators.locator._static.LocalSidsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.Routing1Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.routing.Srv6Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.LocatorsBuilder;
+
+public class Srv6ReaderFactory implements ReaderFactory {
+
+    @Inject
+    private FutureJVppCore vppApi;
+
+    @Inject
+    private LocalSidFunctionReadBindingRegistry bindingRegistry;
+
+    @Inject
+    protected LocatorContextManager locatorContext;
+
+    @Override
+    public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) {
+
+        registry.addStructuralReader(Srv6IIds.RT_RT1_AUG, Routing1Builder.class);
+        registry.addStructuralReader(Srv6IIds.RT_SRV6, Srv6Builder.class);
+        registry.addStructuralReader(Srv6IIds.RT_SRV6_LOCATORS, LocatorsBuilder.class);
+        registry.addStructuralReader(Srv6IIds.RT_SRV6_LOCS_LOC_AUG, Locator1Builder.class);
+        registry.addStructuralReader(Srv6IIds.RT_SRV6_LOCS_LOC_STATIC, StaticBuilder.class);
+        registry.addStructuralReader(Srv6IIds.RT_SRV6_LOCS_LOC_ST_LOCALSIDS, LocalSidsBuilder.class);
+
+        registry.add(new GenericInitListReader<>(Srv6IIds.RT_SRV6_LOCS_LOCATOR,
+                new LocatorCustomizer(vppApi, locatorContext)));
+        registry.add(new GenericInitListReader<>(Srv6IIds.RT_SRV6_LOCS_LOC_ST_LS_SID,
+                new SidCustomizer(vppApi, bindingRegistry, locatorContext)));
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/LocatorCustomizer.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/LocatorCustomizer.java
new file mode 100644
index 000000000..3fc33988c
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/LocatorCustomizer.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read.sid;
+
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.srv6.read.sid.request.LocatorReadRequest;
+import io.fd.hc2vpp.srv6.util.LocatorContextManager;
+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.vpp.jvpp.core.future.FutureJVppCore;
+import java.util.List;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.LocatorsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.Locator;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorKey;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class LocatorCustomizer extends FutureJVppCustomizer
+        implements InitializingListReaderCustomizer<Locator, LocatorKey, LocatorBuilder> {
+
+    private final LocatorContextManager locatorContext;
+
+    public LocatorCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
+                             @Nonnull final LocatorContextManager locatorContext) {
+        super(futureJVppCore);
+        this.locatorContext = locatorContext;
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<Locator> instanceIdentifier,
+                                                  @Nonnull Locator locator,
+                                                  @Nonnull ReadContext readContext) {
+        return Initialized.create(instanceIdentifier, locator);
+    }
+
+    @Nonnull
+    @Override
+    public List<LocatorKey> getAllIds(@Nonnull InstanceIdentifier<Locator> instanceIdentifier,
+                                      @Nonnull ReadContext readContext) throws ReadFailedException {
+        return new LocatorReadRequest(getFutureJVpp(), locatorContext).readAllKeys(instanceIdentifier, readContext);
+    }
+
+    @Override
+    public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<Locator> locators) {
+        ((LocatorsBuilder) builder).setLocator(locators);
+    }
+
+    @Nonnull
+    @Override
+    public LocatorBuilder getBuilder(@Nonnull InstanceIdentifier<Locator> instanceIdentifier) {
+        return new LocatorBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull InstanceIdentifier<Locator> instanceIdentifier,
+                                      @Nonnull LocatorBuilder locatorBuilder,
+                                      @Nonnull ReadContext readContext) throws ReadFailedException {
+        new LocatorReadRequest(getFutureJVpp(), locatorContext)
+                .readSpecific(instanceIdentifier, readContext, locatorBuilder);
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/SidCustomizer.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/SidCustomizer.java
new file mode 100644
index 000000000..58beb9df3
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/SidCustomizer.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read.sid;
+
+import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.srv6.read.sid.request.LocalSidReadRequest;
+import io.fd.hc2vpp.srv6.util.LocatorContextManager;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionReadBindingRegistry;
+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.vpp.jvpp.core.future.FutureJVppCore;
+import java.util.List;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.routing.srv6.locators.locator._static.LocalSidsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidKey;
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class SidCustomizer extends FutureJVppCustomizer
+        implements InitializingListReaderCustomizer<Sid, SidKey, SidBuilder> {
+
+    private final LocalSidFunctionReadBindingRegistry registry;
+    private final LocatorContextManager locatorContext;
+
+    public SidCustomizer(@Nonnull final FutureJVppCore futureJVppCore, LocalSidFunctionReadBindingRegistry registry,
+                         @Nonnull final LocatorContextManager locatorContext) {
+        super(futureJVppCore);
+        this.registry = registry;
+        this.locatorContext = locatorContext;
+    }
+
+    @Nonnull
+    @Override
+    public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<Sid> instanceIdentifier,
+                                                  @Nonnull Sid sid,
+                                                  @Nonnull ReadContext readContext) {
+        return Initialized.create(instanceIdentifier, sid);
+    }
+
+    @Nonnull
+    @Override
+    public List<SidKey> getAllIds(@Nonnull InstanceIdentifier<Sid> instanceIdentifier, @Nonnull ReadContext readContext)
+            throws ReadFailedException {
+
+        return new LocalSidReadRequest(getFutureJVpp(), locatorContext, registry)
+                .readAllKeys(instanceIdentifier, readContext);
+    }
+
+    @Override
+    public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<Sid> list) {
+        ((LocalSidsBuilder) builder).setSid(list);
+    }
+
+    @Nonnull
+    @Override
+    public SidBuilder getBuilder(@Nonnull InstanceIdentifier<Sid> instanceIdentifier) {
+        return new SidBuilder();
+    }
+
+    @Override
+    public void readCurrentAttributes(@Nonnull InstanceIdentifier<Sid> instanceIdentifier,
+                                      @Nonnull SidBuilder sidBuilder,
+                                      @Nonnull ReadContext readContext) throws ReadFailedException {
+        LocalSidReadRequest readRequest = new LocalSidReadRequest(getFutureJVpp(), locatorContext,
+                registry);
+        readRequest.readSpecific(instanceIdentifier, readContext, sidBuilder);
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/request/LocalSidReadRequest.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/request/LocalSidReadRequest.java
new file mode 100644
index 000000000..e1bd8d073
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/request/LocalSidReadRequest.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read.sid.request;
+
+import static java.lang.Integer.parseInt;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import com.googlecode.ipv6.IPv6NetworkMask;
+import io.fd.hc2vpp.srv6.read.ReadRequest;
+import io.fd.hc2vpp.srv6.util.JVppRequest;
+import io.fd.hc2vpp.srv6.util.LocatorContextManager;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionReadBindingRegistry;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+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.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.Locator;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDT4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDT6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDX2;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDX4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDX6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6FuncOpcodeUnreserved;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class LocalSidReadRequest extends JVppRequest implements ReadRequest<Sid, SidKey, SidBuilder> {
+
+    private static final Map<Integer, Class<? extends Srv6EndpointType>> VPP_END_FUNC_REGISTER;
+    private static final SrLocalsidsDump STATIC_DUMP_REQUEST = new SrLocalsidsDump();
+    private static final SrLocalsidsDetailsReplyDump STATIC_EMPTY_REPLY = new SrLocalsidsDetailsReplyDump();
+
+    static {
+        VPP_END_FUNC_REGISTER = ImmutableMap.<Integer, Class<? extends Srv6EndpointType>>builder()
+                .put(1, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.End.class)
+                .put(2, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndX.class)
+                .put(3, org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndT.class)
+                .put(5, EndDX2.class)
+                .put(6, EndDX6.class)
+                .put(7, EndDX4.class)
+                .put(8, EndDT6.class)
+                .put(9, EndDT4.class)
+                .build();
+    }
+
+    private final DumpCacheManager<SrLocalsidsDetailsReplyDump, Void> dumpManager;
+    private final LocatorContextManager locatorContext;
+    private final LocalSidFunctionReadBindingRegistry registry;
+
+    public LocalSidReadRequest(final FutureJVppCore api,
+                               final LocatorContextManager locatorContext,
+                               final LocalSidFunctionReadBindingRegistry registry) {
+        super(api);
+        this.dumpManager = new DumpCacheManager.DumpCacheManagerBuilder<SrLocalsidsDetailsReplyDump, Void>()
+                .acceptOnly(SrLocalsidsDetailsReplyDump.class)
+                .withExecutor((identifier, params) -> getReplyForRead(
+                        api.srLocalsidsDump(STATIC_DUMP_REQUEST).toCompletableFuture(), identifier))
+                .build();
+        this.locatorContext = locatorContext;
+        this.registry = registry;
+    }
+
+    /**
+     * Extracts Operational code (SRv6 endpoint function) from provided SID value. SID value consists of two parts.
+     * First part is Locator defined by its IPv6 address and length (stored in mappingContext referenced
+     * by locator name). Second part is Operational code (endpoint function). Locator length(number of bits) divides SID
+     * address to bits used for locator value and bits used for endpoint function.
+     *
+     * @see <a href="https://tools.ietf.org/html/draft-filsfils-spring-srv6-network-programming-04">
+     *     SRv6 network programming (SRv6 Segment)</a>
+     * @see <a href="https://tools.ietf.org/html/draft-raza-spring-srv6-yang-01">
+     *      *     SRv6 Yang (SRv6 Types)</a>
+     *
+     * @param sid provided SRv6 SIDs IPv6 address
+     * @param mappingContext mapping context which stores mapping for locator length
+     * @param locName locator name used as a key to retrieve locator length from mapping context
+     * @return operational code (endpoint function) of SRv6 SID address
+     */
+    private Srv6FuncOpcodeUnreserved extractOpCode(Ipv6Address sid, MappingContext mappingContext,
+                                                   final String locName) {
+        int locLength = LocatorContextManager.parseLength(locatorContext.getLocator(locName, mappingContext));
+        com.googlecode.ipv6.IPv6Address ip = com.googlecode.ipv6.IPv6Address.fromString(sid.getValue());
+        IPv6NetworkMask mask = IPv6NetworkMask.fromPrefixLength(locLength);
+        com.googlecode.ipv6.IPv6Address locator = ip.maskWithNetworkMask(mask);
+
+        long function = ip.toBigInteger().subtract(locator.toBigInteger()).longValue();
+
+        return new Srv6FuncOpcodeUnreserved(function);
+    }
+
+    @Override
+    @Nonnull
+    public List<SidKey> readAllKeys(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx)
+            throws ReadFailedException {
+        final LocatorKey key = Preconditions.checkNotNull(identifier.firstKeyOf(Locator.class),
+                "Identifier does not have %s ", LocatorKey.class);
+        String locator = key.getName();
+
+        return dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srLocalsidsDetails
+                .stream()
+                .filter(detail -> arrayToIpv6AddressNoZone(detail.addr.addr).getValue().contains(locator))
+                .map(srLocalsidsDetails -> extractOpCode(arrayToIpv6AddressNoZone(srLocalsidsDetails.addr.addr),
+                        ctx.getMappingContext(), locator))
+                .map(SidKey::new)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public void readSpecific(@Nonnull InstanceIdentifier<Sid> identifier, @Nonnull ReadContext ctx,
+                             @Nonnull SidBuilder builder)
+            throws ReadFailedException {
+        final SidKey sidKey = Preconditions.checkNotNull(identifier.firstKeyOf(Sid.class),
+                "Identifier does not contain %s ", SidKey.class);
+        final LocatorKey locatorKey = Preconditions.checkNotNull(identifier.firstKeyOf(Locator.class),
+                "Identifier does not contain %s ", Locator.class);
+
+        // VPP stores SID address as whole without defining locator and function parts (or locator length).
+        // It is necessary to split SID address to locator and function (operational code), because that is how SID
+        // is identified in model. Currently we use locatorContext to store locator length, so it is possible to split
+        // SID address back to locator (used as LocatorKey) and function (used as SidKey) or to construct SID from
+        // from locator and function (opCode)
+        Integer locLength = LocatorContextManager
+                .parseLength(locatorContext.getLocator(locatorKey.getName(), ctx.getMappingContext()));
+        Ipv6Address locator = LocatorContextManager
+                .parseLocator(locatorContext.getLocator(locatorKey.getName(), ctx.getMappingContext()));
+
+        Ipv6Address sidAddress =
+                parseSrv6SidAddress(locator.getValue(), locLength.toString(), sidKey.getOpcode().getValue());
+
+        dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srLocalsidsDetails
+                .stream()
+                .filter(detail -> Arrays.equals(detail.addr.addr, ipv6AddressNoZoneToArray(sidAddress)))
+                .findFirst()
+                .ifPresent(detail -> bindLocalSid(detail, ctx, locatorKey.getName(), sidAddress, builder));
+    }
+
+    private Ipv6Address parseSrv6SidAddress(final String locatorIp, final String locatorLength, final Long opcode) {
+        com.googlecode.ipv6.IPv6Address ip =
+                com.googlecode.ipv6.IPv6Address.fromString(locatorIp);
+        IPv6NetworkMask mask = IPv6NetworkMask.fromPrefixLength(parseInt(locatorLength));
+        com.googlecode.ipv6.IPv6Address srv6Sid = ip.maskWithNetworkMask(mask);
+        return new Ipv6Address(srv6Sid.add(opcode.intValue()).toString());
+    }
+
+    private void bindLocalSid(final SrLocalsidsDetails detail, final ReadContext readContext, final String locName,
+                              final Ipv6Address sidAddress, final SidBuilder builder) {
+        Class<? extends Srv6EndpointType> behaviorType = parseEndBehaviorType(detail.behavior);
+        Srv6FuncOpcodeUnreserved opcode = extractOpCode(sidAddress, readContext.getMappingContext(), locName);
+        builder.setEndBehaviorType(behaviorType).setKey(new SidKey(opcode)).setOpcode(opcode);
+        parseEndFunction(builder, detail, readContext);
+    }
+
+    private void parseEndFunction(SidBuilder builder, SrLocalsidsDetails detail, ReadContext readContext) {
+        registry.bind(detail, readContext, builder);
+    }
+
+    private Class<? extends Srv6EndpointType> parseEndBehaviorType(short behavior) {
+        return VPP_END_FUNC_REGISTER.get((int) behavior);
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/request/LocatorReadRequest.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/request/LocatorReadRequest.java
new file mode 100644
index 000000000..ff6316b01
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/read/sid/request/LocatorReadRequest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read.sid.request;
+
+import static io.fd.hc2vpp.srv6.Srv6Configuration.DEFAULT_LOCATOR_LENGTH;
+
+import com.google.common.base.Preconditions;
+import com.googlecode.ipv6.IPv6NetworkMask;
+import io.fd.hc2vpp.srv6.read.ReadRequest;
+import io.fd.hc2vpp.srv6.util.JVppRequest;
+import io.fd.hc2vpp.srv6.util.LocatorContextManager;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.hc2vpp.params.xml.ns.yang.vpp.ietf.srv6.base.rev180613.VppSrv6FibLocatorAugment;
+import org.opendaylight.yang.gen.v1.urn.hc2vpp.params.xml.ns.yang.vpp.ietf.srv6.base.rev180613.VppSrv6FibLocatorAugmentBuilder;
+import org.opendaylight.yang.gen.v1.urn.hc2vpp.params.xml.ns.yang.vpp.ietf.srv6.base.rev180613.vpp.srv6.fib.FibTableBuilder;
+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.inet.types.rev130715.Ipv6AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.Locator;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.locator.PrefixBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6LocatorLen;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.fib.table.management.rev180521.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.fib.table.management.rev180521.VniReference;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class LocatorReadRequest extends JVppRequest implements ReadRequest<Locator, LocatorKey, LocatorBuilder> {
+
+    private static final SrLocalsidsDump STATIC_DUMP_REQUEST = new SrLocalsidsDump();
+    private static final SrLocalsidsDetailsReplyDump STATIC_EMPTY_REPLY = new SrLocalsidsDetailsReplyDump();
+    private final DumpCacheManager<SrLocalsidsDetailsReplyDump, Void> dumpManager;
+    private final LocatorContextManager locatorCtx;
+
+    public LocatorReadRequest(final FutureJVppCore api, LocatorContextManager locatorCtx) {
+        super(api);
+        this.dumpManager = new DumpCacheManager.DumpCacheManagerBuilder<SrLocalsidsDetailsReplyDump, Void>()
+                .acceptOnly(SrLocalsidsDetailsReplyDump.class)
+                .withExecutor((identifier, params) -> getReplyForRead(
+                        api.srLocalsidsDump(STATIC_DUMP_REQUEST).toCompletableFuture(), identifier))
+                .build();
+        this.locatorCtx = locatorCtx;
+    }
+
+    private Ipv6Address extractLocator(Ipv6Address sid, final MappingContext mappingContext, String locName) {
+        /*
+        * TODO(HC2VPP-353): VPP does not support locator length, therefore it is necessary to use default value for
+        * locator length, if there is no other way of getting the value (e.g. hc2vpp starts with configuration already
+        * present in VPP).
+        * */
+        int locLength = locName == null
+                ? DEFAULT_LOCATOR_LENGTH
+                : LocatorContextManager.parseLength(locatorCtx.getLocator(locName, mappingContext));
+        com.googlecode.ipv6.IPv6Address ip = com.googlecode.ipv6.IPv6Address.fromString(sid.getValue());
+        IPv6NetworkMask mask = IPv6NetworkMask.fromPrefixLength(locLength);
+        // strip function part if present
+        ip = ip.maskWithNetworkMask(mask);
+        return new Ipv6AddressNoZone(ip.toString());
+    }
+
+    @Override
+    @Nonnull
+    public List<LocatorKey> readAllKeys(@Nonnull final InstanceIdentifier<Locator> identifier,
+                                        @Nonnull final ReadContext ctx)
+            throws ReadFailedException {
+        return dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srLocalsidsDetails
+                .stream()
+                .map(srLocalsidsDetails -> extractLocator(arrayToIpv6AddressNoZone(srLocalsidsDetails.addr.addr),
+                        ctx.getMappingContext(), null).getValue())
+                .map(LocatorKey::new)
+                .distinct()
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public void readSpecific(@Nonnull final InstanceIdentifier<Locator> identifier, @Nonnull final ReadContext ctx,
+                             @Nonnull LocatorBuilder builder) throws ReadFailedException {
+        final LocatorKey key = Preconditions.checkNotNull(identifier.firstKeyOf(Locator.class),
+                "Identifier does not have %s ", LocatorKey.class);
+        String locator = key.getName();
+
+        dumpManager.getDump(identifier, ctx.getModificationCache()).or(STATIC_EMPTY_REPLY).srLocalsidsDetails
+                .stream()
+                .filter(detail -> arrayToIpv6AddressNoZone(detail.addr.addr).getValue().contains(locator))
+                .findFirst()
+                .ifPresent(srLocalsidsDetails -> bindLocalSid(srLocalsidsDetails, ctx.getMappingContext(), locator,
+                        builder));
+    }
+
+    private void bindLocalSid(final SrLocalsidsDetails detail, final MappingContext mappingContext,
+                              final String locName, LocatorBuilder builder) {
+        Ipv6Address locator = extractLocator(arrayToIpv6AddressNoZone(detail.addr.addr), mappingContext, locName);
+        int locLength = LocatorContextManager.parseLength(locatorCtx.getLocator(locName, mappingContext));
+
+        builder.setKey(new LocatorKey(locator.getValue()))
+                .setName(locator.getValue())
+                .setPrefix(
+                        new PrefixBuilder()
+                                .setAddress(locator)
+                                .setLength(new Srv6LocatorLen((short) locLength))
+                                .build())
+                .setIsDefault(false)
+                .setEnable(true)
+                .addAugmentation(VppSrv6FibLocatorAugment.class, new VppSrv6FibLocatorAugmentBuilder()
+                        .setFibTable(new FibTableBuilder()
+                                .setAddressFamily(Ipv6.class)
+                                .setTableId(new VniReference(Integer.toUnsignedLong(detail.fibTable)))
+                                .build())
+                        .build());
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/LocatorContextManager.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/LocatorContextManager.java
new file mode 100644
index 000000000..6241ae8e3
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/LocatorContextManager.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.util;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import io.fd.honeycomb.translate.MappingContext;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.annotation.Nonnull;
+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.inet.types.rev130715.Ipv6Prefix;
+
+/**
+ * Manages metadata for SRv6 plugin
+ */
+public interface LocatorContextManager {
+    String GROUP_IP = "ip";
+    String GROUP_PREFIX = "prefix";
+    Pattern IP_PREFIX_PATTERN = Pattern.compile("(?<ip>\\S.*)/(?<prefix>\\d{1,3})");
+
+    /**
+     * Creates metadata for locator. Existing mapping is overwritten if exists.
+     *
+     * @param name       locator name
+     * @param ipv6Prefix locator with locator length in form of Ipv6Prefix
+     * @param ctx        mapping context providing context data for current transaction
+     */
+    void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix, @Nonnull final MappingContext ctx);
+
+    /**
+     * Check whether metadata for given locator is present.
+     *
+     * @param name locator name
+     * @param ctx  mapping context providing context data for current transaction
+     * @return true if present, false otherwise
+     */
+    boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx);
+
+    /**
+     * Retrieves locator IPv6 prefix for given locator IPv6 address. If not present, artificial name will be generated.
+     *
+     * @param name locator name
+     * @param ctx  mapping context providing context data for current transaction
+     * @return Locator prefix matching supplied locator address
+     */
+    Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx);
+
+    /**
+     * Removes locator metadata from current context.
+     *
+     * @param name locator name
+     * @param ctx  mapping context providing context data for current transaction
+     */
+    void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx);
+
+    static Integer parseLength(@Nonnull final Ipv6Prefix prefix) {
+        Matcher matcher = IP_PREFIX_PATTERN.matcher(prefix.getValue());
+        checkArgument(matcher.matches(), "Could`t parse Locator length: {}", prefix);
+        return Integer.parseInt(matcher.group(GROUP_PREFIX));
+    }
+
+    static Ipv6Address parseLocator(@Nonnull final Ipv6Prefix prefix) {
+        Matcher matcher = IP_PREFIX_PATTERN.matcher(prefix.getValue());
+        checkArgument(matcher.matches(), "Could`t parse Locator: {}", prefix);
+        return new Ipv6Address(matcher.group(GROUP_IP));
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/LocatorContextManagerImpl.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/LocatorContextManagerImpl.java
new file mode 100644
index 000000000..aba852dde
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/LocatorContextManagerImpl.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.util;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.MappingContext;
+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.ThreadSafe;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.locator.context.rev180605.Srv6LocatorContextAugmentation;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.locator.context.rev180605.srv6.locator.context.attributes.Srv6LocatorMappings;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.locator.context.rev180605.srv6.locator.context.attributes.srv6.locator.mappings.Srv6LocatorMapping;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.locator.context.rev180605.srv6.locator.context.attributes.srv6.locator.mappings.Srv6LocatorMappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.locator.context.rev180605.srv6.locator.context.attributes.srv6.locator.mappings.Srv6LocatorMappingKey;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.Contexts;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+
+/**
+ * Facade on top of {@link MappingContext} that manages {@link Srv6LocatorMappings}.
+ */
+@ThreadSafe
+public final class LocatorContextManagerImpl implements LocatorContextManager {
+    private static final String SLASH = "/";
+    private final InstanceIdentifier<Srv6LocatorMappings> ctxIid;
+    private final Integer defaultLocatorLength;
+
+    public LocatorContextManagerImpl(@Nonnull final Integer defaultLocatorLength) {
+        checkArgument(defaultLocatorLength > 0 && defaultLocatorLength < 128,
+                "defaultLocatorLength is out of range(1-127).");
+        this.defaultLocatorLength = checkNotNull(defaultLocatorLength, "defaultLocatorLength should not be null");
+
+        this.ctxIid = InstanceIdentifier.create(Contexts.class)
+                .augmentation(Srv6LocatorContextAugmentation.class)
+                .child(Srv6LocatorMappings.class);
+    }
+
+    @Override
+    public void addLocator(@Nonnull final String name, @Nonnull Ipv6Prefix ipv6Prefix,
+                           @Nonnull final MappingContext ctx) {
+        final KeyedInstanceIdentifier<Srv6LocatorMapping, Srv6LocatorMappingKey> mappingIid = getLocatorIid(name);
+        final Srv6LocatorMappingBuilder builder = new Srv6LocatorMappingBuilder()
+                .setKey(new Srv6LocatorMappingKey(name)).setPrefix(ipv6Prefix).setName(name);
+        ctx.put(mappingIid, builder.build());
+    }
+
+    @Override
+    public boolean containsLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) {
+        final Optional<Srv6LocatorMapping> read = ctx.read(getLocatorIid(name));
+        return read.isPresent();
+    }
+
+    @Override
+    public Ipv6Prefix getLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) {
+        final Optional<Srv6LocatorMapping> read = ctx.read(getLocatorIid(name));
+        if (read.isPresent()) {
+            return read.get().getPrefix();
+        }
+
+        // construct artificial mapping with default locator length
+        Ipv6Prefix ipv6Prefix = new Ipv6Prefix(getArtificialName(name));
+        addLocator(getArtificialName(name), ipv6Prefix, ctx);
+        return ipv6Prefix;
+    }
+
+    @Override
+    public void removeLocator(@Nonnull final String name, @Nonnull final MappingContext ctx) {
+        ctx.delete(getLocatorIid(name));
+    }
+
+    private KeyedInstanceIdentifier<Srv6LocatorMapping, Srv6LocatorMappingKey> getLocatorIid(
+            @Nonnull final String locator) {
+        return ctxIid.child(Srv6LocatorMapping.class, new Srv6LocatorMappingKey(locator));
+    }
+
+    private synchronized String getArtificialName(String name) {
+        return name + SLASH + defaultLocatorLength;
+    }
+
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBindingRegistry.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBindingRegistry.java
index d56656fb9..361f042a8 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBindingRegistry.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBindingRegistry.java
@@ -28,23 +28,40 @@ import org.slf4j.LoggerFactory;
 abstract class LocalSidFunctionBindingRegistry<T extends LocalSidFunctionRequest> {
 
     private static final Logger LOG = LoggerFactory.getLogger(LocalSidFunctionBindingRegistry.class);
-    final List<LocalSidFunctionBinder<T>> binders;
+    final List<LocalSidFunctionWriteBinder<T>> wBinders;
+    final List<LocalSidFunctionReadBinder> rBinders;
+
 
     LocalSidFunctionBindingRegistry() {
-        binders = new ArrayList<>();
+        wBinders = new ArrayList<>();
+        rBinders = new ArrayList<>();
+    }
+
+    @SuppressWarnings("unchecked")
+    public void registerWriteFunctionType(@Nonnull final LocalSidFunctionWriteBinder binder) {
+        checkNotNull(binder, "Cannot register null binder");
+        if (!isFunctionRegistered(binder)) {
+            wBinders.add(binder);
+        } else {
+            LOG.warn("Binder for class already registered. Canceling registration for {}.", binder);
+        }
+    }
+
+    private boolean isFunctionRegistered(@Nonnull final LocalSidFunctionWriteBinder binder) {
+        return wBinders.stream().parallel().anyMatch(locBinder -> locBinder.getClass().equals(binder.getClass()));
     }
 
     @SuppressWarnings("unchecked")
-    public void registerFunctionType(@Nonnull final LocalSidFunctionBinder binder) {
+    public void registerReadFunctionType(@Nonnull final LocalSidFunctionReadBinder binder) {
         checkNotNull(binder, "Cannot register null binder");
         if (!isFunctionRegistered(binder)) {
-            binders.add(binder);
+            rBinders.add(binder);
         } else {
             LOG.warn("Binder for class already registered. Canceling registration for {}.", binder);
         }
     }
 
-    private boolean isFunctionRegistered(@Nonnull final LocalSidFunctionBinder binder) {
-        return binders.stream().parallel().anyMatch(locBinder -> locBinder.getClass().equals(binder.getClass()));
+    private boolean isFunctionRegistered(@Nonnull final LocalSidFunctionReadBinder binder) {
+        return rBinders.stream().parallel().anyMatch(locBinder -> locBinder.getClass().equals(binder.getClass()));
     }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionReadBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionReadBinder.java
new file mode 100644
index 000000000..ab624fbf7
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionReadBinder.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.util.function;
+
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
+
+/**
+ * Binder interface, which is used to map local sid function requests from VPP to yang model data classes of
+ * local sid functions. It uses behavior function type integer value defined by VPP API, to find
+ * suitable binder. This value is translated to {@link Srv6EndpointType} in model, which represents the same endpoint
+ * function as defined by VPP API.
+ */
+public interface LocalSidFunctionReadBinder {
+
+    /**
+     * Translate data read From VPP to data defined by model
+     *
+     * @param data local sid details read from VPP
+     * @param ctx read context that contains modification cache and mapping chache
+     * @param builder builder for setting data
+     */
+    void translateFromDump(@Nonnull final SrLocalsidsDetails data, @Nonnull final ReadContext ctx,
+                           @Nonnull final SidBuilder builder);
+
+    /**
+     * Provide behavior function type integer value.
+     *
+     * @return integer value of behaviour function type as defined in VPP api
+     */
+    int getBehaviourFunctionType();
+
+    /**
+     * Checks whether this binder is able to process provided function from VPP
+     *
+     * @param functionCode integer value of behaviour function type as defined in VPP api
+     * @return true if endpoint function binder is able to process provided functionCode, false otherwise
+     */
+    default boolean canHandle(int functionCode) {
+        return getBehaviourFunctionType() == functionCode;
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionReadBindingRegistry.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionReadBindingRegistry.java
new file mode 100644
index 000000000..66586b9c2
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionReadBindingRegistry.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.util.function;
+
+import io.fd.hc2vpp.srv6.write.sid.request.LocalSidFunctionRequest;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.util.RWUtils;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
+import javax.annotation.Nonnull;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+
+public class LocalSidFunctionReadBindingRegistry<T extends LocalSidFunctionRequest>
+        extends LocalSidFunctionBindingRegistry<T> {
+
+    public void bind(@Nonnull final SrLocalsidsDetails details, @Nonnull final ReadContext ctx,
+                     @Nonnull final SidBuilder builder) {
+        rBinders.parallelStream()
+                .filter(localSidFunctionBinder -> localSidFunctionBinder.canHandle(details.behavior))
+                .collect(RWUtils.singleItemCollector())
+                .translateFromDump(details, ctx, builder);
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionReadBindingRegistryProvider.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionReadBindingRegistryProvider.java
new file mode 100644
index 000000000..40e305371
--- /dev/null
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionReadBindingRegistryProvider.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.util.function;
+
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.srv6.util.function.lookup.EndDT4FunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.lookup.EndDT6FunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.lookup.EndTFunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.nofunction.EndFunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.xconnect.EndDX2FunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.xconnect.EndDX4FunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.xconnect.EndDX6FunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.xconnect.EndXFunctionBinder;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import javax.inject.Named;
+
+public class LocalSidFunctionReadBindingRegistryProvider implements Provider<LocalSidFunctionReadBindingRegistry> {
+
+    @Inject
+    @Named("interface-context")
+    private NamingContext interfaceContext;
+
+    @Inject
+    private FutureJVppCore api;
+    private final LocalSidFunctionReadBindingRegistry registry = new LocalSidFunctionReadBindingRegistry();
+
+    @Override
+    public LocalSidFunctionReadBindingRegistry get() {
+        registry.registerReadFunctionType(new EndFunctionBinder(api));
+        registry.registerReadFunctionType(new EndTFunctionBinder(api));
+        registry.registerReadFunctionType(new EndDT4FunctionBinder(api));
+        registry.registerReadFunctionType(new EndDT6FunctionBinder(api));
+        registry.registerReadFunctionType(new EndXFunctionBinder(api, interfaceContext));
+        registry.registerReadFunctionType(new EndDX2FunctionBinder(api, interfaceContext));
+        registry.registerReadFunctionType(new EndDX4FunctionBinder(api, interfaceContext));
+        registry.registerReadFunctionType(new EndDX6FunctionBinder(api, interfaceContext));
+
+        return registry;
+    }
+}
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBinder.java
index e51ee5ac5..30c875f4c 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBinder.java
@@ -24,14 +24,14 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.
 
 /**
  * Binder interface, which is used to map yang model data classes of local sid functions to local sid function requests
- * used to configure endpoint functions on VPP. It uses behavior function type integer value defined by VPP API, to find
- * suitable binder. This value is translated to {@link Srv6EndpointType} in model, which represents the same endpoint
- * function as defined by VPP API.
+ * used to configure endpoint functions on VPP. It uses {@link Srv6EndpointType} class value, to find suitable binder.
+ * This value is translated to behavior function type integer value defined by VPP API, which represents the same
+ * function as defined by the model.
  *
  * @param <T> Type which extends general interface for {@link LocalSidFunctionRequest} and represents template binder
  *            that is used to process end function data represented by provided class type.
  */
-public interface LocalSidFunctionBinder<T extends LocalSidFunctionRequest> {
+public interface LocalSidFunctionWriteBinder<T extends LocalSidFunctionRequest> {
 
     /**
      * Binds request accordingly to type of function implemented by this interface
@@ -43,20 +43,14 @@ public interface LocalSidFunctionBinder<T extends LocalSidFunctionRequest> {
 
     /**
      * Provides Endpoint function type class.
+     *
      * @return Endpoint function class
      */
     @Nonnull
     Class<? extends Srv6EndpointType> getHandledFunctionType();
 
     /**
-     * Provide behavior function type integer value.
-     *
-     * @return integer value of behaviour function type as defined in VPP api
-     */
-    int getBehaviourFunctionType();
-
-    /**
-     * Checks whether binder can handle provided data
+     * Checks whether binder can handle provided Sid data from model
      *
      * @param data sid function data to be checked
      * @return true if function binder is able to process provided data, false otherwise
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBindingRegistry.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBindingRegistry.java
index b74a7668b..8558fb9af 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBindingRegistry.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBindingRegistry.java
@@ -26,7 +26,7 @@ public class LocalSidFunctionWriteBindingRegistry<T extends LocalSidFunctionRequ
         extends LocalSidFunctionBindingRegistry<T> {
 
     public LocalSidFunctionRequest bind(final Sid localSid, @Nonnull final WriteContext ctx) {
-        return binders.parallelStream()
+        return wBinders.parallelStream()
                 .filter(toLocalSidFunctionBinder -> toLocalSidFunctionBinder.canHandle(localSid))
                 .map(binder -> binder.createWriteRequestAndBind(localSid, ctx))
                 .collect(RWUtils.singleItemCollector());
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBindingRegistryProvider.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBindingRegistryProvider.java
index 20189b702..ead94c90f 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBindingRegistryProvider.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionWriteBindingRegistryProvider.java
@@ -42,14 +42,14 @@ public class LocalSidFunctionWriteBindingRegistryProvider implements Provider<Lo
 
     @Override
     public LocalSidFunctionWriteBindingRegistry get() {
-        registry.registerFunctionType(new EndFunctionBinder(api));
-        registry.registerFunctionType(new EndTFunctionBinder(api));
-        registry.registerFunctionType(new EndDT4FunctionBinder(api));
-        registry.registerFunctionType(new EndDT6FunctionBinder(api));
-        registry.registerFunctionType(new EndXFunctionBinder(api, interfaceContext));
-        registry.registerFunctionType(new EndDX2FunctionBinder(api, interfaceContext));
-        registry.registerFunctionType(new EndDX4FunctionBinder(api, interfaceContext));
-        registry.registerFunctionType(new EndDX6FunctionBinder(api, interfaceContext));
+        registry.registerWriteFunctionType(new EndFunctionBinder(api));
+        registry.registerWriteFunctionType(new EndTFunctionBinder(api));
+        registry.registerWriteFunctionType(new EndDT4FunctionBinder(api));
+        registry.registerWriteFunctionType(new EndDT6FunctionBinder(api));
+        registry.registerWriteFunctionType(new EndXFunctionBinder(api, interfaceContext));
+        registry.registerWriteFunctionType(new EndDX2FunctionBinder(api, interfaceContext));
+        registry.registerWriteFunctionType(new EndDX4FunctionBinder(api, interfaceContext));
+        registry.registerWriteFunctionType(new EndDX6FunctionBinder(api, interfaceContext));
 
         return registry;
     }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndDT4FunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndDT4FunctionBinder.java
index e8ea22419..67b739161 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndDT4FunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndDT4FunctionBinder.java
@@ -18,15 +18,22 @@ package io.fd.hc2vpp.srv6.util.function.lookup;
 
 import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.srv6.write.sid.request.TableLookupLocalSidRequest;
+import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndDt4Builder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDT4;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.TableId;
 
 public class EndDT4FunctionBinder extends TableLookupFunctionBinder {
 
+    private static final int END_DT4_FUNCTION_VALUE = 9;
+
     public EndDT4FunctionBinder(@Nonnull final FutureJVppCore api) {
         super(api);
     }
@@ -42,8 +49,20 @@ public class EndDT4FunctionBinder extends TableLookupFunctionBinder {
     }
 
     @Override
+    public void translateFromDump(@Nonnull SrLocalsidsDetails data, @Nonnull ReadContext ctx,
+                                  @Nonnull final SidBuilder builder) {
+        builder.setEndDt4(new EndDt4Builder()
+                .setLookupTableIpv4(new TableId(Integer.toUnsignedLong(data.xconnectIfaceOrVrfTable))).build());
+    }
+
+    @Override
     @Nonnull
     public Class<? extends Srv6EndpointType> getHandledFunctionType() {
         return EndDT4.class;
     }
+
+    @Override
+    public int getBehaviourFunctionType() {
+        return END_DT4_FUNCTION_VALUE;
+    }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndDT6FunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndDT6FunctionBinder.java
index 01e6c6bb2..d9782a1af 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndDT6FunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndDT6FunctionBinder.java
@@ -18,15 +18,22 @@ package io.fd.hc2vpp.srv6.util.function.lookup;
 
 import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.srv6.write.sid.request.TableLookupLocalSidRequest;
+import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndDt6Builder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDT6;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.TableId;
 
 public class EndDT6FunctionBinder extends TableLookupFunctionBinder {
 
+    private static final int END_DT6_FUNCTION_VALUE = 8;
+
     public EndDT6FunctionBinder(@Nonnull final FutureJVppCore api) {
         super(api);
     }
@@ -42,8 +49,20 @@ public class EndDT6FunctionBinder extends TableLookupFunctionBinder {
     }
 
     @Override
+    public void translateFromDump(@Nonnull SrLocalsidsDetails data, @Nonnull ReadContext ctx,
+                                  @Nonnull final SidBuilder builder) {
+        builder.setEndDt6(new EndDt6Builder()
+                .setLookupTableIpv6(new TableId(Integer.toUnsignedLong(data.xconnectIfaceOrVrfTable))).build());
+    }
+
+    @Override
     @Nonnull
     public Class<? extends Srv6EndpointType> getHandledFunctionType() {
         return EndDT6.class;
     }
+
+    @Override
+    public int getBehaviourFunctionType() {
+        return END_DT6_FUNCTION_VALUE;
+    }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndTFunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndTFunctionBinder.java
index 13a2d3bc7..cd9a37c48 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndTFunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/EndTFunctionBinder.java
@@ -18,14 +18,22 @@ package io.fd.hc2vpp.srv6.util.function.lookup;
 
 import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.srv6.write.sid.request.TableLookupLocalSidRequest;
+import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndTBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndT;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.TableId;
 
 public class EndTFunctionBinder extends TableLookupFunctionBinder {
 
+    private static final int END_T_FUNCTION_VALUE = 3;
+
     public EndTFunctionBinder(@Nonnull FutureJVppCore api) {
         super(api);
     }
@@ -40,8 +48,21 @@ public class EndTFunctionBinder extends TableLookupFunctionBinder {
     }
 
     @Override
+    public void translateFromDump(@Nonnull SrLocalsidsDetails data, @Nonnull ReadContext ctx,
+                                  @Nonnull final SidBuilder builder) {
+        builder.setEndT(
+                new EndTBuilder().setLookupTableIpv6(new TableId(Integer.toUnsignedLong(data.xconnectIfaceOrVrfTable)))
+                        .build());
+    }
+
+    @Override
     @Nonnull
     public Class<? extends Srv6EndpointType> getHandledFunctionType() {
-        return org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndT.class;
+        return EndT.class;
+    }
+
+    @Override
+    public int getBehaviourFunctionType() {
+        return END_T_FUNCTION_VALUE;
     }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/TableLookupFunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/TableLookupFunctionBinder.java
index 8e6ab4f40..a775a78db 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/TableLookupFunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/lookup/TableLookupFunctionBinder.java
@@ -16,21 +16,14 @@
 
 package io.fd.hc2vpp.srv6.util.function.lookup;
 
-import static com.google.common.base.Preconditions.checkState;
-
-import com.google.common.collect.ImmutableMap;
 import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
 import io.fd.hc2vpp.fib.management.FibManagementIIds;
-import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionReadBinder;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionWriteBinder;
 import io.fd.hc2vpp.srv6.write.sid.request.TableLookupLocalSidRequest;
 import io.fd.honeycomb.translate.write.WriteContext;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.Map;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDT4;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDT6;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndT;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.fib.table.management.rev180521.AddressFamilyIdentity;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.fib.table.management.rev180521.Ipv4;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.fib.table.management.rev180521.Ipv6;
@@ -40,18 +33,10 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.fib.
 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 
 abstract class TableLookupFunctionBinder extends FutureJVppCustomizer
-        implements LocalSidFunctionBinder<TableLookupLocalSidRequest> {
-
-    private static final Map<Class<? extends Srv6EndpointType>, Integer> REGISTER = ImmutableMap.of(
-            EndT.class, 3,
-            EndDT6.class, 8,
-            EndDT4.class, 9
-    );
+        implements LocalSidFunctionWriteBinder<TableLookupLocalSidRequest>, LocalSidFunctionReadBinder {
 
     TableLookupFunctionBinder(@Nonnull final FutureJVppCore api) {
         super(api);
-        checkState(REGISTER.containsKey(getHandledFunctionType()),
-                "Unsupported type of Local SID function %s", getHandledFunctionType());
     }
 
     TableLookupLocalSidRequest bindData(TableLookupLocalSidRequest request, int tableIndex, final boolean isIpv6,
@@ -68,9 +53,4 @@ abstract class TableLookupFunctionBinder extends FutureJVppCustomizer
         request.setFunction(getBehaviourFunctionType());
         return request;
     }
-
-    @Override
-    public int getBehaviourFunctionType() {
-        return REGISTER.get(getHandledFunctionType());
-    }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/nofunction/EndFunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/nofunction/EndFunctionBinder.java
index a1952e3c4..4d7ad69fe 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/nofunction/EndFunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/nofunction/EndFunctionBinder.java
@@ -18,16 +18,22 @@ package io.fd.hc2vpp.srv6.util.function.nofunction;
 
 import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
-import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionReadBinder;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionWriteBinder;
 import io.fd.hc2vpp.srv6.write.sid.request.NoProtocolLocalSidRequest;
+import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.End;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
 
 public class EndFunctionBinder extends FutureJVppCustomizer implements
-        LocalSidFunctionBinder<NoProtocolLocalSidRequest> {
+        LocalSidFunctionWriteBinder<NoProtocolLocalSidRequest>, LocalSidFunctionReadBinder {
 
     private static final int END_FUNCTION_VALUE = 1;
 
@@ -45,10 +51,16 @@ public class EndFunctionBinder extends FutureJVppCustomizer implements
         return request;
     }
 
+    @Override
+    public void translateFromDump(@Nonnull SrLocalsidsDetails data, @Nonnull ReadContext ctx,
+                                  @Nonnull final SidBuilder builder) {
+        builder.setEnd(new EndBuilder().build());
+    }
+
     @Nonnull
     @Override
     public Class<? extends Srv6EndpointType> getHandledFunctionType() {
-        return org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.End.class;
+        return End.class;
     }
 
     @Override
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX2FunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX2FunctionBinder.java
index 63de40b9c..551a211dd 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX2FunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX2FunctionBinder.java
@@ -19,15 +19,22 @@ package io.fd.hc2vpp.srv6.util.function.xconnect;
 import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
 import io.fd.hc2vpp.srv6.write.sid.request.XConnectLocalSidRequest;
+import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import javax.annotation.Nonnull;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndDx2Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.end.dx2.PathsBuilder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDX2;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
 
 public class EndDX2FunctionBinder extends XConnectFunctionBinder {
 
+    private static final int END_DX2_FUNCTION_VALUE = 5;
+
     public EndDX2FunctionBinder(@Nonnull final FutureJVppCore api, @Nonnull final NamingContext interfaceContext) {
         super(api, interfaceContext);
     }
@@ -48,9 +55,21 @@ public class EndDX2FunctionBinder extends XConnectFunctionBinder {
         return request;
     }
 
+    @Override
+    public void translateFromDump(@Nonnull SrLocalsidsDetails data, @Nonnull ReadContext ctx,
+                                  @Nonnull final SidBuilder builder) {
+        String interfaceName = getInterfaceName(ctx.getMappingContext(), data.xconnectIfaceOrVrfTable);
+        builder.setEndDx2(new EndDx2Builder().setPaths(new PathsBuilder().setInterface(interfaceName).build()).build());
+    }
+
     @Nonnull
     @Override
     public Class<? extends Srv6EndpointType> getHandledFunctionType() {
         return EndDX2.class;
     }
+
+    @Override
+    public int getBehaviourFunctionType() {
+        return END_DX2_FUNCTION_VALUE;
+    }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX4FunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX4FunctionBinder.java
index 51abc9876..cb8dbfeb1 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX4FunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX4FunctionBinder.java
@@ -19,18 +19,30 @@ package io.fd.hc2vpp.srv6.util.function.xconnect;
 import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
 import io.fd.hc2vpp.srv6.write.sid.request.XConnectLocalSidRequest;
+import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import java.util.Collections;
 import java.util.Optional;
 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.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.multi.paths.v4.PathsBuilder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.multi.paths.v4.paths.Path;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.multi.paths.v4.paths.PathBuilder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndDx4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndDx4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.PathAttrsCmn;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDX4;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
 
 public class EndDX4FunctionBinder extends XConnectFunctionBinder {
 
+    private static final int END_DX4_FUNCTION_VALUE = 7;
+
     public EndDX4FunctionBinder(@Nonnull FutureJVppCore api, @Nonnull NamingContext interfaceContext) {
         super(api, interfaceContext);
     }
@@ -52,9 +64,31 @@ public class EndDX4FunctionBinder extends XConnectFunctionBinder {
         return request;
     }
 
+    @Override
+    public void translateFromDump(@Nonnull SrLocalsidsDetails data, @Nonnull ReadContext ctx,
+                                  @Nonnull final SidBuilder builder) {
+        Ipv4AddressNoZone ipv4AddressNoZone = arrayToIpv4AddressNoZone(data.xconnectNhAddr4);
+        String interfaceName = getInterfaceName(ctx.getMappingContext(), data.xconnectIfaceOrVrfTable);
+        EndDx4 endDx4 = new EndDx4Builder().setPaths(new PathsBuilder().setPath(Collections.singletonList(
+                // TODO(HC2VPP-335): currently vpp allows to configure only one next hop
+                // therefore setting path index, role and weight to constants
+                new PathBuilder().setNextHop(ipv4AddressNoZone)
+                        .setInterface(interfaceName)
+                        .setPathIndex(DEFAULT_PATH_INDEX)
+                        .setWeight(DEFAULT_WEIGHT)
+                        .setRole(PathAttrsCmn.Role.PRIMARY)
+                        .build())).build()).build();
+        builder.setEndDx4(endDx4);
+    }
+
     @Nonnull
     @Override
     public Class<? extends Srv6EndpointType> getHandledFunctionType() {
         return EndDX4.class;
     }
+
+    @Override
+    public int getBehaviourFunctionType() {
+        return END_DX4_FUNCTION_VALUE;
+    }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX6FunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX6FunctionBinder.java
index 71194fbd4..3c1218005 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX6FunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndDX6FunctionBinder.java
@@ -19,18 +19,30 @@ package io.fd.hc2vpp.srv6.util.function.xconnect;
 import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
 import io.fd.hc2vpp.srv6.write.sid.request.XConnectLocalSidRequest;
+import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import java.util.Collections;
 import java.util.Optional;
 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.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.multi.paths.v6.PathsBuilder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.multi.paths.v6.paths.Path;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.multi.paths.v6.paths.PathBuilder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndDx6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndDx6Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.PathAttrsCmn;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDX6;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
 
 public class EndDX6FunctionBinder extends XConnectFunctionBinder {
 
+    private static final int END_DX6_FUNCTION_VALUE = 6;
+
     public EndDX6FunctionBinder(@Nonnull FutureJVppCore api, @Nonnull NamingContext interfaceContext) {
         super(api, interfaceContext);
     }
@@ -52,9 +64,31 @@ public class EndDX6FunctionBinder extends XConnectFunctionBinder {
         return request;
     }
 
+    @Override
+    public void translateFromDump(@Nonnull SrLocalsidsDetails data, @Nonnull ReadContext ctx,
+                                  @Nonnull final SidBuilder builder) {
+        Ipv6AddressNoZone ipv6AddressNoZone = arrayToIpv6AddressNoZone(data.xconnectNhAddr6);
+        String interfaceName = getInterfaceName(ctx.getMappingContext(), data.xconnectIfaceOrVrfTable);
+        EndDx6 endDx6 = new EndDx6Builder().setPaths(new PathsBuilder().setPath(Collections.singletonList(
+                // TODO(HC2VPP-335): currently vpp allows to configure only one next hop
+                // therefore setting path index, role and weight to constants
+                new PathBuilder().setNextHop(ipv6AddressNoZone)
+                        .setInterface(interfaceName)
+                        .setPathIndex(DEFAULT_PATH_INDEX)
+                        .setWeight(DEFAULT_WEIGHT)
+                        .setRole(PathAttrsCmn.Role.PRIMARY)
+                        .build())).build()).build();
+        builder.setEndDx6(endDx6);
+    }
+
     @Nonnull
     @Override
     public Class<? extends Srv6EndpointType> getHandledFunctionType() {
         return EndDX6.class;
     }
+
+    @Override
+    public int getBehaviourFunctionType() {
+        return END_DX6_FUNCTION_VALUE;
+    }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndXFunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndXFunctionBinder.java
index 0b3af395c..e153bd5f8 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndXFunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/EndXFunctionBinder.java
@@ -19,17 +19,29 @@ package io.fd.hc2vpp.srv6.util.function.xconnect;
 import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
 import io.fd.hc2vpp.srv6.write.sid.request.XConnectLocalSidRequest;
+import io.fd.honeycomb.translate.read.ReadContext;
 import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import java.util.Collections;
 import java.util.Optional;
 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.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.multi.paths.v6.PathsBuilder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.multi.paths.v6.paths.Path;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.multi.paths.v6.paths.PathBuilder;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.EndXBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.PathAttrsCmn;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndX;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
 
 public class EndXFunctionBinder extends XConnectFunctionBinder {
 
+    private static final int END_X_FUNCTION_VALUE = 2;
+
     public EndXFunctionBinder(@Nonnull FutureJVppCore api, @Nonnull NamingContext interfaceContext) {
         super(api, interfaceContext);
     }
@@ -53,9 +65,33 @@ public class EndXFunctionBinder extends XConnectFunctionBinder {
         return request;
     }
 
+    @Override
+    public void translateFromDump(@Nonnull SrLocalsidsDetails data, @Nonnull ReadContext ctx,
+                                  @Nonnull final SidBuilder builder) {
+        Ipv6AddressNoZone ipv6AddressNoZone = arrayToIpv6AddressNoZone(data.xconnectNhAddr6);
+        String interfaceName = getInterfaceName(ctx.getMappingContext(), data.xconnectIfaceOrVrfTable);
+        EndXBuilder endX = new EndXBuilder()
+                // TODO(HC2VPP-335): currently vpp allows to configure only one next hop
+                // therefore setting path index, role and weight to constants
+                .setPaths(new PathsBuilder().setPath(Collections.singletonList(
+                        new PathBuilder()
+                                .setNextHop(ipv6AddressNoZone)
+                                .setInterface(interfaceName)
+                                .setPathIndex(DEFAULT_PATH_INDEX)
+                                .setWeight(DEFAULT_WEIGHT)
+                                .setRole(PathAttrsCmn.Role.PRIMARY)
+                                .build())).build());
+        builder.setEndX(endX.build());
+    }
+
     @Nonnull
     @Override
     public Class<? extends Srv6EndpointType> getHandledFunctionType() {
-        return org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndX.class;
+        return EndX.class;
+    }
+
+    @Override
+    public int getBehaviourFunctionType() {
+        return END_X_FUNCTION_VALUE;
     }
 }
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/XConnectFunctionBinder.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/XConnectFunctionBinder.java
index 9f69c9041..eef5d9622 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/XConnectFunctionBinder.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/util/function/xconnect/XConnectFunctionBinder.java
@@ -16,46 +16,37 @@
 
 package io.fd.hc2vpp.srv6.util.function.xconnect;
 
-import static com.google.common.base.Preconditions.checkState;
 import static java.lang.String.format;
 
-import com.google.common.collect.ImmutableMap;
 import io.fd.hc2vpp.common.translate.util.AddressTranslator;
 import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionBinder;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionReadBinder;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionWriteBinder;
 import io.fd.hc2vpp.srv6.write.sid.request.XConnectLocalSidRequest;
 import io.fd.honeycomb.translate.MappingContext;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.Map;
 import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDX2;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDX4;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndDX6;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndX;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6EndpointType;
 
 abstract class XConnectFunctionBinder extends FutureJVppCustomizer
-        implements LocalSidFunctionBinder<XConnectLocalSidRequest>, AddressTranslator {
-
-    private static final Map<Class<? extends Srv6EndpointType>, Integer>
-            REGISTER = ImmutableMap.of(EndX.class, 2,
-            EndDX2.class, 5,
-            EndDX4.class, 7,
-            EndDX6.class, 6);
+        implements LocalSidFunctionWriteBinder<XConnectLocalSidRequest>, LocalSidFunctionReadBinder, AddressTranslator {
 
     private final NamingContext interfaceContext;
+    static final long DEFAULT_WEIGHT = 1L;
+    static final short DEFAULT_PATH_INDEX = 1;
 
     XConnectFunctionBinder(@Nonnull final FutureJVppCore api, @Nonnull final NamingContext interfaceContext) {
         super(api);
         this.interfaceContext = interfaceContext;
-        checkState(REGISTER.containsKey(getHandledFunctionType()), "Unsupported type of Local SID function %s",
-                getHandledFunctionType());
     }
 
-    @Override
-    public int getBehaviourFunctionType() {
-        return REGISTER.get(getHandledFunctionType());
+    String getInterfaceName(final MappingContext ctx, final int index) {
+        return interfaceContext.getName(index, ctx);
+    }
+
+    protected int getVLanIndex(final MappingContext ctx, final String name) {
+        return interfaceContext.getIndex(name, ctx, () -> new IllegalArgumentException(
+                format("VLan with name %s not found", name)));
     }
 
     int getInterfaceIndex(final MappingContext ctx, final String name) {
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/write/Srv6WriterFactory.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/write/Srv6WriterFactory.java
index 5dea50f48..d9f022970 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/write/Srv6WriterFactory.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/write/Srv6WriterFactory.java
@@ -19,6 +19,7 @@ package io.fd.hc2vpp.srv6.write;
 import com.google.common.collect.ImmutableSet;
 import com.google.inject.Inject;
 import io.fd.hc2vpp.srv6.Srv6IIds;
+import io.fd.hc2vpp.srv6.util.LocatorContextManager;
 import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionWriteBindingRegistry;
 import io.fd.hc2vpp.srv6.write.encap.source.EncapsulationSourceCustomizer;
 import io.fd.hc2vpp.srv6.write.sid.LocatorCustomizer;
@@ -36,6 +37,8 @@ public class Srv6WriterFactory implements WriterFactory {
     private FutureJVppCore futureJVppCore;
     @Inject
     private LocalSidFunctionWriteBindingRegistry bindingRegistry;
+    @Inject
+    protected LocatorContextManager locatorContext;
 
     @Override
     public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) {
@@ -43,7 +46,7 @@ public class Srv6WriterFactory implements WriterFactory {
         registry.add(new GenericWriter<>(Srv6IIds.RT_SRV6, new Srv6Customizer()));
 
         registry.subtreeAdd(ImmutableSet.of(Srv6IIds.LOC_PREFIX, Srv6IIds.LOC_FT_AUG, Srv6IIds.LOC_FT),
-                new GenericWriter<>(Srv6IIds.RT_SRV6_LOCS_LOCATOR, new LocatorCustomizer(futureJVppCore)));
+                new GenericWriter<>(Srv6IIds.RT_SRV6_LOCS_LOCATOR, new LocatorCustomizer(futureJVppCore, locatorContext)));
 
         registry.add(new GenericWriter<>(Srv6IIds.RT_SRV6_ENCAP, new EncapsulationSourceCustomizer(futureJVppCore)));
 
diff --git a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/write/sid/LocatorCustomizer.java b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/write/sid/LocatorCustomizer.java
index 86ab3599c..41e838ee7 100644
--- a/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/write/sid/LocatorCustomizer.java
+++ b/srv6/srv6-impl/src/main/java/io/fd/hc2vpp/srv6/write/sid/LocatorCustomizer.java
@@ -16,30 +16,51 @@
 
 package io.fd.hc2vpp.srv6.write.sid;
 
+import com.google.common.base.Preconditions;
 import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
+import io.fd.hc2vpp.srv6.util.LocatorContextManager;
 import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer;
 import io.fd.honeycomb.translate.write.WriteContext;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
 import javax.annotation.Nonnull;
+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.inet.types.rev130715.Ipv6Prefix;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.Locator;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorKey;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 
 public class LocatorCustomizer extends FutureJVppCustomizer implements ListWriterCustomizer<Locator, LocatorKey> {
 
-    public LocatorCustomizer(@Nonnull final FutureJVppCore futureJVppCore) {
+    private final LocatorContextManager locatorCtx;
+
+    public LocatorCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
+                             @Nonnull final LocatorContextManager locatorContext) {
         super(futureJVppCore);
+        this.locatorCtx = locatorContext;
     }
 
     @Override
     public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Locator> instanceIdentifier,
                                        @Nonnull final Locator locator, @Nonnull final WriteContext writeContext) {
-        // noop
+        Preconditions.checkNotNull(locator.getPrefix(), "Prefix should not be empty in locator: {}", locator);
+        Preconditions.checkNotNull(locator.getPrefix().getLength(),
+                "Length in prefix should not be empty for locator: {}", locator);
+        Ipv6Address locAddress = Preconditions.checkNotNull(locator.getPrefix().getAddress(),
+                "Address in prefix should not be empty for locator: {}", locator);
+        Short locLength = Preconditions.checkNotNull(locator.getPrefix().getLength().getValue(),
+                "Length in prefix should not be empty for locator: {}", locator);
+
+        locatorCtx.addLocator(locAddress.getValue(), new Ipv6Prefix(locAddress.getValue() + "/" + locLength),
+                writeContext.getMappingContext());
     }
 
     @Override
     public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Locator> instanceIdentifier,
                                         @Nonnull final Locator locator, @Nonnull final WriteContext writeContext) {
-        // noop
+        Preconditions.checkNotNull(locator.getPrefix(), "Prefix should not be empty in locator: {}", locator);
+        Ipv6Address locAddress = Preconditions.checkNotNull(locator.getPrefix().getAddress(),
+                "Address in prefix should not be empty for locator: {}", locator);
+
+        locatorCtx.removeLocator(locAddress.getValue(), writeContext.getMappingContext());
     }
 }
diff --git a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/Srv6ModuleTest.java b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/Srv6ModuleTest.java
index c465dfbaf..54e4cdd26 100644
--- a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/Srv6ModuleTest.java
+++ b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/Srv6ModuleTest.java
@@ -31,10 +31,13 @@ import com.google.inject.name.Named;
 import com.google.inject.testing.fieldbinder.Bind;
 import com.google.inject.testing.fieldbinder.BoundFieldModule;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.srv6.read.Srv6ReaderFactory;
 import io.fd.hc2vpp.srv6.write.Srv6WriterFactory;
 import io.fd.hc2vpp.vpp.classifier.context.VppClassifierContextManager;
 import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.impl.read.registry.CompositeReaderRegistryBuilder;
 import io.fd.honeycomb.translate.impl.write.registry.FlatWriterRegistryBuilder;
+import io.fd.honeycomb.translate.read.ReaderFactory;
 import io.fd.honeycomb.translate.util.YangDAG;
 import io.fd.honeycomb.translate.write.WriterFactory;
 import io.fd.vpp.jvpp.core.future.FutureJVppCore;
@@ -44,6 +47,7 @@ import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.routing.rev180313.RoutingBuilder;
 
 public class Srv6ModuleTest {
 
@@ -75,6 +79,9 @@ public class Srv6ModuleTest {
     private VppClassifierContextManager classifierContextManager;
 
     @Inject
+    private Set<ReaderFactory> readerFactories = new HashSet<>();
+
+    @Inject
     private Set<WriterFactory> writerFactories = new HashSet<>();
 
     @Before
@@ -85,6 +92,19 @@ public class Srv6ModuleTest {
     }
 
     @Test
+    public void testReaderFactories() {
+        assertThat(readerFactories, is(not(empty())));
+
+        // Test registration process (all dependencies present, topological order of readers does exist, etc.)
+        final CompositeReaderRegistryBuilder registryBuilder = new CompositeReaderRegistryBuilder(new YangDAG());
+        readerFactories.forEach(factory -> factory.init(registryBuilder));
+        registryBuilder.addStructuralReader(Srv6IIds.RT, RoutingBuilder.class);
+        assertNotNull(registryBuilder.build());
+        assertEquals(1, readerFactories.size());
+        assertTrue(readerFactories.iterator().next() instanceof Srv6ReaderFactory);
+    }
+
+    @Test
     public void testWriterFactories() {
         assertThat(writerFactories, is(not(empty())));
 
diff --git a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/LocatorCustomizerTest.java b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/LocatorCustomizerTest.java
new file mode 100644
index 000000000..3f2a74fd7
--- /dev/null
+++ b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/LocatorCustomizerTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read.sid;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+import io.fd.hc2vpp.srv6.write.sid.request.LocalSidRequestTest;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetailsReplyDump;
+import io.fd.vpp.jvpp.core.types.Srv6Sid;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Mock;
+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.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.LocatorsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.Locator;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorKey;
+
+public class LocatorCustomizerTest extends LocalSidRequestTest {
+
+    private static final Ipv6Address SID_ADR = new Ipv6Address("a::101");
+
+    @Mock
+    private ReadContext readCtx;
+
+    @Mock
+    private ModificationCache modificationCache;
+
+    private SrLocalsidsDetailsReplyDump replyDump = new SrLocalsidsDetailsReplyDump();
+
+    @Override
+    protected void init() {
+        when(readCtx.getModificationCache()).thenReturn(modificationCache);
+        when(modificationCache.get(any())).thenReturn(replyDump);
+        when(locatorContext.getLocator(eq(LOCATOR.getName()), any())).thenReturn(new Ipv6Prefix("a::/64"));
+    }
+
+    @Test
+    public void getAllIdsTest() throws ReadFailedException {
+        SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails();
+        srLocalsidsDetails.behavior = 1;
+        Srv6Sid sid = new Srv6Sid();
+        sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR));
+        srLocalsidsDetails.addr = sid;
+        replyDump.srLocalsidsDetails.add(srLocalsidsDetails);
+
+        LocatorCustomizer customizer = new LocatorCustomizer(api, locatorContext);
+        List<LocatorKey> allIds = customizer.getAllIds(SID_A_101.firstIdentifierOf(Locator.class), readCtx);
+
+        Assert.assertNotNull(allIds);
+        Assert.assertFalse(allIds.isEmpty());
+        Assert.assertTrue(allIds.contains(SID_A_101.firstKeyOf(Locator.class)));
+    }
+
+    @Test
+    public void readCurrentAttributesTest() throws ReadFailedException {
+        SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails();
+        srLocalsidsDetails.behavior = 1;
+        Srv6Sid sid = new Srv6Sid();
+        sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR));
+        srLocalsidsDetails.addr = sid;
+        replyDump.srLocalsidsDetails.add(srLocalsidsDetails);
+
+        LocatorCustomizer customizer = new LocatorCustomizer(api, locatorContext);
+        LocatorBuilder builder = new LocatorBuilder();
+        customizer.readCurrentAttributes(SID_A_101.firstIdentifierOf(Locator.class), builder, readCtx);
+        Assert.assertEquals(SID_A_101.firstKeyOf(Locator.class), builder.getKey());
+        Assert.assertNotNull(customizer.getBuilder(SID_A_101.firstIdentifierOf(Locator.class)));
+
+        LocatorsBuilder parentBuilder = new LocatorsBuilder();
+        customizer.merge(parentBuilder, Collections.singletonList(builder.build()));
+
+        Assert.assertNotNull(parentBuilder.getLocator());
+        Assert.assertFalse(parentBuilder.getLocator().isEmpty());
+        Assert.assertTrue(parentBuilder.getLocator().contains(builder.build()));
+    }
+}
diff --git a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/SidCustomizerTest.java b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/SidCustomizerTest.java
new file mode 100644
index 000000000..419c431ed
--- /dev/null
+++ b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/SidCustomizerTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read.sid;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+import io.fd.hc2vpp.srv6.write.sid.request.LocalSidRequestTest;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetailsReplyDump;
+import io.fd.vpp.jvpp.core.types.Srv6Sid;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Mock;
+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.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.routing.srv6.locators.locator._static.LocalSidsBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidKey;
+
+public class SidCustomizerTest extends LocalSidRequestTest {
+
+    private static final Ipv6Address SID_ADR = new Ipv6Address("a::101");
+
+    @Mock
+    private ReadContext readCtx;
+
+    @Mock
+    private ModificationCache modificationCache;
+
+    @Mock
+    private MappingContext mappingContext;
+
+    private SrLocalsidsDetailsReplyDump replyDump = new SrLocalsidsDetailsReplyDump();
+
+    @Override
+    protected void init() {
+        when(readCtx.getModificationCache()).thenReturn(modificationCache);
+        when(modificationCache.get(any())).thenReturn(replyDump);
+        when(readCtx.getMappingContext()).thenReturn(mappingContext);
+        when(mappingContext.read(any())).thenReturn(Optional.of(LOCATOR));
+        when(locatorContext.getLocator(eq(LOCATOR.getName()), any())).thenReturn(new Ipv6Prefix("a::/64"));
+    }
+
+    @Test
+    public void getAllIdsTest() throws ReadFailedException {
+        SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails();
+        srLocalsidsDetails.behavior = 1;
+        Srv6Sid sid = new Srv6Sid();
+        sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR));
+        srLocalsidsDetails.addr = sid;
+        replyDump.srLocalsidsDetails.add(srLocalsidsDetails);
+
+        SidCustomizer customizer = new SidCustomizer(api, READ_REGISTRY, locatorContext);
+        List<SidKey> allIds = customizer.getAllIds(SID_A_101, readCtx);
+
+        Assert.assertNotNull(allIds);
+        Assert.assertFalse(allIds.isEmpty());
+        Assert.assertTrue(allIds.contains(SID_A_101.firstKeyOf(Sid.class)));
+    }
+
+    @Test
+    public void readCurrentAttributesTest() throws ReadFailedException {
+        SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails();
+        srLocalsidsDetails.behavior = 1;
+        Srv6Sid sid = new Srv6Sid();
+        sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR));
+        srLocalsidsDetails.addr = sid;
+        replyDump.srLocalsidsDetails.add(srLocalsidsDetails);
+
+        SidCustomizer customizer = new SidCustomizer(api, READ_REGISTRY, locatorContext);
+        SidBuilder builder = new SidBuilder();
+        customizer.readCurrentAttributes(SID_A_101, builder, readCtx);
+        Assert.assertEquals(SID_A_101.firstKeyOf(Sid.class), builder.getKey());
+        Assert.assertNotNull(builder.getEnd());
+        Assert.assertNotNull(customizer.getBuilder(SID_A_101));
+
+        LocalSidsBuilder parentBuilder = new LocalSidsBuilder();
+        customizer.merge(parentBuilder, Collections.singletonList(builder.build()));
+        Assert.assertNotNull(parentBuilder.getSid());
+        Assert.assertFalse(parentBuilder.getSid().isEmpty());
+        Assert.assertTrue(parentBuilder.getSid().contains(builder.build()));
+    }
+}
diff --git a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/request/LocalSidReadRequestTest.java b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/request/LocalSidReadRequestTest.java
new file mode 100644
index 000000000..21668e3b1
--- /dev/null
+++ b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/request/LocalSidReadRequestTest.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read.sid.request;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+import io.fd.hc2vpp.srv6.write.sid.request.LocalSidRequestTest;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetailsReplyDump;
+import io.fd.vpp.jvpp.core.types.Srv6Sid;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+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.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.routing.rev180313.Routing;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.Locator1;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.routing.srv6.locators.locator.Static;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.routing.srv6.locators.locator._static.LocalSids;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.Sid;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6._static.cfg.SidKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.Routing1;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.routing.Srv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.Locators;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.Locator;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndT;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.EndX;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.types.rev180301.Srv6FuncOpcodeUnreserved;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class LocalSidReadRequestTest extends LocalSidRequestTest {
+
+    private static final String LOCAL_0 = "local0";
+    private static final String VLAN_0 = "vlan0";
+    private static final Ipv6Address SID_ADR = new Ipv6Address("a::100");
+    private static final Ipv6Address SID_ADR_2 = new Ipv6Address("a::101");
+    private static final Ipv6AddressNoZone ADDRESS_NO_ZONE = new Ipv6AddressNoZone(SID_ADR_2);
+    private static final long OPERATION = 256L; // 100 in hex IPv6 format
+    private static final InstanceIdentifier<Sid> ID_SID =
+            InstanceIdentifier.create(Routing.class)
+                    .augmentation(Routing1.class)
+                    .child(Srv6.class)
+                    .child(Locators.class)
+                    .child(Locator.class, new LocatorKey("a::"))
+                    .augmentation(Locator1.class)
+                    .child(Static.class)
+                    .child(LocalSids.class)
+                    .child(Sid.class, new SidKey(new Srv6FuncOpcodeUnreserved(OPERATION)));
+
+    @Mock
+    private ReadContext readCtx;
+
+    @Mock
+    private CompletionStage<SrLocalsidsDetailsReplyDump> stage;
+
+    @Mock
+    private CompletableFuture<SrLocalsidsDetailsReplyDump> detailsFuture;
+
+    @Mock
+    private ModificationCache modificationCache;
+
+    @Mock
+    private MappingContext mappingContext;
+
+    private SrLocalsidsDetailsReplyDump replyDump = new SrLocalsidsDetailsReplyDump();
+
+    @Override
+    protected void init() {
+        MockitoAnnotations.initMocks(this);
+        defineMapping(mappingContext, LOCAL_0, 1, "interface-context");
+        defineMapping(mappingContext, VLAN_0, 2, "interface-context");
+        replyDump.srLocalsidsDetails = new ArrayList<>();
+        when(ctx.getMappingContext()).thenReturn(mappingContext);
+        when(readCtx.getMappingContext()).thenReturn(mappingContext);
+        when(readCtx.getModificationCache()).thenReturn(modificationCache);
+        when(modificationCache.get(any())).thenReturn(replyDump);
+        when(api.srLocalsidsDump(any())).thenReturn(stage);
+        when(stage.toCompletableFuture()).thenReturn(detailsFuture);
+        when(locatorContext.getLocator(eq(LOCATOR.getName()), any())).thenReturn(new Ipv6Prefix("a::/64"));
+
+
+        try {
+            when(detailsFuture.get()).thenReturn(replyDump);
+        } catch (InterruptedException | ExecutionException e) {
+            // noop
+        }
+    }
+
+    @Test
+    public void readAllKeysTest() throws ReadFailedException {
+        SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails();
+        Srv6Sid sid = new Srv6Sid();
+        sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR));
+        srLocalsidsDetails.addr = sid;
+
+        SrLocalsidsDetails srLocalsidsDetails2 = new SrLocalsidsDetails();
+        Srv6Sid sid2 = new Srv6Sid();
+        sid2.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR_2));
+        srLocalsidsDetails2.addr = sid2;
+
+        replyDump.srLocalsidsDetails.add(srLocalsidsDetails);
+        replyDump.srLocalsidsDetails.add(srLocalsidsDetails2);
+
+        final LocalSidReadRequest request = new LocalSidReadRequest(api, locatorContext, READ_REGISTRY);
+        request.checkValid();
+        List<SidKey> sidKeys = request.readAllKeys(ID_SID, readCtx);
+
+        Assert.assertFalse(sidKeys.isEmpty());
+        Assert.assertEquals(2, sidKeys.size());
+    }
+
+    @Test
+    public void readSpecificEndXTest() throws ReadFailedException {
+        SrLocalsidsDetails endX = new SrLocalsidsDetails();
+        endX.behavior = 2;
+        endX.endPsp = 0;
+        endX.xconnectNhAddr6 = AddressTranslator.INSTANCE.ipv6AddressNoZoneToArray(SID_ADR_2);
+        endX.xconnectIfaceOrVrfTable = 1;
+
+        Srv6Sid sid = new Srv6Sid();
+        sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR));
+        endX.addr = sid;
+
+        replyDump.srLocalsidsDetails.add(endX);
+
+        final LocalSidReadRequest request = new LocalSidReadRequest(api, locatorContext, READ_REGISTRY);
+        SidBuilder sidBuilder = new SidBuilder();
+        request.readSpecific(ID_SID, readCtx, sidBuilder);
+
+        Assert.assertNotNull(sidBuilder.getEndX());
+        Assert.assertEquals(EndX.class, sidBuilder.getEndBehaviorType());
+        Assert.assertEquals(OPERATION, sidBuilder.getOpcode().getValue().longValue());
+        Assert.assertNotNull(sidBuilder.getEndX().getPaths().getPath());
+        Assert.assertFalse(sidBuilder.getEndX().getPaths().getPath().isEmpty());
+        Assert.assertEquals(LOCAL_0, sidBuilder.getEndX().getPaths().getPath().get(0).getInterface());
+        Assert.assertEquals(ADDRESS_NO_ZONE, sidBuilder.getEndX().getPaths().getPath().get(0).getNextHop());
+    }
+
+
+    @Test
+    public void readSpecificEndTTest() throws ReadFailedException {
+        SrLocalsidsDetails endT = new SrLocalsidsDetails();
+        endT.behavior = 3;
+        endT.xconnectIfaceOrVrfTable = 4;
+        endT.endPsp = 0;
+
+        Srv6Sid sid = new Srv6Sid();
+        sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR));
+        endT.addr = sid;
+
+        replyDump.srLocalsidsDetails.add(endT);
+
+        final LocalSidReadRequest request = new LocalSidReadRequest(api, locatorContext, READ_REGISTRY);
+        SidBuilder sidBuilder = new SidBuilder();
+        request.readSpecific(ID_SID, readCtx, sidBuilder);
+
+        Assert.assertNotNull(sidBuilder.getEndT());
+        Assert.assertEquals(EndT.class, sidBuilder.getEndBehaviorType());
+        Assert.assertEquals(OPERATION, sidBuilder.getOpcode().getValue().longValue());
+        Assert.assertEquals(4L, sidBuilder.getEndT().getLookupTableIpv6().getValue().longValue());
+    }
+}
diff --git a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/request/LocatorReadRequestTest.java b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/request/LocatorReadRequestTest.java
new file mode 100644
index 000000000..404aa6b9d
--- /dev/null
+++ b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/read/sid/request/LocatorReadRequestTest.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.read.sid.request;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+import io.fd.hc2vpp.srv6.write.sid.request.LocalSidRequestTest;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetailsReplyDump;
+import io.fd.vpp.jvpp.core.types.Srv6Sid;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+import org.junit.Assert;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+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.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.routing.rev180313.Routing;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.Routing1;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.routing.Srv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.Locators;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.Locator;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6.base.rev180301.srv6.locators.locators.LocatorKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class LocatorReadRequestTest extends LocalSidRequestTest {
+
+    private static final String LOCAL_0 = "local0";
+    private static final Ipv6Address SID_ADR = new Ipv6Address("a::100");
+    private static final Ipv6Address SID_ADR_2 = new Ipv6Address("b::101");
+    private static final InstanceIdentifier<Locator> ID_LOC =
+            InstanceIdentifier.create(Routing.class)
+                    .augmentation(Routing1.class)
+                    .child(Srv6.class)
+                    .child(Locators.class)
+                    .child(Locator.class, new LocatorKey("a::"));
+
+    @Mock
+    private ReadContext readCtx;
+
+    @Mock
+    private CompletionStage<SrLocalsidsDetailsReplyDump> stage;
+
+    @Mock
+    private CompletableFuture<SrLocalsidsDetailsReplyDump> detailsFuture;
+
+    @Mock
+    private ModificationCache modificationCache;
+
+    private SrLocalsidsDetailsReplyDump replyDump = new SrLocalsidsDetailsReplyDump();
+
+    @Override
+    protected void init() {
+        MockitoAnnotations.initMocks(this);
+        defineMapping(mappingContext, LOCAL_0, 1, "interface-context");
+        replyDump.srLocalsidsDetails = new ArrayList<>();
+        when(readCtx.getModificationCache()).thenReturn(modificationCache);
+        when(modificationCache.get(any())).thenReturn(replyDump);
+        when(api.srLocalsidsDump(any())).thenReturn(stage);
+        when(stage.toCompletableFuture()).thenReturn(detailsFuture);
+        when(locatorContext.getLocator(eq(LOCATOR.getName()), any())).thenReturn(new Ipv6Prefix("a::/64"));
+
+        try {
+            when(detailsFuture.get()).thenReturn(replyDump);
+        } catch (InterruptedException | ExecutionException e) {
+            // noop
+        }
+    }
+
+    @Test
+    public void readAllKeysTest() throws ReadFailedException {
+        SrLocalsidsDetails srLocalsidsDetails = new SrLocalsidsDetails();
+        Srv6Sid sid = new Srv6Sid();
+        sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR));
+        srLocalsidsDetails.addr = sid;
+
+        SrLocalsidsDetails srLocalsidsDetails2 = new SrLocalsidsDetails();
+        Srv6Sid sid2 = new Srv6Sid();
+        sid2.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR_2));
+        srLocalsidsDetails2.addr = sid2;
+
+        replyDump.srLocalsidsDetails.add(srLocalsidsDetails);
+        replyDump.srLocalsidsDetails.add(srLocalsidsDetails2);
+
+        final LocatorReadRequest request = new LocatorReadRequest(api, locatorContext);
+        request.checkValid();
+        List<LocatorKey> locatorKeys = request.readAllKeys(ID_LOC, readCtx);
+
+        Assert.assertFalse(locatorKeys.isEmpty());
+        Assert.assertEquals(2, locatorKeys.size());
+        Assert.assertTrue(locatorKeys.contains(new LocatorKey("a::")));
+        Assert.assertTrue(locatorKeys.contains(new LocatorKey("b::")));
+    }
+
+    @Test
+    public void readSpecificEndXTest() throws ReadFailedException {
+        SrLocalsidsDetails endX = new SrLocalsidsDetails();
+        endX.behavior = 2;
+        endX.endPsp = 0;
+        endX.xconnectNhAddr6 = AddressTranslator.INSTANCE.ipv6AddressNoZoneToArray(SID_ADR_2);
+        endX.xconnectIfaceOrVrfTable = 1;
+
+        Srv6Sid sid = new Srv6Sid();
+        sid.addr = AddressTranslator.INSTANCE.ipAddressToArray(new IpAddress(SID_ADR));
+        endX.addr = sid;
+
+        replyDump.srLocalsidsDetails.add(endX);
+
+        final LocatorReadRequest request = new LocatorReadRequest(api, locatorContext);
+        LocatorBuilder builder = new LocatorBuilder();
+        request.readSpecific(ID_LOC, readCtx, builder);
+
+        Assert.assertEquals(new LocatorKey("a::"), builder.getKey());
+    }
+}
diff --git a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/JvppRequestTest.java b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/JvppRequestTest.java
index 0bc3f6b6d..cd3369956 100644
--- a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/JvppRequestTest.java
+++ b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/JvppRequestTest.java
@@ -21,6 +21,7 @@ import com.google.inject.Inject;
 import io.fd.hc2vpp.common.test.util.FutureProducer;
 import io.fd.hc2vpp.common.test.util.NamingContextHelper;
 import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionReadBindingRegistry;
 import io.fd.hc2vpp.srv6.util.function.LocalSidFunctionWriteBindingRegistry;
 import io.fd.hc2vpp.srv6.util.function.lookup.EndDT4FunctionBinder;
 import io.fd.hc2vpp.srv6.util.function.lookup.EndDT6FunctionBinder;
@@ -43,6 +44,8 @@ import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
 
 @RunWith(HoneycombTestRunner.class)
 public abstract class JvppRequestTest implements FutureProducer, NamingContextHelper {
+    protected static final LocalSidFunctionReadBindingRegistry READ_REGISTRY =
+            new LocalSidFunctionReadBindingRegistry();
     protected static final LocalSidFunctionWriteBindingRegistry WRITE_REGISTRY =
             new LocalSidFunctionWriteBindingRegistry();
 
@@ -69,14 +72,22 @@ public abstract class JvppRequestTest implements FutureProducer, NamingContextHe
         EndDX2FunctionBinder endDX2FunctionBinder = new EndDX2FunctionBinder(api, interfaceContext);
         EndDX4FunctionBinder endDX4FunctionBinder = new EndDX4FunctionBinder(api, interfaceContext);
         EndDX6FunctionBinder endDX6FunctionBinder = new EndDX6FunctionBinder(api, interfaceContext);
-        WRITE_REGISTRY.registerFunctionType(endFunctionBinder);
-        WRITE_REGISTRY.registerFunctionType(endTFunctionBinder);
-        WRITE_REGISTRY.registerFunctionType(endDT4FunctionBinder);
-        WRITE_REGISTRY.registerFunctionType(endDT6FunctionBinder);
-        WRITE_REGISTRY.registerFunctionType(endXFunctionBinder);
-        WRITE_REGISTRY.registerFunctionType(endDX2FunctionBinder);
-        WRITE_REGISTRY.registerFunctionType(endDX4FunctionBinder);
-        WRITE_REGISTRY.registerFunctionType(endDX6FunctionBinder);
+        READ_REGISTRY.registerReadFunctionType(endFunctionBinder);
+        READ_REGISTRY.registerReadFunctionType(endTFunctionBinder);
+        READ_REGISTRY.registerReadFunctionType(endDT4FunctionBinder);
+        READ_REGISTRY.registerReadFunctionType(endDT6FunctionBinder);
+        READ_REGISTRY.registerReadFunctionType(endXFunctionBinder);
+        READ_REGISTRY.registerReadFunctionType(endDX2FunctionBinder);
+        READ_REGISTRY.registerReadFunctionType(endDX4FunctionBinder);
+        READ_REGISTRY.registerReadFunctionType(endDX6FunctionBinder);
+        WRITE_REGISTRY.registerWriteFunctionType(endFunctionBinder);
+        WRITE_REGISTRY.registerWriteFunctionType(endTFunctionBinder);
+        WRITE_REGISTRY.registerWriteFunctionType(endDT4FunctionBinder);
+        WRITE_REGISTRY.registerWriteFunctionType(endDT6FunctionBinder);
+        WRITE_REGISTRY.registerWriteFunctionType(endXFunctionBinder);
+        WRITE_REGISTRY.registerWriteFunctionType(endDX2FunctionBinder);
+        WRITE_REGISTRY.registerWriteFunctionType(endDX4FunctionBinder);
+        WRITE_REGISTRY.registerWriteFunctionType(endDX6FunctionBinder);
         init();
     }
 
diff --git a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/LocatorContextManagerImplTest.java b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/LocatorContextManagerImplTest.java
new file mode 100644
index 000000000..919e013b1
--- /dev/null
+++ b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/LocatorContextManagerImplTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2018 Bell Canada, Pantheon Technologies 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.srv6.util;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.hc2vpp.srv6.write.sid.request.LocalSidRequestTest;
+import io.fd.honeycomb.translate.MappingContext;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.locator.context.rev180605.srv6.locator.context.attributes.srv6.locator.mappings.Srv6LocatorMapping;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.locator.context.rev180605.srv6.locator.context.attributes.srv6.locator.mappings.Srv6LocatorMappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class LocatorContextManagerImplTest extends LocalSidRequestTest {
+
+    private static final Ipv6Prefix LOCATOR_PREFIX = new Ipv6Prefix("a::/64");
+
+    @Mock
+    MappingContext mappingContext;
+
+    @Captor
+    ArgumentCaptor<Srv6LocatorMapping> locMappingCaptor;
+
+    @Captor
+    ArgumentCaptor<InstanceIdentifier<Srv6LocatorMapping>> iidCaptor;
+
+    @Before
+    public void setup() {
+        Srv6LocatorMapping locatorMapping =
+                new Srv6LocatorMappingBuilder().setName(LOCATOR.getName()).setPrefix(LOCATOR_PREFIX).build();
+        when(ctx.getMappingContext()).thenReturn(mappingContext);
+        when(mappingContext.read(any())).thenReturn(Optional.of(locatorMapping));
+    }
+
+    @Test
+    public void addLocatorTest() {
+        LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64);
+        contextManager.addLocator(LOCATOR.getName(), LOCATOR_PREFIX, ctx.getMappingContext());
+        verify(mappingContext, times(1)).put(any(), locMappingCaptor.capture());
+        Srv6LocatorMapping mapping = locMappingCaptor.getValue();
+
+        Assert.assertEquals(mapping.getPrefix(), LOCATOR_PREFIX);
+        Assert.assertEquals(mapping.getName(), LOCATOR.getName());
+    }
+
+    @Test
+    public void containsLocatorTest() {
+        LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64);
+        boolean containsLocator = contextManager.containsLocator(LOCATOR.getName(), ctx.getMappingContext());
+        Assert.assertTrue(containsLocator);
+    }
+
+
+    @Test
+    public void getLocatorTest() {
+        LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64);
+        Ipv6Prefix locator = contextManager.getLocator(LOCATOR.getName(), ctx.getMappingContext());
+        Assert.assertEquals(LOCATOR_PREFIX, locator);
+    }
+
+    @Test
+    public void removeLocatorTest() {
+        MappingContext mappingContext = ctx.getMappingContext();
+        LocatorContextManagerImpl contextManager = new LocatorContextManagerImpl(64);
+        contextManager.removeLocator(LOCATOR.getName(), mappingContext);
+        verify(mappingContext, times(1)).delete(iidCaptor.capture());
+        Assert.assertEquals(LOCATOR.getName(), iidCaptor.getValue().firstKeyOf(Srv6LocatorMapping.class).getName());
+    }
+}
diff --git a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBindingRegistryTest.java b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBindingRegistryTest.java
index 66ddf48db..998916ee1 100644
--- a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBindingRegistryTest.java
+++ b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/util/function/LocalSidFunctionBindingRegistryTest.java
@@ -19,6 +19,7 @@ package io.fd.hc2vpp.srv6.util.function;
 import static org.mockito.Mockito.when;
 
 import com.google.common.base.Optional;
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
 import io.fd.hc2vpp.fib.management.FibManagementIIds;
 import io.fd.hc2vpp.srv6.util.JvppRequestTest;
 import io.fd.hc2vpp.srv6.write.sid.request.LocalSidFunctionRequest;
@@ -26,6 +27,7 @@ import io.fd.hc2vpp.srv6.write.sid.request.NoProtocolLocalSidRequest;
 import io.fd.hc2vpp.srv6.write.sid.request.TableLookupLocalSidRequest;
 import io.fd.hc2vpp.srv6.write.sid.request.XConnectLocalSidRequest;
 import io.fd.honeycomb.translate.read.ReadContext;
+import io.fd.vpp.jvpp.core.dto.SrLocalsidsDetails;
 import java.util.Collections;
 import org.junit.Assert;
 import org.junit.Test;
@@ -114,6 +116,16 @@ public class LocalSidFunctionBindingRegistryTest extends JvppRequestTest {
     }
 
     @Test
+    public void testEndVpp() {
+        SrLocalsidsDetails details = new SrLocalsidsDetails();
+        details.behavior = 1;
+        details.endPsp = 0;
+        SidBuilder builder = new SidBuilder();
+        READ_REGISTRY.bind(details, readCtx, builder);
+        Assert.assertNotNull(builder.getEnd());
+    }
+
+    @Test
     public void testEndX() {
         EndX endX = new EndXBuilder()
                 .setPaths(new PathsBuilder().setPath(Collections.singletonList(
@@ -138,6 +150,20 @@ public class LocalSidFunctionBindingRegistryTest extends JvppRequestTest {
     }
 
     @Test
+    public void testEndXVpp() {
+        SrLocalsidsDetails details = new SrLocalsidsDetails();
+        details.behavior = 2;
+        details.endPsp = 0;
+        details.xconnectNhAddr6 = AddressTranslator.INSTANCE.ipv6AddressNoZoneToArray(A);
+        details.xconnectIfaceOrVrfTable = 1;
+        SidBuilder builder = new SidBuilder();
+        READ_REGISTRY.bind(details, readCtx, builder);
+        Assert.assertNotNull(builder.getEndX());
+        Assert.assertEquals(LOCAL_0, builder.getEndX().getPaths().getPath().get(0).getInterface());
+        Assert.assertEquals(A_NO_ZONE, builder.getEndX().getPaths().getPath().get(0).getNextHop());
+    }
+
+    @Test
     public void testEndDX2() {
         EndDx2 endDx2 = new EndDx2Builder().setPaths(
                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.srv6._static.rev180301.srv6.sid.config.end.dx2.PathsBuilder()
@@ -156,6 +182,17 @@ public class LocalSidFunctionBindingRegistryTest extends JvppRequestTest {
     }
 
     @Test
+    public void testEndDX2Vpp() {
+        SrLocalsidsDetails details = new SrLocalsidsDetails();
+        details.behavior = 5;
+        details.xconnectIfaceOrVrfTable = 1;
+        SidBuilder builder = new SidBuilder();
+        READ_REGISTRY.bind(details, readCtx, builder);
+        Assert.assertNotNull(builder.getEndDx2());
+        Assert.assertEquals(LOCAL_0, builder.getEndDx2().getPaths().getInterface());
+    }
+
+    @Test
     public void testEndDX6() {
         EndDx6 endDx6 = new EndDx6Builder()
                 .setPaths(new PathsBuilder()
@@ -178,6 +215,19 @@ public class LocalSidFunctionBindingRegistryTest extends JvppRequestTest {
     }
 
     @Test
+    public void testEndDX6Vpp() {
+        SrLocalsidsDetails details = new SrLocalsidsDetails();
+        details.behavior = 6;
+        details.xconnectIfaceOrVrfTable = 1;
+        details.xconnectNhAddr6 = AddressTranslator.INSTANCE.ipv6AddressNoZoneToArray(A);
+        SidBuilder builder = new SidBuilder();
+        READ_REGISTRY.bind(details, readCtx, builder);
+        Assert.assertNotNull(builder.getEndDx6());
+        Assert.assertEquals(LOCAL_0, builder.getEndDx6().getPaths().getPath().get(0).getInterface());
+        Assert.assertEquals(A_NO_ZONE, builder.getEndDx6().getPaths().getPath().get(0).getNextHop());
+    }
+
+    @Test
     public void testEndDX4() {
         EndDx4 endDx4 = new EndDx4Builder()
                 .setPaths(
@@ -202,6 +252,19 @@ public class LocalSidFunctionBindingRegistryTest extends JvppRequestTest {
     }
 
     @Test
+    public void testEndDX4Vpp() {
+        SrLocalsidsDetails details = new SrLocalsidsDetails();
+        details.behavior = 7;
+        details.xconnectIfaceOrVrfTable = 1;
+        details.xconnectNhAddr4 = AddressTranslator.INSTANCE.ipv4AddressNoZoneToArray(A_V4);
+        SidBuilder builder = new SidBuilder();
+        READ_REGISTRY.bind(details, readCtx, builder);
+        Assert.assertNotNull(builder.getEndDx4());
+        Assert.assertEquals(LOCAL_0, builder.getEndDx4().getPaths().getPath().get(0).getInterface());
+        Assert.assertEquals(A_V4, builder.getEndDx4().getPaths().getPath().get(0).getNextHop());
+    }
+
+    @Test
     public void testEndT() {
         EndT endT = new EndTBuilder().setLookupTableIpv6(TABLE_ID_4).build();
         Sid localSid = new SidBuilder()
@@ -217,6 +280,18 @@ public class LocalSidFunctionBindingRegistryTest extends JvppRequestTest {
     }
 
     @Test
+    public void testEndDTVpp() {
+        SrLocalsidsDetails details = new SrLocalsidsDetails();
+        details.behavior = 3;
+        details.xconnectIfaceOrVrfTable = TABLE_ID_4.getValue().intValue();
+        SidBuilder builder = new SidBuilder();
+        READ_REGISTRY.bind(details, readCtx, builder);
+        Assert.assertNotNull(builder.getEndT());
+        Assert.assertEquals(TABLE_ID_4.getValue().intValue(),
+                builder.getEndT().getLookupTableIpv6().getValue().intValue());
+    }
+
+    @Test
     public void testEndDT6() {
         EndDt6 endDt6 = new EndDt6Builder().setLookupTableIpv6(TABLE_ID_4).build();
         Sid localSid = new SidBuilder()
@@ -231,6 +306,18 @@ public class LocalSidFunctionBindingRegistryTest extends JvppRequestTest {
     }
 
     @Test
+    public void testEndDT6Vpp() {
+        SrLocalsidsDetails details = new SrLocalsidsDetails();
+        details.behavior = 8;
+        details.xconnectIfaceOrVrfTable = TABLE_ID_4.getValue().intValue();
+        SidBuilder builder = new SidBuilder();
+        READ_REGISTRY.bind(details, readCtx, builder);
+        Assert.assertNotNull(builder.getEndDt6());
+        Assert.assertEquals(TABLE_ID_4.getValue().intValue(),
+                builder.getEndDt6().getLookupTableIpv6().getValue().intValue());
+    }
+
+    @Test
     public void testEndDT4() {
         EndDt4 endDt4 = new EndDt4Builder().setLookupTableIpv4(TABLE_ID_4).build();
         Sid localSid = new SidBuilder()
@@ -243,4 +330,16 @@ public class LocalSidFunctionBindingRegistryTest extends JvppRequestTest {
         TableLookupLocalSidRequest tableLookupRequest = TableLookupLocalSidRequest.class.cast(request);
         Assert.assertEquals(TABLE_ID_4.getValue().intValue(), tableLookupRequest.getLookupFibTable());
     }
+
+    @Test
+    public void testEndDT4Vpp() {
+        SrLocalsidsDetails details = new SrLocalsidsDetails();
+        details.behavior = 9;
+        details.xconnectIfaceOrVrfTable = TABLE_ID_4.getValue().intValue();
+        SidBuilder builder = new SidBuilder();
+        READ_REGISTRY.bind(details, readCtx, builder);
+        Assert.assertNotNull(builder.getEndDt4());
+        Assert.assertEquals(TABLE_ID_4.getValue().intValue(),
+                builder.getEndDt4().getLookupTableIpv4().getValue().intValue());
+    }
 }
diff --git a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/write/sid/request/LocalSidRequestTest.java b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/write/sid/request/LocalSidRequestTest.java
index 80cf47aa0..fa30c07fb 100644
--- a/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/write/sid/request/LocalSidRequestTest.java
+++ b/srv6/srv6-impl/src/test/java/io/fd/hc2vpp/srv6/write/sid/request/LocalSidRequestTest.java
@@ -25,6 +25,7 @@ import io.fd.hc2vpp.common.translate.util.AddressTranslator;
 import io.fd.hc2vpp.common.translate.util.ByteDataTranslator;
 import io.fd.hc2vpp.srv6.Srv6IIds;
 import io.fd.hc2vpp.srv6.util.JvppRequestTest;
+import io.fd.hc2vpp.srv6.util.LocatorContextManager;
 import io.fd.vpp.jvpp.core.dto.SrLocalsidAddDel;
 import io.fd.vpp.jvpp.core.dto.SrLocalsidAddDelReply;
 import java.util.Arrays;
@@ -60,6 +61,9 @@ public abstract class LocalSidRequestTest extends JvppRequestTest {
             new PrefixBuilder().setLength(new Srv6LocatorLen((short) 64)).setAddress(new Ipv6Address("a::")).build())
             .build();
 
+    @Mock
+    protected static LocatorContextManager locatorContext;
+
     @Captor
     ArgumentCaptor<SrLocalsidAddDel> requestcaptor;