From 481fe32d90010b4570fd97239ca6c7940880d133 Mon Sep 17 00:00:00 2001 From: Maros Marsalek Date: Wed, 2 Nov 2016 12:35:50 +0100 Subject: HONEYCOMB-281 Loopback interface management Change-Id: I7e4d817bb7dfe9ccd779e59347c956233c012e4a Signed-off-by: Maros Marsalek --- v3po/api/src/main/yang/v3po.yang | 21 +++- v3po/postman_rest_collection.json | 51 ++++++++++ .../translate/v3po/InterfacesWriterFactory.java | 8 +- .../v3po/interfaces/LoopbackCustomizer.java | 112 +++++++++++++++++++++ .../v3po/interfacesstate/InterfaceCustomizer.java | 8 +- .../interfacesstate/InterfaceDataTranslator.java | 5 + .../v3po/interfaces/LoopbackCustomizerTest.java | 105 +++++++++++++++++++ 7 files changed, 306 insertions(+), 4 deletions(-) create mode 100644 v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfaces/LoopbackCustomizer.java create mode 100644 v3po/v3po2vpp/src/test/java/io/fd/honeycomb/translate/v3po/interfaces/LoopbackCustomizerTest.java diff --git a/v3po/api/src/main/yang/v3po.yang b/v3po/api/src/main/yang/v3po.yang index f272a489a..18b68620e 100644 --- a/v3po/api/src/main/yang/v3po.yang +++ b/v3po/api/src/main/yang/v3po.yang @@ -9,7 +9,8 @@ module v3po { - ingress/egress ACLs support - moved ACL definitions to vpp-acl module - updated l2 container constraint (permit IP address on BVI interface) - - added PID of vpp process to vpp-state"; + - added PID of vpp process to vpp-state + - added support for Loopback interfaces"; } revision "2015-01-05" { @@ -70,6 +71,10 @@ module v3po { base if:interface-type; } + identity loopback { + base if:interface-type; + } + identity l2-fib-action { description "Base identity for l2-fib actions"; } @@ -244,6 +249,14 @@ module v3po { } } + grouping loopback-interface-base-attributes { + leaf mac { + type yang:phys-address; + mandatory false; + description "Mac address of the loopback interface"; + } + } + grouping ethernet-base-attributes { leaf mtu { type uint16 { @@ -436,6 +449,12 @@ module v3po { uses tap-interface-config-attributes; } + container loopback { + presence "Presence of this container indicates loopback nature of the interface"; + when "../if:type = 'v3po:loopback'"; + uses loopback-interface-base-attributes; + } + container ethernet { when "../if:type = 'ianaift:ethernetCsmacd'"; uses ethernet-base-attributes; diff --git a/v3po/postman_rest_collection.json b/v3po/postman_rest_collection.json index e25cfb6f2..15e61afdc 100644 --- a/v3po/postman_rest_collection.json +++ b/v3po/postman_rest_collection.json @@ -33,6 +33,17 @@ "owner": "45557", "collectionId": "e9ba4e80-fb4d-1eae-07e7-97b323164130" }, + { + "id": "f59ae95c-b691-1283-8b2b-539a00da0178", + "name": "Loopback", + "description": "", + "order": [ + "3090675a-fb54-3cc8-71d7-0675b7b79eb8", + "9306bff2-f310-986e-44cf-7845ba82b980" + ], + "owner": "45557", + "collectionId": "e9ba4e80-fb4d-1eae-07e7-97b323164130" + }, { "id": "e742a44e-2e82-fe0c-d7c1-2f6b6bc1f0e9", "name": "Bridge Domain management", @@ -205,6 +216,46 @@ "public": false, "published": false, "requests": [ + { + "id": "3090675a-fb54-3cc8-71d7-0675b7b79eb8", + "headers": "Authorization: Basic YWRtaW46YWRtaW4=\nContent-Type: application/json\n", + "url": "http://localhost:8183/restconf/config/ietf-interfaces:interfaces/interface/loop1", + "preRequestScript": "", + "pathVariables": {}, + "method": "PUT", + "data": [], + "dataMode": "raw", + "version": 2, + "tests": "", + "currentHelper": "normal", + "helperAttributes": {}, + "time": 1478080135790, + "name": "Add loopback ifc - cfg ", + "description": "create loop interface", + "collectionId": "5bad4634-e5cf-900e-9733-0976aa9bea64", + "responses": [], + "rawModeData": "{\r\n \r\n \"interface\": [\r\n {\r\n \"name\": \"loop1\",\r\n \"description\": \"for testing purposes\",\r\n \"type\": \"v3po:loopback\",\r\n \"loopback\" :{\r\n \"mac\" : \"00:ff:ff:ff:ff:ff\"\r\n }\r\n }\r\n ]\r\n \r\n}" + }, + { + "id": "9306bff2-f310-986e-44cf-7845ba82b980", + "headers": "Authorization: Basic YWRtaW46YWRtaW4=\nContent-Type: application/json\n", + "url": "http://localhost:8183/restconf/config/ietf-interfaces:interfaces/interface/loop1", + "preRequestScript": "", + "pathVariables": {}, + "method": "DELETE", + "data": [], + "dataMode": "raw", + "version": 2, + "tests": "", + "currentHelper": "normal", + "helperAttributes": {}, + "time": 1478085084456, + "name": "Delete loopback ifc - cfg ", + "description": "delete loop interface intfc loop1", + "collectionId": "5bad4634-e5cf-900e-9733-0976aa9bea64", + "responses": [], + "rawModeData": "" + }, { "id": "4fd61184-7a23-f84a-6734-b2c96d10c908", "headers": "Authorization: Basic YWRtaW46YWRtaW4=\nContent-Type: application/json\n", diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/InterfacesWriterFactory.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/InterfacesWriterFactory.java index 63593afd5..7bf5a432c 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/InterfacesWriterFactory.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/InterfacesWriterFactory.java @@ -28,15 +28,16 @@ import io.fd.honeycomb.translate.v3po.interfaces.EthernetCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.GreCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.InterfaceCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.L2Customizer; +import io.fd.honeycomb.translate.v3po.interfaces.LoopbackCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.ProxyArpCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.RoutingCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.TapCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.VhostUserCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.VxlanCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.VxlanGpeCustomizer; -import io.fd.honeycomb.translate.v3po.interfaces.acl.ingress.IetfAclCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.acl.egress.EgressIetfAclWriter; import io.fd.honeycomb.translate.v3po.interfaces.acl.ingress.AclCustomizer; +import io.fd.honeycomb.translate.v3po.interfaces.acl.ingress.IetfAclCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.acl.ingress.IngressIetfAclWriter; import io.fd.honeycomb.translate.v3po.interfaces.ip.Ipv4AddressCustomizer; import io.fd.honeycomb.translate.v3po.interfaces.ip.Ipv4Customizer; @@ -62,6 +63,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Gre; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.IetfAcl; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.L2; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Loopback; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.ProxyArp; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Routing; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Tap; @@ -173,6 +175,10 @@ public final class InterfacesWriterFactory implements WriterFactory { final InstanceIdentifier tapId = VPP_IFC_AUG_ID.child(Tap.class); registry.addBefore(new GenericWriter<>(tapId, new TapCustomizer(jvpp, ifcNamingContext)), ifcId); + // Loopback(Needs to be executed before Interface customizer) = + final InstanceIdentifier loopbackId = VPP_IFC_AUG_ID.child(Loopback.class); + registry.addBefore(new GenericWriter<>(loopbackId, new LoopbackCustomizer(jvpp, ifcNamingContext)), + ifcId); // Gre(Needs to be executed before Interface customizer) = final InstanceIdentifier greId = VPP_IFC_AUG_ID.child(Gre.class); diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfaces/LoopbackCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfaces/LoopbackCustomizer.java new file mode 100644 index 000000000..47a71750d --- /dev/null +++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfaces/LoopbackCustomizer.java @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.translate.v3po.interfaces; + +import io.fd.honeycomb.translate.vpp.util.AbstractInterfaceTypeCustomizer; +import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.vpp.util.MacTranslator; +import io.fd.honeycomb.translate.vpp.util.NamingContext; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.CreateLoopback; +import io.fd.vpp.jvpp.core.dto.CreateLoopbackReply; +import io.fd.vpp.jvpp.core.dto.DeleteLoopback; +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.interfaces.rev140508.InterfaceType; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Loopback; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public final class LoopbackCustomizer extends AbstractInterfaceTypeCustomizer + implements MacTranslator, JvppReplyConsumer { + + private static final Logger LOG = LoggerFactory.getLogger(LoopbackCustomizer.class); + private final NamingContext interfaceContext; + + public LoopbackCustomizer(final FutureJVppCore vppApi, final NamingContext interfaceContext) { + super(vppApi); + this.interfaceContext = interfaceContext; + } + + @Override + protected Class getExpectedInterfaceType() { + return org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.Loopback.class; + } + + @Override + protected final void writeInterface(@Nonnull final InstanceIdentifier id, @Nonnull final Loopback dataAfter, + @Nonnull final WriteContext writeContext) + throws WriteFailedException { + final String ifcName = id.firstKeyOf(Interface.class).getName(); + createLoopback(id, ifcName, dataAfter, writeContext); + } + + @Override + public void updateCurrentAttributes(@Nonnull final InstanceIdentifier id, @Nonnull final Loopback dataBefore, + @Nonnull final Loopback dataAfter, @Nonnull final WriteContext writeContext) + throws WriteFailedException { + throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, + new UnsupportedOperationException("Modification of loopback interface is not supported")); + } + + @Override + public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier id, @Nonnull final Loopback dataBefore, + @Nonnull final WriteContext writeContext) + throws WriteFailedException { + final String ifcName = id.firstKeyOf(Interface.class).getName(); + + final int index; + try { + index = interfaceContext.getIndex(ifcName, writeContext.getMappingContext()); + } catch (IllegalArgumentException e) { + throw new WriteFailedException.DeleteFailedException(id, e); + } + + deleteLoopback(id, ifcName, index, dataBefore, writeContext); + } + + private void createLoopback(final InstanceIdentifier id, final String swIfName, final Loopback loopback, + final WriteContext writeContext) throws WriteFailedException { + LOG.debug("Setting loopback interface: {}. Loopback: {}", swIfName, loopback); + + final CreateLoopback createLoopback = new CreateLoopback(); + if (loopback.getMac() != null) { + createLoopback.macAddress = parseMac(loopback.getMac().getValue()); + } + final CreateLoopbackReply reply = + getReplyForCreate(getFutureJVpp().createLoopback(createLoopback).toCompletableFuture(), id, loopback); + + LOG.debug("Loopback set successfully for: {}, loopback: {}", swIfName, loopback); + // Add new interface to our interface context + interfaceContext.addName(reply.swIfIndex, swIfName, writeContext.getMappingContext()); + } + + private void deleteLoopback(final InstanceIdentifier id, final String swIfName, final int index, + final Loopback dataBefore, final WriteContext writeContext) + throws WriteFailedException { + LOG.debug("Deleting loopback interface: {}. Loopback: {}", swIfName, dataBefore); + final DeleteLoopback deleteLoopback = new DeleteLoopback(); + deleteLoopback.swIfIndex = index; + getReplyForDelete(getFutureJVpp().deleteLoopback(deleteLoopback).toCompletableFuture(), id); + LOG.debug("Loopback deleted successfully for: {}, loopback: {}", swIfName, dataBefore); + // Remove deleted interface from interface context + interfaceContext.removeName(swIfName, writeContext.getMappingContext()); + } +} diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceCustomizer.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceCustomizer.java index fdb8397dd..4308f34a0 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceCustomizer.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceCustomizer.java @@ -72,6 +72,11 @@ public class InterfaceCustomizer extends FutureJVppCustomizer this.interfaceDisableContext = interfaceDisableContext; } + public static void cacheInterfaceDump(final @Nonnull ReadContext context, final SwInterfaceDetailsReplyDump ifaces) { + context.getModificationCache().put(DUMPED_IFCS_CONTEXT_KEY, ifaces.swInterfaceDetails.stream() + .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails))); + } + @Nonnull @SuppressWarnings("unchecked") public static Map getCachedInterfaceDump(@Nonnull final ModificationCache ctx) { @@ -155,8 +160,7 @@ public class InterfaceCustomizer extends FutureJVppCustomizer } // Cache interfaces dump in per-tx context to later be used in readCurrentAttributes - context.getModificationCache().put(DUMPED_IFCS_CONTEXT_KEY, ifaces.swInterfaceDetails.stream() - .collect(Collectors.toMap(t -> t.swIfIndex, swInterfaceDetails -> swInterfaceDetails))); + cacheInterfaceDump(context, ifaces); final MappingContext mappingCtx = context.getMappingContext(); final Set interfacesIdxs = ifaces.swInterfaceDetails.stream() diff --git a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceDataTranslator.java b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceDataTranslator.java index 376b7863f..2864c6e6a 100644 --- a/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceDataTranslator.java +++ b/v3po/v3po2vpp/src/main/java/io/fd/honeycomb/translate/v3po/interfacesstate/InterfaceDataTranslator.java @@ -40,6 +40,7 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces. import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Gauge64; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.GreTunnel; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.Loopback; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.Tap; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VhostUser; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VxlanGpeTunnel; @@ -253,6 +254,10 @@ public interface InterfaceDataTranslator extends ByteDataTranslator, JvppReplyCo return VhostUser.class; } + if (interfaceName.startsWith("loop")) { + return Loopback.class; + } + return EthernetCsmacd.class; } diff --git a/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/translate/v3po/interfaces/LoopbackCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/translate/v3po/interfaces/LoopbackCustomizerTest.java new file mode 100644 index 000000000..60af7a143 --- /dev/null +++ b/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/translate/v3po/interfaces/LoopbackCustomizerTest.java @@ -0,0 +1,105 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.translate.v3po.interfaces; + +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import io.fd.honeycomb.translate.vpp.util.NamingContext; +import io.fd.honeycomb.vpp.test.write.WriterCustomizerTest; +import io.fd.vpp.jvpp.core.dto.CreateLoopback; +import io.fd.vpp.jvpp.core.dto.CreateLoopbackReply; +import io.fd.vpp.jvpp.core.dto.DeleteLoopback; +import io.fd.vpp.jvpp.core.dto.DeleteLoopbackReply; +import org.junit.Test; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.VppInterfaceAugmentation; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.Loopback; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.interfaces._interface.LoopbackBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class LoopbackCustomizerTest extends WriterCustomizerTest { + + private static final String IFC_TEST_INSTANCE = "ifc-test-instance"; + private LoopbackCustomizer loopCustomizer; + + @Override + public void setUp() throws Exception { + InterfaceTypeTestUtils.setupWriteContext(writeContext, + org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev161214.Loopback.class); + loopCustomizer = new LoopbackCustomizer(api, new NamingContext("ifcintest", IFC_TEST_INSTANCE)); + } + + @Test + public void testCreate() throws Exception { + doAnswer(new Answer() { + + int idx = 0; + + @Override + public Object answer(final InvocationOnMock invocation) throws Throwable { + final CreateLoopbackReply t = new CreateLoopbackReply(); + t.swIfIndex = idx++; + return future(t); + } + }).when(api).createLoopback(any(CreateLoopback.class)); + + loopCustomizer.writeCurrentAttributes(getLoopbackId("loop"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext); + loopCustomizer.writeCurrentAttributes(getLoopbackId("loop2"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext); + + verify(api, times(2)).createLoopback(any(CreateLoopback.class)); + verify(mappingContext).put(eq(mappingIid("loop", IFC_TEST_INSTANCE)), eq( + mapping("loop", 0).get())); + verify(mappingContext).put(eq(mappingIid("loop2", IFC_TEST_INSTANCE)), eq( + mapping("loop2", 1).get())); + } + + @Test + public void testDelete() throws Exception { + final CreateLoopbackReply t = new CreateLoopbackReply(); + t.swIfIndex = 0; + doReturn(future(t)).when(api).createLoopback(any(CreateLoopback.class)); + + doReturn(future(new DeleteLoopbackReply())).when(api).deleteLoopback(any(DeleteLoopback.class)); + + loopCustomizer.writeCurrentAttributes(getLoopbackId("loop"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext); + defineMapping(mappingContext, "loop", 1, IFC_TEST_INSTANCE); + loopCustomizer.deleteCurrentAttributes(getLoopbackId("loop"), getLoopbackData("ff:ff:ff:ff:ff:ff"), writeContext); + + verify(api).createLoopback(any(CreateLoopback.class)); + verify(api).deleteLoopback(any(DeleteLoopback.class)); + verify(mappingContext).delete(eq(mappingIid("loop", IFC_TEST_INSTANCE))); + } + + private InstanceIdentifier getLoopbackId(final String loop) { + return InstanceIdentifier.create(Interfaces.class).child(Interface.class, new InterfaceKey(loop)).augmentation( + VppInterfaceAugmentation.class).child(Loopback.class); + } + + private Loopback getLoopbackData(final String mac) { + return new LoopbackBuilder().setMac(new PhysAddress(mac)).build(); + } +} \ No newline at end of file -- cgit 1.2.3-korg