diff options
Diffstat (limited to 'acl/acl-impl/src')
66 files changed, 2804 insertions, 2406 deletions
diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclIIds.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclIIds.java new file mode 100644 index 000000000..ad4bcae68 --- /dev/null +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclIIds.java @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2018 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; + +import com.google.common.collect.ImmutableSet; +import java.util.Set; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAclAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppIcmpAceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppTcpAceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpCodeRange; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpTypeRange; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acls.acl.aces.ace.matches.l4.icmp.icmp.VppIcmpAce; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acls.acl.aces.ace.matches.l4.tcp.tcp.VppTcpAce; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Acls; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPoints; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.Aces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Actions; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Matches; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.eth.Eth; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.icmp.Icmp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.Tcp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.DestinationPort; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.SourcePort; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.Udp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.Egress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.Ingress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSets; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; +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.InterfacesState; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class AclIIds { + public final static InstanceIdentifier<Acls> ACLS = InstanceIdentifier.create(Acls.class); + public final static InstanceIdentifier<Acl> ACLS_ACL = ACLS.child(Acl.class); + public final static InstanceIdentifier<Acl> ACL = InstanceIdentifier.create(Acl.class); + + public final static InstanceIdentifier<AttachmentPoints> ACLS_AP = ACLS.child(AttachmentPoints.class); + public final static InstanceIdentifier<Interface> ACLS_AP_INT = ACLS_AP.child(Interface.class); + public static final InstanceIdentifier<Ingress> ACLS_AP_INT_ING = ACLS_AP_INT.child(Ingress.class); + public static final InstanceIdentifier<AclSets> ACLS_AP_INT_ING_ACLS = ACLS_AP_INT_ING.child(AclSets.class); + public static final InstanceIdentifier<AclSet> ACLS_AP_INT_ING_ACLS_ACL = ACLS_AP_INT_ING_ACLS.child(AclSet.class); + public static final InstanceIdentifier<Egress> ACLS_AP_INT_EGR = ACLS_AP_INT.child(Egress.class); + public static final InstanceIdentifier<AclSets> ACLS_AP_INT_EGR_ACLS = ACLS_AP_INT_EGR.child(AclSets.class); + public static final InstanceIdentifier<AclSet> ACLS_AP_INT_EGR_ACLS_ACL = ACLS_AP_INT_EGR_ACLS.child(AclSet.class); + public final static InstanceIdentifier<Interface> IFC_ACL = InstanceIdentifier.create(Interface.class); + public final static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface> + IFC = InstanceIdentifier.create(Interfaces.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface.class); + public static final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface> + IFC_STATE = InstanceIdentifier.create(InterfacesState.class) + .child(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.class); + + + public static Set<InstanceIdentifier<?>> vppAclChildren(final InstanceIdentifier<Acl> parentId) { + final InstanceIdentifier<Matches> matchesIid = + parentId.child(Aces.class).child(Ace.class).child(Matches.class); + return ImmutableSet.of( + parentId.augmentation(VppAclAugmentation.class), + parentId.child(Aces.class), + parentId.child(Aces.class).child(Ace.class), + parentId.child(Aces.class).child(Ace.class).child(Actions.class), + matchesIid, + matchesIid.child(Eth.class), + matchesIid.child(Ipv4.class), + matchesIid.child(Ipv6.class), + matchesIid.child(Tcp.class), + matchesIid.child(Tcp.class).augmentation(VppTcpAceAugmentation.class), + matchesIid.child(Tcp.class).augmentation(VppTcpAceAugmentation.class).child(VppTcpAce.class), + matchesIid.child(Tcp.class).child(DestinationPort.class), + matchesIid.child(Tcp.class).child(SourcePort.class), + matchesIid.child(Udp.class), + matchesIid.child(Udp.class).child( + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.DestinationPort.class), + matchesIid.child(Udp.class).child( + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.SourcePort.class), + matchesIid.child(Icmp.class), + matchesIid.child(Icmp.class).augmentation(VppIcmpAceAugmentation.class), + matchesIid.child(Icmp.class).augmentation(VppIcmpAceAugmentation.class).child(VppIcmpAce.class), + matchesIid.child(Icmp.class).augmentation(VppIcmpAceAugmentation.class).child(VppIcmpAce.class) + .child(IcmpTypeRange.class), + matchesIid.child(Icmp.class).augmentation(VppIcmpAceAugmentation.class).child(VppIcmpAce.class) + .child(IcmpCodeRange.class) + ); + } + + public static Set<InstanceIdentifier<?>> aclHandledChildren(final InstanceIdentifier<Interface> parentId) { + return ImmutableSet.of( + parentId.child(Ingress.class), + parentId.child(Ingress.class).child(AclSets.class), + parentId.child(Ingress.class).child(AclSets.class).child(AclSet.class), + parentId.child(Egress.class), + parentId.child(Egress.class).child(AclSets.class), + parentId.child(Egress.class).child(AclSets.class).child(AclSet.class)); + } +} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclModule.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclModule.java index afb7da669..a21978e73 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclModule.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/AclModule.java @@ -26,8 +26,8 @@ import io.fd.hc2vpp.acl.read.factory.AclReaderFactory; import io.fd.hc2vpp.acl.read.factory.InterfaceAclReaderFactory; import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.acl.util.AclContextManagerImpl; +import io.fd.hc2vpp.acl.write.factory.AclWriterFactory; import io.fd.hc2vpp.acl.write.factory.InterfaceAclWriterFactory; -import io.fd.hc2vpp.acl.write.factory.VppAclWriterFactory; import io.fd.honeycomb.translate.read.ReaderFactory; import io.fd.honeycomb.translate.write.WriterFactory; import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; @@ -72,7 +72,7 @@ public class AclModule extends AbstractModule { final Multibinder<WriterFactory> writerFactoryMultibinder = Multibinder.newSetBinder(binder(), WriterFactory.class); - writerFactoryMultibinder.addBinding().to(VppAclWriterFactory.class); + writerFactoryMultibinder.addBinding().to(AclWriterFactory.class); writerFactoryMultibinder.addBinding().to(InterfaceAclWriterFactory.class); final Multibinder<ReaderFactory> readerFactoryMultibinder = diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractAclCustomizer.java new file mode 100644 index 000000000..5f6ca36b3 --- /dev/null +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractAclCustomizer.java @@ -0,0 +1,133 @@ +/* + * 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.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.JvppReplyConsumer; +import io.fd.hc2vpp.common.translate.util.NamingContext; +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.honeycomb.translate.util.read.cache.DumpCacheManager; +import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager.DumpCacheManagerBuilder; +import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor; +import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory; +import io.fd.vpp.jvpp.acl.dto.AclDetailsReplyDump; +import io.fd.vpp.jvpp.acl.dto.AclDump; +import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails; +import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump; +import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDump; +import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; +import java.util.Arrays; +import java.util.stream.Stream; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +abstract class AbstractAclCustomizer extends FutureJVppAclCustomizer implements JvppReplyConsumer { + + final NamingContext interfaceContext; + final AclContextManager standardAclContext; + + final DumpCacheManager<AclInterfaceListDetailsReplyDump, Integer> aclReferenceDumpManager; + final DumpCacheManager<AclDetailsReplyDump, Integer> aclDumpManager; + + protected AbstractAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, + @Nonnull final NamingContext interfaceContext, + @Nonnull final AclContextManager standardAclContext) { + super(jVppAclFacade); + this.interfaceContext = interfaceContext; + this.standardAclContext = standardAclContext; + + aclReferenceDumpManager = + new DumpCacheManagerBuilder<AclInterfaceListDetailsReplyDump, Integer>() + .withExecutor(createAclReferenceDumpExecutor()) + // Key needs to contain interface ID to distinguish dumps between interfaces + .withCacheKeyFactory( + new TypeAwareIdentifierCacheKeyFactory(AclInterfaceListDetailsReplyDump.class, + ImmutableSet.of(Interface.class))) + .build(); + + aclDumpManager = new DumpCacheManagerBuilder<AclDetailsReplyDump, Integer>() + .withExecutor(createAclExecutor()) + .acceptOnly(AclDetailsReplyDump.class) + .build(); + } + + private EntityDumpExecutor<AclDetailsReplyDump, Integer> createAclExecutor() { + return (identifier, params) -> { + AclDump request = new AclDump(); + request.aclIndex = params; + return getReplyForRead(getjVppAclFacade().aclDump(request).toCompletableFuture(), identifier); + }; + } + + private EntityDumpExecutor<AclInterfaceListDetailsReplyDump, Integer> createAclReferenceDumpExecutor() { + return (identifier, params) -> { + AclInterfaceListDump dumpRequest = new AclInterfaceListDump(); + dumpRequest.swIfIndex = params; + return getReplyForRead(getjVppAclFacade().aclInterfaceListDump(dumpRequest).toCompletableFuture(), + identifier); + }; + } + + Stream<AclSetKey> getStandardAclSetKeys(@Nonnull final ReadContext readContext, + final Optional<AclInterfaceListDetailsReplyDump> dumpReply, + final boolean isIngress) { + if (dumpReply.isPresent() && !dumpReply.get().aclInterfaceListDetails.isEmpty()) { + // if dumpReply is present, then aclInterfaceListDetails contains single element (actually it should not be + // dump message in vpp) + final AclInterfaceListDetails aclDetails = dumpReply.get().aclInterfaceListDetails.get(0); + + if (isIngress) { + return Arrays.stream(aclDetails.acls).limit(aclDetails.nInput) + .mapToObj(aclIndex -> standardAclContext.getAclName(aclIndex, readContext.getMappingContext())) + .map(AclSetKey::new); + } else { + return Arrays.stream(aclDetails.acls).skip(aclDetails.nInput) + .mapToObj(aclIndex -> standardAclContext.getAclName(aclIndex, readContext.getMappingContext())) + .map(AclSetKey::new); + } + } else { + return Stream.empty(); + } + } + + void parseStandardAclSet(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier, + @Nonnull final AclSetBuilder aclSetBuilder, final String aclName, + final MappingContext mappingContext, final ModificationCache modificationCache) + throws ReadFailedException { + final int aclIndex = standardAclContext.getAclIndex(aclName, mappingContext); + + final Optional<AclDetailsReplyDump> dumpReply = + aclDumpManager.getDump(instanceIdentifier, modificationCache, aclIndex); + + if (dumpReply.isPresent() && !dumpReply.get().aclDetails.isEmpty()) { + aclSetBuilder.setName(aclName); + } else { + throw new ReadFailedException(instanceIdentifier, + new IllegalArgumentException(String.format("Acl with name %s not found", aclName))); + } + } +} 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 deleted file mode 100644 index c6d61f653..000000000 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizer.java +++ /dev/null @@ -1,180 +0,0 @@ -/* - * 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.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; -import io.fd.hc2vpp.common.translate.util.NamingContext; -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.DumpCacheManager.DumpCacheManagerBuilder; -import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor; -import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory; -import io.fd.vpp.jvpp.acl.dto.AclDetailsReplyDump; -import io.fd.vpp.jvpp.acl.dto.AclDump; -import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails; -import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump; -import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDump; -import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; -import java.util.Collections; -import java.util.List; -import java.util.stream.Collectors; -import java.util.stream.IntStream; -import javax.annotation.Nonnull; -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.state.Interface; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAclsBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAclsKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAcl; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - -abstract class AbstractVppAclCustomizer extends FutureJVppAclCustomizer - implements InitializingListReaderCustomizer<VppAcls, VppAclsKey, VppAclsBuilder>, JvppReplyConsumer, - ByteDataTranslator { - - private final NamingContext interfaceContext; - 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 AclContextManager standardAclContext) { - super(jVppAclFacade); - this.interfaceContext = interfaceContext; - this.standardAclContext = standardAclContext; - - aclReferenceDumpManager = - new DumpCacheManagerBuilder<AclInterfaceListDetailsReplyDump, Integer>() - .withExecutor(createAclReferenceDumpExecutor()) - // Key needs to contain interface ID to distinguish dumps between interfaces - .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(AclInterfaceListDetailsReplyDump.class, - ImmutableSet.of(Interface.class))) - .build(); - - aclDumpManager = new DumpCacheManagerBuilder<AclDetailsReplyDump, Integer>() - .withExecutor(createAclExecutor()) - .acceptOnly(AclDetailsReplyDump.class) - .build(); - } - - protected static InstanceIdentifier<Acl> getAclCfgId( - final InstanceIdentifier<Acl> id) { - return InstanceIdentifier.create(Interfaces.class).child( - org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface.class, - new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey( - id.firstKeyOf(Interface.class).getName())).augmentation(VppAclInterfaceAugmentation.class) - .child(Acl.class); - } - - private EntityDumpExecutor<AclDetailsReplyDump, Integer> createAclExecutor() { - return (identifier, params) -> { - AclDump request = new AclDump(); - request.aclIndex = params; - return getReplyForRead(getjVppAclFacade().aclDump(request).toCompletableFuture(), identifier); - }; - } - - private EntityDumpExecutor<AclInterfaceListDetailsReplyDump, Integer> createAclReferenceDumpExecutor() { - return (identifier, params) -> { - AclInterfaceListDump dumpRequest = new AclInterfaceListDump(); - dumpRequest.swIfIndex = params; - return getReplyForRead(getjVppAclFacade().aclInterfaceListDump(dumpRequest).toCompletableFuture(), - identifier); - }; - } - - @Nonnull - @Override - public final List<VppAclsKey> getAllIds(@Nonnull final InstanceIdentifier<VppAcls> id, - @Nonnull final ReadContext context) - throws ReadFailedException { - - final String parentInterfaceName = id.firstKeyOf(Interface.class).getName(); - final int parentInterfaceIndex = interfaceContext.getIndex(parentInterfaceName, context.getMappingContext()); - - final Optional<AclInterfaceListDetailsReplyDump> dumpReply = - aclReferenceDumpManager.getDump(id, context.getModificationCache(), parentInterfaceIndex); - - if (dumpReply.isPresent() && !dumpReply.get().aclInterfaceListDetails.isEmpty()) { - // if dumpReply is present, then aclInterfaceListDetails contains single element (actually it should not be - // dump message in vpp) - final AclInterfaceListDetails aclDetails = dumpReply.get().aclInterfaceListDetails.get(0); - return filterAcls(aclDetails) - .mapToObj(aclIndex -> standardAclContext.getAclName(aclIndex, context.getMappingContext())) - .map(aclName -> new VppAclsKey(aclName, VppAcl.class)) - .collect(Collectors.toList()); - } else { - return Collections.emptyList(); - } - } - - /** - * Streams ids of ACLs. - * - * @param aclDetails describes ACLs assigned to interface - * @return sequence of acl ids - */ - protected abstract IntStream filterAcls(@Nonnull final AclInterfaceListDetails aclDetails); - - @Nonnull - @Override - public final VppAclsBuilder getBuilder(@Nonnull final InstanceIdentifier<VppAcls> id) { - return new VppAclsBuilder(); - } - - @Override - public final void readCurrentAttributes(@Nonnull final InstanceIdentifier<VppAcls> id, - @Nonnull final VppAclsBuilder builder, - @Nonnull final ReadContext ctx) throws ReadFailedException { - final VppAclsKey vppAclsKey = id.firstKeyOf(VppAcls.class); - final String aclName = vppAclsKey.getName(); - 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()) { - builder.setName(aclName); - builder.setType(vppAclsKey.getType()); - } else { - throw new ReadFailedException(id, - new IllegalArgumentException(String.format("Acl with name %s not found", aclName))); - } - } - - @Nonnull - @Override - public Initialized<VppAcls> init(@Nonnull final InstanceIdentifier<VppAcls> id, - @Nonnull final VppAcls vppAcls, - @Nonnull final ReadContext readContext) { - return Initialized.create(getCfgId(id), vppAcls); - } - - protected abstract InstanceIdentifier<VppAcls> getCfgId(final InstanceIdentifier<VppAcls> id); -} 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 index 0ebc938ea..e1f0ccf14 100644 --- 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 @@ -41,16 +41,13 @@ import java.util.ArrayList; import java.util.List; import javax.annotation.Nonnull; import javax.annotation.Nullable; -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.rev170615.VppAcl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAclAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAclAugmentationBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAcl; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAclAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAclAugmentationBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.AclsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.AcesBuilder; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -119,7 +116,7 @@ public class AclCustomizer extends FutureJVppAclCustomizer if (vppAclDump.isPresent()) { vppAclDump.get().aclDetails.stream() .map(details -> standardAclContext.getAclName(details.aclIndex, context.getMappingContext())) - .forEach(name -> keys.add(new AclKey(name, VppAcl.class))); + .forEach(name -> keys.add(new AclKey(name))); } final Optional<MacipAclDetailsReplyDump> macipAclDump = @@ -127,7 +124,7 @@ public class AclCustomizer extends FutureJVppAclCustomizer if (macipAclDump.isPresent()) { macipAclDump.get().macipAclDetails.stream() .map(details -> macipAclContext.getAclName(details.aclIndex, context.getMappingContext())) - .forEach(name -> keys.add(new AclKey(name, VppMacipAcl.class))); + .forEach(name -> keys.add(new AclKey(name))); } return keys; @@ -135,7 +132,7 @@ public class AclCustomizer extends FutureJVppAclCustomizer @Override public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Acl> readData) { - ((AccessListsBuilder)builder).setAcl(readData); + ((AclsBuilder) builder).setAcl(readData); } @Nonnull @@ -149,10 +146,9 @@ public class AclCustomizer extends FutureJVppAclCustomizer @Nonnull final ReadContext ctx) throws ReadFailedException { final AclKey key = id.firstKeyOf(Acl.class); builder.withKey(key); - final Class<? extends AclBase> aclType = key.getAclType(); - final String name = key.getAclName(); + final String name = key.getName(); - if (aclType.equals(VppAcl.class)) { + if (standardAclContext.containsAcl(name, ctx.getMappingContext())) { final int index = standardAclContext.getAclIndex(name, ctx.getMappingContext()); final Optional<AclDetailsReplyDump> dump = vppAclDumpManager.getDump(id, ctx.getModificationCache(), index); @@ -162,12 +158,12 @@ public class AclCustomizer extends FutureJVppAclCustomizer if (detail.isPresent()) { final AclDetails aclDetails = detail.get(); setTag(builder, aclDetails.tag); - builder.setAccessListEntries(new AccessListEntriesBuilder() + builder.setAces(new AcesBuilder() .setAce(toStandardAces(name, aclDetails.r, standardAclContext, ctx.getMappingContext())) .build()); } } - } else if (aclType.equals(VppMacipAcl.class)) { + } else if (macipAclContext.containsAcl(name, ctx.getMappingContext())) { final int index = macipAclContext.getAclIndex(name, ctx.getMappingContext()); final Optional<MacipAclDetailsReplyDump> dump = macipAclDumpManager.getDump(id, ctx.getModificationCache(), index); @@ -178,13 +174,13 @@ public class AclCustomizer extends FutureJVppAclCustomizer final MacipAclDetails macipAclDetails = detail.get(); setTag(builder, macipAclDetails.tag); if (detail.isPresent()) { - builder.setAccessListEntries(new AccessListEntriesBuilder() + builder.setAces(new AcesBuilder() .setAce(toMacIpAces(name, macipAclDetails.r, macipAclContext, ctx.getMappingContext())) .build()); } } } else { - throw new IllegalArgumentException("Unsupported acl type: " + aclType); + throw new IllegalArgumentException("Unsupported acl: " + id); } } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressAclCustomizer.java new file mode 100644 index 000000000..59990d5ea --- /dev/null +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressAclCustomizer.java @@ -0,0 +1,102 @@ +/* + * 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.hc2vpp.acl.read; + +import com.google.common.base.Optional; +import io.fd.hc2vpp.acl.util.AclContextManager; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.common.translate.util.NamingContext; +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.honeycomb.translate.spi.read.Initialized; +import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer; +import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump; +import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; +import java.util.List; +import java.util.stream.Collectors; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class EgressAclCustomizer extends AbstractAclCustomizer + implements InitializingListReaderCustomizer<AclSet, AclSetKey, AclSetBuilder>, JvppReplyConsumer { + + public EgressAclCustomizer(final FutureJVppAclFacade futureAclFacade, final NamingContext interfaceContext, + final AclContextManager standardAclContext) { + super(futureAclFacade, interfaceContext, standardAclContext); + } + + @Nonnull + @Override + public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier, + @Nonnull final AclSet aclSet, + @Nonnull final ReadContext readContext) { + return Initialized.create(instanceIdentifier, aclSet); + } + + @Nonnull + @Override + public List<AclSetKey> getAllIds(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier, + @Nonnull final ReadContext readContext) throws ReadFailedException { + final String parentInterfaceName = instanceIdentifier.firstKeyOf(Interface.class).getInterfaceId(); + final int parentInterfaceIndex = + interfaceContext.getIndex(parentInterfaceName, readContext.getMappingContext()); + + //TODO stdDumpReply keys need to be filtered as egress only + final Optional<AclInterfaceListDetailsReplyDump> stdDumpReply = + aclReferenceDumpManager + .getDump(instanceIdentifier, readContext.getModificationCache(), parentInterfaceIndex); + + return getStandardAclSetKeys(readContext, stdDumpReply, false).collect(Collectors.toList()); + } + + @Override + public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<AclSet> list) { + ((AclSetsBuilder) builder).setAclSet(list); + } + + @Nonnull + @Override + public AclSetBuilder getBuilder(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier) { + return new AclSetBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier, + @Nonnull final AclSetBuilder aclSetBuilder, + @Nonnull final ReadContext readContext) + throws ReadFailedException { + final AclSetKey vppAclsKey = instanceIdentifier.firstKeyOf(AclSet.class); + final String aclName = vppAclsKey.getName(); + final MappingContext mappingContext = readContext.getMappingContext(); + ModificationCache modificationCache = readContext.getModificationCache(); + + if (standardAclContext.containsAcl(aclName, mappingContext)) { + parseStandardAclSet(instanceIdentifier, aclSetBuilder, aclName, mappingContext, modificationCache); + } + + } +} 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 deleted file mode 100644 index 8e5d0dfce..000000000 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizer.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * 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.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; -import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; -import java.util.Arrays; -import java.util.List; -import java.util.stream.IntStream; -import javax.annotation.Nonnull; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Egress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.EgressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; -import org.opendaylight.yangtools.concepts.Builder; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - -public final class EgressVppAclCustomizer extends AbstractVppAclCustomizer { - - public EgressVppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, - @Nonnull final NamingContext interfaceContext, - @Nonnull final AclContextManager standardAclContext) { - super(jVppAclFacade, interfaceContext, standardAclContext); - } - - @Override - protected IntStream filterAcls(@Nonnull final AclInterfaceListDetails aclDetails) { - return Arrays.stream(aclDetails.acls).skip(aclDetails.nInput); - } - - @Override - public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<VppAcls> readData) { - EgressBuilder.class.cast(builder).setVppAcls(readData); - } - - @Override - protected InstanceIdentifier<VppAcls> getCfgId( - final InstanceIdentifier<VppAcls> id) { - return getAclCfgId(RWUtils.cutId(id, Acl.class)).child(Egress.class) - .child(VppAcls.class, id.firstKeyOf(VppAcls.class)); - } -} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressAclCustomizer.java new file mode 100644 index 000000000..467c4e5db --- /dev/null +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressAclCustomizer.java @@ -0,0 +1,226 @@ +/* + * 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.hc2vpp.acl.read; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Optional; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Streams; +import io.fd.hc2vpp.acl.util.AclContextManager; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.common.translate.util.NamingContext; +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.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.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory; +import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump; +import io.fd.vpp.jvpp.acl.dto.MacipAclDetailsReplyDump; +import io.fd.vpp.jvpp.acl.dto.MacipAclDump; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceGet; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceGetReply; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDetails; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDetailsReplyDump; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDump; +import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class IngressAclCustomizer extends AbstractAclCustomizer + implements InitializingListReaderCustomizer<AclSet, AclSetKey, AclSetBuilder>, JvppReplyConsumer { + @VisibleForTesting + protected static final int ACL_NOT_ASSIGNED = -1; + private static final Logger LOG = LoggerFactory.getLogger(IngressAclCustomizer.class); + + private final AclContextManager macIpAclContext; + + private final DumpCacheManager<MacipAclDetailsReplyDump, Integer> macIpAclDumpManager; + private final DumpCacheManager<MacipAclInterfaceGetReply, Void> interfaceMacIpAclDumpManager; + private final DumpCacheManager<MacipAclInterfaceListDetailsReplyDump, Integer> macAclReferenceDumpManager; + + public IngressAclCustomizer(final FutureJVppAclFacade futureAclFacade, final NamingContext interfaceContext, + final AclContextManager standardAclContext, final AclContextManager macIpAClContext) { + super(futureAclFacade, interfaceContext, standardAclContext); + this.macIpAclContext = macIpAClContext; + + macAclReferenceDumpManager = + new DumpCacheManager.DumpCacheManagerBuilder<MacipAclInterfaceListDetailsReplyDump, Integer>() + .withExecutor(createMacIpAclReferenceDumpExecutor()) + // Key needs to contain interface ID to distinguish dumps between interfaces + .withCacheKeyFactory( + new TypeAwareIdentifierCacheKeyFactory(MacipAclInterfaceListDetailsReplyDump.class, + ImmutableSet.of(Interface.class))) + .build(); + + // for dumping of Mac-ip details + macIpAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<MacipAclDetailsReplyDump, Integer>() + .withExecutor(createMacIpDumpExecutor()) + .acceptOnly(MacipAclDetailsReplyDump.class) + .build(); + + // for dumping of reference on interface + interfaceMacIpAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<MacipAclInterfaceGetReply, Void>() + .withExecutor(createInterfaceMacIpDumpExecutor()) + .acceptOnly(MacipAclInterfaceGetReply.class) + .build(); + } + + @Nonnull + @Override + public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier, + @Nonnull final AclSet aclSet, + @Nonnull final ReadContext readContext) { + return Initialized.create(instanceIdentifier, aclSet); + } + + @Nonnull + @Override + public List<AclSetKey> getAllIds(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier, + @Nonnull final ReadContext readContext) throws ReadFailedException { + final String parentInterfaceName = instanceIdentifier.firstKeyOf(Interface.class).getInterfaceId(); + final int parentInterfaceIndex = + interfaceContext.getIndex(parentInterfaceName, readContext.getMappingContext()); + + //TODO stdDumpReply keys need to be filtered as ingress only + final Optional<AclInterfaceListDetailsReplyDump> stdDumpReply = + aclReferenceDumpManager + .getDump(instanceIdentifier, readContext.getModificationCache(), parentInterfaceIndex); + final Optional<MacipAclInterfaceListDetailsReplyDump> macipDumpReply = + macAclReferenceDumpManager + .getDump(instanceIdentifier, readContext.getModificationCache(), parentInterfaceIndex); + + Stream<AclSetKey> macIpAclSetKeys = getMacIpAclSetKeys(readContext, macipDumpReply); + Stream<AclSetKey> standardAclSetKeys = getStandardAclSetKeys(readContext, stdDumpReply, true); + + return Streams.concat(standardAclSetKeys, macIpAclSetKeys).distinct().collect(Collectors.toList()); + } + + @Override + public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<AclSet> list) { + ((AclSetsBuilder) builder).setAclSet(list); + } + + @Nonnull + @Override + public AclSetBuilder getBuilder(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier) { + return new AclSetBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier, + @Nonnull final AclSetBuilder aclSetBuilder, + @Nonnull final ReadContext readContext) throws ReadFailedException { + final AclSetKey vppAclsKey = instanceIdentifier.firstKeyOf(AclSet.class); + final String interfaceName = instanceIdentifier.firstKeyOf(Interface.class).getInterfaceId(); + final String aclName = vppAclsKey.getName(); + final MappingContext mappingContext = readContext.getMappingContext(); + ModificationCache modificationCache = readContext.getModificationCache(); + + if (standardAclContext.containsAcl(aclName, mappingContext)) { + parseStandardAclSet(instanceIdentifier, aclSetBuilder, aclName, mappingContext, modificationCache); + } else if (macIpAclContext.containsAcl(aclName, mappingContext)) { + parseMacIpAclSet(instanceIdentifier, aclSetBuilder, interfaceName, mappingContext, modificationCache); + } + } + + public void parseMacIpAclSet(@Nonnull final InstanceIdentifier<AclSet> instanceIdentifier, + @Nonnull final AclSetBuilder aclSetBuilder, + final String interfaceName, final MappingContext mappingContext, + final ModificationCache modificationCache) + throws ReadFailedException { + final Optional<MacipAclInterfaceGetReply> interfacesMacIpDumpReply = + interfaceMacIpAclDumpManager.getDump(instanceIdentifier, modificationCache); + final int interfaceIndex = interfaceContext.getIndex(interfaceName, mappingContext); + MacipAclInterfaceGetReply reply = interfacesMacIpDumpReply.get(); + if (reply.acls == null || reply.acls.length == 0) { + LOG.debug("No MacACls found for interface. Iid: {}", instanceIdentifier); + return; + } + final int aclIndex = reply.acls[interfaceIndex]; + if (aclIndex != ACL_NOT_ASSIGNED) { + final Optional<MacipAclDetailsReplyDump> macIpDumpReply = + macIpAclDumpManager.getDump(instanceIdentifier, modificationCache, aclIndex); + + if (macIpDumpReply.isPresent() && !macIpDumpReply.get().macipAclDetails.isEmpty()) { + aclSetBuilder.setName(macIpAclContext.getAclName(aclIndex, mappingContext)); + } else { + // this is invalid state(Interface in VPP will act as "deny-all" for security reasons), but generally + // it should not happen + throw new ReadFailedException(instanceIdentifier, + new IllegalStateException(String.format("ACE with index %s not found in VPP", aclIndex))); + } + } + } + + private EntityDumpExecutor<MacipAclInterfaceListDetailsReplyDump, Integer> createMacIpAclReferenceDumpExecutor() { + return (identifier, params) -> { + MacipAclInterfaceListDump dumpRequest = new MacipAclInterfaceListDump(); + dumpRequest.swIfIndex = params; + return getReplyForRead(getjVppAclFacade().macipAclInterfaceListDump(dumpRequest).toCompletableFuture(), + identifier); + }; + } + + private EntityDumpExecutor<MacipAclDetailsReplyDump, Integer> createMacIpDumpExecutor() { + return (identifier, params) -> { + MacipAclDump request = new MacipAclDump(); + request.aclIndex = params; + + return getReplyForRead(getjVppAclFacade().macipAclDump(request).toCompletableFuture(), identifier); + }; + } + + private EntityDumpExecutor<MacipAclInterfaceGetReply, Void> createInterfaceMacIpDumpExecutor() { + return (identifier, params) -> getReplyForRead( + getjVppAclFacade().macipAclInterfaceGet(new MacipAclInterfaceGet()).toCompletableFuture(), + identifier); + } + + + private Stream<AclSetKey> getMacIpAclSetKeys(@Nonnull final ReadContext readContext, + final Optional<MacipAclInterfaceListDetailsReplyDump> dumpReply) { + if (dumpReply.isPresent() && !dumpReply.get().macipAclInterfaceListDetails.isEmpty()) { + // if dumpReply is present, then aclInterfaceListDetails contains single element (actually it should not be + // dump message in vpp) + final MacipAclInterfaceListDetails aclDetails = dumpReply.get().macipAclInterfaceListDetails.get(0); + + return Arrays.stream(aclDetails.acls).limit(aclDetails.count) + .mapToObj(aclIndex -> macIpAclContext.getAclName(aclIndex, readContext.getMappingContext())) + .map(AclSetKey::new); + } else { + return Stream.empty(); + } + } +} 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 deleted file mode 100644 index 598066282..000000000 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizer.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * 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.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; -import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; -import java.util.Arrays; -import java.util.List; -import java.util.stream.IntStream; -import javax.annotation.Nonnull; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.IngressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; -import org.opendaylight.yangtools.concepts.Builder; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - -public final class IngressVppAclCustomizer extends AbstractVppAclCustomizer { - - public IngressVppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, - @Nonnull final NamingContext interfaceContext, - @Nonnull final AclContextManager standardAclContext) { - super(jVppAclFacade, interfaceContext, standardAclContext); - } - - @Override - protected IntStream filterAcls(@Nonnull final AclInterfaceListDetails aclDetails) { - return Arrays.stream(aclDetails.acls).limit(aclDetails.nInput); - } - - @Override - public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<VppAcls> readData) { - IngressBuilder.class.cast(builder).setVppAcls(readData); - } - - @Override - protected InstanceIdentifier<VppAcls> getCfgId( - final InstanceIdentifier<VppAcls> id) { - return getAclCfgId(RWUtils.cutId(id, Acl.class)).child(Ingress.class) - .child(VppAcls.class, id.firstKeyOf(VppAcls.class)); - } -} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/InterfaceAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/InterfaceAclCustomizer.java new file mode 100644 index 000000000..64720de5d --- /dev/null +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/InterfaceAclCustomizer.java @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2018 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 com.google.common.collect.Streams; +import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.common.translate.util.NamingContext; +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.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump; +import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDump; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDetailsReplyDump; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDump; +import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; +import java.util.Collection; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPointsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceKey; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfaceAclCustomizer extends FutureJVppAclCustomizer implements + InitializingListReaderCustomizer<Interface, InterfaceKey, InterfaceBuilder>, JvppReplyConsumer { + private final NamingContext interfaceContext; + + private final DumpCacheManager<MacipAclInterfaceListDetailsReplyDump, Void> macipAclInterfaceListDumpManager; + private final DumpCacheManager<AclInterfaceListDetailsReplyDump, Void> aclInterfaceListDumpManager; + + public InterfaceAclCustomizer(final FutureJVppAclFacade futureAclFacade, final NamingContext interfaceContext) { + super(futureAclFacade); + this.interfaceContext = interfaceContext; + + //list all standard ACL interfaces + AclInterfaceListDump aclInterfaceListDump = new AclInterfaceListDump(); + aclInterfaceListDump.swIfIndex = -1; + aclInterfaceListDumpManager = + new DumpCacheManager.DumpCacheManagerBuilder<AclInterfaceListDetailsReplyDump, Void>() + .withExecutor((identifier, params) -> getReplyForRead( + getjVppAclFacade().aclInterfaceListDump(aclInterfaceListDump).toCompletableFuture(), + identifier)) + .acceptOnly(AclInterfaceListDetailsReplyDump.class) + .build(); + + //list all macIp ACL interfaces + MacipAclInterfaceListDump macipAclInterfaceListDump = new MacipAclInterfaceListDump(); + macipAclInterfaceListDump.swIfIndex = 0; + macipAclInterfaceListDumpManager = + new DumpCacheManager.DumpCacheManagerBuilder<MacipAclInterfaceListDetailsReplyDump, Void>() + .withExecutor((identifier, params) -> getReplyForRead( + getjVppAclFacade().macipAclInterfaceListDump(macipAclInterfaceListDump) + .toCompletableFuture(), + identifier)) + .acceptOnly(MacipAclInterfaceListDetailsReplyDump.class) + .build(); + } + + @Nonnull + @Override + public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, + @Nonnull final Interface anInterface, + @Nonnull final ReadContext readContext) { + return Initialized.create(instanceIdentifier, anInterface); + } + + @Nonnull + @Override + public List<InterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, + @Nonnull final ReadContext readContext) throws ReadFailedException { + final Optional<AclInterfaceListDetailsReplyDump> stdIfcDumpReply = + aclInterfaceListDumpManager.getDump(instanceIdentifier, readContext.getModificationCache()); + + final Optional<MacipAclInterfaceListDetailsReplyDump> macIpIfcDumpReply = + macipAclInterfaceListDumpManager.getDump(instanceIdentifier, readContext.getModificationCache()); + + Stream<InterfaceKey> stdAclIfcKeys = stdIfcDumpReply.asSet().stream() + .map(dump -> dump.aclInterfaceListDetails) + .flatMap(Collection::stream) + .filter(aclInterfaceListDetails -> aclInterfaceListDetails.acls.length != 0) + .map(details -> getInterfaceKey(readContext, details.swIfIndex)); + + Stream<InterfaceKey> macIpAclIfcKeys = macIpIfcDumpReply.asSet().stream() + .map(dump -> dump.macipAclInterfaceListDetails) + .flatMap(Collection::stream) + .map(details -> getInterfaceKey(readContext, details.swIfIndex)); + return Streams.concat(stdAclIfcKeys, macIpAclIfcKeys).distinct().collect(Collectors.toList()); + } + + private InterfaceKey getInterfaceKey(@Nonnull final ReadContext readContext, final int swIfIndex) { + return new InterfaceKey(interfaceContext.getName(swIfIndex, readContext.getMappingContext())); + } + + @Override + public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Interface> list) { + ((AttachmentPointsBuilder) builder).setInterface(list); + } + + @Nonnull + @Override + public InterfaceBuilder getBuilder(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier) { + return new InterfaceBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> instanceIdentifier, + @Nonnull final InterfaceBuilder interfaceBuilder, + @Nonnull final ReadContext readContext) + throws ReadFailedException { + interfaceBuilder.withKey(instanceIdentifier.firstKeyOf(Interface.class)); + } +} 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 deleted file mode 100644 index 0ae05826c..000000000 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizer.java +++ /dev/null @@ -1,160 +0,0 @@ -/* - * 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.hc2vpp.acl.read; - -import static io.fd.hc2vpp.acl.read.AbstractVppAclCustomizer.getAclCfgId; - -import com.google.common.annotations.VisibleForTesting; -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; -import io.fd.hc2vpp.common.translate.util.NamingContext; -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.honeycomb.translate.spi.read.Initialized; -import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer; -import io.fd.honeycomb.translate.util.RWUtils; -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.MacipAclDetailsReplyDump; -import io.fd.vpp.jvpp.acl.dto.MacipAclDump; -import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceGet; -import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceGetReply; -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.interfaces.rev140508.interfaces.state.Interface; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.IngressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAclBuilder; -import org.opendaylight.yangtools.concepts.Builder; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class VppMacIpAclCustomizer extends FutureJVppAclCustomizer - implements InitializingReaderCustomizer<VppMacipAcl, VppMacipAclBuilder>, JvppReplyConsumer, ByteDataTranslator { - - private static final Logger LOG = LoggerFactory.getLogger(VppMacIpAclCustomizer.class); - @VisibleForTesting - protected static final int ACL_NOT_ASSIGNED = -1; - - private final DumpCacheManager<MacipAclDetailsReplyDump, Integer> macIpAclDumpManager; - private final DumpCacheManager<MacipAclInterfaceGetReply, Void> interfaceMacIpAclDumpManager; - private final NamingContext interfaceContext; - private final AclContextManager macIpAclContext; - - public VppMacIpAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, - @Nonnull final NamingContext interfaceContext, - @Nonnull final AclContextManager macIpAclContext) { - super(jVppAclFacade); - - // for dumping of Mac-ip details - macIpAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<MacipAclDetailsReplyDump, Integer>() - .withExecutor(createMacIpDumpExecutor()) - .acceptOnly(MacipAclDetailsReplyDump.class) - .build(); - - // for dumping of reference on interface - interfaceMacIpAclDumpManager = new DumpCacheManager.DumpCacheManagerBuilder<MacipAclInterfaceGetReply, Void>() - .withExecutor(createInterfaceMacIpDumpExecutor()) - .acceptOnly(MacipAclInterfaceGetReply.class) - .build(); - this.interfaceContext = interfaceContext; - this.macIpAclContext = macIpAclContext; - } - - private static InstanceIdentifier<VppMacipAcl> getCfgId( - final InstanceIdentifier<VppMacipAcl> id) { - return getAclCfgId(RWUtils.cutId(id, Acl.class)).child(Ingress.class).child(VppMacipAcl.class); - } - - private EntityDumpExecutor<MacipAclDetailsReplyDump, Integer> createMacIpDumpExecutor() { - return (identifier, params) -> { - MacipAclDump request = new MacipAclDump(); - request.aclIndex = params; - - return getReplyForRead(getjVppAclFacade().macipAclDump(request).toCompletableFuture(), identifier); - }; - } - - private EntityDumpExecutor<MacipAclInterfaceGetReply, Void> createInterfaceMacIpDumpExecutor() { - return (identifier, params) -> getReplyForRead( - getjVppAclFacade().macipAclInterfaceGet(new MacipAclInterfaceGet()).toCompletableFuture(), - identifier); - } - - @Nonnull - @Override - public VppMacipAclBuilder getBuilder(@Nonnull final InstanceIdentifier<VppMacipAcl> id) { - return new VppMacipAclBuilder(); - } - - @Override - public void readCurrentAttributes(@Nonnull final InstanceIdentifier<VppMacipAcl> id, - @Nonnull final VppMacipAclBuilder builder, - @Nonnull final ReadContext ctx) throws ReadFailedException { - final String interfaceName = id.firstKeyOf(Interface.class).getName(); - final MappingContext mappingContext = ctx.getMappingContext(); - final int interfaceIndex = interfaceContext.getIndex(interfaceName, mappingContext); - final ModificationCache modificationCache = ctx.getModificationCache(); - final Optional<MacipAclInterfaceGetReply> interfacesMacIpDumpReply = - interfaceMacIpAclDumpManager.getDump(id, modificationCache); - - if (interfacesMacIpDumpReply.isPresent() && interfaceIndex < interfacesMacIpDumpReply.get().count) { - final int aclIndex = interfacesMacIpDumpReply.get().acls[interfaceIndex]; - if (aclIndex != ACL_NOT_ASSIGNED) { - final Optional<MacipAclDetailsReplyDump> macIpDumpReply = - macIpAclDumpManager.getDump(id, modificationCache, aclIndex); - - if (macIpDumpReply.isPresent() && !macIpDumpReply.get().macipAclDetails.isEmpty()) { - builder.setName(macIpAclContext.getAclName(aclIndex, mappingContext)); - builder.setType( - org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAcl.class); - return; - } else { - // this is invalid state(Interface in VPP will act as "deny-all" for security reasons), but generally - // it should not happen - throw new ReadFailedException(id, - new IllegalStateException(String.format("ACE with index %s not found in VPP", aclIndex))); - } - } - } - // this is valid state, so just logging - LOG.debug("No Mac-ip ACL specified for Interface name={},index={}", interfaceName, interfaceIndex); - } - - @Override - public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, - @Nonnull final VppMacipAcl readValue) { - IngressBuilder.class.cast(parentBuilder).setVppMacipAcl(readValue); - } - - @Nonnull - @Override - public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<VppMacipAcl> id, - @Nonnull final VppMacipAcl readValue, - @Nonnull final ReadContext ctx) { - return Initialized.create(getCfgId(id), readValue); - } -} 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 index 34352e8f3..6a743ca80 100644 --- 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 @@ -16,27 +16,23 @@ 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 static io.fd.hc2vpp.acl.AclIIds.vppAclChildren; import com.google.common.collect.ImmutableSet; import com.google.inject.Inject; import com.google.inject.name.Named; +import io.fd.hc2vpp.acl.AclIIds; 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; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.AclsBuilder; -public class AclReaderFactory implements ReaderFactory, AclFactory { +public class AclReaderFactory implements ReaderFactory { @Inject private FutureJVppAclFacade futureAclFacade; @@ -49,16 +45,13 @@ public class AclReaderFactory implements ReaderFactory, AclFactory { @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); + registry.addStructuralReader(AclIIds.ACLS, AclsBuilder.class); - registry.subtreeAddBefore(vppAclChildren(InstanceIdentifier.create(Acl.class)), - new GenericInitListReader<>(ACL_ID, + registry.subtreeAddBefore(vppAclChildren(AclIIds.ACL), + new GenericInitListReader<>(AclIIds.ACLS_ACL, new AclCustomizer(futureAclFacade, standardAclContext, macIpAClContext)), - ImmutableSet.of(ACL_INGRESS_IID, ACL_EGRESS_IID)); + ImmutableSet.of(AclIIds.ACLS_AP_INT_ING, AclIIds.ACLS_AP_INT_EGR)); } } 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 173223648..1c4f0d982 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 @@ -18,31 +18,22 @@ package io.fd.hc2vpp.acl.read.factory; import com.google.inject.Inject; import com.google.inject.name.Named; +import io.fd.hc2vpp.acl.AclIIds; 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.read.InterfaceAclCustomizer; +import io.fd.hc2vpp.acl.read.EgressAclCustomizer; +import io.fd.hc2vpp.acl.read.IngressAclCustomizer; 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; 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.interfaces.rev140508.InterfacesState; -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.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceStateAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceStateAugmentationBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.AclBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Egress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.EgressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.IngressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPointsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.EgressBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.IngressBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder; public class InterfaceAclReaderFactory implements ReaderFactory { @@ -61,27 +52,23 @@ public class InterfaceAclReaderFactory implements ReaderFactory { @Named("interface-context") private NamingContext interfaceContext; - private static final InstanceIdentifier<Interface> - IFC_ID = InstanceIdentifier.create(InterfacesState.class).child(Interface.class); - private static final InstanceIdentifier<VppAclInterfaceStateAugmentation> VPP_ACL_AUG_IID = - IFC_ID.augmentation(VppAclInterfaceStateAugmentation.class); - 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); + registry.addStructuralReader(AclIIds.ACLS_AP, AttachmentPointsBuilder.class); + + registry.addAfter(new GenericInitListReader<>(AclIIds.ACLS_AP_INT, + new InterfaceAclCustomizer(futureAclFacade, interfaceContext)), + AclIIds.IFC_STATE); - 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<>(ACL_INGRESS_IID.child(VppMacipAcl.class), - new VppMacIpAclCustomizer(futureAclFacade, interfaceContext, macIpAClContext)), IFC_ID); + registry.addStructuralReader(AclIIds.ACLS_AP_INT_ING, IngressBuilder.class); + registry.addStructuralReader(AclIIds.ACLS_AP_INT_EGR, EgressBuilder.class); + registry.addStructuralReader(AclIIds.ACLS_AP_INT_ING_ACLS, AclSetsBuilder.class); + registry.addStructuralReader(AclIIds.ACLS_AP_INT_EGR_ACLS, AclSetsBuilder.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); + registry.addAfter(new GenericInitListReader<>(AclIIds.ACLS_AP_INT_ING_ACLS_ACL, + new IngressAclCustomizer(futureAclFacade, interfaceContext, standardAclContext, macIpAClContext)), + AclIIds.ACLS_AP_INT); + registry.addAfter(new GenericInitListReader<>(AclIIds.ACLS_AP_INT_EGR_ACLS_ACL, + new EgressAclCustomizer(futureAclFacade, interfaceContext, standardAclContext)), AclIIds.ACLS_AP_INT); } } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManager.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManager.java index 377d4e1dc..1b590cb7b 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManager.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManager.java @@ -19,7 +19,7 @@ package io.fd.hc2vpp.acl.util; import io.fd.honeycomb.translate.MappingContext; 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.access.lists.acl.access.list.entries.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; /** * Manages metadata for acl plugin diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManagerImpl.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManagerImpl.java index aa25c3eb1..a96680897 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManagerImpl.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/AclContextManagerImpl.java @@ -29,18 +29,18 @@ import java.util.List; import java.util.stream.Collector; import javax.annotation.Nonnull; import javax.annotation.concurrent.ThreadSafe; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.VppAclContextAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.VppAclMappings; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.VppAclContext; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.VppAclContextKey; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMapping; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMappingBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMappingKey; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMapping; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMappingBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMappingKey; 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.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.VppAclContextAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.VppAclMappings; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.VppAclContext; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.VppAclContextKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMapping; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMappingBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.AclMappingKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMapping; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMappingBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.context.rev170104.vpp.acl.context.attributes.vpp.acl.mappings.vpp.acl.context.acl.mapping.AceMappingKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; @@ -77,7 +77,7 @@ public final class AclContextManagerImpl implements AclContextManager { final List<AceMapping> mappings = new ArrayList<>(aces.size()); int aceIndex = 0; for (final Ace ace : aces) { - mappings.add(new AceMappingBuilder().setName(ace.getRuleName()).setIndex(aceIndex++).build()); + mappings.add(new AceMappingBuilder().setName(ace.getName()).setIndex(aceIndex++).build()); } aclMapping.setAceMapping(mappings); ctx.put(mappingIid, aclMapping.build()); diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/AceConverter.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/AceConverter.java index db5efb4d6..8e774104a 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/AceConverter.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/AceConverter.java @@ -16,6 +16,7 @@ package io.fd.hc2vpp.acl.util.ace; +import com.google.common.base.Preconditions; import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.acl.util.ace.extractor.MacIpAceDataExtractor; import io.fd.hc2vpp.acl.util.ace.extractor.StandardAceDataExtractor; @@ -27,16 +28,16 @@ import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; import javax.annotation.Nonnull; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.AceBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.AceKey; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.MatchesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAceBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAceBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.VppMacipAceNodesBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.AceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.AceKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.MatchesBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.EthBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.eth.Eth; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.SourceNetwork; /** * Convert between Ace's and vpp rules. @@ -45,23 +46,55 @@ public interface AceConverter extends MacIpAceDataExtractor, StandardAceDataExtr default MacipAclRule[] toMacIpAclRules(@Nonnull final List<Ace> aces) { return aces.stream() + .filter(ace -> ace.getMatches() != null && ace.getMatches().getL2() != null) + .filter(ace -> ace.getMatches().getL2().getImplementedInterface() + .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.Eth.class)) .map(ace -> { - final VppMacipAce macIpAce = fromMacIpAce(ace); - MacipAclRule rule = new MacipAclRule(); + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.Eth + l2 = + (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.Eth) ace + .getMatches().getL2(); + + Eth eth = Preconditions + .checkNotNull(l2.getEth(), "Cannot parse eth for MacIpAcl ACE rule: {}", ace); - rule.srcMac = sourceMacAsBytes(macIpAce); - rule.srcMacMask = sourceMacMaskAsBytes(macIpAce); + rule.srcMac = sourceMacAsBytes(eth.getSourceMacAddress()); + rule.srcMacMask = sourceMacMaskAsBytes(eth.getSourceMacAddressMask()); rule.isPermit = macIpAction(ace); - if (macIpIsIpv6(macIpAce)) { - rule.isIpv6 = 1; - rule.srcIpAddr = ipv6Address(macIpAce); - rule.srcIpPrefixLen = ipv6AddressPrefix(macIpAce); + L3 l3 = ace.getMatches().getL3(); + + if (l3 != null && l3.getImplementedInterface() + .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4.class)) { + Ipv4 ipv4 = + ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4) l3) + .getIpv4(); + if (ipv4 != null && ipv4.getSourceNetwork() != null) { + // IPv4 is set for MacIpAcl + SourceNetwork sourceNetwork = ipv4.getSourceNetwork(); + rule.isIpv6 = 0; + rule.srcIpAddr = ipv4Address(sourceNetwork); + rule.srcIpPrefixLen = ipv4AddressPrefix(sourceNetwork); + } + } else if (l3 != null && l3.getImplementedInterface() + .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6.class)) { + Ipv6 ipv6 = + ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6) l3) + .getIpv6(); + if (ipv6 != null && ipv6.getSourceNetwork() != null) { + // IPv6 is set for MacIpAcl + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.SourceNetwork + sourceNetwork = ipv6.getSourceNetwork(); + rule.isIpv6 = 1; + rule.srcIpAddr = ipv6Address(sourceNetwork); + rule.srcIpPrefixLen = ipv6AddressPrefix(sourceNetwork); + } } else { + // No IP is set for MacIpAcl rule.isIpv6 = 0; - rule.srcIpAddr = ipv4Address(macIpAce); - rule.srcIpPrefixLen = ipv4AddressPrefix(macIpAce); + rule.srcIpAddr = new byte[4]; + rule.srcIpPrefixLen = 0; } return rule; @@ -72,26 +105,25 @@ public interface AceConverter extends MacIpAceDataExtractor, StandardAceDataExtr default AclRule[] toStandardAclRules(@Nonnull final List<Ace> aces) { return aces.stream() + .filter(ace -> ace.getMatches() != null) .map(ace -> { - final VppAce standardAce = fromStandardAce(ace); - // pre-bind rule with protocol based attributes (if present) - AclRule rule = createPreBindRule(standardAce); + AclRule rule = createPreBindRule(ace); rule.isPermit = standardAction(ace); - if (standardIsIpv6(standardAce, ace.getMatches())) { + if (standardIsIpv6(ace.getMatches())) { rule.isIpv6 = 1; - rule.srcIpAddr = ipv6SourceAddress(standardAce); - rule.srcIpPrefixLen = ipv6SourceAddressPrefix(standardAce); - rule.dstIpAddr = ipv6DestinationAddress(standardAce); - rule.dstIpPrefixLen = ipv6DestinationAddressPrefix(standardAce); + rule.srcIpAddr = ipv6SourceAddress(ace.getMatches()); + rule.srcIpPrefixLen = ipv6SourceAddressPrefix(ace.getMatches()); + rule.dstIpAddr = ipv6DestinationAddress(ace.getMatches()); + rule.dstIpPrefixLen = ipv6DestinationAddressPrefix(ace.getMatches()); } else { rule.isIpv6 = 0; - rule.srcIpAddr = ipv4SourceAddress(standardAce); - rule.srcIpPrefixLen = ipv4SourceAddressPrefix(standardAce); - rule.dstIpAddr = ipv4DestinationAddress(standardAce); - rule.dstIpPrefixLen = ipv4DestinationAddressPrefix(standardAce); + rule.srcIpAddr = ipv4SourceAddress(ace.getMatches()); + rule.srcIpPrefixLen = ipv4SourceAddressPrefix(ace.getMatches()); + rule.dstIpAddr = ipv4DestinationAddress(ace.getMatches()); + rule.dstIpPrefixLen = ipv4DestinationAddressPrefix(ace.getMatches()); } return rule; @@ -107,18 +139,20 @@ public interface AceConverter extends MacIpAceDataExtractor, StandardAceDataExtr int i = 0; for (final MacipAclRule rule : rules) { final AceBuilder ace = new AceBuilder(); - final VppMacipAceBuilder aceType = new VppMacipAceBuilder(); - final VppMacipAceNodesBuilder nodes = new VppMacipAceNodesBuilder(); - nodes.setAceIpVersion(ipVersion(rule)); - nodes.setSourceMacAddress(sourceMac(rule)); - nodes.setSourceMacAddressMask(sourceMacMask(rule)); - aceType.setVppMacipAceNodes(nodes.build()); - - ace.setMatches(new MatchesBuilder().setAceType(aceType.build()).build()); + ace.setMatches( + new MatchesBuilder() + .setL3(parseMacIpAceL3(rule)) + .setL2(new EthBuilder() + .setEth(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.eth.EthBuilder() + .setSourceMacAddress(sourceMac(rule)) + .setSourceMacAddressMask(sourceMacMask(rule)) + .build()) + .build()) + .build()); ace.setActions(actions(rule.isPermit)); final String aceName = macipAclContext.getAceName(aclName, i++, mappingContext); - ace.setRuleName(aceName); + ace.setName(aceName); ace.withKey(new AceKey(aceName)); aces.add(ace.build()); @@ -133,17 +167,14 @@ public interface AceConverter extends MacIpAceDataExtractor, StandardAceDataExtr int i = 0; for (final AclRule rule : rules) { final AceBuilder ace = new AceBuilder(); - final VppAceBuilder aceType = new VppAceBuilder(); - final VppAceNodesBuilder nodes = new VppAceNodesBuilder(); - nodes.setAceIpVersion(ipVersion(rule)); - nodes.setIpProtocol(parseProtocol(rule)); - aceType.setVppAceNodes(nodes.build()); - - ace.setMatches(new MatchesBuilder().setAceType(aceType.build()).build()); + ace.setMatches(new MatchesBuilder() + .setL3(parseStandardAceL3(rule)) + .setL4(parseProtocol(rule)) + .build()); ace.setActions(actions(rule.isPermit)); final String aceName = standardAclContext.getAceName(aclName, i++, mappingContext); - ace.setRuleName(aceName); + ace.setName(aceName); ace.withKey(new AceKey(aceName)); aces.add(ace.build()); } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractor.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractor.java index ddb41ee3c..0c7d761a0 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractor.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractor.java @@ -21,84 +21,67 @@ import io.fd.hc2vpp.common.translate.util.MacTranslator; import io.fd.vpp.jvpp.acl.types.MacipAclRule; import java.util.Optional; import javax.annotation.Nonnull; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.PacketHandling; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Deny; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Permit; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Accept; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Actions; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6Builder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix; 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.packet.fields.rev181001.acl.ipv4.header.fields.SourceNetwork; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4NetworkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6NetworkBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAceEthHeaderFields; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAceIpv4HeaderFields; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAceIpv6HeaderFields; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.VppMacipAceNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.AceIpVersion; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv4Builder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv6; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv6Builder; public interface MacIpAceDataExtractor extends AddressExtractor, MacTranslator { - default VppMacipAce fromMacIpAce(@Nonnull final Ace ace) { - return Optional.ofNullable(ace.getMatches()) - .map(Matches::getAceType) - .map(VppMacipAce.class::cast) - .orElseThrow( - () -> new IllegalArgumentException(String.format("Unable to create VppMacipAce from %s", ace))); - } - - default boolean macIpIsIpv6(@Nonnull final VppMacipAce ace) { - return Optional.ofNullable(ace.getVppMacipAceNodes()) - .map(VppMacipAceNodes::getAceIpVersion) - .map(aceIpVersion -> aceIpVersion instanceof AceIpv6) - .orElse(false); - } - - default byte[] sourceMacAsBytes(@Nonnull final VppMacipAce ace) { - return macToByteArray(Optional.ofNullable(ace.getVppMacipAceNodes()) - .map(VppMacipAceEthHeaderFields::getSourceMacAddress) + default byte[] sourceMacAsBytes(final MacAddress mac) { + return macToByteArray(Optional.ofNullable(mac) .map(MacAddress::getValue) .orElse(Impl.DEFAULT_MAC)); } - default byte[] sourceMacMaskAsBytes(@Nonnull final VppMacipAce ace) { - return macToByteArray(Optional.ofNullable(ace.getVppMacipAceNodes()) - .map(VppMacipAceEthHeaderFields::getSourceMacAddressMask) + default byte[] sourceMacMaskAsBytes(final MacAddress mac) { + return macToByteArray(Optional.ofNullable(mac) .map(MacAddress::getValue) .orElse(Impl.DEFAULT_MAC_MASK)); } - default byte[] ipv4Address(@Nonnull final VppMacipAce ace) { - return extractIp4Address(extractV4NetworkAddressOrNull(ace)); + default byte[] ipv4Address(@Nonnull final SourceNetwork network) { + return extractIp4Address(extractV4NetworkAddressOrNull(network)); } - default byte ipv4AddressPrefix(@Nonnull final VppMacipAce ace) { - return extractIp4AddressPrefix(extractV4NetworkAddressOrNull(ace)); + default byte ipv4AddressPrefix(@Nonnull final SourceNetwork network) { + return extractIp4AddressPrefix(extractV4NetworkAddressOrNull(network)); } - static Ipv4Prefix extractV4NetworkAddressOrNull(final @Nonnull VppMacipAce ace) { - return Optional.ofNullable(ace.getVppMacipAceNodes()) - .map(VppMacipAceNodes::getAceIpVersion) - .map(VppMacipAceIpv4HeaderFields.class::cast) - .map(VppMacipAceIpv4HeaderFields::getSourceIpv4Network) + static Ipv4Prefix extractV4NetworkAddressOrNull(final @Nonnull SourceNetwork network) { + return Optional.of(network).filter(net -> net instanceof SourceIpv4Network) + .map(SourceIpv4Network.class::cast) + .map(SourceIpv4Network::getSourceIpv4Network) .orElse(null); } - default byte[] ipv6Address(@Nonnull final VppMacipAce ace) { - return extractIp6Address(extractV6NetworkAddressOrNull(ace)); + default byte[] ipv6Address( + @Nonnull final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.SourceNetwork network) { + return extractIp6Address(extractV6NetworkAddressOrNull(network)); } - default byte ipv6AddressPrefix(@Nonnull final VppMacipAce ace) { - return extractIp6AddressPrefix(extractV6NetworkAddressOrNull(ace)); + default byte ipv6AddressPrefix( + @Nonnull final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.SourceNetwork network) { + return extractIp6AddressPrefix(extractV6NetworkAddressOrNull(network)); } - default Ipv6Prefix extractV6NetworkAddressOrNull(@Nonnull final VppMacipAce ace) { - return Optional.ofNullable(ace.getVppMacipAceNodes()) - .map(VppMacipAceNodes::getAceIpVersion) - .map(VppMacipAceIpv6HeaderFields.class::cast) - .map(VppMacipAceIpv6HeaderFields::getSourceIpv6Network) + default Ipv6Prefix extractV6NetworkAddressOrNull( + @Nonnull final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.SourceNetwork network) { + return Optional.of(network).filter(net -> net instanceof SourceIpv6Network) + .map(SourceIpv6Network.class::cast) + .map(SourceIpv6Network::getSourceIpv6Network) .orElse(null); } @@ -107,41 +90,54 @@ public interface MacIpAceDataExtractor extends AddressExtractor, MacTranslator { */ default byte macIpAction(@Nonnull final Ace ace) { // action choice itself has default, but nothing stops us from not defining actions container itself - final PacketHandling action = Optional.ofNullable(ace.getActions()).orElseThrow( - () -> new IllegalArgumentException(String.format("Unable to extract Action from %s", ace))) - .getPacketHandling(); - if (action instanceof Permit) { - return 1; - } else if (action instanceof Deny) { - return 0; + Actions actions = Optional.ofNullable(ace.getActions()).orElseThrow( + () -> new IllegalArgumentException(String.format("Unable to extract Action from %s", ace))); + if (actions.getForwarding() != null) { + if (ace.getActions().getForwarding().equals(Accept.class)) { + return 1; + } else { + return 0; + } } else { throw new IllegalArgumentException( - String.format("Unsupported packet-handling action %s for ACE %s", action, ace)); + String.format("Unsupported packet-handling action %s for ACE %s", actions, ace)); } } - default AceIpVersion ipVersion(@Nonnull final MacipAclRule rule) { + default L3 parseMacIpAceL3(@Nonnull final MacipAclRule rule) { if (rule.isIpv6 == 0) { - return ip4Ace(rule); + return ip4L3(rule); } else { - return ip6Ace(rule); + return ip6L3(rule); } } - default AceIpVersion ip4Ace(@Nonnull final MacipAclRule rule) { - final AceIpv4Builder ipVersion = new AceIpv4Builder(); + default Ipv4 ip4L3(@Nonnull final MacipAclRule rule) { + final Ipv4Builder ipv4Builder = new Ipv4Builder(); + if (rule.srcIpAddr != null && rule.srcIpAddr.length != 0) { - ipVersion.setSourceIpv4Network(toIpv4Prefix(truncateIp4Array(rule.srcIpAddr), rule.srcIpPrefixLen)); + ipv4Builder.setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .setSourceNetwork(new SourceIpv4NetworkBuilder() + .setSourceIpv4Network( + toIpv4Prefix(truncateIp4Array(rule.srcIpAddr), rule.srcIpPrefixLen)) + .build()) + .build()); } - return ipVersion.build(); + return ipv4Builder.build(); } - default AceIpVersion ip6Ace(@Nonnull final MacipAclRule rule) { - final AceIpv6Builder ipVersion = new AceIpv6Builder(); + default Ipv6 ip6L3(@Nonnull final MacipAclRule rule) { + final Ipv6Builder ipv6Builder = new Ipv6Builder(); if (rule.srcIpAddr != null && rule.srcIpAddr.length != 0) { - ipVersion.setSourceIpv6Network(toIpv6Prefix(rule.srcIpAddr, rule.srcIpPrefixLen)); + ipv6Builder.setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .setSourceNetwork(new SourceIpv6NetworkBuilder() + .setSourceIpv6Network(toIpv6Prefix(rule.srcIpAddr, rule.srcIpPrefixLen)) + .build()) + .build()); } - return ipVersion.build(); + return ipv6Builder.build(); } default MacAddress sourceMac(@Nonnull final MacipAclRule rule) { diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractor.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractor.java index 8f463aef5..9f454fd38 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractor.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractor.java @@ -24,147 +24,148 @@ import java.util.Map; import java.util.Optional; import javax.annotation.Nonnull; import javax.annotation.Nullable; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Actions; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.ActionsBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.PacketHandling; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Deny; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.DenyBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Permit; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.PermitBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.AcceptAndReflect; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Accept; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Drop; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.ForwardingAction; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Reject; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Actions; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.ActionsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Matches; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6Builder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix; 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.packet.fields.rev160708.AclIpv4HeaderFields; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.AclIpv6HeaderFields; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.AclIpProtocolHeaderFields; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.actions.packet.handling.Stateful; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.actions.packet.handling.StatefulBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.AceIpVersion; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv4Builder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv6; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv6Builder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.AclIpv4HeaderFields; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.AclIpv6HeaderFields; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.destination.network.DestinationIpv4Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.destination.network.DestinationIpv4NetworkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4NetworkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.destination.network.DestinationIpv6Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.destination.network.DestinationIpv6NetworkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6NetworkBuilder; public interface StandardAceDataExtractor extends AddressExtractor, ProtoPreBindRuleProducer, IpProtocolReader { /** * Allowed packet-processing actions for Acl's */ - Map<Class<? extends PacketHandling>, Integer> ACTION_VALUE_PAIRS = ImmutableMap.of(Deny.class, 0, Permit.class, 1, - Stateful.class, 2); - - default VppAce fromStandardAce(@Nonnull final Ace ace) { - return Optional.ofNullable(ace.getMatches()) - .map(Matches::getAceType) - .map(VppAce.class::cast) - .orElseThrow(() -> new IllegalArgumentException(String.format("Unable to create VppAce from %s", ace))); - } - - default boolean standardIsIpv6(@Nonnull final VppAce ace, @Nullable final Matches matches) { - final Optional<AceIpVersion> aceIpVersion = Optional.ofNullable(matches) - .map(Matches::getAceType) - .map(VppAce.class::cast) - .map(VppAce::getVppAceNodes) - .map(VppAceNodes::getAceIpVersion); - - // tries to detect version by ace-ip-version - if(aceIpVersion.isPresent()){ - return aceIpVersion - .map(version -> version instanceof AceIpv6) - .orElse(false); - } + Map<Class<? extends ForwardingAction>, Integer> ACTION_VALUE_PAIRS = + ImmutableMap.of(Drop.class, 0, Reject.class, 0, Accept.class, 1, AcceptAndReflect.class, 2); - // otherwise goes by ip-protocol - return Optional.ofNullable(ace.getVppAceNodes()) - .map(AclIpProtocolHeaderFields::getIpProtocol) - .map(ipProtocol -> ipProtocol instanceof IcmpV6) - .orElse(false); + default boolean standardIsIpv6(@Nullable final Matches matches) { + return Optional.ofNullable(matches) + .map(Matches::getL3) + .filter(l3 -> l3.getImplementedInterface().equals(Ipv6.class)) + .map(Ipv6.class::cast) + .map(Ipv6::getIpv6) + .isPresent(); } - default byte[] ipv4SourceAddress(@Nonnull final VppAce ace) { - return extractIp4Address( - extractV4SourceAddressOrNull(ace)); + default byte[] ipv4SourceAddress(@Nonnull final Matches matches) { + return extractIp4Address(extractV4SourceAddressOrNull(matches)); } - default byte ipv4SourceAddressPrefix(@Nonnull final VppAce ace) { - return extractIp4AddressPrefix( - extractV4SourceAddressOrNull(ace)); + default byte ipv4SourceAddressPrefix(@Nonnull final Matches matches) { + return extractIp4AddressPrefix(extractV4SourceAddressOrNull(matches)); } - static Ipv4Prefix extractV4SourceAddressOrNull(@Nonnull final VppAce ace) { - return Optional.ofNullable(ace.getVppAceNodes()) - .map(VppAceNodes::getAceIpVersion) - .map(AclIpv4HeaderFields.class::cast) - .map(AclIpv4HeaderFields::getSourceIpv4Network) + static Ipv4Prefix extractV4SourceAddressOrNull(@Nonnull final Matches matches) { + return getIpv4Optional(matches) + .map(AclIpv4HeaderFields::getSourceNetwork) + .filter(network -> network instanceof SourceIpv4Network) + .map(SourceIpv4Network.class::cast) + .map(SourceIpv4Network::getSourceIpv4Network) .orElse(null); } - default byte[] ipv4DestinationAddress(@Nonnull final VppAce ace) { - return extractIp4Address(extractV4DestinationAddressOrNull(ace)); + default byte[] ipv4DestinationAddress(@Nonnull final Matches matches) { + return extractIp4Address(extractV4DestinationAddressOrNull(matches)); } - default byte ipv4DestinationAddressPrefix(@Nonnull final VppAce ace) { - return extractIp4AddressPrefix(extractV4DestinationAddressOrNull(ace)); + default byte ipv4DestinationAddressPrefix(@Nonnull final Matches matches) { + return extractIp4AddressPrefix(extractV4DestinationAddressOrNull(matches)); } - static Ipv4Prefix extractV4DestinationAddressOrNull(@Nonnull final VppAce ace) { - return Optional.ofNullable(ace.getVppAceNodes()) - .map(VppAceNodes::getAceIpVersion) - .map(AclIpv4HeaderFields.class::cast) - .map(AclIpv4HeaderFields::getDestinationIpv4Network) + static Ipv4Prefix extractV4DestinationAddressOrNull(@Nonnull final Matches matches) { + return getIpv4Optional(matches) + .map(AclIpv4HeaderFields::getDestinationNetwork) + .filter(destinationNetwork -> destinationNetwork instanceof DestinationIpv4Network) + .map(DestinationIpv4Network.class::cast) + .map(DestinationIpv4Network::getDestinationIpv4Network) .orElse(null); } - default byte[] ipv6SourceAddress(@Nonnull final VppAce ace) { - return extractIp6Address(extractV6SourceAddressOrNull(ace)); + static Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4> getIpv4Optional( + @Nonnull final Matches matches) { + return Optional.ofNullable(matches.getL3()) + .filter(l3 -> l3.getImplementedInterface().equals(Ipv4.class)) + .map(Ipv4.class::cast) + .map(Ipv4::getIpv4); + } + + default byte[] ipv6SourceAddress(@Nonnull final Matches matches) { + return extractIp6Address(extractV6SourceAddressOrNull(matches)); } - default byte ipv6SourceAddressPrefix(@Nonnull final VppAce ace) { - return extractIp6AddressPrefix(extractV6SourceAddressOrNull(ace)); + default byte ipv6SourceAddressPrefix(@Nonnull final Matches matches) { + return extractIp6AddressPrefix(extractV6SourceAddressOrNull(matches)); } - static Ipv6Prefix extractV6SourceAddressOrNull(@Nonnull final VppAce ace) { - return Optional.ofNullable(ace.getVppAceNodes()) - .map(VppAceNodes::getAceIpVersion) - .map(AclIpv6HeaderFields.class::cast) - .map(AclIpv6HeaderFields::getSourceIpv6Network) + static Ipv6Prefix extractV6SourceAddressOrNull(@Nonnull final Matches matches) { + return getIpv6Optional(matches) + .map(AclIpv6HeaderFields::getSourceNetwork) + .filter(sourceNetwork -> sourceNetwork instanceof SourceIpv6Network) + .map(SourceIpv6Network.class::cast) + .map(SourceIpv6Network::getSourceIpv6Network) .orElse(null); } - default byte[] ipv6DestinationAddress(@Nonnull final VppAce ace) { - return extractIp6Address(extractV6DestinationAddressOrNull(ace)); + default byte[] ipv6DestinationAddress(@Nonnull final Matches matches) { + return extractIp6Address(extractV6DestinationAddressOrNull(matches)); } - default byte ipv6DestinationAddressPrefix(@Nonnull final VppAce ace) { - return extractIp6AddressPrefix(extractV6DestinationAddressOrNull(ace)); + default byte ipv6DestinationAddressPrefix(@Nonnull final Matches matches) { + return extractIp6AddressPrefix(extractV6DestinationAddressOrNull(matches)); } - static Ipv6Prefix extractV6DestinationAddressOrNull(@Nonnull final VppAce ace) { - return Optional.ofNullable(ace.getVppAceNodes()) - .map(VppAceNodes::getAceIpVersion) - .map(AclIpv6HeaderFields.class::cast) - .map(AclIpv6HeaderFields::getDestinationIpv6Network) + static Ipv6Prefix extractV6DestinationAddressOrNull(@Nonnull final Matches matches) { + return getIpv6Optional(matches) + .map(AclIpv6HeaderFields::getDestinationNetwork) + .filter(destinationNetwork -> destinationNetwork instanceof DestinationIpv6Network) + .map(DestinationIpv6Network.class::cast) + .map(DestinationIpv6Network::getDestinationIpv6Network) .orElse(null); } + static Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6> getIpv6Optional( + @Nonnull final Matches matches) { + return Optional.ofNullable(matches.getL3()) + .filter(l3 -> l3.getImplementedInterface().equals(Ipv6.class)) + .map(Ipv6.class::cast) + .map(Ipv6::getIpv6); + } + default byte standardAction(@Nonnull final Ace ace) { - // default == deny - final PacketHandling action = Optional.ofNullable(ace.getActions()) + Class<? extends ForwardingAction> forwarding = Optional.ofNullable(ace.getActions()) .orElseThrow(() -> new IllegalArgumentException(String.format("Unable to extract Action from %s", ace))) - .getPacketHandling(); + .getForwarding(); return ACTION_VALUE_PAIRS.get(ACTION_VALUE_PAIRS.keySet().stream() - .filter(aClass -> aClass.isInstance(action)) + .filter(aClass -> aClass.equals(forwarding)) .findAny() .orElseThrow(() -> new IllegalArgumentException( - String.format("Unsupported packet-handling action %s for ACE %s", action, - ace.getRuleName())))).byteValue(); + String.format("Unsupported packet-handling action %s for ACE %s", forwarding, + ace.getName())))).byteValue(); } - default AceIpVersion ipVersion(@Nonnull final AclRule rule) { + default L3 parseStandardAceL3(@Nonnull final AclRule rule) { if (rule.isIpv6 == 0) { return ip4Ace(rule); } else { @@ -172,40 +173,55 @@ public interface StandardAceDataExtractor extends AddressExtractor, ProtoPreBind } } - default AceIpVersion ip4Ace(@Nonnull final AclRule rule) { - final AceIpv4Builder ipVersion = new AceIpv4Builder(); + default org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4 ip4Ace( + @Nonnull final AclRule rule) { + Ipv4Builder ipv4Builder = new Ipv4Builder(); + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder + ip4Builder = + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder(); if (rule.srcIpAddr != null && rule.srcIpAddr.length != 0) { - ipVersion.setSourceIpv4Network(toIpv4Prefix(truncateIp4Array(rule.srcIpAddr), rule.srcIpPrefixLen)); + ip4Builder.setSourceNetwork(new SourceIpv4NetworkBuilder() + .setSourceIpv4Network(toIpv4Prefix(truncateIp4Array(rule.srcIpAddr), rule.srcIpPrefixLen)) + .build()); } if (rule.dstIpAddr != null && rule.dstIpAddr.length != 0) { - ipVersion.setDestinationIpv4Network(toIpv4Prefix(truncateIp4Array(rule.dstIpAddr), rule.dstIpPrefixLen)); + ip4Builder.setDestinationNetwork(new DestinationIpv4NetworkBuilder() + .setDestinationIpv4Network(toIpv4Prefix(truncateIp4Array(rule.dstIpAddr), rule.dstIpPrefixLen)) + .build()); } - return ipVersion.build(); + return ipv4Builder.setIpv4(ip4Builder.build()).build(); } - default AceIpVersion ip6Ace(@Nonnull final AclRule rule) { - final AceIpv6Builder ipVersion = new AceIpv6Builder(); + default org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6 ip6Ace( + @Nonnull final AclRule rule) { + Ipv6Builder ipv6Builder = new Ipv6Builder(); + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder + ip6Builder = + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder(); + if (rule.srcIpAddr != null && rule.srcIpAddr.length != 0) { - ipVersion.setSourceIpv6Network(toIpv6Prefix(rule.srcIpAddr, rule.srcIpPrefixLen)); + ip6Builder.setSourceNetwork(new SourceIpv6NetworkBuilder() + .setSourceIpv6Network(toIpv6Prefix(rule.srcIpAddr, rule.srcIpPrefixLen)) + .build()); } if (rule.dstIpAddr != null && rule.dstIpAddr.length != 0) { - ipVersion.setDestinationIpv6Network(toIpv6Prefix(rule.dstIpAddr, rule.dstIpPrefixLen)); + ip6Builder.setDestinationNetwork(new DestinationIpv6NetworkBuilder() + .setDestinationIpv6Network(toIpv6Prefix(rule.dstIpAddr, rule.dstIpPrefixLen)) + .build()); } - return ipVersion.build(); + return ipv6Builder.setIpv6(ip6Builder.build()).build(); } default Actions actions(final byte isPermit) { final ActionsBuilder actions = new ActionsBuilder(); switch (isPermit) { case 0: - actions.setPacketHandling(new DenyBuilder().setDeny(true).build()); + actions.setForwarding(Drop.class); break; case 1: - actions.setPacketHandling(new PermitBuilder().setPermit(true).build()); - break; - case 2: - actions.setPacketHandling(new StatefulBuilder().setPermitAndReflect(true).build()); + actions.setForwarding(Accept.class); break; + default: throw new IllegalArgumentException("Unsupported action: " + isPermit); } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclDataExtractor.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclDataExtractor.java index 5f75ae306..977dd4062 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclDataExtractor.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclDataExtractor.java @@ -16,16 +16,19 @@ package io.fd.hc2vpp.acl.util.acl; +import com.google.common.base.Preconditions; +import io.fd.hc2vpp.acl.write.AclValidator; import java.nio.charset.StandardCharsets; import java.util.List; import java.util.Optional; import javax.annotation.Nonnull; -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.acl.access.list.entries.Ace; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAclAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAce; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAcl; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAclAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppMacipAcl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.AclBase; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Ipv4AclType; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; /** * Extracts data from Acls. @@ -34,31 +37,25 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl. public interface AclDataExtractor { /** - * Checks if provided {@link Acl} has aces of type {@link VppAce} + * Checks if provided {@link Acl} has aces of type {@link Ipv4AclType} or {@link VppAcl} */ default boolean isStandardAcl(@Nonnull final Acl acl) { - return acl.getAccessListEntries().getAce().stream() - .map(Ace::getMatches) - .map(Matches::getAceType) - .filter(aceType -> aceType instanceof VppAce) - .findAny() - .isPresent(); + Class<? extends AclBase> type = + Preconditions.checkNotNull(acl.getType(), "Type is not set for ACL:{}", acl); + return type.equals(VppAcl.class); } /** - * Checks if provided {@link Acl} has aces of type {@link VppMacipAce} + * Checks if provided {@link Acl} has aces of type {@link VppMacipAcl} */ default boolean isMacIpAcl(@Nonnull final Acl acl) { - return acl.getAccessListEntries().getAce().stream() - .map(Ace::getMatches) - .map(Matches::getAceType) - .filter(aceType -> aceType instanceof VppMacipAce) - .findAny() - .isPresent(); + Class<? extends AclBase> type = + Preconditions.checkNotNull(acl.getType(), "Type is not set for ACL:{}", acl); + return type.equals(VppMacipAcl.class); } default List<Ace> getAces(@Nonnull final Acl acl) { - return Optional.ofNullable(acl.getAccessListEntries()).orElseThrow(() -> + return Optional.ofNullable(acl.getAces()).orElseThrow(() -> new IllegalArgumentException(String.format("Unable to extract aces from %s", acl))).getAce(); } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/factory/AclFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/factory/AclFactory.java deleted file mode 100644 index 474a52844..000000000 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/factory/AclFactory.java +++ /dev/null @@ -1,71 +0,0 @@ -/* - * 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.util.factory; - -import com.google.common.collect.ImmutableSet; -import java.util.Set; -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.acl.AccessListEntries; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Actions; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRange; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRange; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAclAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.VppMacipAceNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpCodeRange; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpTypeRange; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.IcmpNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.v6.IcmpV6Nodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.other.OtherNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.tcp.TcpNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.udp.UdpNodes; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - -public interface AclFactory { - - default Set<InstanceIdentifier<?>> vppAclChildren(final InstanceIdentifier<Acl> parentId) { - final InstanceIdentifier<Matches> matchesIid = - parentId.child(AccessListEntries.class).child(Ace.class).child(Matches.class); - return ImmutableSet.of( - parentId.augmentation(VppAclAugmentation.class), - parentId.child(AccessListEntries.class), - parentId.child(AccessListEntries.class).child(Ace.class), - parentId.child(AccessListEntries.class).child(Ace.class).child(Matches.class), - parentId.child(AccessListEntries.class).child(Ace.class).child(Actions.class), - matchesIid, - matchesIid.child(VppMacipAceNodes.class), - matchesIid.child(VppAceNodes.class), - matchesIid.child(VppAceNodes.class).child(IcmpNodes.class), - matchesIid.child(VppAceNodes.class).child(IcmpNodes.class).child(IcmpCodeRange.class), - matchesIid.child(VppAceNodes.class).child(IcmpNodes.class).child(IcmpTypeRange.class), - matchesIid.child(VppAceNodes.class).child(IcmpV6Nodes.class), - matchesIid.child(VppAceNodes.class).child(IcmpV6Nodes.class).child(IcmpCodeRange.class), - matchesIid.child(VppAceNodes.class).child(IcmpV6Nodes.class).child(IcmpTypeRange.class), - matchesIid.child(VppAceNodes.class).child(UdpNodes.class), - matchesIid.child(VppAceNodes.class).child(UdpNodes.class).child(SourcePortRange.class), - matchesIid.child(VppAceNodes.class).child(UdpNodes.class).child(DestinationPortRange.class), - matchesIid.child(VppAceNodes.class).child(TcpNodes.class), - matchesIid.child(VppAceNodes.class).child(TcpNodes.class).child(SourcePortRange.class), - matchesIid.child(VppAceNodes.class).child(TcpNodes.class).child(DestinationPortRange.class), - matchesIid.child(VppAceNodes.class).child(OtherNodes.class) - - ); - } - -} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/IpProtocolReader.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/IpProtocolReader.java index 9c8b99b45..3207ecd4b 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/IpProtocolReader.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/IpProtocolReader.java @@ -21,40 +21,42 @@ import static io.fd.hc2vpp.acl.util.protocol.ProtoPreBindRuleProducer.ICMP_INDEX import static io.fd.hc2vpp.acl.util.protocol.ProtoPreBindRuleProducer.TCP_INDEX; import static io.fd.hc2vpp.acl.util.protocol.ProtoPreBindRuleProducer.UDP_INDEX; +import com.google.common.annotations.VisibleForTesting; import io.fd.vpp.jvpp.acl.types.AclRule; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppIcmpAceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppIcmpAceAugmentationBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppTcpAceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppTcpAceAugmentationBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpCodeRange; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpCodeRangeBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpTypeRange; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acl.icmp.header.fields.IcmpTypeRangeBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acls.acl.aces.ace.matches.l4.icmp.icmp.VppIcmpAceBuilder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.acls.acl.aces.ace.matches.l4.tcp.tcp.VppTcpAceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.IcmpBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Tcp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.TcpBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Udp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.UdpBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.DestinationPortBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.SourcePortBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.source.port.source.port.RangeOrOperatorBuilder; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRange; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRangeBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRange; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRangeBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpCodeRange; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpCodeRangeBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpTypeRange; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.icmp.header.fields.IcmpTypeRangeBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.IpProtocol; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Icmp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6Builder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Other; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.OtherBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Tcp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.TcpBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Udp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.UdpBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.IcmpNodesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.v6.IcmpV6NodesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.other.OtherNodesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.tcp.TcpNodesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.udp.UdpNodesBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.AclTcpHeaderFields; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.PortRangeOrOperator; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.port.range.or.operator.Range; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.port.range.or.operator.RangeBuilder; /** * Utility for parsing IpProtocol DO based on data returned by vpp as {@link AclRule}. */ public interface IpProtocolReader { - default IpProtocol parseProtocol(final AclRule rule) { + default L4 parseProtocol(final AclRule rule) { switch (rule.proto) { + case ICMPV6_INDEX: case ICMP_INDEX: { return Impl.parseIcmp(rule); } @@ -66,14 +68,8 @@ public interface IpProtocolReader { case UDP_INDEX: { return Impl.parseUdp(rule); } - - case ICMPV6_INDEX: { - return Impl.parseIcmp6(rule); - } - default: { - return Impl.parse(rule); - } } + return null; } class Impl { @@ -91,51 +87,107 @@ public interface IpProtocolReader { } private static Icmp parseIcmp(final AclRule rule) { - final IcmpNodesBuilder nodes = new IcmpNodesBuilder(); - nodes.setIcmpCodeRange(parseIcmpCodeRange(rule)); - nodes.setIcmpTypeRange(parseIcmpTypeRange(rule)); - return new IcmpBuilder().setIcmpNodes(nodes.build()).build(); + return new IcmpBuilder().setIcmp( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.icmp.IcmpBuilder() + .addAugmentation(VppIcmpAceAugmentation.class, + new VppIcmpAceAugmentationBuilder() + .setVppIcmpAce(new VppIcmpAceBuilder() + .setIcmpCodeRange(parseIcmpCodeRange(rule)) + .setIcmpTypeRange(parseIcmpTypeRange(rule)) + .build()) + .build()) + .build()) + .build(); } - private static DestinationPortRange parseDstPortRange(final AclRule rule) { - return new DestinationPortRangeBuilder() - .setLowerPort(new PortNumber(Short.toUnsignedInt(rule.dstportOrIcmpcodeFirst))) - .setUpperPort(new PortNumber(Short.toUnsignedInt(rule.dstportOrIcmpcodeLast))).build(); + private static PortRangeOrOperator parseDstPortRange(final AclRule rule) { + return new RangeBuilder() + .setLowerPort(new PortNumber(Short.toUnsignedInt(rule.dstportOrIcmpcodeFirst))) + .setUpperPort(new PortNumber(Short.toUnsignedInt(rule.dstportOrIcmpcodeLast))).build(); } - private static SourcePortRange parseSrcPortRange(final AclRule rule) { - return new SourcePortRangeBuilder() + private static Range parseSrcPortRange(final AclRule rule) { + return new RangeBuilder() .setLowerPort(new PortNumber(Short.toUnsignedInt(rule.srcportOrIcmptypeFirst))) .setUpperPort(new PortNumber(Short.toUnsignedInt(rule.srcportOrIcmptypeLast))).build(); } private static Tcp parseTcp(final AclRule rule) { - final TcpNodesBuilder nodes = new TcpNodesBuilder(); - nodes.setDestinationPortRange(parseDstPortRange(rule)); - nodes.setSourcePortRange(parseSrcPortRange(rule)); - nodes.setTcpFlagsMask((short) Byte.toUnsignedInt(rule.tcpFlagsMask)); - nodes.setTcpFlagsValue((short) Byte.toUnsignedInt(rule.tcpFlagsValue)); - return new TcpBuilder().setTcpNodes(nodes.build()).build(); + return new TcpBuilder().setTcp( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.TcpBuilder() + .setFlags(parseTcpFlags((short) Byte.toUnsignedInt(rule.tcpFlagsValue))) + .addAugmentation(VppTcpAceAugmentation.class, new VppTcpAceAugmentationBuilder() + .setVppTcpAce(new VppTcpAceBuilder() + .setFlagsMask( + parseTcpFlagsMask((short) Byte.toUnsignedInt(rule.tcpFlagsMask))) + .build()) + .build()) + .setSourcePort(new SourcePortBuilder() + .setSourcePort(new RangeOrOperatorBuilder() + .setPortRangeOrOperator(parseSrcPortRange(rule)) + .build()) + .build()) + .setDestinationPort(new DestinationPortBuilder() + .setDestinationPort( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperatorBuilder() + .setPortRangeOrOperator(parseDstPortRange(rule)) + .build()) + .build()) + .build()) + .build(); } - private static Udp parseUdp(final AclRule rule) { - final UdpNodesBuilder nodes = new UdpNodesBuilder(); - nodes.setDestinationPortRange(parseDstPortRange(rule)); - nodes.setSourcePortRange(parseSrcPortRange(rule)); - return new UdpBuilder().setUdpNodes(nodes.build()).build(); + @VisibleForTesting + private static org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.AclTcpHeaderFields.FlagsMask parseTcpFlagsMask( + final short tcpFlagsMask) { + // Flags from bit on position 1 to 8 + final Boolean cwr = (tcpFlagsMask & 0b00000001) == 1; + final Boolean ece = (tcpFlagsMask & 0b00000010) >> 1 == 1; + final Boolean urg = (tcpFlagsMask & 0b00000100) >> 2 == 1; + final Boolean ack = (tcpFlagsMask & 0b00001000) >> 3 == 1; + final Boolean psh = (tcpFlagsMask & 0b00010000) >> 4 == 1; + final Boolean rst = (tcpFlagsMask & 0b00100000) >> 5 == 1; + final Boolean syn = (tcpFlagsMask & 0b01000000) >> 6 == 1; + final Boolean fin = (tcpFlagsMask & 0b10000000) >> 7 == 1; + + return new org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.AclTcpHeaderFields.FlagsMask( + ack, cwr, ece, fin, psh, rst, syn, urg); } - private static IcmpV6 parseIcmp6(final AclRule rule) { - final IcmpV6NodesBuilder nodes = new IcmpV6NodesBuilder(); - nodes.setIcmpCodeRange(parseIcmpCodeRange(rule)); - nodes.setIcmpTypeRange(parseIcmpTypeRange(rule)); - return new IcmpV6Builder().setIcmpV6Nodes(nodes.build()).build(); + @VisibleForTesting + private static AclTcpHeaderFields.Flags parseTcpFlags(final short tcpFlagsValue) { + // Flags from bit on position 1 to 8 + final Boolean cwr = (tcpFlagsValue & 0b00000001) == 1; + final Boolean ece = (tcpFlagsValue & 0b00000010) >> 1 == 1; + final Boolean urg = (tcpFlagsValue & 0b00000100) >> 2 == 1; + final Boolean ack = (tcpFlagsValue & 0b00001000) >> 3 == 1; + final Boolean psh = (tcpFlagsValue & 0b00010000) >> 4 == 1; + final Boolean rst = (tcpFlagsValue & 0b00100000) >> 5 == 1; + final Boolean syn = (tcpFlagsValue & 0b01000000) >> 6 == 1; + final Boolean fin = (tcpFlagsValue & 0b10000000) >> 7 == 1; + + return new AclTcpHeaderFields.Flags(ack, cwr, ece, fin, psh, rst, syn, urg); } - private static Other parse(final AclRule rule) { - final OtherNodesBuilder nodes = new OtherNodesBuilder(); - nodes.setProtocol((short) Short.toUnsignedInt(rule.proto)); - return new OtherBuilder().setOtherNodes(nodes.build()).build(); + private static Udp parseUdp(final AclRule rule) { + return new UdpBuilder().setUdp( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.UdpBuilder() + .setSourcePort( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.SourcePortBuilder() + .setSourcePort( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.source.port.RangeOrOperatorBuilder() + .setPortRangeOrOperator(parseSrcPortRange(rule)) + .build()) + .build()) + .setDestinationPort( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.DestinationPortBuilder() + .setDestinationPort( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.destination.port.RangeOrOperatorBuilder() + .setPortRangeOrOperator(parseDstPortRange(rule)) + .build()) + .build()) + .build()) + .build(); } } } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/ProtoPreBindRuleProducer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/ProtoPreBindRuleProducer.java index 582da0357..3ca18d6e6 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/ProtoPreBindRuleProducer.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/protocol/ProtoPreBindRuleProducer.java @@ -16,31 +16,27 @@ package io.fd.hc2vpp.acl.util.protocol; -import static com.google.common.base.Preconditions.checkArgument; -import static io.fd.hc2vpp.acl.util.protocol.ProtoPreBindRuleProducer.ProtocolPair.pair; - -import com.google.common.collect.ImmutableSet; +import com.google.common.base.Preconditions; import io.fd.vpp.jvpp.acl.types.AclRule; -import java.util.Optional; -import java.util.Set; import javax.annotation.Nonnull; import javax.annotation.Nullable; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.ValueRange; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppIcmpAceAugmentation; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppTcpAceAugmentation; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.icmp.Icmp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.Tcp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.DestinationPort; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.source.port.SourcePort; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.source.port.source.port.RangeOrOperator; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.Udp; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.DestinationPortRange; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.acl.transport.header.fields.SourcePortRange; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.ValueRange; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.IpProtocol; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Icmp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Other; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Tcp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Udp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.IcmpNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.icmp.v6.IcmpV6Nodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.tcp.TcpNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.udp.UdpNodes; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.AclTcpHeaderFields; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.PortRangeOrOperator; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.port.range.or.operator.Range; +import org.opendaylight.yangtools.yang.binding.DataContainer; /** * Creates ACL rules pre-bind with protocol-related fields.<br> @@ -53,89 +49,41 @@ public interface ProtoPreBindRuleProducer { int TCP_INDEX = 6; int UDP_INDEX = 17; int ICMPV6_INDEX = 58; - short MAX_PORT_NUMBER = (short)65535; - - Set<ProtocolPair> PROTOCOL_PAIRS = ImmutableSet.of(pair(Icmp.class, ICMP_INDEX), pair(Tcp.class, TCP_INDEX), - pair(Udp.class, UDP_INDEX), pair(IcmpV6.class, ICMPV6_INDEX)); - - class ProtocolPair { - private final Class<? extends IpProtocol> protocolClass; - private final int index; + short MAX_PORT_NUMBER = (short) 65535; - private ProtocolPair(final Class<? extends IpProtocol> protocolClass, final int index) { - this.protocolClass = protocolClass; - this.index = index; - } - - static ProtocolPair pair(@Nonnull final Class<? extends IpProtocol> protocolClass, @Nonnull final int index) { - return new ProtocolPair(protocolClass, index); - } + static AclRule bindIcmpVppFields(AclRule rule, Icmp icmp) { + VppIcmpAceAugmentation vppIcmp = icmp.augmentation(VppIcmpAceAugmentation.class); + Preconditions.checkNotNull(vppIcmp.getVppIcmpAce(), "Cannot determine VPP ICMP attributes!"); + final ValueRange typesRange = vppIcmp.getVppIcmpAce().getIcmpTypeRange(); + final ValueRange codesRange = vppIcmp.getVppIcmpAce().getIcmpCodeRange(); - boolean match(@Nonnull final Class<? extends IpProtocol> protocolClass) { - return this.protocolClass.isAssignableFrom(protocolClass); + if (typesRange != null) { + rule.srcportOrIcmptypeFirst = Preconditions.checkNotNull(typesRange.getFirst()); + rule.srcportOrIcmptypeLast = Preconditions.checkNotNull(typesRange.getLast()); } - int getIndex() { - return this.index; + if (codesRange != null) { + rule.dstportOrIcmpcodeFirst = Preconditions.checkNotNull(codesRange.getFirst()); + rule.dstportOrIcmpcodeLast = Preconditions.checkNotNull(codesRange.getLast()); } - } - - static byte protocol(final IpProtocol ipProtocol) { - final Optional<ProtocolPair> optPair = PROTOCOL_PAIRS.stream() - .filter(protocolPair -> protocolPair.match(ipProtocol.getClass())) - .findAny(); - - if (!optPair.isPresent()) { - if (Other.class.isAssignableFrom(ipProtocol.getClass())) { - return Other.class.cast(ipProtocol).getOtherNodes().getProtocol().byteValue(); - } - - throw new IllegalArgumentException(String.format("Unsupported Protocol Type %s", ipProtocol.getClass())); - } - return (byte) optPair.get().getIndex(); - } - - static AclRule bindIcmpNodes(AclRule rule, VppAce ace) { - final VppAceNodes vppAceNodes = ace.getVppAceNodes(); - checkArgument(vppAceNodes.getIpProtocol() instanceof Icmp); - final IcmpNodes icmp = Icmp.class.cast(vppAceNodes.getIpProtocol()).getIcmpNodes(); - final ValueRange typesRange = icmp.getIcmpTypeRange(); - final ValueRange codesRange = icmp.getIcmpCodeRange(); - - rule.srcportOrIcmptypeFirst = typesRange.getFirst(); - rule.srcportOrIcmptypeLast = typesRange.getLast(); - rule.dstportOrIcmpcodeFirst = codesRange.getFirst(); - rule.dstportOrIcmpcodeLast = codesRange.getLast(); return rule; } - static AclRule bindIcmpv6Nodes(AclRule rule, VppAce ace) { - final VppAceNodes vppAceNodes = ace.getVppAceNodes(); - checkArgument(vppAceNodes.getIpProtocol() instanceof IcmpV6); - final IcmpV6Nodes icmpV6 = IcmpV6.class.cast(vppAceNodes.getIpProtocol()).getIcmpV6Nodes(); - final ValueRange typesRange = icmpV6.getIcmpTypeRange(); - final ValueRange codesRange = icmpV6.getIcmpCodeRange(); - - rule.srcportOrIcmptypeFirst = typesRange.getFirst(); - rule.srcportOrIcmptypeLast = typesRange.getLast(); - rule.dstportOrIcmpcodeFirst = codesRange.getFirst(); - rule.dstportOrIcmpcodeLast = codesRange.getLast(); - - return rule; - } - - static void bindSourcePortRange(@Nonnull final AclRule rule, @Nullable final SourcePortRange sourcePortRange) { + static void bindSourcePortRange(@Nonnull final AclRule rule, @Nullable final PortRangeOrOperator sourcePortRange) { // allow all ports by default: rule.srcportOrIcmptypeFirst = 0; rule.srcportOrIcmptypeLast = MAX_PORT_NUMBER; - if(sourcePortRange != null) { + if (sourcePortRange != null) { // lower port is mandatory - rule.srcportOrIcmptypeFirst = portNumber(sourcePortRange.getLowerPort()); + Preconditions.checkArgument(sourcePortRange instanceof Range); + Range portRange = (Range) sourcePortRange; + Preconditions.checkNotNull(portRange.getLowerPort(), "Lower port is mandatory!"); + rule.srcportOrIcmptypeFirst = portNumber(portRange.getLowerPort()); - if (sourcePortRange.getUpperPort() != null) { - rule.srcportOrIcmptypeLast = portNumber(sourcePortRange.getUpperPort()); + if (portRange.getUpperPort() != null) { + rule.srcportOrIcmptypeLast = portNumber(portRange.getUpperPort()); } else { // if upper port is missing, set lower port value as end of checked range: rule.srcportOrIcmptypeLast = rule.srcportOrIcmptypeFirst; @@ -143,17 +91,21 @@ public interface ProtoPreBindRuleProducer { } } - static void bindDestinationPortRange(@Nonnull final AclRule rule, @Nullable final DestinationPortRange destinationPortRange) { + static void bindDestinationPortRange(@Nonnull final AclRule rule, + @Nullable final PortRangeOrOperator destinationPortRange) { // allow all ports by default: rule.dstportOrIcmpcodeFirst = 0; rule.dstportOrIcmpcodeLast = MAX_PORT_NUMBER; - if(destinationPortRange != null) { + if (destinationPortRange != null) { // lower port is mandatory - rule.dstportOrIcmpcodeFirst = portNumber(destinationPortRange.getLowerPort()); + Preconditions.checkArgument(destinationPortRange instanceof Range); + Range portRange = (Range) destinationPortRange; + Preconditions.checkNotNull(portRange.getLowerPort(), "Lower port is mandatory!"); + rule.dstportOrIcmpcodeFirst = portNumber(portRange.getLowerPort()); - if (destinationPortRange.getUpperPort() != null) { - rule.dstportOrIcmpcodeLast = portNumber(destinationPortRange.getUpperPort()); + if (portRange.getUpperPort() != null) { + rule.dstportOrIcmpcodeLast = portNumber(portRange.getUpperPort()); } else { // if upper port is missing, set lower port value as end of checked range: rule.dstportOrIcmpcodeLast = rule.dstportOrIcmpcodeFirst; @@ -161,30 +113,78 @@ public interface ProtoPreBindRuleProducer { } } - static AclRule bindTcpNodes(AclRule rule, VppAce ace) { - final VppAceNodes vppAceNodes = ace.getVppAceNodes(); - checkArgument(vppAceNodes.getIpProtocol() instanceof Tcp); + static AclRule bindTcpAttributes(AclRule rule, Tcp tcp) { + SourcePort srcPort = Preconditions.checkNotNull(tcp.getSourcePort()).getSourcePort(); + if (srcPort instanceof RangeOrOperator) { + bindSourcePortRange(rule, ((RangeOrOperator) srcPort).getPortRangeOrOperator()); + } - final TcpNodes tcp = Tcp.class.cast(vppAceNodes.getIpProtocol()).getTcpNodes(); - bindSourcePortRange(rule, tcp.getSourcePortRange()); - bindDestinationPortRange(rule, tcp.getDestinationPortRange()); + DestinationPort dstPort = Preconditions.checkNotNull(tcp.getDestinationPort()).getDestinationPort(); + if (dstPort instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperator) { + bindDestinationPortRange(rule, + ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperator) dstPort) + .getPortRangeOrOperator()); + } + AclTcpHeaderFields.Flags flags = tcp.getFlags(); - if(tcp.getTcpFlagsMask() != null) { - rule.tcpFlagsMask = tcp.getTcpFlagsMask().byteValue(); + if (flags != null) { + rule.tcpFlagsValue = parseTcpFlagsValue(flags); } - if(tcp.getTcpFlagsValue() != null) { - rule.tcpFlagsValue = tcp.getTcpFlagsValue().byteValue(); + + VppTcpAceAugmentation vppTcpAceAugmentation = tcp.augmentation(VppTcpAceAugmentation.class); + if (vppTcpAceAugmentation != null && vppTcpAceAugmentation.getVppTcpAce() != null && + vppTcpAceAugmentation.getVppTcpAce().getFlagsMask() != null) { + rule.tcpFlagsMask = parseTcpFlagsMask(vppTcpAceAugmentation.getVppTcpAce().getFlagsMask()); } + return rule; } - static AclRule bindUdpNodes(AclRule rule, VppAce ace) { - final VppAceNodes vppAceNodes = ace.getVppAceNodes(); - checkArgument(vppAceNodes.getIpProtocol() instanceof Udp); + static byte parseTcpFlagsValue(AclTcpHeaderFields.Flags flags) { + int fin = flags.isFin() ? 1 : 0; + int syn = flags.isSyn() ? 1 : 0; + int rst = flags.isRst() ? 1 : 0; + int psh = flags.isPsh() ? 1 : 0; + int ack = flags.isAck() ? 1 : 0; + int urg = flags.isUrg() ? 1 : 0; + int ece = flags.isEce() ? 1 : 0; + int cwr = flags.isCwr() ? 1 : 0; + String strFlags = String.format("%d%d%d%d%d%d%d%d", fin, syn, rst, psh, ack, urg, ece, cwr); + return Byte.parseByte(strFlags, 2); + } + + static byte parseTcpFlagsMask( + org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.AclTcpHeaderFields.FlagsMask flags) { + int fin = flags.isFin() ? 1 : 0; + int syn = flags.isSyn() ? 1 : 0; + int rst = flags.isRst() ? 1 : 0; + int psh = flags.isPsh() ? 1 : 0; + int ack = flags.isAck() ? 1 : 0; + int urg = flags.isUrg() ? 1 : 0; + int ece = flags.isEce() ? 1 : 0; + int cwr = flags.isCwr() ? 1 : 0; + String strFlags = String.format("%d%d%d%d%d%d%d%d", fin, syn, rst, psh, ack, urg, ece, cwr); + return Byte.parseByte(strFlags, 2); + } + + static AclRule bindUdpAttributes(AclRule rule, Udp udp) { + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.SourcePort + srcPort = Preconditions.checkNotNull(udp.getSourcePort()).getSourcePort(); + + if (srcPort instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.source.port.RangeOrOperator) { + bindSourcePortRange(rule, + ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.source.port.RangeOrOperator) srcPort) + .getPortRangeOrOperator()); + } + + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.DestinationPort + dstPort = Preconditions.checkNotNull(udp.getDestinationPort()).getDestinationPort(); - final UdpNodes udp = Udp.class.cast(vppAceNodes.getIpProtocol()).getUdpNodes(); - bindSourcePortRange(rule, udp.getSourcePortRange()); - bindDestinationPortRange(rule, udp.getDestinationPortRange()); + if (dstPort instanceof org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.destination.port.RangeOrOperator) { + bindDestinationPortRange(rule, + ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.destination.port.RangeOrOperator) dstPort) + .getPortRangeOrOperator()); + } return rule; } @@ -208,39 +208,56 @@ public interface ProtoPreBindRuleProducer { * @param vppAce rule to be processed * @return AclRule with protocol filled protocol fields */ - default AclRule createPreBindRule(@Nonnull final VppAce vppAce) { + default AclRule createPreBindRule(@Nonnull final Ace vppAce) { AclRule rule = new AclRule(); - - final IpProtocol ipProtocol = vppAce.getVppAceNodes().getIpProtocol(); - if (ipProtocol == null) { + L4 l4 = Preconditions.checkNotNull(vppAce.getMatches(), "Matches are not defined for ACE: {}!", vppAce).getL4(); + if (l4 == null) { // returns AclRule with rule.proto set to 0 (protocol fields will be ignored by vpp) return rule; } - rule.proto = protocol(ipProtocol); - - switch (rule.proto) { - case ICMP_INDEX: { - return bindIcmpNodes(rule, vppAce); - } - - case TCP_INDEX: { - return bindTcpNodes(rule, vppAce); - } - - case UDP_INDEX: { - return bindUdpNodes(rule, vppAce); - } + if (l4.getImplementedInterface() + .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp.class)) { + return getIcmpAclRule(vppAce, rule, + (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp) l4); + } else if (l4.getImplementedInterface() + .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Tcp.class)) { + return getTcpAclRule(rule, + (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Tcp) l4); + } else if (l4.getImplementedInterface() + .equals(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Udp.class)) { + return getUdpAclRule(rule, + (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Udp) l4); + } else { + return bindDefaultNodes(rule); + } + } - case ICMPV6_INDEX: { - return bindIcmpv6Nodes(rule, vppAce); - } - default: { - return bindDefaultNodes(rule); - } + default AclRule getIcmpAclRule(@Nonnull final Ace vppAce, final AclRule rule, + final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp l4) { + if (vppAce.getMatches().getL3() == null) { + rule.proto = ICMP_INDEX; + } else { + Class<? extends DataContainer> ipVersion = vppAce.getMatches().getL3().getImplementedInterface(); + rule.proto = (byte) (ipVersion.equals(Ipv6.class) ? ICMPV6_INDEX : ICMP_INDEX); } + Icmp icmp = l4.getIcmp(); + return icmp != null ? bindIcmpVppFields(rule, icmp) : bindDefaultNodes(rule); } + default AclRule getUdpAclRule(final AclRule rule, + final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Udp l4) { + rule.proto = UDP_INDEX; + Udp udp = l4.getUdp(); + return udp != null ? bindUdpAttributes(rule, udp) : bindDefaultNodes(rule); + } + + default AclRule getTcpAclRule(final AclRule rule, + final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Tcp l4) { + rule.proto = TCP_INDEX; + Tcp tcp = l4.getTcp(); + return tcp != null ? bindTcpAttributes(rule, tcp) : bindDefaultNodes(rule); + } } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclCustomizer.java index 00cd8a56c..1161c09ef 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclCustomizer.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclCustomizer.java @@ -19,26 +19,25 @@ package io.fd.hc2vpp.acl.write; import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer; import io.fd.hc2vpp.acl.util.acl.AclDataExtractor; -import io.fd.hc2vpp.acl.util.acl.AclWriter; -import io.fd.honeycomb.translate.MappingContext; +import io.fd.hc2vpp.acl.write.request.AclAddReplaceRequest; import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer; import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; import javax.annotation.Nonnull; -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.AclKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -public class VppAclCustomizer extends FutureJVppAclCustomizer - implements ListWriterCustomizer<Acl, AclKey>, AclDataExtractor, AclWriter { +public class AclCustomizer extends FutureJVppAclCustomizer + implements ListWriterCustomizer<Acl, AclKey>, AclDataExtractor { private final AclContextManager standardAclContext; private final AclContextManager macIpAclContext; - public VppAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, - @Nonnull final AclContextManager standardAclContext, - @Nonnull final AclContextManager macIpAclContext) { + public AclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, + @Nonnull final AclContextManager standardAclContext, + @Nonnull final AclContextManager macIpAclContext) { super(jVppAclFacade); this.standardAclContext = standardAclContext; this.macIpAclContext = macIpAclContext; @@ -47,12 +46,11 @@ public class VppAclCustomizer extends FutureJVppAclCustomizer @Override public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { - final MappingContext mappingContext = writeContext.getMappingContext(); - + AclAddReplaceRequest request = new AclAddReplaceRequest(getjVppAclFacade(), writeContext.getMappingContext()); if (isStandardAcl(dataAfter)) { - addStandardAcl(getjVppAclFacade(), id, dataAfter, standardAclContext, mappingContext); + request.addStandardAcl(id, dataAfter, standardAclContext); } else if (isMacIpAcl(dataAfter)) { - addMacIpAcl(getjVppAclFacade(), id, dataAfter, macIpAclContext, mappingContext); + request.addMacIpAcl(id, dataAfter, macIpAclContext); } else { // double check, first one done by validation throw new WriteFailedException.CreateFailedException(id, dataAfter, @@ -64,17 +62,17 @@ public class VppAclCustomizer extends FutureJVppAclCustomizer public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore, @Nonnull final Acl dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { - final MappingContext mappingContext = writeContext.getMappingContext(); + AclAddReplaceRequest request = new AclAddReplaceRequest(getjVppAclFacade(), writeContext.getMappingContext()); if (isStandardAcl(dataAfter)) { - updateStandardAcl(getjVppAclFacade(), id, dataAfter, standardAclContext, mappingContext); + request.updateStandardAcl(id, dataAfter, standardAclContext); } else if (isMacIpAcl(dataAfter)) { synchronized (macIpAclContext) { // there is no direct support for update of mac-ip acl, but only one is allowed per interface // so it is atomic from vpp standpoint. Enclosed in synchronized block to prevent issues with // multiple threads managing naming context - deleteMacIpAcl(getjVppAclFacade(), id, dataBefore, macIpAclContext, mappingContext); - addMacIpAcl(getjVppAclFacade(), id, dataAfter, macIpAclContext, mappingContext); + request.deleteMacIpAcl(id, dataBefore, macIpAclContext); + request.addMacIpAcl(id, dataAfter, macIpAclContext); } } else { // double check, first one done by validation @@ -86,12 +84,12 @@ public class VppAclCustomizer extends FutureJVppAclCustomizer @Override public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore, @Nonnull final WriteContext writeContext) throws WriteFailedException { - final MappingContext mappingContext = writeContext.getMappingContext(); + AclAddReplaceRequest request = new AclAddReplaceRequest(getjVppAclFacade(), writeContext.getMappingContext()); if (isStandardAcl(dataBefore)) { - deleteStandardAcl(getjVppAclFacade(), id, dataBefore, standardAclContext, mappingContext); + request.deleteStandardAcl(id, dataBefore, standardAclContext); } else if (isMacIpAcl(dataBefore)) { - deleteMacIpAcl(getjVppAclFacade(), id, dataBefore, macIpAclContext, mappingContext); + request.deleteMacIpAcl(id, dataBefore, macIpAclContext); } else { // double check, first one done by validation throw new WriteFailedException.DeleteFailedException(id, diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclValidator.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclValidator.java new file mode 100644 index 000000000..b7aaebcff --- /dev/null +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/AclValidator.java @@ -0,0 +1,233 @@ +/* + * Copyright (c) 2018 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.write; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkState; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableSet; +import io.fd.hc2vpp.acl.AclIIds; +import io.fd.hc2vpp.acl.util.acl.AclDataExtractor; +import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; +import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; +import io.fd.honeycomb.translate.write.Validator; +import io.fd.honeycomb.translate.write.WriteContext; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Objects; +import java.util.Set; +import java.util.stream.Collectors; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAcl; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppMacipAcl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.AclBase; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPoints; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.Aces; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.Matches; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.Eth; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSets; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6Network; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public final class AclValidator implements Validator<Acl>, AclDataExtractor { + + private static final Set<Class<? extends AclBase>> SUPPORTED_ACL_TYPES = + ImmutableSet.of(VppAcl.class, VppMacipAcl.class); + + @Override + public void validateWrite(final InstanceIdentifier<Acl> id, final Acl dataAfter, final WriteContext ctx) + throws CreateValidationFailedException { + try { + validateAcl(dataAfter); + } catch (RuntimeException e) { + throw new CreateValidationFailedException(id, dataAfter, e); + } + } + + @Override + public void validateUpdate(final InstanceIdentifier<Acl> id, final Acl dataBefore, final Acl dataAfter, + final WriteContext ctx) throws UpdateValidationFailedException { + try { + validateAcl(dataAfter); + } catch (RuntimeException e) { + throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); + } + } + + @Override + public void validateDelete(final InstanceIdentifier<Acl> id, final Acl dataBefore, final WriteContext ctx) + throws DeleteValidationFailedException { + try { + validateAcl(dataBefore); + final List<String> references = checkAclReferenced(ctx, dataBefore); + // references must be check, to not leave dead references in configuration + checkState(references.isEmpty(), + "%s cannot be removed, it is referenced in following interfaces %s", dataBefore, references); + } catch (RuntimeException e) { + throw new DeleteValidationFailedException(id, e); + } + } + + private static void validateAcl(@Nonnull final Acl acl) { + hasAceList(acl); + isSupportedAclType(acl); + hasConsistentAceTypeForAclType(acl); + } + + private static void hasAceList(final Acl acl) { + final Aces accessListEntries = acl.getAces(); + checkArgument(accessListEntries != null, "The access-list-entries container is not defined."); + final List<Ace> ace = accessListEntries.getAce(); + checkArgument(ace != null, "The ace list is not defined."); + checkArgument(!ace.isEmpty(), "The ace list is empty."); + } + + private static void isSupportedAclType(final Acl acl) { + checkArgument(SUPPORTED_ACL_TYPES.contains(acl.getType()), + "Unsupported Acl type %s detected for acl %s, allowed types are %s", acl.getType(), + acl.getName(), SUPPORTED_ACL_TYPES); + } + + private static void hasConsistentAceTypeForAclType(final Acl acl) { + Class<? extends AclBase> type = acl.getType(); + Preconditions.checkNotNull(type, "Cannot resolve Acl type for validation of Acl: {}", acl); + Preconditions.checkNotNull(acl.getAces(), "ACEs are missing for validation of Acl: {}", acl); + Preconditions.checkNotNull(acl.getAces().getAce(), "List of ACEs is null for validation of Acl: {}", acl); + if (type.equals(VppAcl.class)) { + Set<Ace> unsupportedVppAcls = + acl.getAces().getAce().stream().filter(ace -> !isVppAce(ace)).collect(Collectors.toSet()); + checkArgument(unsupportedVppAcls.isEmpty(), "Detected unsupported ace types [%s] for ACL %s", + unsupportedVppAcls, acl.getName()); + } + + if (type.equals(VppMacipAcl.class)) { + Set<Ace> unsupportedVppMacipAclAcls = + acl.getAces().getAce().stream().filter(ace -> !isVppMacipAclAce(ace)).collect(Collectors.toSet()); + checkArgument(unsupportedVppMacipAclAcls.isEmpty(), "Detected unsupported ace types [%s] for ACL %s", + unsupportedVppMacipAclAcls, acl.getName()); + } + } + + private static boolean isVppMacipAclAce(final Ace ace) { + Matches matches = Preconditions + .checkNotNull(ace.getMatches(), "Cannot validate VppMacipAcl type for Ace: {}, matches are not defined", + ace); + if (matches.getL2() == null || !(matches.getL2() instanceof Eth)) { + return false; + } + + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l2.eth.Eth + eth = ((Eth) matches.getL2()).getEth(); + if (eth == null) { + return false; + } + + return true; + } + + private static boolean isVppAce(final Ace ace) { + Matches matches = Preconditions + .checkNotNull(ace.getMatches(), "Cannot validate VppMacipAcl type for Ace: {}, matches are not defined", + ace); + L3 l3 = matches.getL3(); + if (l3 == null || (!(l3 instanceof Ipv4)) && (!(l3 instanceof Ipv6))) { + return false; + } + + if (l3 instanceof Ipv4) { + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4 + ipv4 = ((Ipv4) l3).getIpv4(); + if (ipv4 == null || ipv4.getSourceNetwork() == null || + !(ipv4.getSourceNetwork() instanceof SourceIpv4Network)) { + return false; + } + } + + if (l3 instanceof Ipv6) { + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6 + ipv6 = ((Ipv6) l3).getIpv6(); + if (ipv6 == null || ipv6.getSourceNetwork() == null || + !(ipv6.getSourceNetwork() instanceof SourceIpv6Network)) { + return false; + } + } + + return true; + } + + @VisibleForTesting + static List<String> checkAclReferenced(@Nonnull final WriteContext writeContext, @Nonnull final Acl acl) { + Preconditions.checkNotNull(acl.getType(), "Cannot validate acl: {}, type is not set.", acl); + if (!acl.getType().equals(VppAcl.class) && !acl.getType().equals(VppMacipAcl.class)) { + throw new IllegalArgumentException(String.format("Acl type %s not supported", acl.getType())); + } + + Optional<AttachmentPoints> attachmentPointsOpt = writeContext.readAfter(AclIIds.ACLS_AP); + if (!attachmentPointsOpt.isPresent() || attachmentPointsOpt.get().getInterface() == null) { + return Collections.emptyList(); + } + + final List<Interface> interfaces = attachmentPointsOpt.get().getInterface(); + if (interfaces == null) { + return Collections.emptyList(); + } + final String aclName = acl.getName(); + + HashMap<String, AclSets> sets = getIngressAclSets(interfaces); + sets.putAll(getEgressAclSets(interfaces)); + List<String> referencedIfcs = new ArrayList<>(); + sets.forEach((ifc, aclSets) -> { + if (aclSets.getAclSet() != null) { + if (aclSets.getAclSet().stream() + .map(AclSet::getName) + .filter(Objects::nonNull) + .anyMatch(name -> name.equalsIgnoreCase(aclName))) { + referencedIfcs.add(ifc); + } + } + }); + return referencedIfcs.stream().distinct().collect(Collectors.toList()); + } + + private static HashMap<String, AclSets> getEgressAclSets(final List<Interface> interfaces) { + HashMap<String, AclSets> map = new HashMap<>(); + interfaces.stream().filter(anInterface -> anInterface.getEgress() != null) + .forEach(anInterface -> map.put(anInterface.getInterfaceId(), anInterface.getEgress().getAclSets())); + return map; + } + + private static HashMap<String, AclSets> getIngressAclSets(final List<Interface> interfaces) { + HashMap<String, AclSets> map = new HashMap<>(); + interfaces.stream().filter(anInterface -> anInterface.getIngress() != null) + .forEach(anInterface -> map.put(anInterface.getInterfaceId(), anInterface.getIngress().getAclSets())); + return map; + } +} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizer.java index a6ca35af3..622a84d93 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizer.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizer.java @@ -16,82 +16,177 @@ package io.fd.hc2vpp.acl.write; +import static io.fd.hc2vpp.acl.write.request.MacIpInterfaceAssignmentRequest.deleteExisting; import static java.util.stream.Collectors.toList; import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer; -import io.fd.hc2vpp.acl.util.iface.acl.AclInterfaceAssignmentRequest; +import io.fd.hc2vpp.acl.write.request.AclInterfaceAssignmentRequest; +import io.fd.hc2vpp.acl.write.request.MacIpInterfaceAssignmentRequest; import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.spi.write.WriterCustomizer; import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; import java.util.Collections; import java.util.List; +import java.util.stream.Collectors; import javax.annotation.Nonnull; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclsBaseAttributes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSets; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; /** * Handles acl assignments(only standard ones, mac-ip have dedicated customizer) */ -public class InterfaceAclCustomizer extends FutureJVppAclCustomizer implements WriterCustomizer<Acl> { +public class InterfaceAclCustomizer extends FutureJVppAclCustomizer implements WriterCustomizer<Interface> { private final NamingContext interfaceContext; private final AclContextManager standardAclContext; + private final AclContextManager macIpAclContext; public InterfaceAclCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, @Nonnull final NamingContext interfaceContext, - @Nonnull final AclContextManager standardAclContext) { + @Nonnull final AclContextManager standardAclContext, + @Nonnull final AclContextManager macIpAclContext) { super(jVppAclFacade); this.interfaceContext = interfaceContext; this.standardAclContext = standardAclContext; + this.macIpAclContext = macIpAclContext; + } + + private static List<String> getAclNames(final AclSets acls) { + if (acls == null || acls.getAclSet() == null) { + return Collections.emptyList(); + } else { + return acls.getAclSet().stream().map(AclSet::getName).collect(toList()); + } } @Override - public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataAfter, + public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { - AclInterfaceAssignmentRequest.create(writeContext.getMappingContext()) - .standardAclContext(standardAclContext) - .interfaceContext(interfaceContext) - .identifier(id) - .inputAclNames(getAclNames(dataAfter.getIngress())) - .outputAclNames(getAclNames(dataAfter.getEgress())) - .executeAsCreate(getjVppAclFacade()); + AclSets egress = dataAfter.getEgress() != null ? dataAfter.getEgress().getAclSets() : null; + AclSets ingress = dataAfter.getIngress() != null ? dataAfter.getIngress().getAclSets() : null; + List<String> macIngress = parseMacRules(getAclNames(ingress), writeContext.getMappingContext()); + List<String> standardIngress = parseStandardRules(getAclNames(ingress), writeContext.getMappingContext()); + List<String> standardEgress = parseStandardRules(getAclNames(egress), writeContext.getMappingContext()); + + // Process standard ACLs + if (!standardIngress.isEmpty() || !standardEgress.isEmpty()) { + AclInterfaceAssignmentRequest.create(writeContext.getMappingContext()) + .standardAclContext(standardAclContext) + .interfaceContext(interfaceContext) + .identifier(id) + .inputAclNames(standardIngress) + .outputAclNames(standardEgress) + .executeAsCreate(getjVppAclFacade()); + } + // Process mac ACLs + if (!macIngress.isEmpty()) { + addMacAcls(id, writeContext, macIngress); + } } @Override - public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore, - @Nonnull final Acl dataAfter, @Nonnull final WriteContext writeContext) + public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final Interface dataBefore, + @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext) throws WriteFailedException { + AclSets egress = dataAfter.getEgress() != null ? dataAfter.getEgress().getAclSets() : null; + AclSets ingress = dataAfter.getIngress() != null ? dataAfter.getIngress().getAclSets() : null; + List<String> standardIngress = parseStandardRules(getAclNames(ingress), writeContext.getMappingContext()); + List<String> standardEgress = parseStandardRules(getAclNames(egress), writeContext.getMappingContext()); + + // update standard ACLs AclInterfaceAssignmentRequest.create(writeContext.getMappingContext()) .standardAclContext(standardAclContext) .interfaceContext(interfaceContext) .identifier(id) - .inputAclNames(getAclNames(dataAfter.getIngress())) - .outputAclNames(getAclNames(dataAfter.getEgress())) + .inputAclNames(standardIngress) + .outputAclNames(standardEgress) .executeAsUpdate(getjVppAclFacade(), dataBefore, dataAfter); + + // Process mac ACLs + AclSets ingressBefore = dataBefore.getIngress() != null ? dataBefore.getIngress().getAclSets() : null; + List<String> macIngressAfter = parseMacRules(getAclNames(ingress), writeContext.getMappingContext()); + List<String> macIngressBefore = parseMacRules(getAclNames(ingressBefore), writeContext.getMappingContext()); + List<String> added = + macIngressAfter.stream().filter(acl -> !macIngressBefore.contains(acl)).collect(Collectors.toList()); + List<String> removed = + macIngressBefore.stream().filter(acl -> !macIngressAfter.contains(acl)).collect(Collectors.toList()); + + if (!removed.isEmpty()) { + deleteMacACLs(id, writeContext, removed); + } + + if (!added.isEmpty()) { + addMacAcls(id, writeContext, added); + } } @Override - public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl dataBefore, - @Nonnull final WriteContext writeContext) throws WriteFailedException { - AclInterfaceAssignmentRequest.create(writeContext.getMappingContext()) - .standardAclContext(standardAclContext) - .interfaceContext(interfaceContext) - .identifier(id) - .executeAsDelete(getjVppAclFacade()); + public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext) + throws WriteFailedException { + AclSets ingress = dataBefore.getIngress() != null ? dataBefore.getIngress().getAclSets() : null; + List<String> standardIngress = parseStandardRules(getAclNames(ingress), writeContext.getMappingContext()); + List<String> macIngress = parseMacRules(getAclNames(ingress), writeContext.getMappingContext()); + + //Process standard ACLs + if (!standardIngress.isEmpty()) { + AclInterfaceAssignmentRequest.create(writeContext.getMappingContext()) + .standardAclContext(standardAclContext) + .interfaceContext(interfaceContext) + .identifier(id) + .executeAsDelete(getjVppAclFacade()); + } + + // Process mac ACLs + if (!macIngress.isEmpty()) { + deleteMacACLs(id, writeContext, macIngress); + } } - private static List<String> getAclNames(final VppAclsBaseAttributes acls) { - if (acls == null || acls.getVppAcls() == null) { - return Collections.emptyList(); - } else { - return acls.getVppAcls().stream().map(VppAcls::getName).collect(toList()); + private List<String> parseMacRules(final List<String> ingress, final MappingContext mappingContext) { + return ingress.stream() + .filter(aclName -> macIpAclContext.containsAcl(aclName, mappingContext)).collect(Collectors.toList()); + } + + private List<String> parseStandardRules(final List<String> ingress, final MappingContext mappingContext) { + return ingress.stream() + .filter(aclName -> standardAclContext.containsAcl(aclName, mappingContext)) + .collect(Collectors.toList()); + } + + + private void addMacAcls(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final WriteContext writeContext, final List<String> added) + throws WriteFailedException { + for (String macAcl : added) { + MacIpInterfaceAssignmentRequest.addNew(writeContext.getMappingContext()) + .identifier(id) + .aclName(macAcl) + .macIpAclContext(macIpAclContext) + .interfaceContext(interfaceContext) + .execute(getjVppAclFacade()); } } + private void deleteMacACLs(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final WriteContext writeContext, final List<String> macAcls) + throws WriteFailedException { + for (String macAcl : macAcls) { + deleteExisting(writeContext.getMappingContext()) + .identifier(id) + .aclName(macAcl) + .macIpAclContext(macIpAclContext) + .interfaceContext(interfaceContext) + .execute(getjVppAclFacade()); + } + } } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclMacIpCustomizer.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclMacIpCustomizer.java deleted file mode 100644 index fc0acd223..000000000 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/InterfaceAclMacIpCustomizer.java +++ /dev/null @@ -1,69 +0,0 @@ -/* - * 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.hc2vpp.acl.write; - -import static io.fd.hc2vpp.acl.util.iface.macip.MacIpInterfaceAssignmentRequest.addNew; -import static io.fd.hc2vpp.acl.util.iface.macip.MacIpInterfaceAssignmentRequest.deleteExisting; - -import io.fd.hc2vpp.acl.util.AclContextManager; -import io.fd.hc2vpp.acl.util.FutureJVppAclCustomizer; -import io.fd.hc2vpp.common.translate.util.NamingContext; -import io.fd.honeycomb.translate.spi.write.WriterCustomizer; -import io.fd.honeycomb.translate.write.WriteContext; -import io.fd.honeycomb.translate.write.WriteFailedException; -import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; -import javax.annotation.Nonnull; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - -public class InterfaceAclMacIpCustomizer extends FutureJVppAclCustomizer implements WriterCustomizer<VppMacipAcl> { - - private final AclContextManager macIpAclContext; - private final NamingContext interfaceContext; - - public InterfaceAclMacIpCustomizer(@Nonnull final FutureJVppAclFacade jVppAclFacade, - @Nonnull final AclContextManager macIpAclContext, - @Nonnull final NamingContext interfaceContext) { - super(jVppAclFacade); - this.macIpAclContext = macIpAclContext; - this.interfaceContext = interfaceContext; - } - - @Override - public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<VppMacipAcl> id, - @Nonnull final VppMacipAcl dataAfter, - @Nonnull final WriteContext writeContext) throws WriteFailedException { - addNew(writeContext.getMappingContext()) - .identifier(id) - .aclName(dataAfter.getName()) - .macIpAclContext(macIpAclContext) - .interfaceContext(interfaceContext) - .execute(getjVppAclFacade()); - } - - @Override - public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<VppMacipAcl> id, - @Nonnull final VppMacipAcl dataBefore, - @Nonnull final WriteContext writeContext) throws WriteFailedException { - deleteExisting(writeContext.getMappingContext()) - .identifier(id) - .aclName(dataBefore.getName()) - .macIpAclContext(macIpAclContext) - .interfaceContext(interfaceContext) - .execute(getjVppAclFacade()); - } -} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclValidator.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclValidator.java deleted file mode 100644 index 942d3bcb3..000000000 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/VppAclValidator.java +++ /dev/null @@ -1,178 +0,0 @@ -/* - * Copyright (c) 2018 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.write; - -import static com.google.common.base.Preconditions.checkArgument; -import static com.google.common.base.Preconditions.checkNotNull; -import static com.google.common.base.Preconditions.checkState; -import static java.lang.String.format; -import static java.util.Collections.emptyList; -import static java.util.Optional.ofNullable; - -import com.google.common.annotations.VisibleForTesting; -import com.google.common.base.Optional; -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; -import io.fd.hc2vpp.acl.util.acl.AclDataExtractor; -import io.fd.honeycomb.translate.write.DataValidationFailedException.CreateValidationFailedException; -import io.fd.honeycomb.translate.write.DataValidationFailedException.DeleteValidationFailedException; -import io.fd.honeycomb.translate.write.DataValidationFailedException.UpdateValidationFailedException; -import io.fd.honeycomb.translate.write.Validator; -import io.fd.honeycomb.translate.write.WriteContext; -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.stream.Collectors; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -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.acl.AccessListEntries; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.Matches; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.matches.AceType; -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.opendaylight.params.xml.ns.yang._interface.acl.rev161214.InterfaceAclAttributes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclsBaseAttributes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppMacipAclsBaseAttributes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAcl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAcl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAce; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - -public final class VppAclValidator implements Validator<Acl>, AclDataExtractor { - - private static final Set<Class<? extends AclBase>> SUPPORTED_ACL_TYPES = - ImmutableSet.of(VppAcl.class, VppMacipAcl.class); - private static final Map<Class<? extends AclBase>, Class<? extends AceType>> ACL_ACE_PAIRS = - ImmutableMap.of(VppAcl.class, VppAce.class, VppMacipAcl.class, VppMacipAce.class); - - @Override - public void validateWrite(final InstanceIdentifier<Acl> id, final Acl dataAfter, final WriteContext ctx) - throws CreateValidationFailedException { - try { - validateAcl(dataAfter); - } catch (RuntimeException e) { - throw new CreateValidationFailedException(id, dataAfter, e); - } - } - - @Override - public void validateUpdate(final InstanceIdentifier<Acl> id, final Acl dataBefore, final Acl dataAfter, - final WriteContext ctx) throws UpdateValidationFailedException { - try { - validateAcl(dataAfter); - } catch (RuntimeException e) { - throw new UpdateValidationFailedException(id, dataBefore, dataAfter, e); - } - } - - @Override - public void validateDelete(final InstanceIdentifier<Acl> id, final Acl dataBefore, final WriteContext ctx) - throws DeleteValidationFailedException { - try { - validateAcl(dataBefore); - final List<Interface> references = checkAclReferenced(ctx, dataBefore); - // references must be check, to not leave dead references in configuration - checkState(references.isEmpty(), - "%s cannot be removed, it is referenced in following interfaces %s", dataBefore, references); - } catch (RuntimeException e) { - throw new DeleteValidationFailedException(id, e); - } - } - - private static void validateAcl(@Nonnull final Acl acl) { - hasAceList(acl); - isSupportedAclType(acl); - hasConsistentAceTypeForAclType(acl); - } - - private static void hasAceList(final Acl acl) { - final AccessListEntries accessListEntries = acl.getAccessListEntries(); - checkArgument(accessListEntries != null, "The access-list-entries container is not defined."); - final List<Ace> ace = accessListEntries.getAce(); - checkArgument(ace != null, "The ace list is not defined."); - checkArgument(!ace.isEmpty(), "The ace list is empty."); - } - - private static void isSupportedAclType(final Acl acl) { - checkArgument(SUPPORTED_ACL_TYPES.contains(acl.getAclType()), - "Unsupported Acl type %s detected for acl %s, allowed types are %s", acl.getAclType(), - acl.getAclName(), SUPPORTED_ACL_TYPES); - } - - private static void hasConsistentAceTypeForAclType(final Acl acl) { - checkTypesSame(acl.getAccessListEntries().getAce(), acl.getAclName(), - checkNotNull(ACL_ACE_PAIRS.get(acl.getAclType()), "Unsupported ACL type %s for ACL %s", - acl.getAclType(), acl.getAclName())); - } - - private static void checkTypesSame(final List<Ace> aces, final String aclName, - final Class<? extends AceType> aceType) { - final Set<AceType> unsupportedAceTypes = aces.stream() - .map(Ace::getMatches) - .map(Matches::getAceType) - .filter(aceType::equals) - .collect(Collectors.toSet()); - checkArgument(unsupportedAceTypes.isEmpty(), "Detected unsupported ace types [%s] for ACL %s, expected %s", - unsupportedAceTypes, aclName, aceType); - } - - @VisibleForTesting - static List<Interface> checkAclReferenced(@Nonnull final WriteContext writeContext, - @Nonnull final Acl acl) { - final Optional<Interfaces> readAfter = writeContext.readAfter(InstanceIdentifier.create(Interfaces.class)); - if (!readAfter.isPresent() || readAfter.get().getInterface() == null) { - return Collections.emptyList(); - } - - final List<Interface> interfaces = readAfter.get().getInterface(); - final Class<? extends AclBase> aclType = acl.getAclType(); - final String aclName = acl.getAclName(); - - if (aclType.equals(VppAcl.class)) { - return interfaces.stream() - .filter(iface -> ofNullable(iface.augmentation(VppAclInterfaceAugmentation.class)) - .map(InterfaceAclAttributes::getAcl) - .filter(references -> - checkVppAcls(references.getIngress(), aclName) || - checkVppAcls(references.getEgress(), aclName)).isPresent() - ).collect(Collectors.toList()); - } else if (aclType.equals(VppMacipAcl.class)) { - return interfaces.stream() - .filter(iface -> ofNullable(iface.augmentation(VppAclInterfaceAugmentation.class)) - .map(InterfaceAclAttributes::getAcl) - .map(aclAttr -> aclAttr.getIngress()) - .map(VppMacipAclsBaseAttributes::getVppMacipAcl) - .filter(vppMacipAcl -> vppMacipAcl.getName().equals(aclName)) - .isPresent()) - .collect(Collectors.toList()); - } else { - throw new IllegalArgumentException(format("Acl type %s not supported", aclType)); - } - } - - private static boolean checkVppAcls(@Nullable final VppAclsBaseAttributes attrs, @Nonnull final String name) { - return ofNullable(attrs).map(VppAclsBaseAttributes::getVppAcls) - .orElse(emptyList()) - .stream().anyMatch(acl -> acl.getName().equals(name)); - } -} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AbstractAclWriterFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AbstractAclWriterFactory.java index 37a8de2d1..8944e5977 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AbstractAclWriterFactory.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AbstractAclWriterFactory.java @@ -26,10 +26,10 @@ import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; /** * Created by jsrnicek on 12.12.2016. */ -class AbstractAclWriterFactory { +abstract class AbstractAclWriterFactory { @Inject - protected FutureJVppAclFacade futureAclFacade; + FutureJVppAclFacade futureAclFacade; @Inject @Named(AclModule.STANDARD_ACL_CONTEXT_NAME) @@ -37,7 +37,7 @@ class AbstractAclWriterFactory { @Inject @Named(AclModule.MAC_IP_ACL_CONTEXT_NAME) - protected AclContextManager macIpAClContext; + protected AclContextManager macIpAclContext; @Inject @Named("interface-context") diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AclWriterFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AclWriterFactory.java new file mode 100644 index 000000000..faab3023d --- /dev/null +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/AclWriterFactory.java @@ -0,0 +1,39 @@ +/* + * 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.hc2vpp.acl.write.factory; + +import io.fd.hc2vpp.acl.AclIIds; +import io.fd.hc2vpp.acl.write.AclCustomizer; +import io.fd.hc2vpp.acl.write.AclValidator; +import io.fd.honeycomb.translate.impl.write.GenericListWriter; +import io.fd.honeycomb.translate.write.WriterFactory; +import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder; +import javax.annotation.Nonnull; + +public class AclWriterFactory extends AbstractAclWriterFactory implements WriterFactory { + + @Override + public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) { + + registry.subtreeAddBefore(AclIIds.vppAclChildren(AclIIds.ACL), + new GenericListWriter<>(AclIIds.ACLS_ACL, + new AclCustomizer(futureAclFacade, standardAclContext, macIpAclContext), + new AclValidator() + ), + AclIIds.aclHandledChildren(AclIIds.IFC_ACL)); + } +} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/InterfaceAclWriterFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/InterfaceAclWriterFactory.java index 12be40a14..c5144b362 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/InterfaceAclWriterFactory.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/InterfaceAclWriterFactory.java @@ -17,46 +17,27 @@ package io.fd.hc2vpp.acl.write.factory; import com.google.common.collect.ImmutableSet; +import io.fd.hc2vpp.acl.AclIIds; import io.fd.hc2vpp.acl.write.InterfaceAclCustomizer; -import io.fd.hc2vpp.acl.write.InterfaceAclMacIpCustomizer; import io.fd.honeycomb.translate.impl.write.GenericWriter; import io.fd.honeycomb.translate.write.WriterFactory; import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder; import java.util.Set; import javax.annotation.Nonnull; -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.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Egress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class InterfaceAclWriterFactory extends AbstractAclWriterFactory implements WriterFactory { - static final InstanceIdentifier<Acl> ACL_IID = - InstanceIdentifier.create(Interfaces.class).child(Interface.class) - .augmentation(VppAclInterfaceAugmentation.class).child(Acl.class); - private static final InstanceIdentifier<Interface> IFC_ID = - InstanceIdentifier.create(Interfaces.class).child(Interface.class); - - @Override public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) { - registry.subtreeAddAfter(aclHandledChildren(InstanceIdentifier.create(Acl.class)), - new GenericWriter<>(ACL_IID, - new InterfaceAclCustomizer(futureAclFacade, interfaceContext, standardAclContext)), IFC_ID); - - registry.addAfter(new GenericWriter<>(ACL_IID.child(Ingress.class).child(VppMacipAcl.class), - new InterfaceAclMacIpCustomizer(futureAclFacade, macIpAClContext, interfaceContext)), IFC_ID); + registry.subtreeAddAfter(AclIIds.aclHandledChildren(AclIIds.IFC_ACL), + new GenericWriter<>(AclIIds.ACLS_AP_INT, + new InterfaceAclCustomizer(futureAclFacade, interfaceContext, standardAclContext, + macIpAclContext)), + aclRequiredIids()); } - static Set<InstanceIdentifier<?>> aclHandledChildren(final InstanceIdentifier<Acl> parentId) { - return ImmutableSet.of(parentId.child(Ingress.class), - parentId.child(Ingress.class).child(VppAcls.class), - parentId.child(Egress.class), - parentId.child(Egress.class).child(VppAcls.class)); + static Set<InstanceIdentifier<?>> aclRequiredIids() { + return ImmutableSet.of(AclIIds.IFC, AclIIds.IFC_ACL, AclIIds.ACLS_ACL); } } diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/VppAclWriterFactory.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/VppAclWriterFactory.java deleted file mode 100644 index 883cf4f1f..000000000 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/factory/VppAclWriterFactory.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * 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.hc2vpp.acl.write.factory; - -import static io.fd.hc2vpp.acl.write.factory.InterfaceAclWriterFactory.ACL_IID; -import static io.fd.hc2vpp.acl.write.factory.InterfaceAclWriterFactory.aclHandledChildren; - -import io.fd.hc2vpp.acl.util.factory.AclFactory; -import io.fd.hc2vpp.acl.write.VppAclCustomizer; -import io.fd.hc2vpp.acl.write.VppAclValidator; -import io.fd.honeycomb.translate.impl.write.GenericListWriter; -import io.fd.honeycomb.translate.write.WriterFactory; -import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder; -import javax.annotation.Nonnull; -import org.opendaylight.yang.gen.v1.urn.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.access.lists.Acl; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - -public class VppAclWriterFactory extends AbstractAclWriterFactory implements WriterFactory, AclFactory { - - @Override - public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) { - final InstanceIdentifier<AccessLists> rootNode = InstanceIdentifier.create(AccessLists.class); - - registry.subtreeAddBefore(vppAclChildren(InstanceIdentifier.create(Acl.class)), - new GenericListWriter<>(rootNode.child(Acl.class), - new VppAclCustomizer(futureAclFacade, standardAclContext, macIpAClContext), - new VppAclValidator() - ), - aclHandledChildren(ACL_IID)); - } -} diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclWriter.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/AclAddReplaceRequest.java index 32e20ebac..29a7c7489 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/acl/AclWriter.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/AclAddReplaceRequest.java @@ -14,10 +14,11 @@ * limitations under the License. */ -package io.fd.hc2vpp.acl.util.acl; +package io.fd.hc2vpp.acl.write.request; import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.acl.util.ace.AceConverter; +import io.fd.hc2vpp.acl.util.acl.AclDataExtractor; import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.write.WriteFailedException; @@ -30,21 +31,25 @@ import io.fd.vpp.jvpp.acl.dto.MacipAclDel; import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; 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.access.lists.Acl; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -/** - * Write standard and mac-ip acls - */ -public interface AclWriter extends AclDataExtractor, AceConverter, JvppReplyConsumer { +public class AclAddReplaceRequest implements AclDataExtractor, AceConverter, JvppReplyConsumer { int ACL_INDEX_CREATE_NEW = -1; + private final FutureJVppAclFacade futureFacade; + private final MappingContext mappingContext; + + public AclAddReplaceRequest(@Nonnull final FutureJVppAclFacade futureFacade, + @Nonnull final MappingContext mappingContext) { + this.futureFacade = futureFacade; + this.mappingContext = mappingContext; + } - default void addStandardAcl(@Nonnull final FutureJVppAclFacade futureFacade, - @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, - @Nonnull final AclContextManager standardAclContext, - @Nonnull final MappingContext mappingContext) throws WriteFailedException { + + public void addStandardAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, + @Nonnull final AclContextManager standardAclContext) throws WriteFailedException { final AclAddReplace request = new AclAddReplace(); @@ -59,38 +64,35 @@ public interface AclWriter extends AclDataExtractor, AceConverter, JvppReplyCons getReplyForWrite(futureFacade.aclAddReplace(request).toCompletableFuture(), id); // maps new acl to returned index - standardAclContext.addAcl(reply.aclIndex, acl.getAclName(), aces, mappingContext); + standardAclContext.addAcl(reply.aclIndex, acl.getName(), aces, mappingContext); } // according to vpp team, this was tested extensively, and should work - default void updateStandardAcl(@Nonnull final FutureJVppAclFacade futureFacade, - @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, - @Nonnull final AclContextManager standardAclContext, - @Nonnull final MappingContext mappingContext) throws WriteFailedException { + public void updateStandardAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, + @Nonnull final AclContextManager standardAclContext) throws WriteFailedException { final AclAddReplace request = new AclAddReplace(); request.tag = getAclTag(acl); // by setting existing index, request is resolved as update - request.aclIndex = standardAclContext.getAclIndex(acl.getAclName(), mappingContext); + request.aclIndex = standardAclContext.getAclIndex(acl.getName(), mappingContext); final List<Ace> aces = getAces(acl); request.r = toStandardAclRules(aces); request.count = request.r.length; - final AclAddReplaceReply reply = getReplyForWrite(futureFacade.aclAddReplace(request).toCompletableFuture(), id); + final AclAddReplaceReply reply = + getReplyForWrite(futureFacade.aclAddReplace(request).toCompletableFuture(), id); // overwrites existing acl metadata (aces might have been changed): - standardAclContext.addAcl(reply.aclIndex, acl.getAclName(), aces, mappingContext); + standardAclContext.addAcl(reply.aclIndex, acl.getName(), aces, mappingContext); } - default void deleteStandardAcl(@Nonnull final FutureJVppAclFacade futureFacade, - @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, - @Nonnull final AclContextManager standardAclContext, - @Nonnull final MappingContext mappingContext) throws WriteFailedException { + public void deleteStandardAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, + @Nonnull final AclContextManager standardAclContext) throws WriteFailedException { final AclDel request = new AclDel(); - final String aclName = acl.getAclName(); + final String aclName = acl.getName(); request.aclIndex = standardAclContext.getAclIndex(aclName, mappingContext); getReplyForDelete(futureFacade.aclDel(request).toCompletableFuture(), id); @@ -99,10 +101,8 @@ public interface AclWriter extends AclDataExtractor, AceConverter, JvppReplyCons standardAclContext.removeAcl(aclName, mappingContext); } - default void addMacIpAcl(@Nonnull final FutureJVppAclFacade futureFacade, - @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, - @Nonnull final AclContextManager macIpAclContext, - @Nonnull final MappingContext mappingContext) throws WriteFailedException { + public void addMacIpAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, + @Nonnull final AclContextManager macIpAclContext) throws WriteFailedException { final MacipAclAdd request = new MacipAclAdd(); request.tag = getAclTag(acl); @@ -114,15 +114,13 @@ public interface AclWriter extends AclDataExtractor, AceConverter, JvppReplyCons final MacipAclAddReply reply = getReplyForWrite(futureFacade.macipAclAdd(request).toCompletableFuture(), id); // map mac-ip acl to returned index - macIpAclContext.addAcl(reply.aclIndex, acl.getAclName(), aces, mappingContext); + macIpAclContext.addAcl(reply.aclIndex, acl.getName(), aces, mappingContext); } - default void deleteMacIpAcl(@Nonnull final FutureJVppAclFacade futureFacade, - @Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, - @Nonnull final AclContextManager macIpAclContext, - @Nonnull final MappingContext mappingContext) throws WriteFailedException { + public void deleteMacIpAcl(@Nonnull final InstanceIdentifier<Acl> id, @Nonnull final Acl acl, + @Nonnull final AclContextManager macIpAclContext) throws WriteFailedException { final MacipAclDel request = new MacipAclDel(); - final String aclName = acl.getAclName(); + final String aclName = acl.getName(); request.aclIndex = macIpAclContext.getAclIndex(aclName, mappingContext); getReplyForDelete(futureFacade.macipAclDel(request).toCompletableFuture(), id); diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/iface/acl/AclInterfaceAssignmentRequest.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/AclInterfaceAssignmentRequest.java index bf1f1497e..2d7777e35 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/iface/acl/AclInterfaceAssignmentRequest.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/AclInterfaceAssignmentRequest.java @@ -15,7 +15,7 @@ */ -package io.fd.hc2vpp.acl.util.iface.acl; +package io.fd.hc2vpp.acl.write.request; import static com.google.common.base.Preconditions.checkNotNull; @@ -32,8 +32,7 @@ import java.util.Collections; import java.util.List; import java.util.stream.Stream; import javax.annotation.Nonnull; -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._interface.acl.rev161214._interface.acl.attributes.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -46,7 +45,8 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat private static final Logger LOG = LoggerFactory.getLogger(AclInterfaceAssignmentRequest.class); private final MappingContext mappingContext; - private InstanceIdentifier<Acl> identifier; + private InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface> + identifier; private List<String> inputAclNames = Collections.emptyList(); private List<String> outputAclNames = Collections.emptyList(); private AclContextManager standardAclContext; @@ -62,7 +62,7 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat } public AclInterfaceAssignmentRequest identifier( - @Nonnull final InstanceIdentifier<Acl> identifier) { + @Nonnull final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface> identifier) { this.identifier = identifier; return this; } @@ -97,7 +97,7 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat public void executeAsCreate(@Nonnull final FutureJVppAclFacade api) throws WriteFailedException { checkValidRequest(); - final String interfaceName = identifier.firstKeyOf(Interface.class).getName(); + final String interfaceName = identifier.firstKeyOf(Interface.class).getInterfaceId(); // locking on mapping context, to prevent modifying of mappings (for both contexts) during binding/execution of request synchronized (mappingContext) { @@ -113,10 +113,12 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat } } - public void executeAsUpdate(@Nonnull final FutureJVppAclFacade api, final Acl before, final Acl after) + public void executeAsUpdate(@Nonnull final FutureJVppAclFacade api, + final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface before, + final org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface after) throws WriteFailedException { checkValidRequest(); - final String interfaceName = identifier.firstKeyOf(Interface.class).getName(); + final String interfaceName = identifier.firstKeyOf(Interface.class).getInterfaceId(); // locking on mapping context, to prevent modifying of mappings (for both contexts) during binding/execution of request synchronized (mappingContext) { @@ -134,7 +136,7 @@ public class AclInterfaceAssignmentRequest implements JvppReplyConsumer, ByteDat public void executeAsDelete(@Nonnull final FutureJVppAclFacade api) throws WriteFailedException { checkValidRequest(); - final String interfaceName = identifier.firstKeyOf(Interface.class).getName(); + final String interfaceName = identifier.firstKeyOf(Interface.class).getInterfaceId(); // locking on mapping context, to prevent modifying of mappings (for both contexts) during binding/execution of request synchronized (mappingContext) { diff --git a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/iface/macip/MacIpInterfaceAssignmentRequest.java b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/MacIpInterfaceAssignmentRequest.java index 882cfd631..b7849991b 100644 --- a/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/util/iface/macip/MacIpInterfaceAssignmentRequest.java +++ b/acl/acl-impl/src/main/java/io/fd/hc2vpp/acl/write/request/MacIpInterfaceAssignmentRequest.java @@ -15,7 +15,7 @@ */ -package io.fd.hc2vpp.acl.util.iface.macip; +package io.fd.hc2vpp.acl.write.request; import static com.google.common.base.Preconditions.checkNotNull; @@ -28,8 +28,7 @@ import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceAddDel; 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.interfaces.rev140508.interfaces.Interface; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -40,7 +39,8 @@ public class MacIpInterfaceAssignmentRequest implements ByteDataTranslator, Jvpp private final boolean isNew; private final MappingContext mappingContext; - private InstanceIdentifier<VppMacipAcl> identifier; + private InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface> + identifier; private String aclName; private AclContextManager macIpAclContext; private NamingContext interfaceContext; @@ -59,7 +59,8 @@ public class MacIpInterfaceAssignmentRequest implements ByteDataTranslator, Jvpp return new MacIpInterfaceAssignmentRequest(false, mappingContext); } - public MacIpInterfaceAssignmentRequest identifier(@Nonnull final InstanceIdentifier<VppMacipAcl> identifier) { + public MacIpInterfaceAssignmentRequest identifier( + @Nonnull final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface> identifier) { this.identifier = identifier; return this; } @@ -93,7 +94,7 @@ public class MacIpInterfaceAssignmentRequest implements ByteDataTranslator, Jvpp synchronized (mappingContext) { checkValidRequest(); - final String interfaceName = identifier.firstKeyOf(Interface.class).getName(); + final String interfaceName = identifier.firstKeyOf(Interface.class).getInterfaceId(); MacipAclInterfaceAddDel request = new MacipAclInterfaceAddDel(); request.isAdd = booleanToByte(isNew); diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/AclTestSchemaContext.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/AclTestSchemaContext.java index 6eb6862bf..6e10be47a 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/AclTestSchemaContext.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/AclTestSchemaContext.java @@ -33,13 +33,11 @@ public interface AclTestSchemaContext { .getInstance(), org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.$YangModuleInfoImpl .getInstance(), - org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev160708.$YangModuleInfoImpl + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.$YangModuleInfoImpl .getInstance(), - org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.$YangModuleInfoImpl + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.$YangModuleInfoImpl .getInstance(), - org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.$YangModuleInfoImpl - .getInstance(), - org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.$YangModuleInfoImpl + org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.$YangModuleInfoImpl .getInstance())); return context; } diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizerTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/AbstractAclCustomizerTest.java index 074b25b29..beda3ccff 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/AbstractVppAclCustomizerTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/AbstractAclCustomizerTest.java @@ -25,6 +25,7 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import io.fd.hc2vpp.acl.AclIIds; import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.common.test.read.InitializingListReaderCustomizerTest; import io.fd.hc2vpp.common.translate.util.NamingContext; @@ -35,29 +36,34 @@ import io.fd.vpp.jvpp.acl.dto.AclDetailsReplyDump; import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetails; import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump; import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDump; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceGetReply; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDetails; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDetailsReplyDump; import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; import java.util.ArrayList; +import java.util.Collections; import javax.annotation.Nonnull; import org.junit.Test; import org.mockito.Mock; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState; -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.interfaces.rev140508.interfaces.state.InterfaceKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceStateAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAclsBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAclsKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAcl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; -public abstract class AbstractVppAclCustomizerTest - extends InitializingListReaderCustomizerTest<VppAcls, VppAclsKey, VppAclsBuilder> { +public abstract class AbstractAclCustomizerTest + extends InitializingListReaderCustomizerTest<AclSet, AclSetKey, AclSetBuilder> { protected static final String IF_NAME = "eth1"; protected static final int IF_ID = 1; + protected static final int ACL_ID = 1; + protected static final int ACL_MAC_ID = 2; + private static final String ACL_NAME = "acl-name"; + private static final String ACL_MAC_NAME = "acl-mac-name"; protected static final String IF_NAME_NO_ACL = "eth2"; protected static final int IF_ID_NO_ACL = 2; @@ -73,32 +79,39 @@ public abstract class AbstractVppAclCustomizerTest @Mock protected AclContextManager standardAclContext; - protected AbstractVppAclCustomizerTest(final Class<? extends Builder<? extends DataObject>> parentBuilderClass) { - super(VppAcls.class, parentBuilderClass); + @Mock + protected AclContextManager macIpAclContext; + + protected AbstractAclCustomizerTest(final Class<? extends Builder<? extends DataObject>> parentBuilderClass) { + super(AclSet.class, parentBuilderClass); } - protected static InstanceIdentifier<Acl> getAclId(final String ifName) { - return InstanceIdentifier.create(InterfacesState.class).child(Interface.class, new InterfaceKey(ifName)) - .augmentation(VppAclInterfaceStateAugmentation.class).child(Acl.class); + protected static KeyedInstanceIdentifier<Interface, InterfaceKey> getAclId(final String ifName) { + return AclIIds.ACLS_AP.child(Interface.class, new InterfaceKey(ifName)); } @Override protected void setUp() throws Exception { defineMapping(mappingContext, IF_NAME, IF_ID, IFC_CTX_NAME); defineMapping(mappingContext, IF_NAME_NO_ACL, IF_ID_NO_ACL, IFC_CTX_NAME); + when(macIpAclContext.getAclName(ACL_MAC_ID, mappingContext)).thenReturn(ACL_MAC_NAME); + when(standardAclContext.getAclName(ACL_ID, mappingContext)).thenReturn(ACL_NAME); + when(macIpAclContext.containsAcl(ACL_MAC_NAME, mappingContext)).thenReturn(true); + when(standardAclContext.containsAcl(ACL_NAME, mappingContext)).thenReturn(true); + final MacipAclInterfaceListDetailsReplyDump macReply = macAaclInterfaceDump(0); + when(aclApi.macipAclInterfaceListDump(any())).thenReturn(future(macReply)); + final AclInterfaceListDetailsReplyDump reply = aclInterfaceDump((byte) 0); + when(aclApi.aclInterfaceListDump(any())).thenReturn(future(reply)); } @Test public void testGetAllIdsNoAclConfigured() throws ReadFailedException { - final AclInterfaceListDetailsReplyDump reply = aclInterfaceDump((byte) 0); - when(aclApi.aclInterfaceListDump(any())).thenReturn(future(reply)); assertTrue(getCustomizer().getAllIds(getWildcardedIid(IF_NAME), ctx).isEmpty()); } @Test public void testRead() throws ReadFailedException { final String aclName = "acl-name"; - final Class<VppAcl> aclType = VppAcl.class; defineMapping(mappingContext, aclName, 1, ACL_CTX_NAME); final AclDetailsReplyDump reply = new AclDetailsReplyDump(); @@ -108,19 +121,25 @@ public abstract class AbstractVppAclCustomizerTest reply.aclDetails.add(detail); when(aclApi.aclDump(any())).thenReturn(future(reply)); - final VppAclsBuilder builder = mock(VppAclsBuilder.class); - getCustomizer().readCurrentAttributes(getIid(IF_NAME, new VppAclsKey(aclName, aclType)), builder, ctx); + final AclSetBuilder builder = mock(AclSetBuilder.class); + getCustomizer().readCurrentAttributes(getIid(IF_NAME, new AclSetKey(aclName)), builder, ctx); verify(builder).setName(aclName); - verify(builder).setType(aclType); } @Test public void testReadAllTwoIfacesInOneTx() throws ReadFailedException { final AclInterfaceListDetailsReplyDump reply = aclInterfaceDump((byte) 2, "acl1", "acl2", "acl3"); + final MacipAclInterfaceListDetailsReplyDump macReply = macAaclInterfaceDump(0); + final MacipAclInterfaceListDetailsReplyDump macReply2 = macAaclInterfaceDump(1); + final MacipAclInterfaceGetReply interfaceGet = macipAclInterfaceGetReply(); + + when(aclApi.aclInterfaceListDump(aclInterfaceRequest(IF_ID))).thenReturn(future(reply)); + when(aclApi.macipAclInterfaceListDump(any())).thenReturn(future(macReply)); + when(aclApi.macipAclInterfaceGet(any())).thenReturn(future(interfaceGet)); when(aclApi.aclInterfaceListDump(aclInterfaceRequest(IF_ID_NO_ACL))) - .thenReturn(future(aclInterfaceDump((byte) 0))); + .thenReturn(future(aclInterfaceDump((byte) 0))); // read all for interface with defined ACLs: assertFalse(getCustomizer().getAllIds(getWildcardedIid(IF_NAME), ctx).isEmpty()); @@ -128,19 +147,28 @@ public abstract class AbstractVppAclCustomizerTest assertEquals(0, getCustomizer().getAllIds(getWildcardedIid(IF_NAME_NO_ACL), ctx).size()); } + protected MacipAclInterfaceGetReply macipAclInterfaceGetReply(final String... aclNames) { + final MacipAclInterfaceGetReply reply = new MacipAclInterfaceGetReply(); + reply.acls = new int[aclNames.length]; + for (int i = 0; i < aclNames.length; ++i) { + defineMapping(mappingContext, aclNames[i], i, ACL_CTX_NAME); + reply.acls[i] = i; + } + reply.count = (byte) aclNames.length; + return reply; + } + @Test public void testInit() { final String aclName = "acl-name"; - final Class<VppAcl> aclType = VppAcl.class; defineMapping(mappingContext, aclName, 1, ACL_CTX_NAME); - final VppAcls readValue = new VppAclsBuilder().build(); + final AclSet readValue = new AclSetBuilder().build(); final Initialized<? extends DataObject> cfgValue = - getCustomizer().init(getIid(IF_NAME, new VppAclsKey(aclName, aclType)), readValue, ctx); + getCustomizer().init(getIid(IF_NAME, new AclSetKey(aclName)), readValue, ctx); assertEquals(readValue, cfgValue.getData()); - assertNotNull(cfgValue.getId().firstKeyOf( - org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface.class)); - assertEquals(cfgValue.getId().getTargetType(), VppAcls.class); + assertNotNull(cfgValue.getId().firstKeyOf(Interface.class)); + assertEquals(cfgValue.getId().getTargetType(), AclSet.class); } protected AclInterfaceListDump aclInterfaceRequest(final int swIfIndex) { @@ -157,12 +185,31 @@ public abstract class AbstractVppAclCustomizerTest defineMapping(mappingContext, aclNames[i], i, ACL_CTX_NAME); details.acls[i] = i; } + details.count = (byte) aclNames.length; details.nInput = nInput; reply.aclInterfaceListDetails.add(details); return reply; } - protected abstract InstanceIdentifier<VppAcls> getWildcardedIid(@Nonnull final String ifName); + protected MacipAclInterfaceListDetailsReplyDump macAaclInterfaceDump(int swIfIndex, final String... aclNames) { + final MacipAclInterfaceListDetailsReplyDump assignedAcls = new MacipAclInterfaceListDetailsReplyDump(); + + MacipAclInterfaceListDetails details = new MacipAclInterfaceListDetails(); + details.swIfIndex = swIfIndex; + details.count = (byte) aclNames.length; + details.acls = new int[aclNames.length]; + for (int i = 0; i < aclNames.length; ++i) { + defineMapping(mappingContext, aclNames[i], i, ACL_CTX_NAME); + details.acls[i] = i; + } + + assignedAcls.macipAclInterfaceListDetails.add(details); + assignedAcls.macipAclInterfaceListDetails = Collections.singletonList(details); + + return assignedAcls; + } + + protected abstract InstanceIdentifier<AclSet> getWildcardedIid(@Nonnull final String ifName); - protected abstract InstanceIdentifier<VppAcls> getIid(@Nonnull final String ifName, @Nonnull final VppAclsKey key); + protected abstract InstanceIdentifier<AclSet> getIid(@Nonnull final String ifName, @Nonnull final AclSetKey key); }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/AclCustomizerTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/AclCustomizerTest.java index 1b4403b2d..7501815a6 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/AclCustomizerTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/AclCustomizerTest.java @@ -35,18 +35,15 @@ import java.util.ArrayList; import java.util.List; import org.junit.Test; import org.mockito.Mock; -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.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.access.list.entries.Ace; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Deny; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAcl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAcl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Other; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Acls; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.AclsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Drop; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; @@ -58,7 +55,7 @@ public class AclCustomizerTest extends InitializingListReaderCustomizerTest<Acl, private static final String MACIP_ACL_NAME = "vpp-macip-acl"; private static final String MACIP_ACE_NAME = "vpp-macip-ace"; private static final int MACIP_ACL_INDEX = 456; - private static final short PROTOCOL = 2; + private static final short PROTOCOL = 1; @Mock private FutureJVppAclFacade aclApi; @Mock @@ -66,13 +63,12 @@ public class AclCustomizerTest extends InitializingListReaderCustomizerTest<Acl, @Mock private AclContextManager macipAclContext; private KeyedInstanceIdentifier<Acl, AclKey> ACL_IID = - InstanceIdentifier.create(AccessLists.class).child(Acl.class, new AclKey( - ACL_NAME, VppAcl.class)); + InstanceIdentifier.create(Acls.class).child(Acl.class, new AclKey(ACL_NAME)); private KeyedInstanceIdentifier<Acl, AclKey> MACIP_ACL_IID = - InstanceIdentifier.create(AccessLists.class).child(Acl.class, new AclKey(MACIP_ACL_NAME, VppMacipAcl.class)); + InstanceIdentifier.create(Acls.class).child(Acl.class, new AclKey(MACIP_ACL_NAME)); public AclCustomizerTest() { - super(Acl.class, AccessListsBuilder.class); + super(Acl.class, AclsBuilder.class); } @Override @@ -103,15 +99,18 @@ public class AclCustomizerTest extends InitializingListReaderCustomizerTest<Acl, when(standardAclContext.getAclName(ACL_INDEX, mappingContext)).thenReturn(ACL_NAME); when(standardAclContext.getAclIndex(ACL_NAME, mappingContext)).thenReturn(ACL_INDEX); when(standardAclContext.getAceName(ACL_NAME, 0, mappingContext)).thenReturn(ACE_NAME); + when(standardAclContext.containsAcl(ACL_NAME, mappingContext)).thenReturn(true); when(macipAclContext.getAclName(MACIP_ACL_INDEX, mappingContext)).thenReturn(MACIP_ACL_NAME); when(macipAclContext.getAclIndex(MACIP_ACL_NAME, mappingContext)).thenReturn(MACIP_ACL_INDEX); when(macipAclContext.getAceName(MACIP_ACL_NAME, 0, mappingContext)).thenReturn(MACIP_ACE_NAME); + when(macipAclContext.containsAcl(MACIP_ACL_NAME, mappingContext)).thenReturn(true); } @Test public void testGetAllIds() throws ReadFailedException { - final List<AclKey> allIds = getCustomizer().getAllIds(InstanceIdentifier.create(AccessLists.class).child(Acl.class), ctx); + final List<AclKey> allIds = + getCustomizer().getAllIds(InstanceIdentifier.create(Acls.class).child(Acl.class), ctx); assertEquals(2, allIds.size()); assertEquals(ACL_IID.getKey(), allIds.get(0)); assertEquals(MACIP_ACL_IID.getKey(), allIds.get(1)); @@ -122,14 +121,13 @@ public class AclCustomizerTest extends InitializingListReaderCustomizerTest<Acl, final AclBuilder builder = new AclBuilder(); getCustomizer().readCurrentAttributes(ACL_IID, builder, ctx); assertEquals(ACL_IID.getKey(), builder.key()); - final List<Ace> aces = builder.getAccessListEntries().getAce(); + final List<Ace> aces = builder.getAces().getAce(); assertEquals(1, aces.size()); final Ace ace = aces.get(0); - assertEquals(ACE_NAME, ace.key().getRuleName()); - assertTrue(ace.getActions().getPacketHandling() instanceof Deny); - final VppAceNodes nodes = ((VppAce) (ace.getMatches().getAceType())).getVppAceNodes(); - assertEquals(PROTOCOL, ((Other) nodes.getIpProtocol()).getOtherNodes().getProtocol().shortValue()); - + assertEquals(ACE_NAME, ace.key().getName()); + assertTrue(ace.getActions().getForwarding().equals(Drop.class)); + final L4 l4 = ((ace.getMatches())).getL4(); + assertEquals(Icmp.class, l4.getImplementedInterface()); } @Test @@ -137,10 +135,10 @@ public class AclCustomizerTest extends InitializingListReaderCustomizerTest<Acl, final AclBuilder builder = new AclBuilder(); getCustomizer().readCurrentAttributes(MACIP_ACL_IID, builder, ctx); assertEquals(MACIP_ACL_IID.getKey(), builder.key()); - final List<Ace> aces = builder.getAccessListEntries().getAce(); + final List<Ace> aces = builder.getAces().getAce(); assertEquals(1, aces.size()); final Ace ace = aces.get(0); - assertEquals(MACIP_ACE_NAME, ace.key().getRuleName()); - assertTrue(ace.getActions().getPacketHandling() instanceof Deny); + assertEquals(MACIP_ACE_NAME, ace.key().getName()); + assertTrue(ace.getActions().getForwarding().equals(Drop.class)); } }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizerTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/EgressAclCustomizerTest.java index 967b8200a..18f1978ef 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/EgressVppAclCustomizerTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/EgressAclCustomizerTest.java @@ -25,21 +25,23 @@ import io.fd.honeycomb.translate.read.ReadFailedException; import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump; import javax.annotation.Nonnull; import org.junit.Test; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Egress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.EgressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAclsKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.Egress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSets; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; -public class EgressVppAclCustomizerTest extends AbstractVppAclCustomizerTest { +public class EgressAclCustomizerTest extends AbstractAclCustomizerTest { - public EgressVppAclCustomizerTest() { - super(EgressBuilder.class); + public EgressAclCustomizerTest() { + super(AclSetsBuilder.class); } @Override - protected EgressVppAclCustomizer initCustomizer() { - return new EgressVppAclCustomizer(aclApi, interfaceContext, standardAclContext); + protected EgressAclCustomizer initCustomizer() { + return new EgressAclCustomizer(aclApi, interfaceContext, standardAclContext); } @Test @@ -57,12 +59,12 @@ public class EgressVppAclCustomizerTest extends AbstractVppAclCustomizerTest { } @Override - protected InstanceIdentifier<VppAcls> getWildcardedIid(@Nonnull final String ifName) { - return getAclId(ifName).child(Egress.class).child(VppAcls.class); + protected InstanceIdentifier<AclSet> getWildcardedIid(@Nonnull final String ifName) { + return getAclId(ifName).child(Egress.class).child(AclSets.class).child(AclSet.class); } - @Override - protected InstanceIdentifier<VppAcls> getIid(@Nonnull final String ifName, @Nonnull final VppAclsKey key) { - return getAclId(ifName).child(Egress.class).child(VppAcls.class, key); + protected KeyedInstanceIdentifier<AclSet, AclSetKey> getIid(@Nonnull final String ifName, + @Nonnull final AclSetKey key) { + return getAclId(ifName).child(Egress.class).child(AclSets.class).child(AclSet.class, key); } }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizerTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/IngressAclCustomizerTest.java index 42a798e88..666f6d8c9 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/IngressVppAclCustomizerTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/IngressAclCustomizerTest.java @@ -16,31 +16,33 @@ package io.fd.hc2vpp.acl.read; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static io.fd.vpp.jvpp.Assertions.assertEquals; +import static junit.framework.TestCase.assertTrue; import static org.mockito.Mockito.when; import io.fd.honeycomb.translate.read.ReadFailedException; import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump; import javax.annotation.Nonnull; import org.junit.Test; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.IngressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAclsKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.Ingress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSets; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -public class IngressVppAclCustomizerTest extends AbstractVppAclCustomizerTest { +public class IngressAclCustomizerTest extends AbstractAclCustomizerTest { - public IngressVppAclCustomizerTest() { - super(IngressBuilder.class); + public IngressAclCustomizerTest() { + super(AclSetsBuilder.class); } @Override - protected IngressVppAclCustomizer initCustomizer() { - return new IngressVppAclCustomizer(aclApi, interfaceContext, standardAclContext); + protected IngressAclCustomizer initCustomizer() { + return new IngressAclCustomizer(aclApi, interfaceContext, standardAclContext, macIpAclContext); } + @Test public void testGetAllIdsNoInputAclConfigured() throws ReadFailedException { final AclInterfaceListDetailsReplyDump reply = aclInterfaceDump((byte) 0, "acl1"); @@ -57,12 +59,12 @@ public class IngressVppAclCustomizerTest extends AbstractVppAclCustomizerTest { } @Override - protected InstanceIdentifier<VppAcls> getWildcardedIid(@Nonnull final String ifName) { - return getAclId(ifName).child(Ingress.class).child(VppAcls.class); + protected InstanceIdentifier<AclSet> getWildcardedIid(@Nonnull final String ifName) { + return getAclId(ifName).child(Ingress.class).child(AclSets.class).child(AclSet.class); } @Override - protected InstanceIdentifier<VppAcls> getIid(@Nonnull final String ifName, @Nonnull final VppAclsKey key) { - return getAclId(ifName).child(Ingress.class).child(VppAcls.class, key); + protected InstanceIdentifier<AclSet> getIid(@Nonnull final String ifName, @Nonnull final AclSetKey key) { + return getAclId(ifName).child(Ingress.class).child(AclSets.class).child(AclSet.class, key); } }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/MacIpAclCustomizerTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/MacIpAclCustomizerTest.java new file mode 100644 index 000000000..6678ab53a --- /dev/null +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/MacIpAclCustomizerTest.java @@ -0,0 +1,183 @@ +/* + * 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.hc2vpp.acl.read; + +import static io.fd.hc2vpp.acl.read.IngressAclCustomizer.ACL_NOT_ASSIGNED; +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertNotNull; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.Initialized; +import io.fd.vpp.jvpp.acl.dto.AclInterfaceListDetailsReplyDump; +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.dto.MacipAclInterfaceGetReply; +import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceListDetailsReplyDump; +import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; +import javax.annotation.Nonnull; +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.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.Ingress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSets; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSet; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetKey; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MacIpAclCustomizerTest extends AbstractAclCustomizerTest { + + protected static final String IF_NAME_NO_ACL = "eth2"; + protected static final int IF_ID_NO_ACL = 1; + protected static final String IFC_CTX_NAME = "interface-context"; + private static final String IF_NAME = "eth1"; + private static final int IF_ID = 1; + private static final String ACL_NAME = "acl-name"; + private static final int ACL_ID = 1; + @Mock + protected FutureJVppAclFacade aclApi; + protected NamingContext interfaceContext = new NamingContext("iface", IFC_CTX_NAME); + + public MacIpAclCustomizerTest() { + super(AclSetsBuilder.class); + } + + @Override + protected IngressAclCustomizer initCustomizer() { + return new IngressAclCustomizer(aclApi, interfaceContext, standardAclContext, macIpAclContext); + } + + @Override + protected void setUp() { + defineMapping(mappingContext, IF_NAME, IF_ID, IFC_CTX_NAME); + defineMapping(mappingContext, IF_NAME_NO_ACL, IF_ID_NO_ACL, IFC_CTX_NAME); + when(macIpAclContext.getAclName(ACL_ID, mappingContext)).thenReturn(ACL_NAME); + when(macIpAclContext.containsAcl(ACL_NAME, mappingContext)).thenReturn(true); + when(standardAclContext.containsAcl(ACL_NAME, mappingContext)).thenReturn(false); + final AclInterfaceListDetailsReplyDump reply = aclInterfaceDump((byte) 0); + when(aclApi.aclInterfaceListDump(any())).thenReturn(future(reply)); + final MacipAclInterfaceListDetailsReplyDump macReply = macAaclInterfaceDump(1, "acl-name"); + when(aclApi.macipAclInterfaceListDump(any())).thenReturn(future(macReply)); + } + + + @Test + public void testRead() throws ReadFailedException { + final AclSetBuilder builder = mock(AclSetBuilder.class); + + final MacipAclInterfaceGetReply assignedAcls = new MacipAclInterfaceGetReply(); + assignedAcls.count = 2; + assignedAcls.acls = new int[]{ACL_NOT_ASSIGNED, ACL_ID}; + when(aclApi.macipAclInterfaceGet(any())).thenReturn(future(assignedAcls)); + + final MacipAclDump request = new MacipAclDump(); + request.aclIndex = ACL_ID; + final MacipAclDetailsReplyDump reply = new MacipAclDetailsReplyDump(); + final MacipAclDetails details = new MacipAclDetails(); + details.aclIndex = ACL_ID; + reply.macipAclDetails.add(details); + when(aclApi.macipAclDump(request)).thenReturn(future(reply)); + + getCustomizer().readCurrentAttributes(getIid(IF_NAME_NO_ACL, new AclSetKey(ACL_NAME)), builder, ctx); + verify(builder).setName(ACL_NAME); + } + + @Test + public void testReadNotAssigned() throws ReadFailedException { + final AclSetBuilder builder = mock(AclSetBuilder.class); + + final MacipAclInterfaceGetReply assignedAcls = new MacipAclInterfaceGetReply(); + // pretending we have 3 interfaces, IF_NAME does not have MacipAcl assigned + assignedAcls.count = 3; + assignedAcls.acls = new int[]{ACL_NOT_ASSIGNED, ACL_NOT_ASSIGNED, ACL_NOT_ASSIGNED}; + when(aclApi.macipAclInterfaceGet(any())).thenReturn(future(assignedAcls)); + + final MacipAclDump request = new MacipAclDump(); + request.aclIndex = ACL_ID; + final MacipAclDetailsReplyDump reply = new MacipAclDetailsReplyDump(); + final MacipAclDetails details = new MacipAclDetails(); + details.aclIndex = ACL_ID; + reply.macipAclDetails.add(details); + when(aclApi.macipAclDump(request)).thenReturn(future(reply)); + + getCustomizer().readCurrentAttributes(getIid(IF_NAME_NO_ACL, new AclSetKey(ACL_NAME)), builder, ctx); + verifyZeroInteractions(builder); + } + + @Test + public void testReadNoAcls() throws ReadFailedException { + final AclSetBuilder builder = mock(AclSetBuilder.class); + final MacipAclInterfaceGetReply assignedAcls = new MacipAclInterfaceGetReply(); + assignedAcls.count = 0; + assignedAcls.acls = new int[0]; + when(aclApi.macipAclInterfaceGet(any())).thenReturn(future(assignedAcls)); + getCustomizer().readCurrentAttributes(getIid(IF_NAME_NO_ACL, new AclSetKey(ACL_NAME)), builder, ctx); + verifyZeroInteractions(builder); + } + + @Test + public void testGetAllIdsNoAclConfigured() throws ReadFailedException { + final MacipAclInterfaceListDetailsReplyDump macReply = macAaclInterfaceDump(1); + when(aclApi.macipAclInterfaceListDump(any())).thenReturn(future(macReply)); + assertTrue(getCustomizer().getAllIds(getWildcardedIid(IF_NAME_NO_ACL), ctx).isEmpty()); + } + + @Test + public void testReadAllTwoIfacesInOneTx() throws ReadFailedException { + final MacipAclInterfaceListDetailsReplyDump macReply = macAaclInterfaceDump(1); + final MacipAclInterfaceGetReply interfaceGet = macipAclInterfaceGetReply(); + // read all for interface with defined ACLs: + assertFalse(getCustomizer().getAllIds(getWildcardedIid(IF_NAME), ctx).isEmpty()); + // read all for interface without ACLs defined: + when(aclApi.macipAclInterfaceListDump(any())).thenReturn(future(macReply)); + when(aclApi.macipAclInterfaceGet(any())).thenReturn(future(interfaceGet)); + Assert.assertEquals(0, getCustomizer().getAllIds(getWildcardedIid(IF_NAME_NO_ACL), ctx).size()); + } + + @Test + public void testInit() { + final AclSet readValue = new AclSetBuilder().build(); + final Initialized<? extends DataObject> + cfgValue = getCustomizer().init(getWildcardedIid(IF_NAME), readValue, ctx); + assertEquals(cfgValue.getData(), readValue); + assertNotNull(cfgValue.getId().firstKeyOf(Interface.class)); + assertEquals(cfgValue.getId().getTargetType(), AclSet.class); + + } + + @Override + protected InstanceIdentifier<AclSet> getWildcardedIid(@Nonnull final String ifName) { + return getAclId(ifName).child(Ingress.class).child(AclSets.class).child(AclSet.class); + } + + @Override + protected InstanceIdentifier<AclSet> getIid(@Nonnull final String ifName, @Nonnull final AclSetKey key) { + return getAclId(ifName).child(Ingress.class).child(AclSets.class).child(AclSet.class, key); + } +}
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizerTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizerTest.java deleted file mode 100644 index 23ce85640..000000000 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/read/VppMacIpAclCustomizerTest.java +++ /dev/null @@ -1,150 +0,0 @@ -/* - * 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.hc2vpp.acl.read; - -import static io.fd.hc2vpp.acl.read.VppMacIpAclCustomizer.ACL_NOT_ASSIGNED; -import static io.fd.hc2vpp.acl.read.AbstractVppAclCustomizerTest.getAclId; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyZeroInteractions; -import static org.mockito.Mockito.when; - -import io.fd.hc2vpp.acl.util.AclContextManager; -import io.fd.hc2vpp.common.test.read.InitializingReaderCustomizerTest; -import io.fd.hc2vpp.common.translate.util.NamingContext; -import io.fd.honeycomb.translate.read.ReadFailedException; -import io.fd.honeycomb.translate.spi.read.Initialized; -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.dto.MacipAclInterfaceGetReply; -import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; -import javax.annotation.Nonnull; -import org.junit.Test; -import org.mockito.Mock; -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.interfaces.rev140508.interfaces.Interface; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.IngressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAclBuilder; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; - -public class VppMacIpAclCustomizerTest extends InitializingReaderCustomizerTest<VppMacipAcl, VppMacipAclBuilder> { - - protected static final String IF_NAME_NO_ACL = "eth2"; - protected static final int IF_ID_NO_ACL = 2; - protected static final String IFC_CTX_NAME = "interface-context"; - private static final String IF_NAME = "eth1"; - private static final int IF_ID = 1; - private static final String ACL_NAME = "acl-name"; - private static final int ACL_ID = 1; - private static final Class<? extends AclBase> ACL_TYPE = - org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAcl.class; - @Mock - protected FutureJVppAclFacade aclApi; - protected NamingContext interfaceContext = new NamingContext("iface", IFC_CTX_NAME); - @Mock - protected AclContextManager macIpAclContext; - - public VppMacIpAclCustomizerTest() { - super(VppMacipAcl.class, IngressBuilder.class); - } - - @Override - protected VppMacIpAclCustomizer initCustomizer() { - return new VppMacIpAclCustomizer(aclApi, interfaceContext, macIpAclContext); - } - - @Override - protected void setUp() { - defineMapping(mappingContext, IF_NAME, IF_ID, IFC_CTX_NAME); - defineMapping(mappingContext, IF_NAME_NO_ACL, IF_ID_NO_ACL, IFC_CTX_NAME); - when(macIpAclContext.getAclName(ACL_ID, mappingContext)).thenReturn(ACL_NAME); - } - - @Test - public void testRead() throws ReadFailedException { - final VppMacipAclBuilder builder = mock(VppMacipAclBuilder.class); - - final MacipAclInterfaceGetReply assignedAcls = new MacipAclInterfaceGetReply(); - assignedAcls.count = 2; - assignedAcls.acls = new int[] {ACL_NOT_ASSIGNED, ACL_ID}; - when(aclApi.macipAclInterfaceGet(any())).thenReturn(future(assignedAcls)); - - final MacipAclDump request = new MacipAclDump(); - request.aclIndex = ACL_ID; - final MacipAclDetailsReplyDump reply = new MacipAclDetailsReplyDump(); - final MacipAclDetails details = new MacipAclDetails(); - details.aclIndex = ACL_ID; - reply.macipAclDetails.add(details); - when(aclApi.macipAclDump(request)).thenReturn(future(reply)); - - getCustomizer().readCurrentAttributes(getIid(IF_NAME), builder, ctx); - verify(builder).setName(ACL_NAME); - verify(builder).setType(ACL_TYPE); - } - - @Test - public void testReadNotAssigned() throws ReadFailedException { - final VppMacipAclBuilder builder = mock(VppMacipAclBuilder.class); - - final MacipAclInterfaceGetReply assignedAcls = new MacipAclInterfaceGetReply(); - // pretending we have 3 interfaces, IF_NAME does not have MacipAcl assigned - assignedAcls.count = 3; - assignedAcls.acls = new int[] {ACL_NOT_ASSIGNED, ACL_NOT_ASSIGNED, ACL_ID}; - when(aclApi.macipAclInterfaceGet(any())).thenReturn(future(assignedAcls)); - - final MacipAclDump request = new MacipAclDump(); - request.aclIndex = ACL_ID; - final MacipAclDetailsReplyDump reply = new MacipAclDetailsReplyDump(); - final MacipAclDetails details = new MacipAclDetails(); - details.aclIndex = ACL_ID; - reply.macipAclDetails.add(details); - when(aclApi.macipAclDump(request)).thenReturn(future(reply)); - - getCustomizer().readCurrentAttributes(getIid(IF_NAME), builder, ctx); - verifyZeroInteractions(builder); - } - - @Test - public void testReadNoAcls() throws ReadFailedException { - final VppMacipAclBuilder builder = mock(VppMacipAclBuilder.class); - when(aclApi.macipAclInterfaceGet(any())).thenReturn(future(new MacipAclInterfaceGetReply())); - getCustomizer().readCurrentAttributes(getIid(IF_NAME_NO_ACL), builder, ctx); - verifyZeroInteractions(builder); - } - - @Test - public void testInit() { - final VppMacipAcl readValue = new VppMacipAclBuilder().build(); - final Initialized<? extends DataObject> cfgValue = getCustomizer().init(getIid(IF_NAME), readValue, ctx); - assertEquals(cfgValue.getData(), readValue); - assertNotNull(cfgValue.getId().firstKeyOf(Interface.class)); - assertEquals(cfgValue.getId().getTargetType(), VppMacipAcl.class); - - } - - protected InstanceIdentifier<VppMacipAcl> getIid(@Nonnull final String ifName) { - return getAclId(ifName).child(Ingress.class).child(VppMacipAcl.class); - } - -}
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractorTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractorTest.java index ea01cedb6..5375ee429 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractorTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/ace/extractor/MacIpAceDataExtractorTest.java @@ -17,7 +17,6 @@ package io.fd.hc2vpp.acl.util.ace.extractor; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; @@ -25,114 +24,56 @@ import io.fd.hc2vpp.common.test.util.CommonTests; import io.fd.vpp.jvpp.acl.types.MacipAclRule; import java.util.Arrays; import org.junit.Test; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.AceBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.ActionsBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.MatchesBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.DenyBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.PermitBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppMacipAceBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.VppMacipAceNodesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.AceIpVersion; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv4; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv4Builder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv6; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.macip.ace.vpp.macip.ace.nodes.ace.ip.version.AceIpv6Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Accept; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Drop; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.AceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.ActionsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4NetworkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6NetworkBuilder; public class MacIpAceDataExtractorTest extends AceDataExtractorTestCase implements MacIpAceDataExtractor, CommonTests { @Test - public void testFromMacIpAce() { - verifyExceptionalCase(() -> fromMacIpAce(new AceBuilder().build()), IllegalArgumentException.class); - verifyExceptionalCase(() -> fromMacIpAce(new AceBuilder().setMatches(new MatchesBuilder().build()).build()), - IllegalArgumentException.class); - - final VppMacipAce macipAce = new VppMacipAceBuilder().build(); - assertEquals(macipAce, fromMacIpAce(new AceBuilder().setMatches(new MatchesBuilder() - .setAceType(macipAce).build()).build())); - } - - @Test - public void testMacIpIsIpv6() { - assertFalse(macIpIsIpv6(new VppMacipAceBuilder().build())); - assertFalse(macIpIsIpv6( - new VppMacipAceBuilder().setVppMacipAceNodes(new VppMacipAceNodesBuilder().build()).build())); - assertFalse(macIpIsIpv6(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv4Builder().build()).build()).build())); - assertTrue(macIpIsIpv6(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv6Builder().build()).build()).build())); - } - - @Test public void testSourceMacAsBytes() { - assertTrue(Arrays.equals(DEFAULT_MAC_ADDRESS_BYTES, sourceMacAsBytes(new VppMacipAceBuilder().build()))); - assertTrue( - Arrays.equals(DEFAULT_MAC_ADDRESS_BYTES, sourceMacAsBytes(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().build()).build()))); - assertTrue(Arrays.equals(MAC_ADDRESS_BYTES, - sourceMacAsBytes(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setSourceMacAddress(MAC_ADDRESS).build()) - .build()))); + assertTrue(Arrays.equals(MAC_ADDRESS_BYTES, sourceMacAsBytes(MAC_ADDRESS))); } @Test public void sourceMacMaskAsBytes() { - assertTrue(Arrays.equals(DEFAULT_MAC_ADDRESS_BYTES, sourceMacMaskAsBytes(new VppMacipAceBuilder().build()))); - assertTrue(Arrays.equals(DEFAULT_MAC_ADDRESS_BYTES, - sourceMacMaskAsBytes(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().build()).build()))); - assertTrue(Arrays.equals(MAC_ADDRESS_BYTES, - sourceMacMaskAsBytes(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setSourceMacAddressMask(MAC_ADDRESS).build()) - .build()))); + assertTrue(Arrays.equals(MAC_ADDRESS_BYTES, sourceMacMaskAsBytes(MAC_ADDRESS))); } @Test public void testIpv4Address() { - assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4Address(new VppMacipAceBuilder().build()))); - assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4Address( - new VppMacipAceBuilder().setVppMacipAceNodes(new VppMacipAceNodesBuilder().build()).build()))); - assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4Address(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv4Builder().build()).build()).build()))); - assertTrue(Arrays.equals(IPV4_PREFIX_BYTES, ipv4Address(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv4Builder() - .setSourceIpv4Network(IPV4_PREFIX).build()).build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4Address(new SourceIpv4NetworkBuilder().build()))); + assertTrue(Arrays.equals(IPV4_PREFIX_BYTES, + ipv4Address(new SourceIpv4NetworkBuilder().setSourceIpv4Network(IPV4_PREFIX).build()))); } @Test public void testIpv4AddressPrefix() { - assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4AddressPrefix(new VppMacipAceBuilder().build())); - assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4AddressPrefix( - new VppMacipAceBuilder().setVppMacipAceNodes(new VppMacipAceNodesBuilder().build()).build())); - assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4AddressPrefix(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv4Builder().build()).build()).build())); - assertEquals(IPV4_PREFIX_VALUE, ipv4AddressPrefix(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv4Builder() - .setSourceIpv4Network(IPV4_PREFIX).build()).build()).build())); + assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4AddressPrefix(new SourceIpv4NetworkBuilder().build())); + assertEquals(IPV4_PREFIX_VALUE, + ipv4AddressPrefix(new SourceIpv4NetworkBuilder().setSourceIpv4Network(IPV4_PREFIX).build())); } @Test public void testIpv6Address() { - assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6Address(new VppMacipAceBuilder().build()))); - assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6Address( - new VppMacipAceBuilder().setVppMacipAceNodes(new VppMacipAceNodesBuilder().build()).build()))); - assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6Address(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv6Builder().build()).build()).build()))); - assertTrue(Arrays.equals(IPV6_PREFIX_BYTES, ipv6Address(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv6Builder() - .setSourceIpv6Network(IPV6_PREFIX).build()).build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6Address(new SourceIpv6NetworkBuilder().build()))); + assertTrue(Arrays.equals(IPV6_PREFIX_BYTES, + ipv6Address(new SourceIpv6NetworkBuilder().setSourceIpv6Network(IPV6_PREFIX).build()))); } @Test public void testIpv6AddressPrefix() { - assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6AddressPrefix(new VppMacipAceBuilder().build())); - assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6AddressPrefix( - new VppMacipAceBuilder().setVppMacipAceNodes(new VppMacipAceNodesBuilder().build()).build())); - assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6AddressPrefix(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv6Builder().build()).build()).build())); - assertEquals(IPV6_PREFIX_VALUE, ipv6AddressPrefix(new VppMacipAceBuilder().setVppMacipAceNodes( - new VppMacipAceNodesBuilder().setAceIpVersion(new AceIpv6Builder() - .setSourceIpv6Network(IPV6_PREFIX).build()).build()).build())); + assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6AddressPrefix(new SourceIpv6NetworkBuilder().build())); + assertEquals(IPV6_PREFIX_VALUE, + ipv6AddressPrefix(new SourceIpv6NetworkBuilder().setSourceIpv6Network(IPV6_PREFIX).build())); } @Test @@ -141,11 +82,10 @@ public class MacIpAceDataExtractorTest extends AceDataExtractorTestCase implemen verifyExceptionalCase(() -> macIpAction(new AceBuilder().setActions(new ActionsBuilder().build()).build()), IllegalArgumentException.class); // this one must pass even if deny is not fully set, because of default value definition - assertEquals((byte) 0, macIpAction(new AceBuilder().setActions(new ActionsBuilder().setPacketHandling( - new DenyBuilder().build()).build()).build())); - - assertEquals((byte) 1, macIpAction(new AceBuilder().setActions(new ActionsBuilder().setPacketHandling( - new PermitBuilder().setPermit(true).build()).build()).build())); + assertEquals((byte) 0, macIpAction( + new AceBuilder().setActions(new ActionsBuilder().setForwarding(Drop.class).build()).build())); + assertEquals((byte) 1, macIpAction( + new AceBuilder().setActions(new ActionsBuilder().setForwarding(Accept.class).build()).build())); } @Test @@ -156,9 +96,10 @@ public class MacIpAceDataExtractorTest extends AceDataExtractorTestCase implemen rule.srcIpAddr = IPV4_PREFIX_BYTES; rule.srcIpPrefixLen = IPV4_PREFIX_VALUE; - final AceIpVersion result = ipVersion(rule); - assertTrue(result instanceof AceIpv4); - assertEquals(IPV4_PREFIX, AceIpv4.class.cast(result).getSourceIpv4Network()); + final L3 result = parseMacIpAceL3(rule); + assertEquals(Ipv4.class, result.getImplementedInterface()); + assertEquals(IPV4_PREFIX, + ((SourceIpv4Network) ((Ipv4) result).getIpv4().getSourceNetwork()).getSourceIpv4Network()); } @Test @@ -167,9 +108,9 @@ public class MacIpAceDataExtractorTest extends AceDataExtractorTestCase implemen rule.isIpv6 = 0; - final AceIpVersion result = ipVersion(rule); - assertTrue(result instanceof AceIpv4); - assertNull(AceIpv4.class.cast(result).getSourceIpv4Network()); + final L3 result = parseMacIpAceL3(rule); + assertEquals(Ipv4.class, result.getImplementedInterface()); + assertNull(((Ipv4) result).getIpv4()); } @Test @@ -180,9 +121,10 @@ public class MacIpAceDataExtractorTest extends AceDataExtractorTestCase implemen rule.srcIpAddr = IPV6_PREFIX_BYTES; rule.srcIpPrefixLen = IPV6_PREFIX_VALUE; - final AceIpVersion result = ipVersion(rule); - assertTrue(result instanceof AceIpv6); - assertEquals(IPV6_PREFIX, AceIpv6.class.cast(result).getSourceIpv6Network()); + final L3 result = parseMacIpAceL3(rule); + assertEquals(Ipv6.class, result.getImplementedInterface()); + assertEquals(IPV6_PREFIX, ((SourceIpv6Network) ((Ipv6) result).getIpv6().getSourceNetwork()) + .getSourceIpv6Network()); } @Test @@ -191,9 +133,9 @@ public class MacIpAceDataExtractorTest extends AceDataExtractorTestCase implemen rule.isIpv6 = 1; - final AceIpVersion result = ipVersion(rule); - assertTrue(result instanceof AceIpv6); - assertNull(AceIpv6.class.cast(result).getSourceIpv6Network()); + final L3 result = parseMacIpAceL3(rule); + assertEquals(Ipv6.class, result.getImplementedInterface()); + assertNull(((Ipv6) result).getIpv6()); } @Test diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractorTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractorTest.java index f22d6600a..627dba6b0 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractorTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/ace/extractor/StandardAceDataExtractorTest.java @@ -25,159 +25,212 @@ import io.fd.hc2vpp.common.test.util.CommonTests; import io.fd.vpp.jvpp.acl.types.AclRule; import java.util.Arrays; import org.junit.Test; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.AceBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.ActionsBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.MatchesBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Deny; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.DenyBuilder; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160708.access.lists.acl.access.list.entries.ace.actions.packet.handling.Permit; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.actions.packet.handling.Stateful; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.actions.packet.handling.StatefulBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAceBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.VppAceNodesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.AceIpVersion; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv4; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv4Builder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv6; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.vpp.ace.vpp.ace.nodes.ace.ip.version.AceIpv6Builder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6Builder; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.AcceptAndReflect; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Accept; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Drop; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.AceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.ActionsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.MatchesBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.L3; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv4Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.Ipv6Builder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.destination.network.DestinationIpv4Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.destination.network.DestinationIpv4NetworkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv4.header.fields.source.network.SourceIpv4NetworkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.destination.network.DestinationIpv6Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.destination.network.DestinationIpv6NetworkBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6Network; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.acl.ipv6.header.fields.source.network.SourceIpv6NetworkBuilder; public class StandardAceDataExtractorTest extends AceDataExtractorTestCase implements StandardAceDataExtractor, CommonTests { @Test - public void testFromStandardAce() { - verifyExceptionalCase(() -> fromStandardAce(new AceBuilder().build()), IllegalArgumentException.class); - verifyExceptionalCase(() -> fromStandardAce(new AceBuilder().setMatches(new MatchesBuilder().build()).build()), - IllegalArgumentException.class); - - final VppAce ace = new VppAceBuilder().build(); - assertEquals(ace, fromStandardAce(new AceBuilder().setMatches(new MatchesBuilder() - .setAceType(ace).build()).build())); - } - - @Test public void testStandardIsIpv6WithoutMatch() { - assertFalse(standardIsIpv6(new VppAceBuilder().build(), null)); - assertFalse(standardIsIpv6(new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder().build()).build(), null)); - assertFalse(standardIsIpv6(new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder() - .setIpProtocol(new IcmpBuilder().build()).build()).build(), null)); - assertTrue(standardIsIpv6(new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder() - .setIpProtocol(new IcmpV6Builder().build()).build()).build(), null)); - } - - @Test - public void testStandardIsIpv6WithMatch() { - final VppAce ipv6Ace = new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder() - .setIpProtocol(new IcmpV6Builder().build()).build()).build(); - - assertTrue(standardIsIpv6(ipv6Ace, new MatchesBuilder().build())); - assertTrue(standardIsIpv6(ipv6Ace, new MatchesBuilder().setAceType(new VppAceBuilder().build()).build())); - assertTrue(standardIsIpv6(ipv6Ace, new MatchesBuilder().setAceType(new VppAceBuilder() - .setVppAceNodes(new VppAceNodesBuilder().build()) - .build()).build())); - assertFalse(standardIsIpv6(ipv6Ace, new MatchesBuilder().setAceType(new VppAceBuilder() - .setVppAceNodes(new VppAceNodesBuilder().setAceIpVersion(new AceIpv4Builder().build()).build()) - .build()).build())); + assertFalse(standardIsIpv6(null)); + assertFalse(standardIsIpv6(new MatchesBuilder().build())); + assertFalse(standardIsIpv6(new MatchesBuilder().setL3(new Ipv6Builder().build()).build())); + assertTrue(standardIsIpv6(new MatchesBuilder().setL3(new Ipv6Builder().setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .build()).build()).build())); } @Test public void testIpv4SourceAddress() { - assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4SourceAddress(new VppAceBuilder().build()))); - assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4SourceAddress( - new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder().build()).build()))); - assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4SourceAddress(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv4Builder().build()).build()).build()))); - assertTrue(Arrays.equals(IPV4_PREFIX_BYTES, ipv4SourceAddress(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv4Builder() - .setSourceIpv4Network(IPV4_PREFIX).build()).build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4SourceAddress(new MatchesBuilder().build()))); + assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, + ipv4SourceAddress(new MatchesBuilder().setL3(new Ipv4Builder().build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4SourceAddress(new MatchesBuilder() + .setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .build()).build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4SourceAddress(new MatchesBuilder() + .setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .setSourceNetwork(new SourceIpv4NetworkBuilder().build()).build()).build()).build()))); + assertTrue(Arrays.equals(IPV4_PREFIX_BYTES, ipv4SourceAddress(new MatchesBuilder() + .setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .setSourceNetwork( + new SourceIpv4NetworkBuilder().setSourceIpv4Network(IPV4_PREFIX).build()) + .build()).build()).build()))); } @Test public void testIpv4SourceAddressPrefix() { - assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4SourceAddressPrefix(new VppAceBuilder().build())); - assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4SourceAddressPrefix( - new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder().build()).build())); - assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4SourceAddressPrefix(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv4Builder().build()).build()).build())); - assertEquals(IPV4_PREFIX_VALUE, ipv4SourceAddressPrefix(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv4Builder() - .setSourceIpv4Network(IPV4_PREFIX).build()).build()).build())); + assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4SourceAddressPrefix(new MatchesBuilder().build())); + assertEquals(DEFAULT_IPV4_PREFIX_VALUE, + ipv4SourceAddressPrefix(new MatchesBuilder().setL3(new Ipv4Builder().build()).build())); + assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4SourceAddressPrefix(new MatchesBuilder() + .setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .build()).build()).build())); + assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4SourceAddressPrefix(new MatchesBuilder() + .setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .setSourceNetwork(new SourceIpv4NetworkBuilder().build()).build()).build()).build())); + assertEquals(IPV4_PREFIX_VALUE, ipv4SourceAddressPrefix(new MatchesBuilder() + .setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .setSourceNetwork( + new SourceIpv4NetworkBuilder().setSourceIpv4Network(IPV4_PREFIX).build()) + .build()).build()).build())); } @Test public void testIpv4DestinationAddress() { - assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4DestinationAddress(new VppAceBuilder().build()))); + assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4DestinationAddress(new MatchesBuilder().build()))); + assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4DestinationAddress( + new MatchesBuilder().setL3(new Ipv4Builder().build()).build()))); assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4DestinationAddress( - new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder().build()).build()))); - assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4DestinationAddress(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv4Builder().build()).build()).build()))); - assertTrue(Arrays.equals(IPV4_PREFIX_BYTES, ipv4DestinationAddress(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv4Builder() - .setDestinationIpv4Network(IPV4_PREFIX).build()).build()).build()))); + new MatchesBuilder().setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .build()).build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV4_ADDRESS_BYTES, ipv4DestinationAddress( + new MatchesBuilder().setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .setDestinationNetwork(new DestinationIpv4NetworkBuilder() + .build()).build()).build()).build()))); + assertTrue(Arrays.equals(IPV4_PREFIX_BYTES, ipv4DestinationAddress( + new MatchesBuilder().setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .setDestinationNetwork( + new DestinationIpv4NetworkBuilder().setDestinationIpv4Network(IPV4_PREFIX) + .build()).build()).build()).build()))); } @Test public void testIpv4DestinationAddressPrefix() { - assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4DestinationAddressPrefix(new VppAceBuilder().build())); + assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4DestinationAddressPrefix(new MatchesBuilder().build())); + assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4DestinationAddressPrefix( + new MatchesBuilder().setL3(new Ipv4Builder().build()).build())); assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4DestinationAddressPrefix( - new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder().build()).build())); - assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4DestinationAddressPrefix(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv4Builder().build()).build()).build())); - assertEquals(IPV4_PREFIX_VALUE, ipv4DestinationAddressPrefix(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv4Builder() - .setDestinationIpv4Network(IPV4_PREFIX).build()).build()).build())); + new MatchesBuilder().setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .build()).build()).build())); + assertEquals(DEFAULT_IPV4_PREFIX_VALUE, ipv4DestinationAddressPrefix( + new MatchesBuilder().setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .setDestinationNetwork(new DestinationIpv4NetworkBuilder() + .build()).build()).build()).build())); + assertEquals(IPV4_PREFIX_VALUE, ipv4DestinationAddressPrefix( + new MatchesBuilder().setL3(new Ipv4Builder().setIpv4( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv4.Ipv4Builder() + .setDestinationNetwork( + new DestinationIpv4NetworkBuilder().setDestinationIpv4Network(IPV4_PREFIX) + .build()).build()).build()).build())); } @Test public void testIpv6SourceAddress() { - assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6SourceAddress(new VppAceBuilder().build()))); - assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6SourceAddress( - new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder().build()).build()))); - assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6SourceAddress(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv6Builder().build()).build()).build()))); - assertTrue(Arrays.equals(IPV6_PREFIX_BYTES, ipv6SourceAddress(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv6Builder() - .setSourceIpv6Network(IPV6_PREFIX).build()).build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6SourceAddress(new MatchesBuilder().build()))); + assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, + ipv6SourceAddress(new MatchesBuilder().setL3(new Ipv6Builder().build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6SourceAddress(new MatchesBuilder() + .setL3(new Ipv6Builder().setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .build()).build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6SourceAddress(new MatchesBuilder() + .setL3(new Ipv6Builder().setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .setSourceNetwork(new SourceIpv6NetworkBuilder().build()).build()).build()).build()))); + assertTrue(Arrays.equals(IPV6_PREFIX_BYTES, ipv6SourceAddress(new MatchesBuilder().setL3(new Ipv6Builder() + .setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .setSourceNetwork( + new SourceIpv6NetworkBuilder().setSourceIpv6Network(IPV6_PREFIX).build()) + .build()).build()).build()))); } @Test public void ipv6SourceAddressPrefix() { - assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6SourceAddressPrefix(new VppAceBuilder().build())); - assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6SourceAddressPrefix( - new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder().build()).build())); - assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6SourceAddressPrefix(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv6Builder().build()).build()).build())); - assertEquals(IPV6_PREFIX_VALUE, ipv6SourceAddressPrefix(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv6Builder() - .setSourceIpv6Network(IPV6_PREFIX).build()).build()).build())); + assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6SourceAddressPrefix(new MatchesBuilder().build())); + assertEquals(DEFAULT_IPV6_PREFIX_VALUE, + ipv6SourceAddressPrefix(new MatchesBuilder().setL3(new Ipv6Builder().build()).build())); + assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6SourceAddressPrefix(new MatchesBuilder() + .setL3(new Ipv6Builder().setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .build()).build()).build())); + assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6SourceAddressPrefix(new MatchesBuilder() + .setL3(new Ipv6Builder().setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .setSourceNetwork(new SourceIpv6NetworkBuilder().build()).build()).build()).build())); + assertEquals(IPV6_PREFIX_VALUE, ipv6SourceAddressPrefix(new MatchesBuilder().setL3(new Ipv6Builder() + .setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .setSourceNetwork( + new SourceIpv6NetworkBuilder().setSourceIpv6Network(IPV6_PREFIX).build()) + .build()).build()).build())); } @Test public void ipv6DestinationAddress() { - assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6DestinationAddress(new VppAceBuilder().build()))); - assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6DestinationAddress( - new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder().build()).build()))); - assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6DestinationAddress(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv6Builder().build()).build()).build()))); - assertTrue(Arrays.equals(IPV6_PREFIX_BYTES, ipv6DestinationAddress(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv6Builder() - .setDestinationIpv6Network(IPV6_PREFIX).build()).build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6DestinationAddress(new MatchesBuilder().build()))); + assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, + ipv6DestinationAddress(new MatchesBuilder().setL3(new Ipv6Builder().build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6DestinationAddress(new MatchesBuilder() + .setL3(new Ipv6Builder().setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .build()).build()).build()))); + assertTrue(Arrays.equals(DEFAULT_IPV6_ADDRESS_BYTES, ipv6DestinationAddress(new MatchesBuilder() + .setL3(new Ipv6Builder().setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .setDestinationNetwork(new DestinationIpv6NetworkBuilder().build()).build()).build()) + .build()))); + assertTrue(Arrays.equals(IPV6_PREFIX_BYTES, ipv6DestinationAddress(new MatchesBuilder().setL3(new Ipv6Builder() + .setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .setDestinationNetwork( + new DestinationIpv6NetworkBuilder().setDestinationIpv6Network(IPV6_PREFIX) + .build()) + .build()).build()).build()))); } @Test public void ipv6DestinationAddressPrefix() { - assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6DestinationAddressPrefix(new VppAceBuilder().build())); - assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6DestinationAddressPrefix( - new VppAceBuilder().setVppAceNodes(new VppAceNodesBuilder().build()).build())); - assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6DestinationAddressPrefix(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv6Builder().build()).build()).build())); - assertEquals(IPV6_PREFIX_VALUE, ipv6DestinationAddressPrefix(new VppAceBuilder().setVppAceNodes( - new VppAceNodesBuilder().setAceIpVersion(new AceIpv6Builder() - .setDestinationIpv6Network(IPV6_PREFIX).build()).build()).build())); + assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6DestinationAddressPrefix(new MatchesBuilder().build())); + assertEquals(DEFAULT_IPV6_PREFIX_VALUE, + ipv6DestinationAddressPrefix(new MatchesBuilder().setL3(new Ipv6Builder().build()).build())); + assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6DestinationAddressPrefix(new MatchesBuilder() + .setL3(new Ipv6Builder().setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .build()).build()).build())); + assertEquals(DEFAULT_IPV6_PREFIX_VALUE, ipv6DestinationAddressPrefix(new MatchesBuilder() + .setL3(new Ipv6Builder().setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .setDestinationNetwork(new DestinationIpv6NetworkBuilder().build()).build()).build()) + .build())); + assertEquals(IPV6_PREFIX_VALUE, ipv6DestinationAddressPrefix(new MatchesBuilder().setL3(new Ipv6Builder() + .setIpv6( + new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l3.ipv6.Ipv6Builder() + .setDestinationNetwork( + new DestinationIpv6NetworkBuilder().setDestinationIpv6Network(IPV6_PREFIX) + .build()) + .build()).build()).build())); } @Test @@ -188,12 +241,10 @@ public class StandardAceDataExtractorTest extends AceDataExtractorTestCase imple // this one should pass because of default value assertEquals(0, standardAction( - new AceBuilder().setActions(new ActionsBuilder().setPacketHandling(new DenyBuilder().build()).build()) - .build())); + new AceBuilder().setActions(new ActionsBuilder().setForwarding(Drop.class).build()).build())); assertEquals(2, standardAction(new AceBuilder().setActions( - new ActionsBuilder().setPacketHandling(new StatefulBuilder().setPermitAndReflect(true).build()).build()) - .build())); + new ActionsBuilder().setForwarding(AcceptAndReflect.class).build()).build())); } @Test @@ -206,10 +257,13 @@ public class StandardAceDataExtractorTest extends AceDataExtractorTestCase imple rule.dstIpAddr = IPV4_2_PREFIX_BYTES; rule.dstIpPrefixLen = IPV4_2_PREFIX_VALUE; - final AceIpVersion result = ipVersion(rule); - assertTrue(result instanceof AceIpv4); - assertEquals(IPV4_PREFIX, AceIpv4.class.cast(result).getSourceIpv4Network()); - assertEquals(IPV4_2_PREFIX, AceIpv4.class.cast(result).getDestinationIpv4Network()); + final L3 result = parseStandardAceL3(rule); + assertEquals(result.getImplementedInterface(), Ipv4.class); + assertEquals(IPV4_PREFIX, + ((SourceIpv4Network) ((Ipv4) result).getIpv4().getSourceNetwork()).getSourceIpv4Network()); + assertEquals(IPV4_2_PREFIX, + ((DestinationIpv4Network) ((Ipv4) result).getIpv4().getDestinationNetwork()) + .getDestinationIpv4Network()); } @Test @@ -218,10 +272,10 @@ public class StandardAceDataExtractorTest extends AceDataExtractorTestCase imple rule.isIpv6 = 0; - final AceIpVersion result = ipVersion(rule); - assertTrue(result instanceof AceIpv4); - assertNull(AceIpv4.class.cast(result).getSourceIpv4Network()); - assertNull(AceIpv4.class.cast(result).getDestinationIpv4Network()); + final L3 result = parseStandardAceL3(rule); + assertEquals(result.getImplementedInterface(), Ipv4.class); + assertNull(((Ipv4) result).getIpv4().getSourceNetwork()); + assertNull(((Ipv4) result).getIpv4().getDestinationNetwork()); } @Test @@ -234,10 +288,13 @@ public class StandardAceDataExtractorTest extends AceDataExtractorTestCase imple rule.dstIpAddr = IPV6_2_PREFIX_BYTES; rule.dstIpPrefixLen = IPV6_2_PREFIX_VALUE; - final AceIpVersion result = ipVersion(rule); - assertTrue(result instanceof AceIpv6); - assertEquals(IPV6_PREFIX, AceIpv6.class.cast(result).getSourceIpv6Network()); - assertEquals(IPV6_2_PREFIX, AceIpv6.class.cast(result).getDestinationIpv6Network()); + final L3 result = parseStandardAceL3(rule); + assertEquals(result.getImplementedInterface(), Ipv6.class); + assertEquals(IPV6_PREFIX, + ((SourceIpv6Network) ((Ipv6) result).getIpv6().getSourceNetwork()).getSourceIpv6Network()); + assertEquals(IPV6_2_PREFIX, + ((DestinationIpv6Network) ((Ipv6) result).getIpv6().getDestinationNetwork()) + .getDestinationIpv6Network()); } @Test @@ -246,19 +303,17 @@ public class StandardAceDataExtractorTest extends AceDataExtractorTestCase imple rule.isIpv6 = 1; - final AceIpVersion result = ipVersion(rule); - assertTrue(result instanceof AceIpv6); - assertNull(AceIpv6.class.cast(result).getSourceIpv6Network()); - assertNull(AceIpv6.class.cast(result).getDestinationIpv6Network()); + final L3 result = parseStandardAceL3(rule); + assertEquals(result.getImplementedInterface(), Ipv6.class); + assertNull((((Ipv6) result).getIpv6().getSourceNetwork())); + assertNull((((Ipv6) result).getIpv6().getDestinationNetwork())); } @Test public void testActions() { verifyExceptionalCase(() -> actions((byte) -1), IllegalArgumentException.class); - assertTrue(actions((byte) 0).getPacketHandling() instanceof Deny); - assertTrue(actions((byte) 1).getPacketHandling() instanceof Permit); - assertTrue(actions((byte) 2).getPacketHandling() instanceof Stateful); + assertTrue(actions((byte) 0).getForwarding().equals(Drop.class)); + assertTrue(actions((byte) 1).getForwarding().equals(Accept.class)); } - }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/iface/acl/AclInterfaceAssignmentRequestTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/iface/acl/AclInterfaceAssignmentRequestTest.java index fb5d61458..1b7cf8c32 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/iface/acl/AclInterfaceAssignmentRequestTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/iface/acl/AclInterfaceAssignmentRequestTest.java @@ -16,19 +16,20 @@ package io.fd.hc2vpp.acl.util.iface.acl; -import static io.fd.hc2vpp.acl.util.iface.acl.AclInterfaceAssignmentRequest.create; +import static io.fd.hc2vpp.acl.write.request.AclInterfaceAssignmentRequest.create; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.mockito.MockitoAnnotations.initMocks; import com.google.common.collect.ImmutableList; +import io.fd.hc2vpp.acl.AclIIds; import io.fd.hc2vpp.acl.util.AclContextManager; +import io.fd.hc2vpp.acl.write.request.AclInterfaceAssignmentRequest; import io.fd.hc2vpp.common.test.util.FutureProducer; import io.fd.hc2vpp.common.test.util.NamingContextHelper; import io.fd.hc2vpp.common.translate.util.NamingContext; @@ -43,11 +44,8 @@ import org.junit.Test; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.Mock; -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.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class AclInterfaceAssignmentRequestTest implements NamingContextHelper, FutureProducer { @@ -76,7 +74,7 @@ public class AclInterfaceAssignmentRequestTest implements NamingContextHelper, F @Mock private MappingContext mappingContext; - private InstanceIdentifier<Acl> validIdentifier; + private InstanceIdentifier<Interface> validIdentifier; private NamingContext interfaceContext; @Mock @@ -86,10 +84,8 @@ public class AclInterfaceAssignmentRequestTest implements NamingContextHelper, F public void setUp() { initMocks(this); - validIdentifier = InstanceIdentifier.create(Interfaces.class). - child(Interface.class, new InterfaceKey(INTERFACE_NAME)) - .augmentation(VppAclInterfaceAugmentation.class) - .child(Acl.class); + validIdentifier = AclIIds.ACLS_AP + .child(Interface.class, new InterfaceKey(INTERFACE_NAME)); interfaceContext = new NamingContext("iface", "interface-context"); diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/iface/macip/MacIpInterfaceAssignmentRequestTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/iface/macip/MacIpInterfaceAssignmentRequestTest.java index a7049b77f..145eec38e 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/iface/macip/MacIpInterfaceAssignmentRequestTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/iface/macip/MacIpInterfaceAssignmentRequestTest.java @@ -16,8 +16,8 @@ package io.fd.hc2vpp.acl.util.iface.macip; -import static io.fd.hc2vpp.acl.util.iface.macip.MacIpInterfaceAssignmentRequest.addNew; -import static io.fd.hc2vpp.acl.util.iface.macip.MacIpInterfaceAssignmentRequest.deleteExisting; +import static io.fd.hc2vpp.acl.write.request.MacIpInterfaceAssignmentRequest.addNew; +import static io.fd.hc2vpp.acl.write.request.MacIpInterfaceAssignmentRequest.deleteExisting; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.fail; @@ -27,7 +27,9 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.mockito.MockitoAnnotations.initMocks; +import io.fd.hc2vpp.acl.AclIIds; import io.fd.hc2vpp.acl.util.AclContextManager; +import io.fd.hc2vpp.acl.write.request.MacIpInterfaceAssignmentRequest; import io.fd.hc2vpp.common.test.util.FutureProducer; import io.fd.hc2vpp.common.test.util.NamingContextHelper; import io.fd.hc2vpp.common.translate.util.NamingContext; @@ -41,13 +43,8 @@ import org.junit.Test; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.Mock; -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.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class MacIpInterfaceAssignmentRequestTest implements NamingContextHelper,FutureProducer { @@ -66,7 +63,7 @@ public class MacIpInterfaceAssignmentRequestTest implements NamingContextHelper, @Mock private MappingContext mappingContext; - private InstanceIdentifier<VppMacipAcl> validIdentifier; + private InstanceIdentifier<Interface> validIdentifier; private NamingContext interfaceContext; @Mock private AclContextManager macIpAclContext; @@ -75,12 +72,7 @@ public class MacIpInterfaceAssignmentRequestTest implements NamingContextHelper, public void setUp() throws Exception { initMocks(this); - validIdentifier = InstanceIdentifier.create(Interfaces.class). - child(Interface.class, new InterfaceKey(INTERFACE_NAME)) - .augmentation(VppAclInterfaceAugmentation.class) - .child(Acl.class) - .child(Ingress.class) - .child(VppMacipAcl.class); + validIdentifier = AclIIds.ACLS_AP.child(Interface.class, new InterfaceKey(INTERFACE_NAME)); interfaceContext = new NamingContext("iface", "interface-context"); diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/protocol/ProtocolParsingTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/protocol/ProtocolParsingTest.java index 08fe6f38b..170080b66 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/protocol/ProtocolParsingTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/util/protocol/ProtocolParsingTest.java @@ -24,41 +24,44 @@ import io.fd.honeycomb.test.tools.annotations.InjectTestData; import io.fd.vpp.jvpp.acl.types.AclRule; import org.junit.Test; import org.junit.runner.RunWith; -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.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.access.lists.acl.access.list.entries.ace.matches.ace.type.VppAce; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Icmp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.IcmpV6; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Other; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Tcp; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.acl.ip.protocol.header.fields.ip.protocol.Udp; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppIcmpAceAugmentation; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Acls; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.Ace; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Icmp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Tcp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.Udp; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.source.port.source.port.RangeOrOperator; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.packet.fields.rev181001.port.range.or.operator.port.range.or.operator.Range; @RunWith(HoneycombTestRunner.class) public class ProtocolParsingTest implements ProtoPreBindRuleProducer, IpProtocolReader, AclTestSchemaContext { private static final byte IGNORE_PROTOCOL = 0; - //TODO - remove after resolving how to address identity from different model in textual yang instance identifier - private VppAce extractAce(AccessLists accessLists) { - return VppAce.class - .cast(accessLists.getAcl().get(0).getAccessListEntries().getAce().get(0).getMatches().getAceType()); + private Ace extractAce(Acls acls) { + return acls.getAcl().get(0).getAces().getAce().get(0); } @Test - public void testIcmpRule(@InjectTestData(resourcePath = "/rules/icmp-rule.json") AccessLists acls) { + public void testIcmpRule(@InjectTestData(resourcePath = "/rules/icmp-rule.json") Acls acls) { final AclRule icmpRule = createPreBindRule(extractAce(acls)); assertEquals(1, icmpRule.proto); assertEquals(0, icmpRule.tcpFlagsMask); assertEquals(0, icmpRule.tcpFlagsValue); - final Icmp protocol = (Icmp)parseProtocol(icmpRule); - assertEquals(5, protocol.getIcmpNodes().getIcmpTypeRange().getFirst().shortValue()); - assertEquals(8, protocol.getIcmpNodes().getIcmpTypeRange().getLast().shortValue()); - assertEquals(1, protocol.getIcmpNodes().getIcmpCodeRange().getFirst().shortValue()); - assertEquals(3, protocol.getIcmpNodes().getIcmpCodeRange().getLast().shortValue()); + final Icmp protocol = (Icmp) parseProtocol(icmpRule); + assertEquals(5, protocol.getIcmp().augmentation(VppIcmpAceAugmentation.class).getVppIcmpAce().getIcmpTypeRange() + .getFirst().shortValue()); + assertEquals(8, protocol.getIcmp().augmentation(VppIcmpAceAugmentation.class).getVppIcmpAce().getIcmpTypeRange() + .getLast().shortValue()); + assertEquals(1, protocol.getIcmp().augmentation(VppIcmpAceAugmentation.class).getVppIcmpAce().getIcmpCodeRange() + .getFirst().shortValue()); + assertEquals(3, protocol.getIcmp().augmentation(VppIcmpAceAugmentation.class).getVppIcmpAce().getIcmpCodeRange() + .getLast().shortValue()); } @Test - public void testIcmpv6Rule(@InjectTestData(resourcePath = "/rules/icmp-v6-rule.json") AccessLists acls) { + public void testIcmpv6Rule(@InjectTestData(resourcePath = "/rules/icmp-v6-rule.json") Acls acls) { final AclRule icmpv6Rule = createPreBindRule(extractAce(acls)); assertEquals(58, icmpv6Rule.proto); @@ -69,43 +72,67 @@ public class ProtocolParsingTest implements ProtoPreBindRuleProducer, IpProtocol assertEquals(0, icmpv6Rule.tcpFlagsMask); assertEquals(0, icmpv6Rule.tcpFlagsValue); - final IcmpV6 protocol = (IcmpV6)parseProtocol(icmpv6Rule); - assertEquals(5, protocol.getIcmpV6Nodes().getIcmpTypeRange().getFirst().shortValue()); - assertEquals(8, protocol.getIcmpV6Nodes().getIcmpTypeRange().getLast().shortValue()); - assertEquals(1, protocol.getIcmpV6Nodes().getIcmpCodeRange().getFirst().shortValue()); - assertEquals(3, protocol.getIcmpV6Nodes().getIcmpCodeRange().getLast().shortValue()); + final Icmp protocol = (Icmp) parseProtocol(icmpv6Rule); + assertEquals(5, protocol.getIcmp().augmentation(VppIcmpAceAugmentation.class).getVppIcmpAce().getIcmpTypeRange() + .getFirst().shortValue()); + assertEquals(8, protocol.getIcmp().augmentation(VppIcmpAceAugmentation.class).getVppIcmpAce().getIcmpTypeRange() + .getLast().shortValue()); + assertEquals(1, protocol.getIcmp().augmentation(VppIcmpAceAugmentation.class).getVppIcmpAce().getIcmpCodeRange() + .getFirst().shortValue()); + assertEquals(3, protocol.getIcmp().augmentation(VppIcmpAceAugmentation.class).getVppIcmpAce().getIcmpCodeRange() + .getLast().shortValue()); } @Test - public void testTcpRule(@InjectTestData(resourcePath = "/rules/tcp-rule.json") AccessLists acls) { + public void testTcpRule(@InjectTestData(resourcePath = "/rules/tcp-rule.json") Acls acls) { final AclRule tcpRule = createPreBindRule(extractAce(acls)); assertEquals(6, tcpRule.proto); assertEquals(1, tcpRule.tcpFlagsMask); assertEquals(7, tcpRule.tcpFlagsValue); - final Tcp protocol = (Tcp)parseProtocol(tcpRule); - assertEquals(1, protocol.getTcpNodes().getSourcePortRange().getLowerPort().getValue().intValue()); - assertEquals(5487, protocol.getTcpNodes().getSourcePortRange().getUpperPort().getValue().intValue()); - assertEquals(87, protocol.getTcpNodes().getDestinationPortRange().getLowerPort().getValue().intValue()); - assertEquals(6745, protocol.getTcpNodes().getDestinationPortRange().getUpperPort().getValue().intValue()); + final Tcp protocol = (Tcp) parseProtocol(tcpRule); + assertEquals(1, + ((Range) ((RangeOrOperator) protocol.getTcp().getSourcePort().getSourcePort()).getPortRangeOrOperator()) + .getLowerPort().getValue().intValue()); + assertEquals(5487, + ((Range) ((RangeOrOperator) protocol.getTcp().getSourcePort().getSourcePort()).getPortRangeOrOperator()) + .getUpperPort().getValue().intValue()); + assertEquals(87, + ((Range) ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperator) protocol + .getTcp().getDestinationPort().getDestinationPort()) + .getPortRangeOrOperator()).getLowerPort().getValue().intValue()); + assertEquals(6745, + ((Range) ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperator) protocol + .getTcp().getDestinationPort().getDestinationPort()) + .getPortRangeOrOperator()).getUpperPort().getValue().intValue()); } @Test - public void testTcpRuleNoFlags(@InjectTestData(resourcePath = "/rules/tcp-rule-no-flags.json") AccessLists acls) { + public void testTcpRuleNoFlags(@InjectTestData(resourcePath = "/rules/tcp-rule-no-flags.json") Acls acls) { final AclRule tcpRule = createPreBindRule(extractAce(acls)); assertEquals(6, tcpRule.proto); assertEquals(123, tcpRule.srcportOrIcmptypeFirst); assertEquals(123, tcpRule.srcportOrIcmptypeLast); - assertEquals((short)65000, tcpRule.dstportOrIcmpcodeFirst); - assertEquals((short)65000, tcpRule.dstportOrIcmpcodeLast); + assertEquals((short) 65000, tcpRule.dstportOrIcmpcodeFirst); + assertEquals((short) 65000, tcpRule.dstportOrIcmpcodeLast); assertEquals(0, tcpRule.tcpFlagsMask); assertEquals(0, tcpRule.tcpFlagsValue); - final Tcp protocol = (Tcp)parseProtocol(tcpRule); - assertEquals(123, protocol.getTcpNodes().getSourcePortRange().getLowerPort().getValue().intValue()); - assertEquals(123, protocol.getTcpNodes().getSourcePortRange().getUpperPort().getValue().intValue()); - assertEquals(65000, protocol.getTcpNodes().getDestinationPortRange().getLowerPort().getValue().intValue()); - assertEquals(65000, protocol.getTcpNodes().getDestinationPortRange().getUpperPort().getValue().intValue()); + final Tcp protocol = (Tcp) parseProtocol(tcpRule); + assertEquals(123, + ((Range) ((RangeOrOperator) protocol.getTcp().getSourcePort().getSourcePort()).getPortRangeOrOperator()) + .getLowerPort().getValue().intValue()); + assertEquals(123, + ((Range) ((RangeOrOperator) protocol.getTcp().getSourcePort().getSourcePort()).getPortRangeOrOperator()) + .getUpperPort().getValue().intValue()); + assertEquals(65000, + ((Range) ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperator) protocol + .getTcp().getDestinationPort().getDestinationPort()) + .getPortRangeOrOperator()).getLowerPort().getValue().intValue()); + assertEquals(65000, + ((Range) ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.tcp.tcp.destination.port.destination.port.RangeOrOperator) protocol + .getTcp().getDestinationPort().getDestinationPort()) + .getPortRangeOrOperator()).getUpperPort().getValue().intValue()); } @Test @@ -125,40 +152,36 @@ public class ProtocolParsingTest implements ProtoPreBindRuleProducer, IpProtocol } @Test - public void testUdpRule(@InjectTestData(resourcePath = "/rules/udp-rule.json") AccessLists acls) { + public void testUdpRule(@InjectTestData(resourcePath = "/rules/udp-rule.json") Acls acls) { final AclRule udpRule = createPreBindRule(extractAce(acls)); assertEquals(17, udpRule.proto); assertEquals(0, udpRule.tcpFlagsMask); assertEquals(0, udpRule.tcpFlagsValue); - final Udp protocol = (Udp)parseProtocol(udpRule); - assertEquals(1, protocol.getUdpNodes().getSourcePortRange().getLowerPort().getValue().intValue()); - assertEquals(5487, protocol.getUdpNodes().getSourcePortRange().getUpperPort().getValue().intValue()); - assertEquals(87, protocol.getUdpNodes().getDestinationPortRange().getLowerPort().getValue().intValue()); - assertEquals(6745, protocol.getUdpNodes().getDestinationPortRange().getUpperPort().getValue().intValue()); + final Udp protocol = (Udp) parseProtocol(udpRule); + assertEquals(1, + ((Range) ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.source.port.RangeOrOperator) protocol + .getUdp().getSourcePort().getSourcePort()).getPortRangeOrOperator()) + .getLowerPort().getValue().intValue()); + assertEquals(5487, + ((Range) ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.source.port.source.port.RangeOrOperator) protocol + .getUdp().getSourcePort().getSourcePort()).getPortRangeOrOperator()) + .getUpperPort().getValue().intValue()); + assertEquals(87, + ((Range) ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.destination.port.RangeOrOperator) protocol + .getUdp().getDestinationPort().getDestinationPort()) + .getPortRangeOrOperator()).getLowerPort().getValue().intValue()); + assertEquals(6745, + ((Range) ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.acl.aces.ace.matches.l4.udp.udp.destination.port.destination.port.RangeOrOperator) protocol + .getUdp().getDestinationPort().getDestinationPort()) + .getPortRangeOrOperator()).getUpperPort().getValue().intValue()); } - @Test - public void testOtherRule(@InjectTestData(resourcePath = "/rules/other-rule.json") AccessLists acls) { - final AclRule rule = createPreBindRule(extractAce(acls)); - final int protocolNumber = 64; - assertEquals(protocolNumber, rule.proto); - assertEquals(0, rule.srcportOrIcmptypeFirst); - assertEquals((short) 65535, rule.srcportOrIcmptypeLast); - assertEquals(0, rule.dstportOrIcmpcodeFirst); - assertEquals((short) 65535, rule.dstportOrIcmpcodeLast); - assertEquals(0, rule.tcpFlagsMask); - assertEquals(0, rule.tcpFlagsValue); - - final Other protocol = (Other)parseProtocol(rule); - assertEquals(protocolNumber, protocol.getOtherNodes().getProtocol().shortValue()); - } @Test - public void tesProtocolNotSpecified(@InjectTestData(resourcePath = "/rules/no-protocol-rule.json") AccessLists acls) { + public void tesProtocolNotSpecified(@InjectTestData(resourcePath = "/rules/no-protocol-rule.json") Acls acls) { final AclRule noProtocolRule = createPreBindRule(extractAce(acls)); assertEquals(IGNORE_PROTOCOL, noProtocolRule.proto); } - }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/VppAclCustomizerTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/AclCustomizerTest.java index a3fa6db0e..ae7023059 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/VppAclCustomizerTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/AclCustomizerTest.java @@ -24,6 +24,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import com.google.common.base.Optional; +import io.fd.hc2vpp.acl.AclIIds; import io.fd.hc2vpp.acl.AclTestSchemaContext; import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; @@ -46,15 +47,14 @@ import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.Mock; -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.access.lists.Acl; -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.rev181001.Acls; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclKey; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppAcl; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @RunWith(HoneycombTestRunner.class) -public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTestSchemaContext { +public class AclCustomizerTest extends WriterCustomizerTest implements AclTestSchemaContext { @Mock private FutureJVppAclFacade aclApi; @@ -70,7 +70,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes private InstanceIdentifier<Acl> validId; private InstanceIdentifier<Acl> validMacipId; - private VppAclCustomizer aclCustomizer; + private AclCustomizer aclCustomizer; @Mock private AclContextManager standardAclContext; @@ -80,11 +80,9 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Override protected void setUpTest() throws Exception { - validId = - InstanceIdentifier.create(AccessLists.class).child(Acl.class, new AclKey("standard-acl", VppAcl.class)); - validMacipId = - InstanceIdentifier.create(AccessLists.class).child(Acl.class, new AclKey("macip-acl", VppAcl.class)); - aclCustomizer = new VppAclCustomizer(aclApi, standardAclContext, macIpAclContext); + validId = AclIIds.ACLS.child(Acl.class, new AclKey("standard-acl")); + validMacipId = AclIIds.ACLS.child(Acl.class, new AclKey("macip-acl")); + aclCustomizer = new AclCustomizer(aclApi, standardAclContext, macIpAclContext); when(aclApi.aclAddReplace(any())).thenReturn(future(new AclAddReplaceReply())); when(aclApi.aclDel(any())).thenReturn(future(new AclDelReply())); @@ -93,7 +91,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void writeCurrentAttributesMacip(@InjectTestData(resourcePath = "/acl/macip/macip-acl.json") - AccessLists macipAcl) throws WriteFailedException { + Acls macipAcl) throws WriteFailedException { aclCustomizer.writeCurrentAttributes(validMacipId, macipAcl.getAcl().get(0), writeContext); @@ -116,7 +114,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void writeCurrentAttributesIcmpIpv4(@InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { aclCustomizer.writeCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext); verify(aclApi, times(1)).aclAddReplace(aclAddReplaceRequestCaptor.capture()); @@ -125,7 +123,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void updateCurrentAttributesIcmpIpv4(@InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); final Acl data = standardAcls.getAcl().get(0); @@ -139,7 +137,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void writeCurrentAttributesIcmpIpv6(@InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp-v6.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { aclCustomizer.writeCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext); verify(aclApi, times(1)).aclAddReplace(aclAddReplaceRequestCaptor.capture()); @@ -149,7 +147,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void updateCurrentAttributesIcmpIpv6( @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp-v6.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); final Acl data = standardAcls.getAcl().get(0); @@ -162,7 +160,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void writeCurrentAttributesTcp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-tcp.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { aclCustomizer.writeCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext); verify(aclApi, times(1)).aclAddReplace(aclAddReplaceRequestCaptor.capture()); @@ -171,7 +169,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void updateCurrentAttributesTcp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-tcp.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); final Acl data = standardAcls.getAcl().get(0); @@ -182,8 +180,9 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes } @Test - public void updateCurrentAttributesTcpSrcOnly(@InjectTestData(resourcePath = "/acl/standard/standard-acl-tcp-src-only.json") - AccessLists standardAcls) throws Exception { + public void updateCurrentAttributesTcpSrcOnly( + @InjectTestData(resourcePath = "/acl/standard/standard-acl-tcp-src-only.json") + Acls standardAcls) throws Exception { final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); final Acl data = standardAcls.getAcl().get(0); @@ -201,7 +200,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void writeCurrentAttributesUdp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-udp.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { aclCustomizer.writeCurrentAttributes(validId, standardAcls.getAcl().get(0), writeContext); verify(aclApi, times(1)).aclAddReplace(aclAddReplaceRequestCaptor.capture()); @@ -211,7 +210,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void updateCurrentAttributesUdp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-udp.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); final Acl data = standardAcls.getAcl().get(0); @@ -224,7 +223,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void deleteCurrentAttributesIcmpIpv4(@InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent()); final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); @@ -237,7 +236,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void deleteCurrentAttributesIcmpIpv6( @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp-v6.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent()); final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); @@ -249,7 +248,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void deleteCurrentAttributesTcp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-tcp.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent()); final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); @@ -261,7 +260,7 @@ public class VppAclCustomizerTest extends WriterCustomizerTest implements AclTes @Test public void deleteCurrentAttributesUdp(@InjectTestData(resourcePath = "/acl/standard/standard-acl-udp.json") - AccessLists standardAcls) throws Exception { + Acls standardAcls) throws Exception { when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.absent()); final int aclIndex = 4; when(standardAclContext.getAclIndex("standard-acl", mappingContext)).thenReturn(aclIndex); diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/VppAclValidatorTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/AclValidatorTest.java index 287e53f80..6f4d8556f 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/VppAclValidatorTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/AclValidatorTest.java @@ -16,8 +16,7 @@ package io.fd.hc2vpp.acl.write; -import static io.fd.hc2vpp.acl.write.VppAclValidator.checkAclReferenced; -import static java.util.stream.Collectors.toSet; +import static io.fd.hc2vpp.acl.write.AclValidator.checkAclReferenced; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.containsInAnyOrder; import static org.hamcrest.Matchers.hasSize; @@ -25,51 +24,52 @@ import static org.mockito.Mockito.when; import static org.mockito.MockitoAnnotations.initMocks; import com.google.common.base.Optional; +import io.fd.hc2vpp.acl.AclIIds; import io.fd.hc2vpp.acl.AclTestSchemaContext; import io.fd.honeycomb.test.tools.HoneycombTestRunner; import io.fd.honeycomb.test.tools.annotations.InjectTestData; import io.fd.honeycomb.translate.write.DataValidationFailedException; import io.fd.honeycomb.translate.write.WriteContext; +import java.util.HashSet; import java.util.List; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; -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.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.interfaces.rev140508.Interfaces; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesBuilder; -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.vpp.acl.rev170615.VppAcl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.acl.rev170615.VppMacipAcl; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppAcl; +import org.opendaylight.yang.gen.v1.http.fd.io.hc2vpp.yang.vpp.acl.rev181022.VppMacipAcl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.Acls; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.Acl; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AclKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPoints; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.AttachmentPointsBuilder; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @RunWith(HoneycombTestRunner.class) -public class VppAclValidatorTest implements AclTestSchemaContext { +public class AclValidatorTest implements AclTestSchemaContext { - private static final InstanceIdentifier<Acl> ID = InstanceIdentifier.create(AccessLists.class) - .child(Acl.class, new AclKey("standard-acl", VppAcl.class)); + private static final InstanceIdentifier<Acl> ID = AclIIds.ACLS + .child(Acl.class, new AclKey("standard-acl")); - @InjectTestData(id = "/ietf-interfaces:interfaces", resourcePath = "/interface-acl/acl-references.json") - private Interfaces interfaces; + @InjectTestData(id = "/ietf-access-control-list:acls/ietf-access-control-list:attachment-points", resourcePath = "/interface-acl/acl-references.json") + private AttachmentPoints attachmentPoints; @Mock private WriteContext writeContext; - private VppAclValidator validator; + private AclValidator validator; @Before public void init(){ initMocks(this); - when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn(Optional.of(interfaces)); - validator = new VppAclValidator(); + when(writeContext.readAfter(AclIIds.ACLS_AP)).thenReturn(Optional.of(attachmentPoints)); + validator = new AclValidator(); } @Test public void testValidateWrite( - @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") AccessLists acls) + @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") Acls acls) throws DataValidationFailedException.CreateValidationFailedException { validator.validateWrite(ID, acls.getAcl().get(0), writeContext); } @@ -82,7 +82,7 @@ public class VppAclValidatorTest implements AclTestSchemaContext { @Test public void testValidateUpdate( - @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") AccessLists acls) + @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") Acls acls) throws DataValidationFailedException.UpdateValidationFailedException { final Acl data = acls.getAcl().get(0); validator.validateUpdate(ID, data, data, writeContext); @@ -90,7 +90,7 @@ public class VppAclValidatorTest implements AclTestSchemaContext { @Test(expected = DataValidationFailedException.UpdateValidationFailedException.class) public void testValidateUpdateUnsupportedType( - @InjectTestData(resourcePath = "/acl/ipv4/ipv4-acl.json") AccessLists acls) + @InjectTestData(resourcePath = "/acl/ipv4/ipv4-acl.json") Acls acls) throws DataValidationFailedException.UpdateValidationFailedException { final Acl data = acls.getAcl().get(0); validator.validateUpdate(ID, data, data, writeContext); @@ -98,46 +98,44 @@ public class VppAclValidatorTest implements AclTestSchemaContext { @Test public void testValidateDelete( - @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") AccessLists acls) + @InjectTestData(resourcePath = "/acl/standard/standard-acl-icmp.json") Acls acls) throws DataValidationFailedException.DeleteValidationFailedException { validator.validateDelete(ID, acls.getAcl().get(0), writeContext); } @Test(expected = DataValidationFailedException.DeleteValidationFailedException.class) public void testValidateDeleteReferenced( - @InjectTestData(resourcePath = "/acl/standard/standard-acl-udp.json") - AccessLists standardAcls, - @InjectTestData(resourcePath = "/acl/standard/interface-ref-acl-udp.json") - Interfaces references) throws Exception { - when(writeContext.readAfter(InstanceIdentifier.create(Interfaces.class))).thenReturn( - Optional.of(new InterfacesBuilder().setInterface(references.getInterface()).build())); + @InjectTestData(resourcePath = "/acl/standard/standard-acl-udp.json") + Acls standardAcls, + @InjectTestData(id = "/ietf-access-control-list:acls/ietf-access-control-list:attachment-points", + resourcePath = "/acl/standard/interface-ref-acl-udp.json") + AttachmentPoints references) throws Exception { + when(writeContext.readAfter(AclIIds.ACLS_AP)).thenReturn( + Optional.of(new AttachmentPointsBuilder().setInterface(references.getInterface()).build())); validator.validateDelete(ID, standardAcls.getAcl().get(0), writeContext); } @Test public void testReferencedVppAclFirst() { - final List<Interface> referenced = checkAclReferenced(writeContext, new AclBuilder() - .setAclName("acl1").setAclType(VppAcl.class).build()); + final List<String> referenced = checkAclReferenced(writeContext, new AclBuilder() + .setName("acl1").setType(VppAcl.class).build()); assertThat(referenced, hasSize(3)); - assertThat(referenced.stream().map(Interface::getName).collect(toSet()), - containsInAnyOrder("eth0", "eth1", "eth2")); + assertThat(new HashSet<>(referenced), containsInAnyOrder("eth0", "eth1", "eth2")); } @Test public void testReferencedVppAclSecond() { - final List<Interface> referenced = checkAclReferenced(writeContext, new AclBuilder() - .setAclName("acl2").setAclType(VppAcl.class).build()); + final List<String> referenced = checkAclReferenced(writeContext, new AclBuilder() + .setName("acl2").setType(VppAcl.class).build()); assertThat(referenced, hasSize(1)); - assertThat(referenced.stream().map(Interface::getName).collect(toSet()), - containsInAnyOrder("eth1")); + assertThat(new HashSet<>(referenced), containsInAnyOrder("eth1")); } @Test public void testReferencedMacipAcl() { - final List<Interface> referenced = checkAclReferenced(writeContext, new AclBuilder() - .setAclName("acl4").setAclType(VppMacipAcl.class).build()); + final List<String> referenced = checkAclReferenced(writeContext, new AclBuilder() + .setName("acl4").setType(VppMacipAcl.class).build()); assertThat(referenced, hasSize(1)); - assertThat(referenced.stream().map(Interface::getName).collect(toSet()), - containsInAnyOrder("eth2")); + assertThat(new HashSet<>(referenced), containsInAnyOrder("eth2")); } }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizerTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizerTest.java index 5dc139acc..b6c26ceeb 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizerTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/InterfaceAclCustomizerTest.java @@ -17,10 +17,10 @@ package io.fd.hc2vpp.acl.write; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import io.fd.hc2vpp.acl.AclIIds; import io.fd.hc2vpp.acl.AclTestSchemaContext; import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; @@ -31,15 +31,12 @@ import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; import java.util.Collections; import org.junit.Test; import org.mockito.Mock; -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.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.AclBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.IngressBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAcls; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.acls.base.attributes.VppAclsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.IngressBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class InterfaceAclCustomizerTest extends WriterCustomizerTest implements AclTestSchemaContext { @@ -47,61 +44,70 @@ public class InterfaceAclCustomizerTest extends WriterCustomizerTest implements private static final String IFC_CTX_NAME = "ifc-test-instance"; private static final String IFACE_NAME = "eth0"; private static final int IFACE_ID = 123; + private static final int ACL_ID = 111; @Mock private FutureJVppAclFacade aclApi; @Mock private AclContextManager standardAclContext; + @Mock + private AclContextManager macipAclContext; private InterfaceAclCustomizer customizer; - private NamingContext interfaceContext; - private InstanceIdentifier<Acl> ACL_ID = InstanceIdentifier.create(Interfaces.class) - .child(Interface.class, new InterfaceKey(IFACE_NAME)).augmentation(VppAclInterfaceAugmentation.class).child(Acl.class); + private InstanceIdentifier<Interface> IFC_IID = + AclIIds.ACLS_AP.child(Interface.class, new InterfaceKey(IFACE_NAME)); + private Interface ifcAcl; + private static final String ACL_NAME = "standard_acl"; + @Override - protected void setUpTest() throws Exception { + protected void setUpTest() { defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME); - interfaceContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME); - customizer = new InterfaceAclCustomizer(aclApi, interfaceContext, standardAclContext); + final NamingContext interfaceContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME); + customizer = new InterfaceAclCustomizer(aclApi, interfaceContext, standardAclContext, macipAclContext); + ifcAcl = new InterfaceBuilder() + .setIngress(new IngressBuilder() + .setAclSets(new AclSetsBuilder() + .setAclSet(Collections.singletonList(new AclSetBuilder() + .setName(ACL_NAME) + .build())) + .build()) + .build()) + .build(); + when(standardAclContext.getAclIndex(ACL_NAME, mappingContext)).thenReturn(ACL_ID); + when(standardAclContext.containsAcl(ACL_NAME, mappingContext)).thenReturn(true); when(aclApi.aclInterfaceSetAclList(any())).thenReturn(future(new AclInterfaceSetAclListReply())); } @Test public void testWrite() throws Exception { - final Acl acl = new AclBuilder().build(); - customizer.writeCurrentAttributes(ACL_ID, acl, writeContext); + customizer.writeCurrentAttributes(IFC_IID, ifcAcl, writeContext); final AclInterfaceSetAclList list = new AclInterfaceSetAclList(); list.swIfIndex = IFACE_ID; - list.acls = new int[]{}; + list.acls = new int[]{ACL_ID}; + list.count = 1; + list.nInput = 1; verify(aclApi).aclInterfaceSetAclList(list); } @Test public void testUpdate() throws Exception { - final Acl acl = new AclBuilder().build(); - customizer.updateCurrentAttributes(ACL_ID, acl, acl, writeContext); + final Interface updIfcAcl = new InterfaceBuilder().build(); + customizer.updateCurrentAttributes(IFC_IID, updIfcAcl, ifcAcl, writeContext); final AclInterfaceSetAclList list = new AclInterfaceSetAclList(); list.swIfIndex = IFACE_ID; - list.acls = new int[]{}; + list.acls = new int[]{ACL_ID}; + list.count = 1; + list.nInput = 1; verify(aclApi).aclInterfaceSetAclList(list); } @Test public void testDelete() throws Exception { - final VppAcls - element = mock(VppAcls.class); - final Acl acl = new AclBuilder() - .setIngress(new IngressBuilder() - .setVppAcls(Collections.singletonList(new VppAclsBuilder() - .setName("asd") - .build())) - .build()) - .build(); - customizer.deleteCurrentAttributes(ACL_ID, acl, writeContext); + customizer.deleteCurrentAttributes(IFC_IID, ifcAcl, writeContext); final AclInterfaceSetAclList list = new AclInterfaceSetAclList(); list.swIfIndex = IFACE_ID; list.acls = new int[]{}; verify(aclApi).aclInterfaceSetAclList(list); } - }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/InterfaceAclMacipCustomizerTest.java b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/InterfaceAclMacipCustomizerTest.java index b5fa649ca..af3deaca2 100644 --- a/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/InterfaceAclMacipCustomizerTest.java +++ b/acl/acl-impl/src/test/java/io/fd/hc2vpp/acl/write/InterfaceAclMacipCustomizerTest.java @@ -20,23 +20,24 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import io.fd.hc2vpp.acl.AclIIds; import io.fd.hc2vpp.acl.AclTestSchemaContext; import io.fd.hc2vpp.acl.util.AclContextManager; import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; import io.fd.hc2vpp.common.translate.util.NamingContext; +import io.fd.vpp.jvpp.acl.dto.AclInterfaceSetAclListReply; import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceAddDel; import io.fd.vpp.jvpp.acl.dto.MacipAclInterfaceAddDelReply; import io.fd.vpp.jvpp.acl.future.FutureJVppAclFacade; +import java.util.Collections; import org.junit.Test; import org.mockito.Mock; -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.opendaylight.params.xml.ns.yang._interface.acl.rev161214.VppAclInterfaceAugmentation; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.Acl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214._interface.acl.attributes.acl.Ingress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAcl; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang._interface.acl.rev161214.vpp.macip.acls.base.attributes.VppMacipAclBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.Interface; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points.InterfaceKey; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.IngressBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.AclSetsBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev181001.acls.attachment.points._interface.acl.acl.sets.AclSetBuilder; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; public class InterfaceAclMacipCustomizerTest extends WriterCustomizerTest implements AclTestSchemaContext { @@ -51,27 +52,31 @@ public class InterfaceAclMacipCustomizerTest extends WriterCustomizerTest implem private FutureJVppAclFacade aclApi; @Mock private AclContextManager macipAclContext; + @Mock + private AclContextManager standardAclContext; - private InterfaceAclMacIpCustomizer customizer; + private InterfaceAclCustomizer customizer; private NamingContext interfaceContext; - private InstanceIdentifier<VppMacipAcl> ACL_IID = InstanceIdentifier.create(Interfaces.class) - .child(Interface.class, new InterfaceKey(IFACE_NAME)).augmentation(VppAclInterfaceAugmentation.class) - .child(Acl.class).child(Ingress.class).child(VppMacipAcl.class); - private VppMacipAcl acl; + private InstanceIdentifier<Interface> IFC_IID = + AclIIds.ACLS_AP.child(Interface.class, new InterfaceKey(IFACE_NAME)); + private Interface ifcAcl; @Override protected void setUpTest() throws Exception { defineMapping(mappingContext, IFACE_NAME, IFACE_ID, IFC_CTX_NAME); interfaceContext = new NamingContext("generatedIfaceName", IFC_CTX_NAME); - customizer = new InterfaceAclMacIpCustomizer(aclApi, macipAclContext, interfaceContext); - acl = new VppMacipAclBuilder().setName(ACL_NAME).build(); + customizer = new InterfaceAclCustomizer(aclApi, interfaceContext, standardAclContext, macipAclContext); + ifcAcl = new InterfaceBuilder().setIngress(new IngressBuilder().setAclSets(new AclSetsBuilder().setAclSet( + Collections.singletonList(new AclSetBuilder().setName(ACL_NAME).build())).build()).build()).build(); when(macipAclContext.getAclIndex(ACL_NAME, mappingContext)).thenReturn(ACL_ID); + when(macipAclContext.containsAcl(ACL_NAME, mappingContext)).thenReturn(true); when(aclApi.macipAclInterfaceAddDel(any())).thenReturn(future(new MacipAclInterfaceAddDelReply())); + when(aclApi.aclInterfaceSetAclList(any())).thenReturn(future(new AclInterfaceSetAclListReply())); } @Test public void testWrite() throws Exception { - customizer.writeCurrentAttributes(ACL_IID, acl, writeContext); + customizer.writeCurrentAttributes(IFC_IID, ifcAcl, writeContext); final MacipAclInterfaceAddDel request = new MacipAclInterfaceAddDel(); request.swIfIndex = IFACE_ID; request.isAdd = 1; @@ -79,19 +84,19 @@ public class InterfaceAclMacipCustomizerTest extends WriterCustomizerTest implem verify(aclApi).macipAclInterfaceAddDel(request); } - @Test(expected = UnsupportedOperationException.class) + @Test public void testUpdate() throws Exception { - customizer.updateCurrentAttributes(ACL_IID, acl, acl, writeContext); + customizer.updateCurrentAttributes(IFC_IID, ifcAcl, ifcAcl, writeContext); + verify(aclApi).aclInterfaceSetAclList(any()); } @Test public void testDelete() throws Exception { - customizer.deleteCurrentAttributes(ACL_IID, acl, writeContext); + customizer.deleteCurrentAttributes(IFC_IID, ifcAcl, writeContext); final MacipAclInterfaceAddDel request = new MacipAclInterfaceAddDel(); request.swIfIndex = IFACE_ID; request.isAdd = 0; request.aclIndex = ACL_ID; verify(aclApi).macipAclInterfaceAddDel(request); } - }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/resources/acl/ipv4/ipv4-acl.json b/acl/acl-impl/src/test/resources/acl/ipv4/ipv4-acl.json index 04a08ff44..9946bc4f7 100644 --- a/acl/acl-impl/src/test/resources/acl/ipv4/ipv4-acl.json +++ b/acl/acl-impl/src/test/resources/acl/ipv4/ipv4-acl.json @@ -1,13 +1,13 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "ipv4-acl", - "access-list-entries": { + "name": "standard-acl", + "type": "ipv4-acl-type", + "aces": { "ace": [ { - "rule-name": "rule1" + "name": "rule1" } ] } diff --git a/acl/acl-impl/src/test/resources/acl/macip/macip-acl.json b/acl/acl-impl/src/test/resources/acl/macip/macip-acl.json index 21ac2597c..bcde22d6b 100644 --- a/acl/acl-impl/src/test/resources/acl/macip/macip-acl.json +++ b/acl/acl-impl/src/test/resources/acl/macip/macip-acl.json @@ -1,23 +1,25 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "macip-acl", - "acl-type": "vpp-acl:vpp-macip-acl", + "name": "macip-acl", + "type": "vpp-acl:vpp-macip-acl", "tag": "macip-tag-value", - "access-list-entries": { + "aces": { "ace": [ { - "rule-name": "macip-rule", + "name": "macip-rule", "matches": { - "vpp-macip-ace-nodes": { - "source-ipv4-network": "192.168.2.2/32", + "eth": { "source-mac-address": "aa:aa:aa:aa:aa:aa", "source-mac-address-mask": "ff:00:00:00:00:00" + }, + "ipv4": { + "source-ipv4-network": "192.168.2.2/32" } }, "actions": { - "permit": [null] + "forwarding": "ietf-access-control-list:accept" } } ] diff --git a/acl/acl-impl/src/test/resources/acl/standard/interface-ref-acl-udp.json b/acl/acl-impl/src/test/resources/acl/standard/interface-ref-acl-udp.json index ae987a798..060551b9b 100644 --- a/acl/acl-impl/src/test/resources/acl/standard/interface-ref-acl-udp.json +++ b/acl/acl-impl/src/test/resources/acl/standard/interface-ref-acl-udp.json @@ -1,21 +1,21 @@ { - "interfaces":{ - "interface": [{ - "name": "eth2", - "acl": { + "attachment-points": { + "interface": [ + { + "interface-id": "eth2", "ingress": { - "vpp-acls": [ - { - "type": "vpp-acl:vpp-acl", - "name": "standard-acl" - } - ], - "vpp-macip-acl": { - "name": "acl4", - "type": "vpp-acl:vpp-macip-acl" + "acl-sets": { + "acl-set": [ + { + "name": "standard-acl" + }, + { + "name": "acl4" + } + ] } } } - }] + ] } }
\ No newline at end of file diff --git a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-icmp-v6.json b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-icmp-v6.json index 9c6530fa9..5973741ed 100644 --- a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-icmp-v6.json +++ b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-icmp-v6.json @@ -1,24 +1,26 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", "tag": "icmp-v6-tag-value", - "access-list-entries": { + "aces": { "ace": [ { - "rule-name": "imcp-v6-rule", + "name": "imcp-v6-rule", "matches": { - "vpp-ace-nodes": { - "destination-ipv6-network": "2001:0db8:0a0b:12f0:0000:0000:0000:0001/64", + "ipv6": { "source-ipv6-network": "2001:0db8:0a0b:12f0:0000:0000:0000:0002/48", - "icmp-v6-nodes": { - "icmp-type-range": { + "destination-ipv6-network": "2001:0db8:0a0b:12f0:0000:0000:0000:0001/64" + }, + "icmp": { + "vpp-acl:vpp-icmp-ace": { + "vpp-acl:icmp-type-range": { "first": "5", "last": "8" }, - "icmp-code-range": { + "vpp-acl:icmp-code-range": { "first": "1", "last": "3" } @@ -26,7 +28,7 @@ } }, "actions": { - "permit": [null] + "forwarding": "ietf-access-control-list:accept" } } ] diff --git a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-icmp.json b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-icmp.json index 73a9a6543..cc534f4b4 100644 --- a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-icmp.json +++ b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-icmp.json @@ -1,24 +1,26 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", "tag": "icmp-v4-tag-value", - "access-list-entries": { + "aces": { "ace": [ { - "rule-name": "imcp-rule", + "name": "imcp-rule", "matches": { - "vpp-ace-nodes": { - "destination-ipv4-network": "192.168.2.1/24", + "ipv4": { "source-ipv4-network": "192.168.2.2/32", - "icmp-nodes": { - "icmp-type-range": { + "destination-ipv4-network": "192.168.2.1/24" + }, + "icmp": { + "vpp-acl:vpp-icmp-ace": { + "vpp-acl:icmp-type-range": { "first": "5", "last": "8" }, - "icmp-code-range": { + "vpp-acl:icmp-code-range": { "first": "1", "last": "3" } @@ -26,7 +28,7 @@ } }, "actions": { - "permit": [null] + "forwarding": "ietf-access-control-list:accept" } } ] diff --git a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-tcp-src-only.json b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-tcp-src-only.json index 13e757907..9d9b396ba 100644 --- a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-tcp-src-only.json +++ b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-tcp-src-only.json @@ -1,32 +1,34 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", - "access-list-entries": { + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", + "aces": { "ace": [ { - "rule-name": "tcp-rule", + "name": "tcp-rule", "matches": { - "vpp-ace-nodes": { - "source-ipv4-network": "192.168.2.2/32", - "tcp-nodes": { - "source-port-range": { - "lower-port": "1", - "upper-port": "5487" - }, - "destination-port-range": { - "lower-port": "87", - "upper-port": "6745" - }, - "tcp-flags-mask": "1", - "tcp-flags-value": "7" + "ipv4": { + "source-ipv4-network": "192.168.2.2/32" + }, + "tcp": { + "source-port": { + "lower-port": "1", + "upper-port": "5487" + }, + "destination-port": { + "lower-port": "87", + "upper-port": "6745" + }, + "flags": "cwr ece urg", + "vpp-acl:vpp-tcp-ace": { + "vpp-acl:flags-mask": "cwr" } } }, "actions": { - "permit": [null] + "forwarding": "ietf-access-control-list:accept" } } ] diff --git a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-tcp.json b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-tcp.json index 6b5dbafc7..35ad4b1da 100644 --- a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-tcp.json +++ b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-tcp.json @@ -1,34 +1,36 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", "tag": "tcp-tag-value", - "access-list-entries": { + "aces": { "ace": [ { - "rule-name": "tcp-rule", + "name": "tcp-rule", "matches": { - "vpp-ace-nodes": { + "ipv4": { "destination-ipv4-network": "192.168.2.1/24", - "source-ipv4-network": "192.168.2.2/32", - "tcp-nodes": { - "source-port-range": { - "lower-port": "1", - "upper-port": "5487" - }, - "destination-port-range": { - "lower-port": "87", - "upper-port": "6745" - }, - "tcp-flags-mask": "1", - "tcp-flags-value": "7" + "source-ipv4-network": "192.168.2.2/32" + }, + "tcp": { + "source-port": { + "lower-port": "1", + "upper-port": "5487" + }, + "destination-port": { + "lower-port": "87", + "upper-port": "6745" + }, + "flags": "cwr ece urg", + "vpp-acl:vpp-tcp-ace": { + "vpp-acl:flags-mask": "cwr" } } }, "actions": { - "permit": [null] + "forwarding": "ietf-access-control-list:accept" } } ] diff --git a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-udp.json b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-udp.json index e49a93cfa..10edb349e 100644 --- a/acl/acl-impl/src/test/resources/acl/standard/standard-acl-udp.json +++ b/acl/acl-impl/src/test/resources/acl/standard/standard-acl-udp.json @@ -1,32 +1,32 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", "tag": "udp-tag-value", - "access-list-entries": { + "aces": { "ace": [ { - "rule-name": "udp-rule", + "name": "udp-rule", "matches": { - "vpp-ace-nodes": { + "ipv4": { "destination-ipv4-network": "192.168.2.1/24", - "source-ipv4-network": "192.168.2.2/32", - "udp-nodes": { - "source-port-range": { - "lower-port": "1", - "upper-port": "5487" - }, - "destination-port-range": { - "lower-port": "87", - "upper-port": "6745" - } + "source-ipv4-network": "192.168.2.2/32" + }, + "udp": { + "source-port": { + "lower-port": "1", + "upper-port": "5487" + }, + "destination-port": { + "lower-port": "87", + "upper-port": "6745" } } }, "actions": { - "permit": [null] + "forwarding": "ietf-access-control-list:accept" } } ] diff --git a/acl/acl-impl/src/test/resources/interface-acl/acl-references.json b/acl/acl-impl/src/test/resources/interface-acl/acl-references.json index 63c9e20c9..00a86965d 100644 --- a/acl/acl-impl/src/test/resources/interface-acl/acl-references.json +++ b/acl/acl-impl/src/test/resources/interface-acl/acl-references.json @@ -1,13 +1,12 @@ { - "interfaces": { + "attachment-points": { "interface": [ { - "name": "eth0", - "acl": { - "ingress": { - "vpp-acls": [ + "interface-id": "eth0", + "ingress": { + "acl-sets": { + "acl-set": [ { - "type": "vpp-acl:vpp-acl", "name": "acl1" } ] @@ -15,20 +14,14 @@ } }, { - "name": "eth1", - "acl": { - "egress": { - "vpp-acls": [ + "interface-id": "eth1", + "ingress": { + "acl-sets": { + "acl-set": [ { - "type": "vpp-acl:vpp-acl", "name": "acl1" - } - ] - }, - "ingress": { - "vpp-acls": [ + }, { - "type": "vpp-acl:vpp-acl", "name": "acl2" } ] @@ -36,19 +29,17 @@ } }, { - "name": "eth2", - "acl": { - "ingress": { - "vpp-acls": [ + "interface-id": "eth2", + "ingress": { + "acl-sets": { + "acl-set": [ { - "type": "vpp-acl:vpp-acl", "name": "acl1" + }, + { + "name": "acl4" } - ], - "vpp-macip-acl": { - "name": "acl4", - "type": "vpp-acl:vpp-macip-acl" - } + ] } } } diff --git a/acl/acl-impl/src/test/resources/rules/icmp-rule.json b/acl/acl-impl/src/test/resources/rules/icmp-rule.json index 330a448fc..dbee65ea3 100644 --- a/acl/acl-impl/src/test/resources/rules/icmp-rule.json +++ b/acl/acl-impl/src/test/resources/rules/icmp-rule.json @@ -1,23 +1,25 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", - "access-list-entries": { + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", + "aces": { "ace": [ { - "rule-name": "imcp-rule", + "name": "imcp-rule", "matches": { - "vpp-ace-nodes": { - "destination-ipv4-network": "192.168.2.1/32", + "ipv4": { "source-ipv4-network": "192.168.2.2/32", - "icmp-nodes": { - "icmp-type-range": { + "destination-ipv4-network": "192.168.2.1/32" + }, + "icmp": { + "vpp-acl:vpp-icmp-ace": { + "vpp-acl:icmp-type-range": { "first": "5", "last": "8" }, - "icmp-code-range": { + "vpp-acl:icmp-code-range": { "first": "1", "last": "3" } diff --git a/acl/acl-impl/src/test/resources/rules/icmp-v6-rule.json b/acl/acl-impl/src/test/resources/rules/icmp-v6-rule.json index 9ea82a19a..3cb989858 100644 --- a/acl/acl-impl/src/test/resources/rules/icmp-v6-rule.json +++ b/acl/acl-impl/src/test/resources/rules/icmp-v6-rule.json @@ -1,23 +1,25 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", - "access-list-entries": { + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", + "aces": { "ace": [ { - "rule-name": "imcp-rule", + "name": "imcp-v6-rule", "matches": { - "vpp-ace-nodes": { - "destination-ipv6-network": "2001:0db8:0a0b:12f0:0000:0000:0000:0001/64", - "source-ipv6-network": "2001:0db8:0a0b:12f0:0000:0000:0000:0002/64", - "icmp-v6-nodes": { - "icmp-type-range": { + "ipv6": { + "source-ipv6-network": "2001:0db8:0a0b:12f0:0000:0000:0000:0002/48", + "destination-ipv6-network": "2001:0db8:0a0b:12f0:0000:0000:0000:0001/64" + }, + "icmp": { + "vpp-acl:vpp-icmp-ace": { + "vpp-acl:icmp-type-range": { "first": "5", "last": "8" }, - "icmp-code-range": { + "vpp-acl:icmp-code-range": { "first": "1", "last": "3" } diff --git a/acl/acl-impl/src/test/resources/rules/no-protocol-rule.json b/acl/acl-impl/src/test/resources/rules/no-protocol-rule.json index a022bf08d..dad0f05bb 100644 --- a/acl/acl-impl/src/test/resources/rules/no-protocol-rule.json +++ b/acl/acl-impl/src/test/resources/rules/no-protocol-rule.json @@ -1,17 +1,17 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", - "access-list-entries": { + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", + "aces": { "ace": [ { - "rule-name": "no-protocol-rule", + "name": "no-protocol-rule", "matches": { - "vpp-ace-nodes": { - "destination-ipv4-network": "192.168.2.1/32", - "source-ipv4-network": "192.168.2.2/32" + "ipv4": { + "source-ipv4-network": "192.168.2.2/32", + "destination-ipv4-network": "192.168.2.1/32" } } } diff --git a/acl/acl-impl/src/test/resources/rules/other-rule.json b/acl/acl-impl/src/test/resources/rules/other-rule.json deleted file mode 100644 index 0e60dccf7..000000000 --- a/acl/acl-impl/src/test/resources/rules/other-rule.json +++ /dev/null @@ -1,26 +0,0 @@ -{ - "access-lists": { - "acl": [ - { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", - "access-list-entries": { - "ace": [ - { - "rule-name": "imcp-rule", - "matches": { - "vpp-ace-nodes": { - "destination-ipv4-network": "192.168.2.1/32", - "source-ipv4-network": "192.168.2.2/32", - "other-nodes": { - "protocol": "64" - } - } - } - } - ] - } - } - ] - } -}
\ No newline at end of file diff --git a/acl/acl-impl/src/test/resources/rules/tcp-rule-no-flags.json b/acl/acl-impl/src/test/resources/rules/tcp-rule-no-flags.json index 31cc854df..2130f4a32 100644 --- a/acl/acl-impl/src/test/resources/rules/tcp-rule-no-flags.json +++ b/acl/acl-impl/src/test/resources/rules/tcp-rule-no-flags.json @@ -1,24 +1,24 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", - "access-list-entries": { + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", + "aces": { "ace": [ { - "rule-name": "tcp-no-flags-rule", + "name": "tcp-no-flags-rule", "matches": { - "vpp-ace-nodes": { + "ipv4": { "destination-ipv4-network": "192.168.2.1/32", - "source-ipv4-network": "192.168.2.2/32", - "tcp-nodes": { - "source-port-range": { - "lower-port": "123" - }, - "destination-port-range": { - "lower-port": "65000" - } + "source-ipv4-network": "192.168.2.2/32" + }, + "tcp": { + "source-port": { + "lower-port": "123" + }, + "destination-port": { + "lower-port": "65000" } } } diff --git a/acl/acl-impl/src/test/resources/rules/tcp-rule.json b/acl/acl-impl/src/test/resources/rules/tcp-rule.json index de3697eef..95fa836d4 100644 --- a/acl/acl-impl/src/test/resources/rules/tcp-rule.json +++ b/acl/acl-impl/src/test/resources/rules/tcp-rule.json @@ -1,28 +1,30 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", - "access-list-entries": { + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", + "aces": { "ace": [ { - "rule-name": "imcp-rule", + "name": "tcp-rule", "matches": { - "vpp-ace-nodes": { + "ipv4": { "destination-ipv4-network": "192.168.2.1/32", - "source-ipv4-network": "192.168.2.2/32", - "tcp-nodes": { - "source-port-range": { - "lower-port": "1", - "upper-port": "5487" - }, - "destination-port-range": { - "lower-port": "87", - "upper-port": "6745" - }, - "tcp-flags-mask": "1", - "tcp-flags-value": "7" + "source-ipv4-network": "192.168.2.2/32" + }, + "tcp": { + "source-port": { + "lower-port": "1", + "upper-port": "5487" + }, + "destination-port": { + "lower-port": "87", + "upper-port": "6745" + }, + "flags": "cwr ece urg", + "vpp-acl:vpp-tcp-ace": { + "vpp-acl:flags-mask": "cwr" } } } diff --git a/acl/acl-impl/src/test/resources/rules/udp-rule.json b/acl/acl-impl/src/test/resources/rules/udp-rule.json index 4bc05d4b2..8ee8b82d6 100644 --- a/acl/acl-impl/src/test/resources/rules/udp-rule.json +++ b/acl/acl-impl/src/test/resources/rules/udp-rule.json @@ -1,26 +1,26 @@ { - "access-lists": { + "acls": { "acl": [ { - "acl-name": "standard-acl", - "acl-type": "vpp-acl:vpp-acl", - "access-list-entries": { + "name": "standard-acl", + "type": "vpp-acl:vpp-acl", + "aces": { "ace": [ { - "rule-name": "imcp-rule", + "name": "imcp-rule", "matches": { - "vpp-ace-nodes": { + "ipv4": { "destination-ipv4-network": "192.168.2.1/32", - "source-ipv4-network": "192.168.2.2/32", - "udp-nodes": { - "source-port-range": { - "lower-port": "1", - "upper-port": "5487" - }, - "destination-port-range": { - "lower-port": "87", - "upper-port": "6745" - } + "source-ipv4-network": "192.168.2.2/32" + }, + "udp": { + "source-port": { + "lower-port": "1", + "upper-port": "5487" + }, + "destination-port": { + "lower-port": "87", + "upper-port": "6745" } } } |