", isIpv6=" + isIpv6 +
'}';
}
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ IfaceDumpFilter that = (IfaceDumpFilter) o;
+
+ if (interfaceIndex != that.interfaceIndex) return false;
+ return isIpv6 == that.isIpv6;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = interfaceIndex;
+ result = 31 * result + (isIpv6 ? 1 : 0);
+ return result;
+ }
}
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
-package io.fd.hc2vpp.v3po.interfacesstate.ip;
-
-import static com.google.common.base.Preconditions.checkNotNull;
+package io.fd.hc2vpp.v3po.interfacesstate.ip.readers;
import com.google.common.base.Optional;
-import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+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.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.util.SubInterfaceUtils;
+import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.util.read.cache.DumpSupplier;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
import io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor;
import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
import io.fd.vpp.jvpp.core.dto.IpAddressDump;
-import io.fd.vpp.jvpp.core.dto.IpNeighborDetails;
-import io.fd.vpp.jvpp.core.dto.IpNeighborDetailsReplyDump;
-import io.fd.vpp.jvpp.core.dto.IpNeighborDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
+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.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import javax.annotation.Nonnull;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
-import org.opendaylight.yangtools.yang.binding.Identifier;
+
+import static com.google.common.base.Preconditions.checkNotNull;
/**
- * Utility class providing Ipv4/6 read support.
+ * Provides logic for reading of ip addresses
*/
-public interface IpReader extends AddressTranslator, JvppReplyConsumer {
+public abstract class IpAddressReader extends IpReader {
+
+ private final DumpCacheManager<IpAddressDetailsReplyDump, IfaceDumpFilter> dumpCacheManager;
+
+ protected IpAddressReader(@Nonnull final NamingContext interfaceContext, final boolean isIpv6,
+ @Nonnull final DumpCacheManager<IpAddressDetailsReplyDump, IfaceDumpFilter> dumpCacheManager) {
+ super(interfaceContext, isIpv6);
+ this.dumpCacheManager = dumpCacheManager;
+ }
+
+ @Nonnull
+ protected Optional<IpAddressDetailsReplyDump> interfaceAddressDumpSupplier(@Nonnull final InstanceIdentifier<?> id,
+ @Nonnull final ReadContext context) throws ReadFailedException {
+ return dumpCacheManager.getDump(id, context.getModificationCache(), new IfaceDumpFilter(getInterfaceContext()
+ .getIndex(id.firstKeyOf(Interface.class).getName(), context.getMappingContext()), isIpv6()));
+ }
+
+ @Nonnull
+ protected Optional<IpAddressDetailsReplyDump> subInterfaceAddressDumpSupplier(@Nonnull final InstanceIdentifier<?> id,
+ @Nonnull final ReadContext context) throws ReadFailedException {
+ final String subInterfaceName = SubInterfaceUtils.getSubInterfaceName(id.firstKeyOf(Interface.class).getName(),
+ id.firstKeyOf(SubInterface.class).getIdentifier().intValue());
+ return dumpCacheManager.getDump(id, context.getModificationCache(), new IfaceDumpFilter(getInterfaceContext()
+ .getIndex(subInterfaceName, context.getMappingContext()), isIpv6()));
+ }
@Nonnull
- default <T extends Identifier> List<T> getAllIpv4AddressIds(
+ protected <T extends Identifier> List<T> getAllIpv4AddressIds(
final Optional<IpAddressDetailsReplyDump> dumpOptional,
@Nonnull final Function<Ipv4AddressNoZone, T> keyConstructor) {
if (dumpOptional.isPresent() && dumpOptional.get().ipAddressDetails != null) {
}
@Nonnull
- default <T extends Identifier> List<T> getAllIpv6AddressIds(
+ protected <T extends Identifier> List<T> getAllIpv6AddressIds(
final Optional<IpAddressDetailsReplyDump> dumpOptional,
@Nonnull final Function<Ipv6AddressNoZone, T> keyConstructor) {
if (dumpOptional.isPresent() && dumpOptional.get().ipAddressDetails != null) {
}
}
- default Optional<IpAddressDetails> findIpv4AddressDetailsByIp(
+ @Nonnull
+ protected Optional<IpAddressDetails> findIpv4AddressDetailsByIp(
final Optional<IpAddressDetailsReplyDump> dump,
@Nonnull final Ipv4AddressNoZone ip) {
checkNotNull(ip, "ip address should not be null");
return Optional.absent();
}
- default Optional<IpAddressDetails> findIpv6AddressDetailsByIp(
+ @Nonnull
+ protected Optional<IpAddressDetails> findIpv6AddressDetailsByIp(
final Optional<IpAddressDetailsReplyDump> dump,
@Nonnull final Ipv6AddressNoZone ip) {
checkNotNull(ip, "ip address should not be null");
return Optional.absent();
}
- default EntityDumpExecutor<IpAddressDetailsReplyDump, IfaceDumpFilter> createAddressDumpExecutor(
+ @Nonnull
+ protected static EntityDumpExecutor<IpAddressDetailsReplyDump, IfaceDumpFilter> createAddressDumpExecutor(
@Nonnull final FutureJVppCore vppApi) {
return (identifier, params) -> {
checkNotNull(params, "Address dump params cannot be null");
final IpAddressDump dumpRequest = new IpAddressDump();
- dumpRequest.isIpv6 = booleanToByte(params.isIpv6());
- dumpRequest.swIfIndex = params.getInterfaceIndex();
-
- return getReplyForRead(vppApi.ipAddressDump(dumpRequest).toCompletableFuture(), identifier);
- };
- }
-
- default EntityDumpExecutor<IpNeighborDetailsReplyDump, IfaceDumpFilter> createNeighbourDumpExecutor(
- @Nonnull final FutureJVppCore vppApi) {
- return (identifier, params) -> {
- checkNotNull(params, "Address dump params cannot be null");
-
- final IpNeighborDump dumpRequest = new IpNeighborDump();
- dumpRequest.isIpv6 = booleanToByte(params.isIpv6());
+ dumpRequest.isIpv6 = ByteDataTranslator.INSTANCE.booleanToByte(params.isIpv6());
dumpRequest.swIfIndex = params.getInterfaceIndex();
- return getReplyForRead(vppApi.ipNeighborDump(dumpRequest).toCompletableFuture(), identifier);
+ return JvppReplyConsumer.INSTANCE.getReplyForRead(vppApi.ipAddressDump(dumpRequest).toCompletableFuture(), identifier);
};
}
-
- @Nonnull
- default <T extends Identifier> List<T> getNeighborKeys(
- final DumpSupplier<Optional<IpNeighborDetailsReplyDump>> dumpSupplier,
- final Function<IpNeighborDetails, T> detailToKey)
- throws ReadFailedException {
- final Optional<IpNeighborDetailsReplyDump> neighbourDumpOpt = dumpSupplier.get();
-
- if (neighbourDumpOpt.isPresent()) {
- final IpNeighborDetailsReplyDump neighbourDump = neighbourDumpOpt.get();
-
- return neighbourDump.ipNeighborDetails.stream()
- .map(detailToKey)
- .collect(Collectors.toList());
- } else {
- return Collections.emptyList();
- }
- }
-
-
-
}
--- /dev/null
+/*
+ * 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.v3po.interfacesstate.ip.readers;
+
+import com.google.common.base.Optional;
+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.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.util.SubInterfaceUtils;
+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.EntityDumpExecutor;
+import io.fd.vpp.jvpp.core.dto.IpNeighborDetails;
+import io.fd.vpp.jvpp.core.dto.IpNeighborDetailsReplyDump;
+import io.fd.vpp.jvpp.core.dto.IpNeighborDump;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+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.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yangtools.yang.binding.Identifier;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import javax.annotation.Nonnull;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Provides logic for reading ip neighbours
+ */
+public abstract class IpNeighbourReader extends IpReader {
+
+ private final DumpCacheManager<IpNeighborDetailsReplyDump, IfaceDumpFilter> dumpCacheManager;
+
+ protected IpNeighbourReader(@Nonnull final NamingContext interfaceContext, boolean isIpv6,
+ @Nonnull final DumpCacheManager<IpNeighborDetailsReplyDump, IfaceDumpFilter> dumpCacheManager) {
+ super(interfaceContext, isIpv6);
+ this.dumpCacheManager = dumpCacheManager;
+ }
+
+ @Nonnull
+ protected Optional<IpNeighborDetailsReplyDump> interfaceNeighboursDump(@Nonnull final InstanceIdentifier<?> id,
+ @Nonnull final ReadContext context) throws ReadFailedException {
+ return dumpCacheManager.getDump(id, context.getModificationCache(), new IfaceDumpFilter(getInterfaceContext()
+ .getIndex(id.firstKeyOf(Interface.class).getName(), context.getMappingContext()), isIpv6()));
+ }
+
+ @Nonnull
+ protected Optional<IpNeighborDetailsReplyDump> subInterfaceNeighboursDump(@Nonnull final InstanceIdentifier<?> id,
+ @Nonnull final ReadContext context) throws ReadFailedException {
+ final String subInterfaceName = SubInterfaceUtils.getSubInterfaceName(id.firstKeyOf(Interface.class).getName(),
+ id.firstKeyOf(SubInterface.class).getIdentifier().intValue());
+ return dumpCacheManager.getDump(id, context.getModificationCache(), new IfaceDumpFilter(getInterfaceContext()
+ .getIndex(subInterfaceName, context.getMappingContext()), isIpv6()));
+ }
+
+ @Nonnull
+ protected static EntityDumpExecutor<IpNeighborDetailsReplyDump, IfaceDumpFilter> createNeighbourDumpExecutor(
+ @Nonnull final FutureJVppCore vppApi) {
+ return (identifier, params) -> {
+ checkNotNull(params, "Address dump params cannot be null");
+
+ final IpNeighborDump dumpRequest = new IpNeighborDump();
+ dumpRequest.isIpv6 = ByteDataTranslator.INSTANCE.booleanToByte(params.isIpv6());
+ dumpRequest.swIfIndex = params.getInterfaceIndex();
+
+ return JvppReplyConsumer.INSTANCE.getReplyForRead(vppApi.ipNeighborDump(dumpRequest).toCompletableFuture(), identifier);
+ };
+ }
+
+ @Nonnull
+ protected <T extends Identifier> List<T> getNeighborKeys(
+ final Optional<IpNeighborDetailsReplyDump> neighbourDumpOpt,
+ final Function<IpNeighborDetails, T> detailToKey)
+ throws ReadFailedException {
+ if (neighbourDumpOpt.isPresent()) {
+ final IpNeighborDetailsReplyDump neighbourDump = neighbourDumpOpt.get();
+
+ return neighbourDump.ipNeighborDetails.stream()
+ .map(detailToKey)
+ .collect(Collectors.toList());
+ } else {
+ return Collections.emptyList();
+ }
+ }
+}
--- /dev/null
+/*
+ * 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.v3po.interfacesstate.ip.readers;
+
+import com.google.common.collect.ImmutableSet;
+import io.fd.hc2vpp.common.translate.util.AddressTranslator;
+import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.honeycomb.translate.util.read.cache.CacheKeyFactory;
+import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
+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.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterface;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Utility class providing Ipv4/6 read support.
+ */
+abstract class IpReader implements AddressTranslator, JvppReplyConsumer {
+
+ private final NamingContext interfaceContext;
+ private final boolean isIpv6;
+
+ IpReader(@Nonnull final NamingContext interfaceContext, final boolean isIpv6) {
+ this.interfaceContext = interfaceContext;
+ this.isIpv6 = isIpv6;
+ }
+
+ @Nonnull
+ protected static CacheKeyFactory interfaceScopedCacheKeyFactory(@Nonnull final Class<?> dumpReplyClass) {
+ return new TypeAwareIdentifierCacheKeyFactory(dumpReplyClass, ImmutableSet.of(Interface.class));
+ }
+
+ @Nonnull
+ protected static CacheKeyFactory subInterfaceScopedCacheKeyFactory(@Nonnull final Class<?> dumpReplyClass) {
+ return new TypeAwareIdentifierCacheKeyFactory(dumpReplyClass, ImmutableSet.of(SubInterface.class));
+ }
+
+ protected NamingContext getInterfaceContext() {
+ return interfaceContext;
+ }
+
+ protected boolean isIpv6() {
+ return isIpv6;
+ }
+}
package io.fd.hc2vpp.v3po.interfacesstate.ip.v4;
-import static com.google.common.base.Preconditions.checkNotNull;
-
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.v3po.interfacesstate.InterfaceCustomizer;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.IpReader;
import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.readers.IpAddressReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.Initialized;
import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager.DumpCacheManagerBuilder;
import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.List;
-import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv4;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import javax.annotation.Nonnull;
+import java.util.List;
+
/**
* Read customizer for interface Ipv4 addresses.
*/
-public class Ipv4AddressCustomizer extends FutureJVppCustomizer
- implements InitializingListReaderCustomizer<Address, AddressKey, AddressBuilder>, IpReader {
+public class Ipv4AddressCustomizer extends IpAddressReader
+ implements InitializingListReaderCustomizer<Address, AddressKey, AddressBuilder> {
private static final Logger LOG = LoggerFactory.getLogger(Ipv4AddressCustomizer.class);
- private final NamingContext interfaceContext;
- private final DumpCacheManager<IpAddressDetailsReplyDump, IfaceDumpFilter> dumpManager;
-
public Ipv4AddressCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext) {
- super(futureJVppCore);
- this.interfaceContext = checkNotNull(interfaceContext, "interfaceContext should not be null");
- this.dumpManager =
- new DumpCacheManager.DumpCacheManagerBuilder<IpAddressDetailsReplyDump, IfaceDumpFilter>()
- .withExecutor(createAddressDumpExecutor(futureJVppCore))
- // Key needs to contain interface ID to distinguish dumps between interfaces
- .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(IpAddressDetailsReplyDump.class,
- ImmutableSet.of(Interface.class)))
- .build();
+ super(interfaceContext, false, new DumpCacheManagerBuilder<IpAddressDetailsReplyDump, IfaceDumpFilter>()
+ .withExecutor(createAddressDumpExecutor(futureJVppCore))
+ // Key needs to contain interface ID to distinguish dumps between interfaces
+ .withCacheKeyFactory(interfaceScopedCacheKeyFactory(IpAddressDetailsReplyDump.class))
+ .build());
}
@Override
@Override
public void readCurrentAttributes(@Nonnull InstanceIdentifier<Address> id, @Nonnull AddressBuilder builder,
- @Nonnull ReadContext ctx)
- throws ReadFailedException {
+ @Nonnull ReadContext ctx) throws ReadFailedException {
LOG.debug("Reading attributes for interface address: {}", id);
-
- final String interfaceName = id.firstKeyOf(Interface.class).getName();
- final int interfaceIndex = interfaceContext.getIndex(interfaceName, ctx.getMappingContext());
- final Optional<IpAddressDetailsReplyDump> dumpOptional =
- dumpManager.getDump(id, ctx.getModificationCache(), new IfaceDumpFilter(interfaceIndex, false));
+ final Optional<IpAddressDetailsReplyDump> dumpOptional = interfaceAddressDumpSupplier(id, ctx);
if (!dumpOptional.isPresent() || dumpOptional.get().ipAddressDetails.isEmpty()) {
return;
}
- final Optional<IpAddressDetails> ipAddressDetails =
- findIpv4AddressDetailsByIp(dumpOptional, id.firstKeyOf(Address.class).getIp());
+ final Optional<IpAddressDetails> ipAddressDetails = findIpv4AddressDetailsByIp(dumpOptional, id.firstKeyOf(Address.class).getIp());
if (ipAddressDetails.isPresent()) {
final IpAddressDetails detail = ipAddressDetails.get();
.setSubnet(new PrefixLengthBuilder().setPrefixLength(Short.valueOf(detail.prefixLength)).build());
if (LOG.isDebugEnabled()) {
+ final String interfaceName = id.firstKeyOf(Interface.class).getName();
+ final int interfaceIndex = getInterfaceContext().getIndex(interfaceName, ctx.getMappingContext());
LOG.debug("Attributes for {} interface (id={}) address {} successfully read: {}",
interfaceName, interfaceIndex, id, builder.build());
}
public List<AddressKey> getAllIds(@Nonnull InstanceIdentifier<Address> id, @Nonnull ReadContext ctx)
throws ReadFailedException {
LOG.debug("Reading list of keys for interface addresses: {}", id);
-
- final String interfaceName = id.firstKeyOf(Interface.class).getName();
- final int interfaceIndex = interfaceContext.getIndex(interfaceName, ctx.getMappingContext());
- final Optional<IpAddressDetailsReplyDump> dumpOptional =
- dumpManager.getDump(id, ctx.getModificationCache(), new IfaceDumpFilter(interfaceIndex, false));
-
- return getAllIpv4AddressIds(dumpOptional, AddressKey::new);
+ return getAllIpv4AddressIds(interfaceAddressDumpSupplier(id, ctx), AddressKey::new);
}
@Override
return new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.address.subnet.PrefixLengthBuilder()
.setPrefixLength(
- ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.address.subnet.PrefixLength) subnet)
- .getPrefixLength()).build();
+ ((org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.address.subnet.PrefixLength) subnet)
+ .getPrefixLength()).build();
}
static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.ipv4.Address> getCfgId(
package io.fd.hc2vpp.v3po.interfacesstate.ip.v4;
-import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Dynamic;
-import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Static;
-
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.IpReader;
import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.readers.IpNeighbourReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
-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.DumpSupplier;
-import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
import io.fd.vpp.jvpp.core.dto.IpNeighborDetails;
import io.fd.vpp.jvpp.core.dto.IpNeighborDetailsReplyDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.List;
-import java.util.function.Function;
-import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv4Builder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.Neighbor;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.NeighborBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import javax.annotation.Nonnull;
+import java.util.List;
+import java.util.function.Function;
+
+import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Dynamic;
+import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Static;
+
/**
* Operational data read operation customizer for {@link Neighbor}<br>
* Currently not supported in jvpp, so this is only dummy implementation<br>
*/
-public class Ipv4NeighbourCustomizer extends FutureJVppCustomizer
- implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder>, IpReader {
-
- private final DumpCacheManager<IpNeighborDetailsReplyDump, IfaceDumpFilter> dumpManager;
- private final NamingContext interfaceContext;
+public class Ipv4NeighbourCustomizer extends IpNeighbourReader
+ implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder> {
public Ipv4NeighbourCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext) {
- super(futureJVppCore);
- dumpManager = new DumpCacheManagerBuilder<IpNeighborDetailsReplyDump, IfaceDumpFilter>()
+ super(interfaceContext, false, new DumpCacheManagerBuilder<IpNeighborDetailsReplyDump, IfaceDumpFilter>()
.withExecutor(createNeighbourDumpExecutor(futureJVppCore))
// cached with parent interface scope
- .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(IpNeighborDetailsReplyDump.class,
- ImmutableSet.of(Interface.class)))
- .build();
- this.interfaceContext = interfaceContext;
+ .withCacheKeyFactory(interfaceScopedCacheKeyFactory(IpNeighborDetailsReplyDump.class))
+ .build());
}
@Override
final Ipv4AddressNoZone ip = id.firstKeyOf(Neighbor.class).getIp();
- final Optional<IpNeighborDetailsReplyDump> dumpOpt = dumpSupplier(id, ctx).get();
+ final Optional<IpNeighborDetailsReplyDump> dumpOpt = interfaceNeighboursDump(id, ctx);
if (dumpOpt.isPresent()) {
dumpOpt.get().ipNeighborDetails
@Override
public List<NeighborKey> getAllIds(InstanceIdentifier<Neighbor> id, ReadContext context)
throws ReadFailedException {
- return getNeighborKeys(dumpSupplier(id, context), keyMapper());
+ return getNeighborKeys(interfaceNeighboursDump(id, context), keyMapper());
}
@Override
private Function<IpNeighborDetails, NeighborKey> keyMapper() {
return ipNeighborDetails -> new NeighborKey(arrayToIpv4AddressNoZone(ipNeighborDetails.ipAddress));
}
-
- private DumpSupplier<Optional<IpNeighborDetailsReplyDump>> dumpSupplier(final InstanceIdentifier<Neighbor> id,
- final ReadContext context) {
- return () -> dumpManager
- .getDump(id, context.getModificationCache(), new IfaceDumpFilter(interfaceContext
- .getIndex(id.firstKeyOf(Interface.class).getName(), context.getMappingContext()),
- false));
- }
-
}
\ No newline at end of file
package io.fd.hc2vpp.v3po.interfacesstate.ip.v4.subinterface;
-import static com.google.common.base.Preconditions.checkNotNull;
-
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.v3po.interfacesstate.SubInterfaceCustomizer;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.IpReader;
import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.readers.IpAddressReader;
import io.fd.hc2vpp.v3po.util.SubInterfaceUtils;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.List;
-import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.Ipv4;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import javax.annotation.Nonnull;
+import java.util.List;
+
/**
* Read customizer for sub-interface Ipv4 addresses.
*/
-public class SubInterfaceIpv4AddressCustomizer extends FutureJVppCustomizer
- implements InitializingListReaderCustomizer<Address, AddressKey, AddressBuilder>, IpReader {
+public class SubInterfaceIpv4AddressCustomizer extends IpAddressReader
+ implements InitializingListReaderCustomizer<Address, AddressKey, AddressBuilder> {
private static final Logger LOG = LoggerFactory.getLogger(SubInterfaceIpv4AddressCustomizer.class);
- private final NamingContext interfaceContext;
- private final DumpCacheManager<IpAddressDetailsReplyDump, IfaceDumpFilter> dumpManager;
-
public SubInterfaceIpv4AddressCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext) {
- super(futureJVppCore);
- this.interfaceContext = checkNotNull(interfaceContext, "interfaceContext should not be null");
- this.dumpManager = new DumpCacheManager.DumpCacheManagerBuilder<IpAddressDetailsReplyDump, IfaceDumpFilter>()
+ super(interfaceContext, false, new DumpCacheManager.DumpCacheManagerBuilder<IpAddressDetailsReplyDump, IfaceDumpFilter>()
.withExecutor(createAddressDumpExecutor(futureJVppCore))
//same as with ipv4 addresses for interfaces, these must have cache scope of their parent sub-interface
- .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(IpAddressDetailsReplyDump.class,
- ImmutableSet.of(SubInterface.class)))
- .build();
+ .withCacheKeyFactory(subInterfaceScopedCacheKeyFactory(IpAddressDetailsReplyDump.class))
+ .build());
}
private static String getSubInterfaceName(@Nonnull final InstanceIdentifier<Address> id) {
throws ReadFailedException {
LOG.debug("Reading attributes for sub-interface address: {}", id);
- final String subInterfaceName = getSubInterfaceName(id);
- final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, ctx.getMappingContext());
- final Optional<IpAddressDetailsReplyDump> dumpOptional = dumpManager
- .getDump(id, ctx.getModificationCache(), new IfaceDumpFilter(subInterfaceIndex, false));
-
final Optional<IpAddressDetails> ipAddressDetails =
- findIpv4AddressDetailsByIp(dumpOptional, id.firstKeyOf(Address.class).getIp());
+ findIpv4AddressDetailsByIp(subInterfaceAddressDumpSupplier(id, ctx), id.firstKeyOf(Address.class).getIp());
if (ipAddressDetails.isPresent()) {
final IpAddressDetails detail = ipAddressDetails.get();
builder.setSubnet(new PrefixLengthBuilder().setPrefixLength((short) detail.prefixLength).build());
if (LOG.isDebugEnabled()) {
+ final String subInterfaceName = getSubInterfaceName(id);
+ final int subInterfaceIndex = getInterfaceContext().getIndex(subInterfaceName, ctx.getMappingContext());
LOG.debug("Attributes for {} sub-interface (id={}) address {} successfully read: {}",
subInterfaceName, subInterfaceIndex, id, builder.build());
}
public List<AddressKey> getAllIds(@Nonnull InstanceIdentifier<Address> id, @Nonnull ReadContext ctx)
throws ReadFailedException {
LOG.debug("Reading list of keys for sub-interface addresses: {}", id);
-
- final String subInterfaceName = getSubInterfaceName(id);
- final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, ctx.getMappingContext());
- final Optional<IpAddressDetailsReplyDump> dumpOptional = dumpManager
- .getDump(id, ctx.getModificationCache(), new IfaceDumpFilter(subInterfaceIndex, false));
-
- return getAllIpv4AddressIds(dumpOptional, AddressKey::new);
+ return getAllIpv4AddressIds(subInterfaceAddressDumpSupplier(id, ctx), AddressKey::new);
}
@Override
package io.fd.hc2vpp.v3po.interfacesstate.ip.v4.subinterface;
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.IpReader;
import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.readers.IpNeighbourReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
-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.DumpSupplier;
-import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
import io.fd.vpp.jvpp.core.dto.IpNeighborDetails;
import io.fd.vpp.jvpp.core.dto.IpNeighborDetailsReplyDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.List;
-import java.util.function.Function;
-import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.Ipv4Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.Neighbor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.NeighborBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class SubInterfaceIpv4NeighbourCustomizer extends FutureJVppCustomizer
- implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder>, IpReader {
+import javax.annotation.Nonnull;
+import java.util.List;
+import java.util.function.Function;
- private final DumpCacheManager<IpNeighborDetailsReplyDump, IfaceDumpFilter> dumpManager;
- private final NamingContext interfaceContext;
+public class SubInterfaceIpv4NeighbourCustomizer extends IpNeighbourReader
+ implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder> {
public SubInterfaceIpv4NeighbourCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext) {
- super(futureJVppCore);
- dumpManager = new DumpCacheManagerBuilder<IpNeighborDetailsReplyDump, IfaceDumpFilter>()
+ super(interfaceContext, false, new DumpCacheManagerBuilder<IpNeighborDetailsReplyDump, IfaceDumpFilter>()
.withExecutor(createNeighbourDumpExecutor(futureJVppCore))
// cached with parent interface scope
- .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(IpNeighborDetailsReplyDump.class,
- ImmutableSet.of(Interface.class)))
- .build();
- this.interfaceContext = interfaceContext;
+ .withCacheKeyFactory(subInterfaceScopedCacheKeyFactory(IpNeighborDetailsReplyDump.class))
+ .build());
}
@Override
final Ipv4AddressNoZone ip = id.firstKeyOf(Neighbor.class).getIp();
- final Optional<IpNeighborDetailsReplyDump> dumpOpt = dumpSupplier(id, ctx).get();
+ final Optional<IpNeighborDetailsReplyDump> dumpOpt = subInterfaceNeighboursDump(id, ctx);
if (dumpOpt.isPresent()) {
dumpOpt.get().ipNeighborDetails
@Override
public List<NeighborKey> getAllIds(InstanceIdentifier<Neighbor> id, ReadContext context)
throws ReadFailedException {
- return getNeighborKeys(dumpSupplier(id, context), keyMapper());
+ return getNeighborKeys(subInterfaceNeighboursDump(id, context), keyMapper());
}
@Override
private Function<IpNeighborDetails, NeighborKey> keyMapper() {
return ipNeighborDetails -> new NeighborKey(arrayToIpv4AddressNoZone(ipNeighborDetails.ipAddress));
}
-
- private DumpSupplier<Optional<IpNeighborDetailsReplyDump>> dumpSupplier(final InstanceIdentifier<Neighbor> id,
- final ReadContext context) {
- return () -> dumpManager
- .getDump(id, context.getModificationCache(), new IfaceDumpFilter(interfaceContext
- .getIndex(id.firstKeyOf(Interface.class).getName(), context.getMappingContext()),
- false));
- }
-
}
\ No newline at end of file
package io.fd.hc2vpp.v3po.interfacesstate.ip.v6;
-import static com.google.common.base.Preconditions.checkNotNull;
-
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.v3po.interfacesstate.InterfaceCustomizer;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.IpReader;
import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.readers.IpAddressReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.Initialized;
import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
-import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
+import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager.DumpCacheManagerBuilder;
import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.List;
-import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface1;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces._interface.Ipv6;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class Ipv6AddressCustomizer extends FutureJVppCustomizer
- implements InitializingListReaderCustomizer<Address, AddressKey, AddressBuilder>, IpReader {
+import javax.annotation.Nonnull;
+import java.util.List;
- private static final Logger LOG = LoggerFactory.getLogger(Ipv6AddressCustomizer.class);
+public class Ipv6AddressCustomizer extends IpAddressReader
+ implements InitializingListReaderCustomizer<Address, AddressKey, AddressBuilder> {
- private final NamingContext interfaceContext;
- private final DumpCacheManager<IpAddressDetailsReplyDump, IfaceDumpFilter> dumpManager;
+ private static final Logger LOG = LoggerFactory.getLogger(Ipv6AddressCustomizer.class);
public Ipv6AddressCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext) {
- super(futureJVppCore);
- this.interfaceContext = checkNotNull(interfaceContext, "interfaceContext should not be null");
- this.dumpManager =
- new DumpCacheManager.DumpCacheManagerBuilder<IpAddressDetailsReplyDump, IfaceDumpFilter>()
- .withExecutor(createAddressDumpExecutor(futureJVppCore))
- // Key needs to contain interface ID to distinguish dumps between interfaces
- .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(IpAddressDetailsReplyDump.class,
- ImmutableSet.of(Interface.class)))
- .build();
+ super(interfaceContext, true, new DumpCacheManagerBuilder<IpAddressDetailsReplyDump, IfaceDumpFilter>()
+ .withExecutor(createAddressDumpExecutor(futureJVppCore))
+ // Key needs to contain interface ID to distinguish dumps between interfaces
+ .withCacheKeyFactory(interfaceScopedCacheKeyFactory(IpAddressDetailsReplyDump.class))
+ .build());
}
@Override
@Nonnull ReadContext ctx)
throws ReadFailedException {
LOG.debug("Reading attributes for interface address: {}", id);
-
- final String interfaceName = id.firstKeyOf(Interface.class).getName();
- final int interfaceIndex = interfaceContext.getIndex(interfaceName, ctx.getMappingContext());
- final Optional<IpAddressDetailsReplyDump> dumpOptional =
- dumpManager.getDump(id, ctx.getModificationCache(), new IfaceDumpFilter(interfaceIndex, true));
-
- if (!dumpOptional.isPresent() || dumpOptional.get().ipAddressDetails.isEmpty()) {
- return;
- }
final Optional<IpAddressDetails> ipAddressDetails =
- findIpv6AddressDetailsByIp(dumpOptional, id.firstKeyOf(Address.class).getIp());
+ findIpv6AddressDetailsByIp(interfaceAddressDumpSupplier(id, ctx), id.firstKeyOf(Address.class).getIp());
if (ipAddressDetails.isPresent()) {
final IpAddressDetails detail = ipAddressDetails.get();
.build();
if (LOG.isDebugEnabled()) {
+ final String interfaceName = id.firstKeyOf(Interface.class).getName();
+ final int interfaceIndex = getInterfaceContext().getIndex(interfaceName, ctx.getMappingContext());
LOG.debug("Attributes for {} interface (id={}) address {} successfully read: {}",
interfaceName, interfaceIndex, id, builder.build());
}
public List<AddressKey> getAllIds(@Nonnull InstanceIdentifier<Address> id, @Nonnull ReadContext ctx)
throws ReadFailedException {
LOG.debug("Reading list of keys for interface addresses: {}", id);
-
- final String interfaceName = id.firstKeyOf(Interface.class).getName();
- final int interfaceIndex = interfaceContext.getIndex(interfaceName, ctx.getMappingContext());
- final Optional<IpAddressDetailsReplyDump> dumpOptional =
- dumpManager.getDump(id, ctx.getModificationCache(), new IfaceDumpFilter(interfaceIndex, true));
-
- return getAllIpv6AddressIds(dumpOptional, AddressKey::new);
+ return getAllIpv6AddressIds(interfaceAddressDumpSupplier(id, ctx), AddressKey::new);
}
@Override
package io.fd.hc2vpp.v3po.interfacesstate.ip.v6;
-import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Dynamic;
-import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Static;
-
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.IpReader;
import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.readers.IpNeighbourReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.DumpSupplier;
-import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
import io.fd.vpp.jvpp.core.dto.IpNeighborDetails;
import io.fd.vpp.jvpp.core.dto.IpNeighborDetailsReplyDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.List;
-import java.util.function.Function;
-import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv6Builder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv6.Neighbor;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv6.NeighborBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class Ipv6NeighbourCustomizer extends FutureJVppCustomizer
- implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder>, IpReader {
+import javax.annotation.Nonnull;
+import java.util.List;
+import java.util.function.Function;
+import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Dynamic;
+import static org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.NeighborOrigin.Static;
- private final DumpCacheManager<IpNeighborDetailsReplyDump, IfaceDumpFilter> dumpManager;
- private final NamingContext interfaceContext;
+public class Ipv6NeighbourCustomizer extends IpNeighbourReader
+ implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder> {
public Ipv6NeighbourCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext) {
- super(futureJVppCore);
- dumpManager = new DumpCacheManager.DumpCacheManagerBuilder<IpNeighborDetailsReplyDump, IfaceDumpFilter>()
+ super(interfaceContext, true, new DumpCacheManager.DumpCacheManagerBuilder<IpNeighborDetailsReplyDump, IfaceDumpFilter>()
.withExecutor(createNeighbourDumpExecutor(futureJVppCore))
// cached with parent interface scope
- .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(IpNeighborDetailsReplyDump.class,
- ImmutableSet.of(Interface.class)))
- .build();
- this.interfaceContext = interfaceContext;
+ .withCacheKeyFactory(interfaceScopedCacheKeyFactory(IpNeighborDetailsReplyDump.class))
+ .build());
}
@Override
@Override
public void readCurrentAttributes(InstanceIdentifier<Neighbor> id, NeighborBuilder builder, ReadContext ctx)
throws ReadFailedException {
-
final Ipv6AddressNoZone ip = id.firstKeyOf(Neighbor.class).getIp();
-
- final Optional<IpNeighborDetailsReplyDump> dumpOpt = dumpSupplier(id, ctx).get();
+ final Optional<IpNeighborDetailsReplyDump> dumpOpt = interfaceNeighboursDump(id, ctx);
if (dumpOpt.isPresent()) {
dumpOpt.get().ipNeighborDetails
@Override
public List<NeighborKey> getAllIds(InstanceIdentifier<Neighbor> id, ReadContext context)
throws ReadFailedException {
- return getNeighborKeys(dumpSupplier(id, context), keyMapper());
+ return getNeighborKeys(interfaceNeighboursDump(id, context), keyMapper());
}
@Override
private Function<IpNeighborDetails, NeighborKey> keyMapper() {
return ipNeighborDetails -> new NeighborKey(arrayToIpv6AddressNoZone(ipNeighborDetails.ipAddress));
}
-
- private DumpSupplier<Optional<IpNeighborDetailsReplyDump>> dumpSupplier(final InstanceIdentifier<Neighbor> id,
- final ReadContext context) {
- return () -> dumpManager
- .getDump(id, context.getModificationCache(), new IfaceDumpFilter(interfaceContext
- .getIndex(id.firstKeyOf(Interface.class).getName(), context.getMappingContext()),
- true));
- }
}
\ No newline at end of file
package io.fd.hc2vpp.v3po.interfacesstate.ip.v6.subinterface;
-import static com.google.common.base.Preconditions.checkNotNull;
-
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
import io.fd.hc2vpp.v3po.interfacesstate.SubInterfaceCustomizer;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.IpReader;
import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.readers.IpAddressReader;
import io.fd.hc2vpp.v3po.util.SubInterfaceUtils;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer;
import io.fd.honeycomb.translate.util.RWUtils;
import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager;
-import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.List;
-import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.Ipv6;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class SubInterfaceIpv6AddressCustomizer extends FutureJVppCustomizer
- implements InitializingListReaderCustomizer<Address, AddressKey, AddressBuilder>, IpReader {
+import javax.annotation.Nonnull;
+import java.util.List;
- private static final Logger LOG = LoggerFactory.getLogger(SubInterfaceIpv6AddressCustomizer.class);
+public class SubInterfaceIpv6AddressCustomizer extends IpAddressReader
+ implements InitializingListReaderCustomizer<Address, AddressKey, AddressBuilder> {
- private final NamingContext interfaceContext;
- private final DumpCacheManager<IpAddressDetailsReplyDump, IfaceDumpFilter> dumpManager;
+ private static final Logger LOG = LoggerFactory.getLogger(SubInterfaceIpv6AddressCustomizer.class);
public SubInterfaceIpv6AddressCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext) {
- super(futureJVppCore);
- this.interfaceContext = checkNotNull(interfaceContext, "interfaceContext should not be null");
- this.dumpManager = new DumpCacheManager.DumpCacheManagerBuilder<IpAddressDetailsReplyDump, IfaceDumpFilter>()
+ super(interfaceContext, true, new DumpCacheManager.DumpCacheManagerBuilder<IpAddressDetailsReplyDump, IfaceDumpFilter>()
.withExecutor(createAddressDumpExecutor(futureJVppCore))
- .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(IpAddressDetailsReplyDump.class,
- ImmutableSet.of(SubInterface.class)))
- .build();
+ .withCacheKeyFactory(subInterfaceScopedCacheKeyFactory(IpAddressDetailsReplyDump.class))
+ .build());
}
private static String getSubInterfaceName(@Nonnull final InstanceIdentifier<Address> id) {
@Nonnull ReadContext ctx)
throws ReadFailedException {
LOG.debug("Reading attributes for sub-interface address: {}", id);
-
- final String subInterfaceName = getSubInterfaceName(id);
- final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, ctx.getMappingContext());
- final Optional<IpAddressDetailsReplyDump> dumpOptional = dumpManager
- .getDump(id, ctx.getModificationCache(), new IfaceDumpFilter(subInterfaceIndex, false));
-
final Optional<IpAddressDetails> ipAddressDetails =
- findIpv6AddressDetailsByIp(dumpOptional, id.firstKeyOf(Address.class).getIp());
+ findIpv6AddressDetailsByIp(subInterfaceAddressDumpSupplier(id, ctx), id.firstKeyOf(Address.class).getIp());
if (ipAddressDetails.isPresent()) {
final IpAddressDetails detail = ipAddressDetails.get();
builder.setIp(arrayToIpv6AddressNoZone(detail.ip));
- builder.setPrefixLength((short) detail.prefixLength);
+ builder.setPrefixLength((short) Byte.toUnsignedInt(detail.prefixLength));
if (LOG.isDebugEnabled()) {
+ final String subInterfaceName = getSubInterfaceName(id);
+ final int subInterfaceIndex = getInterfaceContext().getIndex(subInterfaceName, ctx.getMappingContext());
LOG.debug("Attributes for {} sub-interface (id={}) address {} successfully read: {}",
subInterfaceName, subInterfaceIndex, id, builder.build());
}
public List<AddressKey> getAllIds(@Nonnull InstanceIdentifier<Address> id, @Nonnull ReadContext ctx)
throws ReadFailedException {
LOG.debug("Reading list of keys for sub-interface addresses: {}", id);
-
- final String subInterfaceName = getSubInterfaceName(id);
- final int subInterfaceIndex = interfaceContext.getIndex(subInterfaceName, ctx.getMappingContext());
- final Optional<IpAddressDetailsReplyDump> dumpOptional = dumpManager
- .getDump(id, ctx.getModificationCache(), new IfaceDumpFilter(subInterfaceIndex, false));
-
- return getAllIpv6AddressIds(dumpOptional, AddressKey::new);
+ return getAllIpv6AddressIds(subInterfaceAddressDumpSupplier(id, ctx), AddressKey::new);
}
@Override
package io.fd.hc2vpp.v3po.interfacesstate.ip.v6.subinterface;
import com.google.common.base.Optional;
-import com.google.common.collect.ImmutableSet;
-import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.IpReader;
import io.fd.hc2vpp.v3po.interfacesstate.ip.dump.params.IfaceDumpFilter;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.readers.IpNeighbourReader;
import io.fd.honeycomb.translate.read.ReadContext;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
-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.DumpSupplier;
-import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
import io.fd.vpp.jvpp.core.dto.IpNeighborDetails;
import io.fd.vpp.jvpp.core.dto.IpNeighborDetailsReplyDump;
import io.fd.vpp.jvpp.core.future.FutureJVppCore;
-import java.util.List;
-import java.util.function.Function;
-import javax.annotation.Nonnull;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.Ipv6Builder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.ipv6.Neighbor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.ipv6.NeighborBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-public class SubInterfaceIpv6NeighbourCustomizer extends FutureJVppCustomizer
- implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder>, IpReader {
+import javax.annotation.Nonnull;
+import java.util.List;
+import java.util.function.Function;
- private final DumpCacheManager<IpNeighborDetailsReplyDump, IfaceDumpFilter> dumpManager;
- private final NamingContext interfaceContext;
+public class SubInterfaceIpv6NeighbourCustomizer extends IpNeighbourReader
+ implements ListReaderCustomizer<Neighbor, NeighborKey, NeighborBuilder> {
public SubInterfaceIpv6NeighbourCustomizer(@Nonnull final FutureJVppCore futureJVppCore,
@Nonnull final NamingContext interfaceContext) {
- super(futureJVppCore);
- dumpManager = new DumpCacheManagerBuilder<IpNeighborDetailsReplyDump, IfaceDumpFilter>()
+ super(interfaceContext, true, new DumpCacheManagerBuilder<IpNeighborDetailsReplyDump, IfaceDumpFilter>()
.withExecutor(createNeighbourDumpExecutor(futureJVppCore))
// cached with parent interface scope
- .withCacheKeyFactory(new TypeAwareIdentifierCacheKeyFactory(IpNeighborDetailsReplyDump.class,
- ImmutableSet.of(Interface.class)))
- .build();
- this.interfaceContext = interfaceContext;
+ .withCacheKeyFactory(subInterfaceScopedCacheKeyFactory(IpNeighborDetailsReplyDump.class))
+ .build());
}
@Override
final Ipv6AddressNoZone ip = id.firstKeyOf(Neighbor.class).getIp();
- final Optional<IpNeighborDetailsReplyDump> dumpOpt = dumpSupplier(id, ctx).get();
+ final Optional<IpNeighborDetailsReplyDump> dumpOpt = subInterfaceNeighboursDump(id, ctx);
if (dumpOpt.isPresent()) {
dumpOpt.get().ipNeighborDetails
@Override
public List<NeighborKey> getAllIds(InstanceIdentifier<Neighbor> id, ReadContext context)
throws ReadFailedException {
- return getNeighborKeys(dumpSupplier(id, context), keyMapper());
+ return getNeighborKeys(subInterfaceNeighboursDump(id, context), keyMapper());
}
@Override
private Function<IpNeighborDetails, NeighborKey> keyMapper() {
return ipNeighborDetails -> new NeighborKey(arrayToIpv6AddressNoZone(ipNeighborDetails.ipAddress));
}
-
- private DumpSupplier<Optional<IpNeighborDetailsReplyDump>> dumpSupplier(final InstanceIdentifier<Neighbor> id,
- final ReadContext context) {
- return () -> dumpManager
- .getDump(id, context.getModificationCache(), new IfaceDumpFilter(interfaceContext
- .getIndex(id.firstKeyOf(Interface.class).getName(), context.getMappingContext()),
- true));
- }
-
}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.v3po.interfacesstate.ip;
+
+import io.fd.hc2vpp.common.test.util.FutureProducer;
+import io.fd.hc2vpp.common.test.util.NamingContextHelper;
+import io.fd.hc2vpp.common.translate.util.NamingContext;
+import io.fd.vpp.jvpp.core.dto.*;
+import io.fd.vpp.jvpp.core.future.FutureJVppCore;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
+
+import javax.annotation.Nonnull;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+public interface InterfaceChildNodeTest extends NamingContextHelper, FutureProducer {
+
+ String INTERFACE_CONTEXT_NAME = "iface-context";
+ NamingContext INTERFACE_CONTEXT = new NamingContext("prefix", INTERFACE_CONTEXT_NAME);
+
+ String IFACE_NAME = "eth0";
+ int IFACE_ID = 1;
+
+ String SUB_IFACE_NAME = "eth0.4";
+ int SUB_IFACE_ID = 4;
+
+ String IFACE_2_NAME = "eth1";
+ int IFACE_2_ID = 2;
+
+ String SUB_IFACE_2_NAME = "eth1.7";
+ int SUB_IFACE_2_ID = 7;
+
+ String IPV6_ONE_COMPRESSED = "2001:db8:a0b:12f0::1";
+ byte[] IPV6_ONE_BYTES = {32, 1, 13, -72, 10, 11, 18, -16, 0, 0, 0, 0, 0, 0, 0, 1};
+ byte IPV6_ONE_PREFIX = 64;
+ Ipv6AddressNoZone IPV6_ONE_ADDRESS_COMPRESSED = new Ipv6AddressNoZone(IPV6_ONE_COMPRESSED);
+
+ String IPV6_TWO_COMPRESSED = "2001:db8:a0b:12f0::2";
+ byte[] IPV6_TWO_BYTES = {32, 1, 13, -72, 10, 11, 18, -16, 0, 0, 0, 0, 0, 0, 0, 2};
+ byte IPV6_TWO_PREFIX = 48;
+ Ipv6AddressNoZone IPV6_TWO_ADDRESS_COMPRESSED = new Ipv6AddressNoZone(IPV6_TWO_COMPRESSED);
+
+ String IPV4_ONE = "192.168.2.1";
+ byte[] IPV4_ONE_BYTES = {-64, -88, 2, 1};
+ byte IPV4_ONE_PREFIX = 24;
+ Ipv4AddressNoZone IPV4_ONE_ADDRESS = new Ipv4AddressNoZone(IPV4_ONE);
+
+ String IPV4_TWO = "192.168.2.2";
+ byte[] IPV4_TWO_BYTES = {-64, -88, 2, 2};
+ byte IPV4_TWO_PREFIX = 24;
+ Ipv4AddressNoZone IPV4_TWO_ADDRESS = new Ipv4AddressNoZone(IPV4_TWO);
+
+ String MAC_ONE = "00:00:00:00:00:00";
+ byte[] MAC_ONE_BYTES = {0, 0, 0, 0, 0, 0};
+ PhysAddress MAC_ONE_ADDRESS = new PhysAddress(MAC_ONE);
+
+ String MAC_TWO = "00:00:00:00:00:01";
+ byte[] MAC_TWO_BYTES = {0, 0, 0, 0, 0, 1};
+ PhysAddress MAC_TWO_ADDRESS = new PhysAddress(MAC_TWO);
+
+ String MAC_THREE = "00:00:00:00:00:02";
+ byte[] MAC_THREE_BYTES = {0, 0, 0, 0, 0, 2};
+ PhysAddress MAC_THREE_ADDRESS = new PhysAddress(MAC_THREE);
+
+ String MAC_FOUR = "00:00:00:00:00:03";
+ byte[] MAC_FOUR_BYTES = {0, 0, 0, 0, 0, 3};
+ PhysAddress MAC_FOUR_ADDRESS = new PhysAddress(MAC_FOUR);
+
+ default void mockNeighborDump(@Nonnull final FutureJVppCore api,
+ @Nonnull final IpNeighborDump request,
+ @Nonnull final IpNeighborDetailsReplyDump reply) {
+ when(api.ipNeighborDump(request)).thenReturn(future(reply));
+ }
+
+ default void mockAddressDump(@Nonnull final FutureJVppCore api,
+ @Nonnull final IpAddressDump request,
+ @Nonnull final IpAddressDetailsReplyDump reply) {
+ when(api.ipAddressDump(request)).thenReturn(future(reply));
+ }
+
+ default IpAddressDump dumpV6AddressesIfaceTwo() {
+ IpAddressDump request = new IpAddressDump();
+ request.isIpv6 = 1;
+ request.swIfIndex = IFACE_2_ID;
+ return request;
+ }
+
+ default IpAddressDump dumpV6AddressesSubIfaceOne() {
+ IpAddressDump request = new IpAddressDump();
+ request.swIfIndex = SUB_IFACE_ID;
+ request.isIpv6 = 1;
+ return request;
+ }
+
+
+ default IpNeighborDump dumpV4NeighborIfaceOne() {
+ IpNeighborDump request = new IpNeighborDump();
+ request.swIfIndex = IFACE_ID;
+ request.isIpv6 = 0;
+ return request;
+ }
+
+ default IpNeighborDump dumpV6NeighborsIfaceOne() {
+ IpNeighborDump request = new IpNeighborDump();
+ request.swIfIndex = IFACE_ID;
+ request.isIpv6 = 1;
+ return request;
+ }
+
+ default IpNeighborDump dumpV6NeighborsSubIfaceTwo() {
+ IpNeighborDump request = new IpNeighborDump();
+ request.swIfIndex = SUB_IFACE_2_ID;
+ request.isIpv6 = 1;
+ return request;
+ }
+
+ default IpNeighborDump dumpV4NeighborsSubIfaceOne() {
+ IpNeighborDump request = new IpNeighborDump();
+ request.swIfIndex = SUB_IFACE_ID;
+ request.isIpv6 = 0;
+ return request;
+ }
+
+ default void verifyList(@Nonnull final List<?> expected, @Nonnull final List<?> current) {
+ assertThat(current, hasSize(expected.size()));
+ assertTrue(expected.containsAll(current));
+ }
+
+ default IpNeighborDetailsReplyDump v4Neighbors() {
+ IpNeighborDetailsReplyDump fullDump = new IpNeighborDetailsReplyDump();
+ fullDump.ipNeighborDetails = Arrays.asList(
+ neighborDump(IPV4_ONE_BYTES, 0, MAC_ONE_BYTES),
+ neighborDump(IPV4_TWO_BYTES, 0, MAC_TWO_BYTES));
+ return fullDump;
+ }
+
+ default IpNeighborDetailsReplyDump v6Neighbors() {
+ IpNeighborDetailsReplyDump fullDump = new IpNeighborDetailsReplyDump();
+ fullDump.ipNeighborDetails = Arrays.asList(
+ neighborDump(IPV6_ONE_BYTES, 1, MAC_THREE_BYTES),
+ neighborDump(IPV6_TWO_BYTES, 1, MAC_FOUR_BYTES));
+ return fullDump;
+ }
+
+ default IpAddressDetailsReplyDump v4Addresses() {
+ IpAddressDetailsReplyDump fullDump = new IpAddressDetailsReplyDump();
+ fullDump.ipAddressDetails = Arrays.asList(
+ addressDump(IPV4_ONE_BYTES, IPV4_ONE_PREFIX),
+ addressDump(IPV4_TWO_BYTES, IPV4_TWO_PREFIX));
+ return fullDump;
+ }
+
+ default IpAddressDetailsReplyDump v6Addresses() {
+ IpAddressDetailsReplyDump fullDump = new IpAddressDetailsReplyDump();
+ fullDump.ipAddressDetails = Arrays.asList(
+ addressDump(IPV6_ONE_BYTES, IPV6_ONE_PREFIX),
+ addressDump(IPV6_TWO_BYTES, IPV6_TWO_PREFIX));
+ return fullDump;
+ }
+
+ static IpNeighborDetails neighborDump(byte[] address, int isIpv6, byte[] mac) {
+ IpNeighborDetails detail = new IpNeighborDetails();
+ detail.ipAddress = address;
+ detail.isIpv6 = (byte) isIpv6;
+ detail.macAddress = mac;
+ return detail;
+ }
+
+ static IpAddressDetails addressDump(byte[] address, byte prefix) {
+ IpAddressDetails details = new IpAddressDetails();
+ details.ip = address;
+ details.prefixLength = prefix;
+ return details;
+ }
+}
* limitations under the License.
*/
-package io.fd.hc2vpp.v3po.interfacesstate.ip;
+package io.fd.hc2vpp.v3po.interfacesstate.ip.v4;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.when;
-
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.v4.Ipv4AddressCustomizer;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.InterfaceChildNodeTest;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import io.fd.honeycomb.translate.util.read.cache.CacheKeyFactory;
import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
import io.fd.vpp.jvpp.core.dto.IpAddressDump;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.stream.Collectors;
import org.hamcrest.Matchers;
import org.junit.Test;
import org.mockito.Mockito;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.address.subnet.PrefixLength;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.when;
+
public class Ipv4AddressCustomizerTest extends ListReaderCustomizerTest<Address, AddressKey, AddressBuilder> implements
- Ipv4Translator {
+ Ipv4Translator,InterfaceChildNodeTest {
+
- private static final String IFACE_NAME = "eth0";
- private static final String IFACE_2_NAME = "eth1";
- private static final int IFACE_ID = 1;
- private static final int IFACE_2_ID = 2;
private static final String IFC_CTX_NAME = "ifc-test-instance";
private NamingContext interfacesContext;
* limitations under the License.
*/
-package io.fd.hc2vpp.v3po.interfacesstate.ip;
-
-import static org.mockito.Mockito.verifyZeroInteractions;
+package io.fd.hc2vpp.v3po.interfacesstate.ip.v4;
import io.fd.hc2vpp.common.test.read.ReaderCustomizerTest;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.v4.Ipv4Customizer;
import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface2Builder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv4;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv4Builder;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
public class Ipv4CustomizerTest extends ReaderCustomizerTest<Ipv4, Ipv4Builder> {
public Ipv4CustomizerTest() {
--- /dev/null
+/*
+ * 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.v3po.interfacesstate.ip.v4;
+
+import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.InterfaceChildNodeTest;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import org.junit.Test;
+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.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface2;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.Neighbor;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.NeighborBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv4.NeighborKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class Ipv4NeighbourCustomizerTest extends ListReaderCustomizerTest<Neighbor, NeighborKey, NeighborBuilder>
+ implements InterfaceChildNodeTest {
+
+ private InstanceIdentifier<Neighbor> instanceIdentifier;
+
+ public Ipv4NeighbourCustomizerTest() {
+ super(Neighbor.class, Ipv4Builder.class);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ instanceIdentifier = InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class, new InterfaceKey(IFACE_NAME))
+ .augmentation(Interface2.class)
+ .child(Ipv4.class)
+ .child(Neighbor.class, new NeighborKey(IPV4_ONE_ADDRESS));
+ defineMapping(mappingContext, IFACE_NAME, IFACE_ID, INTERFACE_CONTEXT_NAME);
+ mockNeighborDump(api, dumpV4NeighborIfaceOne(), v4Neighbors());
+ }
+
+ @Test
+ public void testGetAll() throws ReadFailedException {
+ verifyList(Arrays.asList(new NeighborKey(IPV4_ONE_ADDRESS), new NeighborKey(IPV4_TWO_ADDRESS)),
+ getCustomizer().getAllIds(instanceIdentifier, ctx));
+ }
+
+ @Test
+ public void readCurrent() throws ReadFailedException {
+ final NeighborBuilder builder = new NeighborBuilder();
+ getCustomizer().readCurrentAttributes(instanceIdentifier, builder, ctx);
+
+ assertEquals(IPV4_ONE_ADDRESS, builder.getIp());
+ assertEquals(MAC_ONE_ADDRESS, builder.getLinkLayerAddress());
+ }
+
+ @Override
+ protected ReaderCustomizer<Neighbor, NeighborBuilder> initCustomizer() {
+ return new Ipv4NeighbourCustomizer(api, INTERFACE_CONTEXT);
+ }
+}
\ No newline at end of file
* limitations under the License.
*/
-package io.fd.hc2vpp.v3po.interfacesstate.ip;
-
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
+package io.fd.hc2vpp.v3po.interfacesstate.ip.v4.subinterface;
import com.google.common.collect.ImmutableSet;
import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
import io.fd.hc2vpp.common.translate.util.Ipv4Translator;
import io.fd.hc2vpp.common.translate.util.NamingContext;
-import io.fd.hc2vpp.v3po.interfacesstate.ip.v4.subinterface.SubInterfaceIpv4AddressCustomizer;
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer;
import io.fd.honeycomb.translate.util.read.cache.CacheKeyFactory;
import io.fd.honeycomb.translate.util.read.cache.TypeAwareIdentifierCacheKeyFactory;
import io.fd.vpp.jvpp.core.dto.IpAddressDetails;
import io.fd.vpp.jvpp.core.dto.IpAddressDetailsReplyDump;
-import java.util.Arrays;
-import java.util.List;
import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.address.subnet.PrefixLengthBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.*;
+
public class SubInterfaceIpv4AddressCustomizerTest extends ListReaderCustomizerTest<Address, AddressKey, AddressBuilder>
implements Ipv4Translator {
getCustomizer().getAllIds(getId(), ctx);
}
- @Test
- public void testCacheScope() {
-
- }
-
@Test
public void testCachingScopeSpecificRequest() throws ReadFailedException {
fillCacheForTwoIfaces();
--- /dev/null
+/*
+ * 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.v3po.interfacesstate.ip.v4.subinterface;
+
+import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.InterfaceChildNodeTest;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import org.junit.Test;
+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.vpp.vlan.rev161214.SubinterfaceStateAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.Neighbor;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.NeighborBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip4.attributes.ipv4.NeighborKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class SubInterfaceIpv4NeighbourCustomizerTest extends ListReaderCustomizerTest<Neighbor, NeighborKey, NeighborBuilder>
+ implements InterfaceChildNodeTest {
+
+ private InstanceIdentifier<Neighbor> instanceIdentifier;
+
+ public SubInterfaceIpv4NeighbourCustomizerTest() {
+ super(Neighbor.class, Ipv4Builder.class);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ instanceIdentifier = InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class, new InterfaceKey(IFACE_NAME))
+ .augmentation(SubinterfaceStateAugmentation.class)
+ .child(SubInterfaces.class)
+ .child(SubInterface.class, new SubInterfaceKey((long) SUB_IFACE_ID))
+ .child(Ipv4.class)
+ .child(Neighbor.class, new NeighborKey(IPV4_TWO_ADDRESS));
+
+ defineMapping(mappingContext, IFACE_NAME, IFACE_ID, INTERFACE_CONTEXT_NAME);
+ defineMapping(mappingContext, SUB_IFACE_NAME, SUB_IFACE_ID, INTERFACE_CONTEXT_NAME);
+ mockNeighborDump(api, dumpV4NeighborsSubIfaceOne(), v4Neighbors());
+ }
+
+ @Test
+ public void testGetAll() throws ReadFailedException {
+ verifyList(Arrays.asList(new NeighborKey(IPV4_ONE_ADDRESS), new NeighborKey(IPV4_TWO_ADDRESS)),
+ getCustomizer().getAllIds(instanceIdentifier, ctx));
+ }
+
+ @Test
+ public void testReadCurrent() throws ReadFailedException {
+ final NeighborBuilder neighborBuilder = new NeighborBuilder();
+ getCustomizer().readCurrentAttributes(instanceIdentifier, neighborBuilder, ctx);
+
+ assertEquals(MAC_TWO_ADDRESS, neighborBuilder.getLinkLayerAddress());
+ assertEquals(IPV4_TWO_ADDRESS, neighborBuilder.getIp());
+ }
+
+ @Override
+ protected ReaderCustomizer<Neighbor, NeighborBuilder> initCustomizer() {
+ return new SubInterfaceIpv4NeighbourCustomizer(api, INTERFACE_CONTEXT);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.v3po.interfacesstate.ip.v6;
+
+import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.InterfaceChildNodeTest;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import org.junit.Test;
+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.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface2;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv6Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv6.Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv6.AddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv6.AddressKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class Ipv6AddressCustomizerTest extends ListReaderCustomizerTest<Address, AddressKey, AddressBuilder>
+ implements InterfaceChildNodeTest {
+
+ private InstanceIdentifier<Address> instanceIdentifier;
+
+ public Ipv6AddressCustomizerTest() {
+ super(Address.class, Ipv6Builder.class);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ instanceIdentifier = InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class, new InterfaceKey(IFACE_2_NAME))
+ .augmentation(Interface2.class)
+ .child(Ipv6.class)
+ .child(Address.class, new AddressKey(IPV6_TWO_ADDRESS_COMPRESSED));
+ defineMapping(mappingContext, IFACE_2_NAME, IFACE_2_ID, INTERFACE_CONTEXT_NAME);
+ mockAddressDump(api, dumpV6AddressesIfaceTwo(), v6Addresses());
+ }
+
+ @Override
+ protected ReaderCustomizer<Address, AddressBuilder> initCustomizer() {
+ return new Ipv6AddressCustomizer(api, INTERFACE_CONTEXT);
+ }
+
+ @Test
+ public void testGetAll() throws ReadFailedException {
+ verifyList(Arrays.asList(
+ new AddressKey(IPV6_ONE_ADDRESS_COMPRESSED), new AddressKey(IPV6_TWO_ADDRESS_COMPRESSED)),
+ getCustomizer().getAllIds(instanceIdentifier, ctx));
+ }
+
+ @Test
+ public void testReadCurrent() throws ReadFailedException {
+ AddressBuilder builder = new AddressBuilder();
+ getCustomizer().readCurrentAttributes(instanceIdentifier, builder, ctx);
+
+ assertEquals(IPV6_TWO_ADDRESS_COMPRESSED, builder.getIp());
+ assertEquals(IPV6_TWO_PREFIX, builder.getPrefixLength().longValue());
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.v3po.interfacesstate.ip.v6;
+
+import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.InterfaceChildNodeTest;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import org.junit.Test;
+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.ietf.params.xml.ns.yang.ietf.ip.rev140616.Interface2;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.Ipv6Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv6.Neighbor;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv6.NeighborBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.ip.rev140616.interfaces.state._interface.ipv6.NeighborKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+
+public class Ipv6NeighbourCustomizerTest extends ListReaderCustomizerTest<Neighbor, NeighborKey, NeighborBuilder>
+ implements InterfaceChildNodeTest {
+
+ private InstanceIdentifier<Neighbor> instanceIdentifier;
+
+ public Ipv6NeighbourCustomizerTest() {
+ super(Neighbor.class, Ipv6Builder.class);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ instanceIdentifier = InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class, new InterfaceKey(IFACE_NAME))
+ .augmentation(Interface2.class)
+ .child(Ipv6.class)
+ .child(Neighbor.class, new NeighborKey(IPV6_ONE_ADDRESS_COMPRESSED));
+ defineMapping(mappingContext, IFACE_NAME, IFACE_ID, INTERFACE_CONTEXT_NAME);
+ mockNeighborDump(api, dumpV6NeighborsIfaceOne(), v6Neighbors());
+ }
+
+ @Test
+ public void testGetAll() throws ReadFailedException {
+ verifyList(Arrays.asList(
+ new NeighborKey(IPV6_ONE_ADDRESS_COMPRESSED),
+ new NeighborKey(IPV6_TWO_ADDRESS_COMPRESSED)),
+ getCustomizer().getAllIds(instanceIdentifier, ctx));
+ }
+
+ @Test
+ public void readCurrent() throws ReadFailedException {
+ final NeighborBuilder builder = new NeighborBuilder();
+ getCustomizer().readCurrentAttributes(instanceIdentifier, builder, ctx);
+
+ assertEquals(IPV6_ONE_ADDRESS_COMPRESSED, builder.getIp());
+ assertEquals(MAC_THREE_ADDRESS, builder.getLinkLayerAddress());
+ }
+
+ @Override
+ protected ReaderCustomizer<Neighbor, NeighborBuilder> initCustomizer() {
+ return new Ipv6NeighbourCustomizer(api, INTERFACE_CONTEXT);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.v3po.interfacesstate.ip.v6.subinterface;
+
+import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.InterfaceChildNodeTest;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import org.junit.Test;
+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.vpp.vlan.rev161214.SubinterfaceStateAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.Ipv6Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.ipv6.Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.ipv6.AddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.ipv6.AddressKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import java.util.Arrays;
+
+public class SubInterfaceIpv6AddressCustomizerTest extends ListReaderCustomizerTest<Address, AddressKey, AddressBuilder>
+ implements InterfaceChildNodeTest {
+
+ private InstanceIdentifier<Address> instanceIdentifier;
+
+ public SubInterfaceIpv6AddressCustomizerTest() {
+ super(Address.class, Ipv6Builder.class);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ instanceIdentifier = InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class, new InterfaceKey(IFACE_NAME))
+ .augmentation(SubinterfaceStateAugmentation.class)
+ .child(SubInterfaces.class)
+ .child(SubInterface.class, new SubInterfaceKey((long) SUB_IFACE_ID))
+ .child(Ipv6.class)
+ .child(Address.class, new AddressKey(IPV6_TWO_ADDRESS_COMPRESSED));
+
+ defineMapping(mappingContext, IFACE_NAME, IFACE_ID, INTERFACE_CONTEXT_NAME);
+ defineMapping(mappingContext, SUB_IFACE_NAME, SUB_IFACE_ID, INTERFACE_CONTEXT_NAME);
+ mockAddressDump(api, dumpV6AddressesSubIfaceOne(), v6Addresses());
+ }
+
+ @Test
+ public void testGetAll() throws ReadFailedException {
+ verifyList(Arrays.asList(
+ new AddressKey(IPV6_ONE_ADDRESS_COMPRESSED), new AddressKey(IPV6_TWO_ADDRESS_COMPRESSED)),
+ getCustomizer().getAllIds(instanceIdentifier, ctx));
+ }
+
+ @Override
+ protected ReaderCustomizer<Address, AddressBuilder> initCustomizer() {
+ return new SubInterfaceIpv6AddressCustomizer(api, INTERFACE_CONTEXT);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * 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.v3po.interfacesstate.ip.v6.subinterface;
+
+import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest;
+import io.fd.hc2vpp.v3po.interfacesstate.ip.InterfaceChildNodeTest;
+import io.fd.honeycomb.translate.read.ReadFailedException;
+import io.fd.honeycomb.translate.spi.read.ReaderCustomizer;
+import org.junit.Test;
+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.vpp.vlan.rev161214.SubinterfaceStateAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.SubInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.interfaces.state._interface.sub.interfaces.SubInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.Ipv6;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.Ipv6Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.ipv6.Neighbor;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.ipv6.NeighborBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.vpp.vlan.rev161214.sub._interface.ip6.attributes.ipv6.NeighborKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import java.util.Arrays;
+
+import static org.junit.Assert.assertEquals;
+
+public class SubInterfaceIpv6NeighbourCustomizerTest extends ListReaderCustomizerTest<Neighbor, NeighborKey, NeighborBuilder>
+ implements InterfaceChildNodeTest {
+
+ private InstanceIdentifier<Neighbor> instanceIdentifier;
+
+ public SubInterfaceIpv6NeighbourCustomizerTest() {
+ super(Neighbor.class, Ipv6Builder.class);
+ }
+
+ @Override
+ protected void setUp() throws Exception {
+ instanceIdentifier = InstanceIdentifier.create(InterfacesState.class)
+ .child(Interface.class, new InterfaceKey(IFACE_2_NAME))
+ .augmentation(SubinterfaceStateAugmentation.class)
+ .child(SubInterfaces.class)
+ .child(SubInterface.class, new SubInterfaceKey((long) SUB_IFACE_2_ID))
+ .child(Ipv6.class)
+ .child(Neighbor.class, new NeighborKey(IPV6_TWO_ADDRESS_COMPRESSED));
+ defineMapping(mappingContext, IFACE_2_NAME, IFACE_2_ID, INTERFACE_CONTEXT_NAME);
+ defineMapping(mappingContext, SUB_IFACE_2_NAME, SUB_IFACE_2_ID, INTERFACE_CONTEXT_NAME);
+ mockNeighborDump(api, dumpV6NeighborsSubIfaceTwo(), v6Neighbors());
+ }
+
+ @Test
+ public void testGetAll() throws ReadFailedException {
+ verifyList(Arrays.asList(
+ new NeighborKey(IPV6_ONE_ADDRESS_COMPRESSED),
+ new NeighborKey(IPV6_TWO_ADDRESS_COMPRESSED)),
+ getCustomizer().getAllIds(instanceIdentifier, ctx));
+ }
+
+ @Test
+ public void readCurrent() throws ReadFailedException {
+ NeighborBuilder builder = new NeighborBuilder();
+ getCustomizer().readCurrentAttributes(instanceIdentifier, builder, ctx);
+
+ assertEquals(IPV6_TWO_ADDRESS_COMPRESSED, builder.getIp());
+ assertEquals(MAC_FOUR_ADDRESS, builder.getLinkLayerAddress());
+ }
+
+ @Override
+ protected ReaderCustomizer<Neighbor, NeighborBuilder> initCustomizer() {
+ return new SubInterfaceIpv6NeighbourCustomizer(api, INTERFACE_CONTEXT);
+ }
+}
\ No newline at end of file
package io.fd.hc2vpp.common.translate.util;
-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 com.google.common.net.InetAddresses;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.*;
+
+import javax.annotation.Nonnull;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
-import javax.annotation.Nonnull;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+
+import static com.google.common.base.Preconditions.*;
/**
* Trait providing logic for translation of ipv6-related data
/**
* Detects whether {@code IpAddress} is ipv6
*/
- default boolean isIpv6(IpAddress address) {
- checkNotNull(address, "Address cannot be null");
-
+ default boolean isIpv6(@Nonnull final IpAddress address) {
checkState(!(address.getIpv4Address() == null && address.getIpv6Address() == null), "Invalid address");
return address.getIpv6Address() != null;
}
/**
* Detects whether {@code IpPrefix} is ipv6
*/
- default boolean isIpv6(IpPrefix address) {
- checkNotNull(address, "Address cannot be null");
+ default boolean isIpv6(@Nonnull final IpPrefix address) {
checkState(!(address.getIpv4Prefix() == null && address.getIpv6Prefix() == null), "Invalid address");
return address.getIpv6Prefix() != null;
}
package io.fd.hc2vpp.common.translate.util;
-import static com.google.common.base.Preconditions.checkArgument;
-
import io.fd.honeycomb.translate.read.ReadFailedException;
import io.fd.honeycomb.translate.write.WriteFailedException;
import io.fd.vpp.jvpp.VppBaseCallException;
import io.fd.vpp.jvpp.dto.JVppReply;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import javax.annotation.Nonnegative;
-import javax.annotation.Nonnull;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import static com.google.common.base.Preconditions.checkArgument;
/**
* Trait providing logic for consuming reply's to jvpp api calls
int DEFAULT_TIMEOUT_IN_SECONDS = 5;
+ JvppReplyConsumer INSTANCE = new JvppReplyConsumer() {
+ };
+
/**
* Consumes reply for jvpp call representing any write operation
* Should be used in case of calls where it's not clear which write crud operation respective
package io.fd.hc2vpp.common.translate.util;
-import static org.junit.Assert.assertEquals;
-
import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix;
+import static org.junit.Assert.*;
+
public class Ipv6TranslatorTest implements Ipv6Translator {
+ private static final byte[] IPV6_BYTES = {32, 1, 13, -72, 10, 11, 18, -16, 0, 0, 0, 0, 0, 0, 0, 1};
+ private static final String IPV6_FULL = "2001:0db8:0a0b:12f0:0000:0000:0000:0001";
+ private static final String IPV6_COMPRESSED = "2001:db8:a0b:12f0::1";
+
+ @Test
+ public void testIpv6AddressNoZoneToArrayFull() throws Exception {
+ assertArrayEquals(IPV6_BYTES, ipv6AddressNoZoneToArray(new Ipv6Address(IPV6_FULL)));
+ }
+
+ @Test
+ public void testIpv6AddressNoZoneToArrayCompressed() throws Exception {
+ assertArrayEquals(IPV6_BYTES, ipv6AddressNoZoneToArray(new Ipv6Address(IPV6_COMPRESSED)));
+ }
+
+ @Test
+ public void testIpv6AddressPrefixToArrayFull() throws Exception {
+ assertArrayEquals(IPV6_BYTES, ipv6AddressPrefixToArray(new Ipv6Prefix(IPV6_FULL + "/64")));
+ }
+
+ @Test
+ public void testIpv6AddressPrefixToArrayCompressed() throws Exception {
+ assertArrayEquals(IPV6_BYTES, ipv6AddressPrefixToArray(new Ipv6Prefix(IPV6_COMPRESSED + "/64")));
+ }
+
+ @Test
+ public void testExtractPrefixFull() throws Exception {
+ assertEquals(64, extractPrefix(new Ipv6Prefix(IPV6_FULL + "/64")));
+ }
+
+ @Test
+ public void testExtractPrefixCompressed() throws Exception {
+ assertEquals(64, extractPrefix(new Ipv6Prefix(IPV6_COMPRESSED + "/64")));
+ }
+
+ @Test
+ public void testArrayToIpv6Prefix() throws Exception {
+ assertEquals(IPV6_COMPRESSED + "/64", arrayToIpv6Prefix(IPV6_BYTES, (byte) 64).getValue());
+ }
+
+ @Test
+ public void testArrayToIpv6AddressNoZone() throws Exception {
+ assertEquals(IPV6_COMPRESSED, arrayToIpv6AddressNoZone(IPV6_BYTES).getValue());
+ }
+
+ @Test
+ public void testIsIpv6Compressed() throws Exception {
+ assertTrue(isIpv6(new IpAddress(new Ipv6Address(IPV6_COMPRESSED))));
+ }
+
+ @Test
+ public void testIsIpv6Full() throws Exception {
+ assertTrue(isIpv6(new IpAddress(new Ipv6Address(IPV6_FULL))));
+ }
+
+ @Test
+ public void testTruncateIp4Array() throws Exception {
+ assertArrayEquals(new byte[]{-64, -84, 2, 1}, truncateIp4Array(new byte[]{-64, -84, 2, 1, 0, 0, 0, 0}));
+ }
+
@Test
public void testIpv6NoZone() {
final Ipv6AddressNoZone ipv6Addr = new Ipv6AddressNoZone("3ffe:1900:4545:3:200:f8ff:fe21:67cf");
Code Review / hc2vpp.git / commitdiff