diff options
Diffstat (limited to 'acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read')
7 files changed, 279 insertions, 20 deletions
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizer.java index 782c1c007..e222c2142 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizer.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizer.java @@ -18,6 +18,7 @@ package io.fd.hc2vpp.acl.read; import com.google.common.base.Optional; import com.google.common.collect.ImmutableSet; +import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer; import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; @@ -58,14 +59,14 @@ abstract class AbstractVppAclCustomizer extends FutureJVppAclCustomizer ByteDataTranslator { private final NamingContext interfaceContext; - private final NamingContext standardAclContext; + private final AclContextManager standardAclContext; private final DumpCacheManager<AclInterfaceListDetailsReplyDump, Integer> aclReferenceDumpManager; private final DumpCacheManager<AclDetailsReplyDump, Integer> aclDumpManager; protected AbstractVppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, @Nonnull final NamingContext interfaceContext, - @Nonnull final NamingContext standardAclContext) { + @Nonnull final AclContextManager standardAclContext) { super(jVppAclFacade); this.interfaceContext = interfaceContext; this.standardAclContext = standardAclContext; @@ -127,7 +128,7 @@ abstract class AbstractVppAclCustomizer extends FutureJVppAclCustomizer // dump message in vpp) final AclInterfaceListDetails aclDetails = dumpReply.get().aclInterfaceListDetails.get(0); return filterAcls(aclDetails) - .mapToObj(aclIndex -> standardAclContext.getName(aclIndex, context.getMappingContext())) + .mapToObj(aclIndex -> standardAclContext.getAclName(aclIndex, context.getMappingContext())) .map(aclName -> new VppAclsKey(aclName, VppAcl.class)) .collect(Collectors.toList()); } else { @@ -155,13 +156,13 @@ abstract class AbstractVppAclCustomizer extends FutureJVppAclCustomizer @Nonnull final ReadContext ctx) throws ReadFailedException { final VppAclsKey vppAclsKey = id.firstKeyOf(VppAcls.class); final String aclName = vppAclsKey.getName(); - final int aclIndex = standardAclContext.getIndex(aclName, ctx.getMappingContext()); + final int aclIndex = standardAclContext.getAclIndex(aclName, ctx.getMappingContext()); final Optional<AclDetailsReplyDump> dumpReply = aclDumpManager.getDump(id, ctx.getModificationCache(), aclIndex); if (dumpReply.isPresent() && !dumpReply.get().aclDetails.isEmpty()) { - // FIXME (model expects hex string, but tag is written and read as ascii string) + // TODO(HONEYCOMB-330): (model expects hex string, but tag is written and read as ascii string) // decide how tag should be handled (model change might be needed). builder.setName(aclName); builder.setType(vppAclsKey.getType()); diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AclCustomizer.java new file mode 100644 index 000000000..83fc3186c --- /dev/null +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AclCustomizer.java @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.acl.read; + +import com.google.common.base.Optional; +import io.fd.hc2vpp.acl.util.AclContextManager; +import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer; +import io.fd.hc2vpp.acl.util.ace.AceConverter; +import io.fd.hc2vpp.acl.util.protocol.IpProtocolReader; +import io.fd.hc2vpp.common.translate.util.Ipv4Translator; +import io.fd.hc2vpp.common.translate.util.Ipv6Translator; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.Initialized; +import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer; +import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager; +import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor; +import io.fd.vpp.jvpp.acl.dto.AclDetails; +import io.fd.vpp.jvpp.acl.dto.AclDetailsReplyDump; +import io.fd.vpp.jvpp.acl.dto.AclDump; +import io.fd.vpp.jvpp.acl.dto.MacipAclDetails; +import io.fd.vpp.jvpp.acl.dto.MacipAclDetailsReplyDump; +import io.fd.vpp.jvpp.acl.dto.MacipAclDump; +import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; +import java.util.ArrayList; +import java.util.List; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AccessListsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AclBase; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.AclKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.AccessListEntriesBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.VppAcl; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.VppMacipAcl; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class AclCustomizer extends FutureJVppAclCustomizer + implements InitializingListReaderCustomizer<Acl, AclKey, AclBuilder>, JvppReplyConsumer, Ipv6Translator, + Ipv4Translator, IpProtocolReader, AceConverter { + + private static final Integer READ_ALL = -1; + private final AclContextManager standardAclContext; + private final AclContextManager macipAclContext; + + private final DumpCacheManager<AclDetailsReplyDump, Integer> vppAclDumpManager; + private final DumpCacheManager<MacipAclDetailsReplyDump, Integer> macipAclDumpManager; + + public AclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, + @Nonnull final AclContextManager standardAclContext, + @Nonnull final AclContextManager macipAclContext) { + super(jVppAclFacade); + this.standardAclContext = standardAclContext; + this.macipAclContext = macipAclContext; + + vppAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<AclDetailsReplyDump, Integer>() + .withExecutor(createVppAclExecutor()) + .acceptOnly(AclDetailsReplyDump.class) + .build(); + + macipAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<MacipAclDetailsReplyDump, Integer>() + .withExecutor(createMacipAclExecutor()) + .acceptOnly(MacipAclDetailsReplyDump.class) + .build(); + } + + private EntityDumpExecutor<AclDetailsReplyDump, Integer> createVppAclExecutor() { + return (identifier, params) -> { + AclDump request = new AclDump(); + request.aclIndex = params; + return getReplyForRead(getjVppAclFacade().aclDump(request).toCompletableFuture(), identifier); + }; + } + + private EntityDumpExecutor<MacipAclDetailsReplyDump, Integer> createMacipAclExecutor() { + return (identifier, params) -> { + MacipAclDump request = new MacipAclDump(); + request.aclIndex = params; + return getReplyForRead(getjVppAclFacade().macipAclDump(request).toCompletableFuture(), identifier); + }; + } + + @Nonnull + @Override + public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<Acl> id, + @Nonnull final Acl readValue, + @Nonnull final ReadContext ctx) { + return Initialized.create(id, readValue); + } + + @Nonnull + @Override + public List<AclKey> getAllIds(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final ReadContext context) + throws ReadFailedException { + final List<AclKey> keys = new ArrayList<>(); + + final Optional<AclDetailsReplyDump> vppAclDump = + vppAclDumpManager.getDump(id, context.getModificationCache(), READ_ALL); + if (vppAclDump.isPresent()) { + vppAclDump.get().aclDetails.stream() + .map(details -> standardAclContext.getAclName(details.aclIndex, context.getMappingContext())) + .forEach(name -> keys.add(new AclKey(name, VppAcl.class))); + } + + final Optional<MacipAclDetailsReplyDump> macipAclDump = + macipAclDumpManager.getDump(id, context.getModificationCache(), READ_ALL); + if (macipAclDump.isPresent()) { + macipAclDump.get().macipAclDetails.stream() + .map(details -> macipAclContext.getAclName(details.aclIndex, context.getMappingContext())) + .forEach(name -> keys.add(new AclKey(name, VppMacipAcl.class))); + } + + return keys; + } + + @Override + public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Acl> readData) { + ((AccessListsBuilder)builder).setAcl(readData); + } + + @Nonnull + @Override + public AclBuilder getBuilder(@Nonnull final InstanceIdentifier<Acl> id) { + return new AclBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final AclBuilder builder, + @Nonnull final ReadContext ctx) throws ReadFailedException { + final AclKey key = id.firstKeyOf(Acl.class); + builder.setKey(key); + final Class<? extends AclBase> aclType = key.getAclType(); + final String name = key.getAclName(); + + if (aclType.equals(VppAcl.class)) { + final int index = standardAclContext.getAclIndex(name, ctx.getMappingContext()); + final Optional<AclDetailsReplyDump> dump = vppAclDumpManager.getDump(id, ctx.getModificationCache(), index); + + if (dump.isPresent() && !dump.get().aclDetails.isEmpty()) { + final java.util.Optional<AclDetails> detail = dump.get().aclDetails.stream() + .filter(acl -> acl.aclIndex == index).findFirst(); + if (detail.isPresent()) { + builder.setAccessListEntries(new AccessListEntriesBuilder() + .setAce(toStandardAces(name, detail.get().r, standardAclContext, ctx.getMappingContext())) + .build()); + } + } + } else if (aclType.equals(VppMacipAcl.class)) { + final int index = macipAclContext.getAclIndex(name, ctx.getMappingContext()); + final Optional<MacipAclDetailsReplyDump> dump = + macipAclDumpManager.getDump(id, ctx.getModificationCache(), index); + + if (dump.isPresent() && !dump.get().macipAclDetails.isEmpty()) { + final java.util.Optional<MacipAclDetails> detail = + dump.get().macipAclDetails.stream().filter(acl -> acl.aclIndex == index).findFirst(); + if (detail.isPresent()) { + builder.setAccessListEntries(new AccessListEntriesBuilder() + .setAce(toMacIpAces(name, detail.get().r, macipAclContext, ctx.getMappingContext())) + .build()); + } + } + } else { + throw new IllegalArgumentException("Unsupported acl type: " + aclType); + } + } +} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizer.java index eaabb0bff..8e5d0dfce 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizer.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizer.java @@ -16,6 +16,7 @@ package io.fd.hc2vpp.acl.read; +import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.common.translate.util.NamingContext; import io.fd.honeycomb.translate.util.RWUtils; import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails; @@ -36,7 +37,7 @@ public final class EgressVppAclCustomizer extends AbstractVppAclCustomizer { public EgressVppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, @Nonnull final NamingContext interfaceContext, - @Nonnull final NamingContext standardAclContext) { + @Nonnull final AclContextManager standardAclContext) { super(jVppAclFacade, interfaceContext, standardAclContext); } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizer.java index e8c79c967..598066282 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizer.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizer.java @@ -16,6 +16,7 @@ package io.fd.hc2vpp.acl.read; +import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.common.translate.util.NamingContext; import io.fd.honeycomb.translate.util.RWUtils; import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails; @@ -36,7 +37,7 @@ public final class IngressVppAclCustomizer extends AbstractVppAclCustomizer { public IngressVppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, @Nonnull final NamingContext interfaceContext, - @Nonnull final NamingContext standardAclContext) { + @Nonnull final AclContextManager standardAclContext) { super(jVppAclFacade, interfaceContext, standardAclContext); } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizer.java index 81799e1fa..23776fe07 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizer.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizer.java @@ -20,6 +20,7 @@ import static io.fd.hc2vpp.acl.read.AbstractVppAclCustomizer.getAclCfgId; import static io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor.NO_PARAMS; import com.google.common.base.Optional; +import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer; import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; @@ -61,11 +62,11 @@ public class VppMacIpAclCustomizer extends FutureJVppAclCustomizer private final DumpCacheManager<MacipAclDetailsReplyDump, Integer> macIpAclDumpManager; private final DumpCacheManager<MacipAclInterfaceGetReply, Void> interfaceMacIpAclDumpManager; private final NamingContext interfaceContext; - private final NamingContext macIpAclContext; + private final AclContextManager macIpAclContext; public VppMacIpAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, @Nonnull final NamingContext interfaceContext, - @Nonnull final NamingContext macIpAclContext) { + @Nonnull final AclContextManager macIpAclContext) { super(jVppAclFacade); // for dumping of Mac-ip details @@ -129,7 +130,7 @@ public class VppMacIpAclCustomizer extends FutureJVppAclCustomizer if (macIpDumpReply.isPresent() && !macIpDumpReply.get().macipAclDetails.isEmpty()) { final MacipAclDetails details = macIpDumpReply.get().macipAclDetails.get(0); - builder.setName(macIpAclContext.getName(aclIndex, mappingContext)); + builder.setName(macIpAclContext.getAclName(aclIndex, mappingContext)); builder.setType( org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev161214.VppMacipAcl.class); if (details.tag != null && details.tag.length > 0) { @@ -143,7 +144,7 @@ public class VppMacIpAclCustomizer extends FutureJVppAclCustomizer } } else { // this is valid state, so just logging - LOG.info("No Mac-ip ACL specified for Interface name={},index={}", interfaceName, interfaceIndex); + LOG.debug("No Mac-ip ACL specified for Interface name={},index={}", interfaceName, interfaceIndex); } } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/AclReaderFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/AclReaderFactory.java new file mode 100644 index 000000000..90c4afe83 --- /dev/null +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/AclReaderFactory.java @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.acl.read.factory; + +import static io.fd.hc2vpp.acl.read.factory.InterfaceAclReaderFactory.ACL_EGRESS_IID; +import static io.fd.hc2vpp.acl.read.factory.InterfaceAclReaderFactory.ACL_INGRESS_IID; + +import com.google.common.collect.ImmutableSet; +import com.google.inject.Inject; +import com.google.inject.name.Named; +import io.fd.hc2vpp.acl.AclModule; +import io.fd.hc2vpp.acl.read.AclCustomizer; +import io.fd.hc2vpp.acl.util.AclContextManager; +import io.fd.hc2vpp.acl.util.factory.AclFactory; +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.acl.future.FutureJVppAclFacade; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AccessLists; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.AccessListsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.Acl; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class AclReaderFactory implements ReaderFactory, AclFactory { + + @Inject + private FutureJVppAclFacade futureAclFacade; + + @Inject + @Named(AclModule.STANDARD_ACL_CONTEXT_NAME) + private AclContextManager standardAclContext; + + @Inject + @Named(AclModule.MAC_IP_ACL_CONTEXT_NAME) + private AclContextManager macIpAClContext; + + private static final InstanceIdentifier<AccessLists> ACLS_ID = InstanceIdentifier.create(AccessLists.class); + private static final InstanceIdentifier<Acl> ACL_ID = ACLS_ID.child(Acl.class); + + @Override + public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) { + registry.addStructuralReader(ACLS_ID, AccessListsBuilder.class); + + // TODO(HONEYCOMB-331): initializer is not registered correctly when subtreeAddBefore is used, + // enable after fixing infra issue: + +// registry.subtreeAddBefore(vppAclChildren(InstanceIdentifier.create(Acl.class)), +// new GenericInitListReader<>(ACL_ID, +// new AclCustomizer(futureAclFacade, standardAclContext, macIpAClContext)), +// ImmutableSet.of(ACL_INGRESS_IID, ACL_EGRESS_IID)); + + registry.addBefore(new GenericInitListReader<>(ACL_ID, + new AclCustomizer(futureAclFacade, standardAclContext, macIpAClContext)), + ImmutableSet.of(ACL_INGRESS_IID, ACL_EGRESS_IID)); + } +} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/InterfaceAclReaderFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/InterfaceAclReaderFactory.java index 5b627fbc3..5b2c45088 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/InterfaceAclReaderFactory.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/factory/InterfaceAclReaderFactory.java @@ -22,6 +22,7 @@ import io.fd.hc2vpp.acl.AclModule; import io.fd.hc2vpp.acl.read.EgressVppAclCustomizer; import io.fd.hc2vpp.acl.read.IngressVppAclCustomizer; import io.fd.hc2vpp.acl.read.VppMacIpAclCustomizer; +import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.common.translate.util.NamingContext; import io.fd.honeycomb.translate.impl.read.GenericInitListReader; import io.fd.honeycomb.translate.impl.read.GenericInitReader; @@ -50,11 +51,11 @@ public class InterfaceAclReaderFactory implements ReaderFactory { @Inject @Named(AclModule.STANDARD_ACL_CONTEXT_NAME) - private NamingContext standardAclContext; + private AclContextManager standardAclContext; @Inject @Named(AclModule.MAC_IP_ACL_CONTEXT_NAME) - private NamingContext macIpAClContext; + private AclContextManager macIpAClContext; @Inject @Named("interface-context") @@ -65,22 +66,22 @@ public class InterfaceAclReaderFactory implements ReaderFactory { private static final InstanceIdentifier<VppAclInterfaceStateAugmentation> VPP_ACL_AUG_IID = IFC_ID.augmentation(VppAclInterfaceStateAugmentation.class); private static final InstanceIdentifier<Acl> ACL_IID = VPP_ACL_AUG_IID.child(Acl.class); + static final InstanceIdentifier<Ingress> ACL_INGRESS_IID = ACL_IID.child(Ingress.class); + static final InstanceIdentifier<Egress> ACL_EGRESS_IID = ACL_IID.child(Egress.class); @Override public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) { registry.addStructuralReader(VPP_ACL_AUG_IID, VppAclInterfaceStateAugmentationBuilder.class); registry.addStructuralReader(ACL_IID, AclBuilder.class); - final InstanceIdentifier<Ingress> ingressInstanceIdentifier = ACL_IID.child(Ingress.class); - registry.addStructuralReader(ingressInstanceIdentifier, IngressBuilder.class); - registry.addAfter(new GenericInitListReader<>(ingressInstanceIdentifier.child(VppAcls.class), + registry.addStructuralReader(ACL_INGRESS_IID, IngressBuilder.class); + registry.addAfter(new GenericInitListReader<>(ACL_INGRESS_IID.child(VppAcls.class), new IngressVppAclCustomizer(futureAclFacade, interfaceContext, standardAclContext)), IFC_ID); - registry.addAfter(new GenericInitReader<>(ingressInstanceIdentifier.child(VppMacipAcl.class), + registry.addAfter(new GenericInitReader<>(ACL_INGRESS_IID.child(VppMacipAcl.class), new VppMacIpAclCustomizer(futureAclFacade, interfaceContext, macIpAClContext)), IFC_ID); - final InstanceIdentifier<Egress> egressInstanceIdentifier = ACL_IID.child(Egress.class); - registry.addStructuralReader(egressInstanceIdentifier, EgressBuilder.class); - registry.addAfter(new GenericInitListReader<>(egressInstanceIdentifier.child(VppAcls.class), + registry.addStructuralReader(ACL_EGRESS_IID, EgressBuilder.class); + registry.addAfter(new GenericInitListReader<>(ACL_EGRESS_IID.child(VppAcls.class), new EgressVppAclCustomizer(futureAclFacade, interfaceContext, standardAclContext)), IFC_ID); } } |