diff options
Diffstat (limited to 'vpp-common')
22 files changed, 939 insertions, 759 deletions
diff --git a/vpp-common/minimal-distribution/pom.xml b/vpp-common/minimal-distribution/pom.xml index 17d8a22a7..12d11ec1a 100644 --- a/vpp-common/minimal-distribution/pom.xml +++ b/vpp-common/minimal-distribution/pom.xml @@ -97,7 +97,7 @@ </dependency> <dependency> <groupId>org.mockito</groupId> - <artifactId>mockito-all</artifactId> + <artifactId>mockito-core</artifactId> <scope>test</scope> </dependency> <dependency> diff --git a/vpp-common/vpp-translate-test/pom.xml b/vpp-common/vpp-translate-test/pom.xml index 0fb5fb192..bef9a3014 100644 --- a/vpp-common/vpp-translate-test/pom.xml +++ b/vpp-common/vpp-translate-test/pom.xml @@ -45,7 +45,7 @@ </dependency> <dependency> <groupId>org.mockito</groupId> - <artifactId>mockito-all</artifactId> + <artifactId>mockito-core</artifactId> <version>1.9.5</version> <scope>compile</scope> </dependency> diff --git a/vpp-common/vpp-translate-test/src/main/java/io/fd/honeycomb/vpp/test/read/ReaderCustomizerTest.java b/vpp-common/vpp-translate-test/src/main/java/io/fd/honeycomb/vpp/test/read/ReaderCustomizerTest.java index 4c6810925..3637ee2c8 100644 --- a/vpp-common/vpp-translate-test/src/main/java/io/fd/honeycomb/vpp/test/read/ReaderCustomizerTest.java +++ b/vpp-common/vpp-translate-test/src/main/java/io/fd/honeycomb/vpp/test/read/ReaderCustomizerTest.java @@ -22,6 +22,8 @@ import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.ModificationCache; import io.fd.honeycomb.translate.read.ReadContext; import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; import io.fd.honeycomb.vpp.test.util.FutureProducer; import org.junit.Before; import org.junit.Test; diff --git a/vpp-common/vpp-translate-utils/pom.xml b/vpp-common/vpp-translate-utils/pom.xml index e8c4d12e2..3b61f5cdf 100644 --- a/vpp-common/vpp-translate-utils/pom.xml +++ b/vpp-common/vpp-translate-utils/pom.xml @@ -78,7 +78,7 @@ </dependency> <dependency> <groupId>org.mockito</groupId> - <artifactId>mockito-all</artifactId> + <artifactId>mockito-core</artifactId> <scope>test</scope> </dependency> <dependency> diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/AbstractInterfaceTypeCustomizer.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/AbstractInterfaceTypeCustomizer.java index dd66f7225..35eb1ad40 100644 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/AbstractInterfaceTypeCustomizer.java +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/AbstractInterfaceTypeCustomizer.java @@ -35,7 +35,7 @@ import org.openvpp.jvpp.core.future.FutureJVppCore; * Validates the type of interface. */ public abstract class AbstractInterfaceTypeCustomizer<D extends DataObject> - extends FutureJVppCustomizer implements WriterCustomizer<D> { + extends FutureJVppCustomizer implements WriterCustomizer<D> { protected AbstractInterfaceTypeCustomizer(final FutureJVppCore futureJVppCore) { super(futureJVppCore); @@ -46,13 +46,13 @@ public abstract class AbstractInterfaceTypeCustomizer<D extends DataObject> final InstanceIdentifier<Interface> ifcTypeFromIid = id.firstIdentifierOf(Interface.class); checkArgument(ifcTypeFromIid != null, "Instance identifier does not contain {} type", Interface.class); checkArgument(id.firstKeyOf(Interface.class) != null, "Instance identifier does not contain keyed {} type", - Interface.class); + Interface.class); final Optional<Interface> interfaceConfig = writeContext.readAfter(ifcTypeFromIid); checkState(interfaceConfig.isPresent(), - "Unable to get Interface configuration for an interface: %s currently being updated", ifcTypeFromIid); + "Unable to get Interface configuration for an interface: %s currently being updated", ifcTypeFromIid); IllegalInterfaceTypeException - .checkInterfaceType(interfaceConfig.get(), getExpectedInterfaceType()); + .checkInterfaceType(interfaceConfig.get(), getExpectedInterfaceType()); } protected abstract Class<? extends InterfaceType> getExpectedInterfaceType(); @@ -62,14 +62,14 @@ public abstract class AbstractInterfaceTypeCustomizer<D extends DataObject> */ @Override public final void writeCurrentAttributes(@Nonnull final InstanceIdentifier<D> id, @Nonnull final D dataAfter, - @Nonnull final WriteContext writeContext) throws WriteFailedException { + @Nonnull final WriteContext writeContext) throws WriteFailedException { checkProperInterfaceType(writeContext, id); writeInterface(id, dataAfter, writeContext); } protected abstract void writeInterface(final InstanceIdentifier<D> id, final D dataAfter, final WriteContext writeContext) - throws WriteFailedException; + throws WriteFailedException; // Validation for update and delete is not necessary @@ -91,8 +91,8 @@ public abstract class AbstractInterfaceTypeCustomizer<D extends DataObject> @Nonnull final Class<? extends InterfaceType> expectedType) { if (ifc.getType() == null || !expectedType.equals(ifc.getType())) { throw new IllegalInterfaceTypeException(String.format( - "Unexpected interface type: %s for interface: %s. Expected interface is: %s", ifc.getType(), - ifc.getName(), expectedType)); + "Unexpected interface type: %s for interface: %s. Expected interface is: %s", ifc.getType(), + ifc.getName(), expectedType)); } } diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/AddressTranslator.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/AddressTranslator.java new file mode 100644 index 000000000..d68331ca8 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/AddressTranslator.java @@ -0,0 +1,57 @@ +package io.fd.honeycomb.translate.v3po.util; + +import static com.google.common.base.Preconditions.checkNotNull; + +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.Ipv4Address; +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.Ipv6Address; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone; + +/** + * Aggregation trait providing logic for converting address based data + */ +public interface AddressTranslator extends Ipv4Translator, Ipv6Translator, MacTranslator { + + default byte[] ipAddressToArray(IpAddress address) { + checkNotNull(address, "Cannot resolve null adddress"); + + if (isIpv6(address)) { + return ipv6AddressNoZoneToArray(new Ipv6AddressNoZone(address.getIpv6Address())); + } else { + return ipv4AddressNoZoneToArray(new Ipv4AddressNoZone(address.getIpv4Address())); + } + } + + + /** + * Converts {@link IpAddress} to array representing {@link Ipv4Address} or {@link Ipv6Address} + */ + default byte[] ipAddressToArray(boolean isIpv6, @Nonnull IpAddress address) { + checkNotNull(address, "Cannot convert null Address"); + + if (isIpv6) { + return ipv6AddressNoZoneToArray(new Ipv6AddressNoZone(address.getIpv6Address())); + } else { + return ipv4AddressNoZoneToArray(new Ipv4AddressNoZone(address.getIpv4Address())); + } + } + + /** + * Converts array bytes to {@link IpAddress} + */ + @Nonnull + default IpAddress arrayToIpAddress(boolean isIpv6, byte[] ip) { + if (isIpv6) { + return new IpAddress(arrayToIpv6AddressNoZone(ip)); + } else { + return new IpAddress(arrayToIpv4AddressNoZone(ip)); + } + } + + default IpAddress reverseAddress(@Nonnull final IpAddress address) { + //arrayToIpAdddress internaly reverts order + return arrayToIpAddress(isIpv6(address), ipAddressToArray(address)); + } +} diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/ByteDataTranslator.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/ByteDataTranslator.java new file mode 100644 index 000000000..fedc3e5d2 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/ByteDataTranslator.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.translate.v3po.util; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + +/** + * Trait providing logic for working with binary-based data + */ +public interface ByteDataTranslator { + + /** + * Returns 0 if argument is null or false, 1 otherwise. + * + * @param value Boolean value to be converted + * @return byte value equal to 0 or 1 + */ + default byte booleanToByte(@Nullable final Boolean value) { + return value != null && value + ? (byte) 1 + : (byte) 0; + } + + /** + * Returns Boolean.TRUE if argument is 0, Boolean.FALSE otherwise. + * + * @param value byte value to be converted + * @return Boolean value + * @throws IllegalArgumentException if argument is neither 0 nor 1 + */ + @Nonnull + default Boolean byteToBoolean(final byte value) { + if (value == 0) { + return Boolean.FALSE; + } else if (value == 1) { + return Boolean.TRUE; + } + throw new IllegalArgumentException(String.format("0 or 1 was expected but was %d", value)); + } + + /** + * Reverses bytes in the byte array + * + * @param bytes input array + * @return reversed array + */ + default byte[] reverseBytes(final byte[] bytes) { + final byte[] reversed = new byte[bytes.length]; + int i = 1; + for (byte aByte : bytes) { + reversed[bytes.length - i++] = aByte; + } + + return reversed; + } + + /** + * Return (interned) string from byte array while removing \u0000. Strings represented as fixed length byte[] from + * vpp contain \u0000. + */ + default String toString(final byte[] cString) { + return new String(cString).replaceAll("\\u0000", "").intern(); + } +} diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/FutureJVppCustomizer.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/FutureJVppCustomizer.java index d0379e7d2..76e7b3316 100644 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/FutureJVppCustomizer.java +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/FutureJVppCustomizer.java @@ -18,9 +18,8 @@ package io.fd.honeycomb.translate.v3po.util; import com.google.common.annotations.Beta; import com.google.common.base.Preconditions; -import org.openvpp.jvpp.core.future.FutureJVppCore; - import javax.annotation.Nonnull; +import org.openvpp.jvpp.core.future.FutureJVppCore; /** * Abstract utility to hold the vppApi reference. diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/Ipv4Translator.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/Ipv4Translator.java new file mode 100644 index 000000000..ebebf60dd --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/Ipv4Translator.java @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.translate.v3po.util; + +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.net.InetAddresses; +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.Ipv4AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix; + +/** + * Trait providing logic for translation of ipv4-related data + */ +public interface Ipv4Translator extends ByteDataTranslator { + + /** + * Creates address array from address part of {@link Ipv4Prefix} + */ + default byte[] ipv4AddressPrefixToArray(@Nonnull final Ipv4Prefix ipv4Prefix) { + checkNotNull(ipv4Prefix, "Cannot convert null prefix"); + + byte[] retval = new byte[4]; + String[] address = ipv4Prefix.getValue().substring(0, ipv4Prefix.getValue().indexOf('/')).split("\\."); + + for (int d = 0; d < 4; d++) { + retval[d] = (byte) (Short.parseShort(address[d]) & 0xff); + } + return retval; + } + + /** + * Extracts {@link Ipv4Prefix} prefix + */ + default byte extractPrefix(Ipv4Prefix data) { + checkNotNull(data, "Cannot extract from null"); + + return Byte.valueOf(data.getValue().substring(data.getValue().indexOf('/') + 1)); + } + + /** + * Converts byte array to {@link Ipv4Prefix} with specified prefixLength + */ + default Ipv4Prefix arrayToIpv4Prefix(final byte[] address, byte prefixLength) { + Ipv4AddressNoZone addressPart = arrayToIpv4AddressNoZone(address); + + return new Ipv4Prefix(addressPart.getValue().concat("/").concat(String.valueOf(prefixLength))); + } + + /** + * Parse byte array returned by VPP representing an Ipv4 address. Vpp returns IP byte arrays in reversed order. + * + * @return Ipv4AddressNoZone containing string representation of IPv4 address constructed from submitted bytes. No + * change in order. + */ + @Nonnull + default Ipv4AddressNoZone arrayToIpv4AddressNoZone(@Nonnull byte[] ip) { + // VPP sends ipv4 in a 16 byte array + if (ip.length == 16) { + ip = Arrays.copyOfRange(ip, 0, 4); + } + try { + // Not reversing the byte array here!! because the IP coming from VPP is in reversed byte order + // compared to byte order it was submitted + return new Ipv4AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip))); + } catch (UnknownHostException e) { + throw new IllegalArgumentException("Unable to parse ipv4", e); + } + } + + /** + * Parse byte array returned by VPP representing an Ipv4 address. Vpp returns IP byte arrays in reversed order. + * + * @return Ipv4AddressNoZone containing string representation of IPv4 address constructed from submitted bytes. No + * change in order. + */ + @Nonnull + default Ipv4AddressNoZone arrayToIpv4AddressNoZoneReversed(@Nonnull byte[] ip) { + // VPP sends ipv4 in a 16 byte array + + if (ip.length == 16) { + ip = Arrays.copyOfRange(ip, 0, 4); + } + + ip = reverseBytes(ip); + + try { + // Not reversing the byte array here!! because the IP coming from VPP is in reversed byte order + // compared to byte order it was submitted + return new Ipv4AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip))); + } catch (UnknownHostException e) { + throw new IllegalArgumentException("Unable to parse ipv4", e); + } + } + + + /** + * Transform Ipv4 address to a byte array acceptable by VPP. VPP expects incoming byte array to be in the same order + * as the address. + * + * @return byte array with address bytes + */ + default byte[] ipv4AddressNoZoneToArray(final Ipv4AddressNoZone ipv4Addr) { + return ipv4AddressNoZoneToArray(ipv4Addr.getValue()); + } + + default byte[] ipv4AddressNoZoneToArray(final String ipv4Addr) { + byte[] retval = new byte[4]; + String[] dots = ipv4Addr.split("\\."); + + for (int d = 0; d < 4; d++) { + retval[d] = (byte) (Short.parseShort(dots[d]) & 0xff); + } + return retval; + } +} diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/Ipv6Translator.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/Ipv6Translator.java new file mode 100644 index 000000000..6be7a5f24 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/Ipv6Translator.java @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.translate.v3po.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 java.net.UnknownHostException; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import javax.annotation.Nonnull; +import org.apache.commons.lang3.StringUtils; +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; + +/** + * Trait providing logic for translation of ipv6-related data + */ +public interface Ipv6Translator extends ByteDataTranslator { + + /** + * Transform Ipv6 address to a byte array acceptable by VPP. VPP expects incoming byte array to be in the same order + * as the address. + * + * @return byte array with address bytes + */ + default byte[] ipv6AddressNoZoneToArray(@Nonnull final Ipv6AddressNoZone ipv6Addr) { + byte[] retval = new byte[16]; + + //splits address and add ommited zeros for easier parsing + List<String> segments = Arrays.asList(ipv6Addr.getValue().split(":")) + .stream() + .map(segment -> StringUtils.repeat('0', 4 - segment.length()) + segment) + .collect(Collectors.toList()); + + byte index = 0; + for (String segment : segments) { + + String firstPart = segment.substring(0, 2); + String secondPart = segment.substring(2); + + //first part should be ommited + if ("00".equals(firstPart)) { + index++; + } else { + retval[index++] = ((byte) Short.parseShort(firstPart, 16)); + } + + retval[index++] = ((byte) Short.parseShort(secondPart, 16)); + } + + return retval; + } + + /** + * Creates address array from address part of {@link Ipv6Prefix} + */ + default byte[] ipv6AddressPrefixToArray(@Nonnull final Ipv6Prefix ipv4Prefix) { + checkNotNull(ipv4Prefix, "Cannot convert null prefix"); + + return ipv6AddressNoZoneToArray(new Ipv6AddressNoZone( + new Ipv6Address(ipv4Prefix.getValue().substring(0, ipv4Prefix.getValue().indexOf('/'))))); + } + + /** + * Extracts {@link Ipv6Prefix} prefix + */ + default byte extractPrefix(Ipv6Prefix data) { + checkNotNull(data, "Cannot extract from null"); + + return Byte.valueOf(data.getValue().substring(data.getValue().indexOf('/') + 1)); + } + + /** + * Converts byte array to {@link Ipv6Prefix} with specified prefixLength + */ + default Ipv6Prefix arrayToIpv6Prefix(final byte[] address, byte prefixLength) { + Ipv6AddressNoZone addressPart = arrayToIpv6AddressNoZone(address); + + return new Ipv6Prefix(addressPart.getValue().concat("/").concat(String.valueOf(prefixLength))); + } + + /** + * Parse byte array returned by VPP representing an Ipv6 address. Vpp returns IP byte arrays in reversed order. + * + * @return Ipv46ddressNoZone containing string representation of IPv6 address constructed from submitted bytes. No + * change in order. + */ + @Nonnull + default Ipv6AddressNoZone arrayToIpv6AddressNoZone(@Nonnull byte[] ip) { + checkArgument(ip.length == 16, "Illegal array length"); + + try { + return new Ipv6AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip))); + } catch (UnknownHostException e) { + throw new IllegalArgumentException("Unable to parse ipv6", e); + } + } + + /** + * Detects whether {@code IpAddress} is ipv6 + */ + default boolean isIpv6(IpAddress address) { + checkNotNull(address, "Address cannot be null"); + + checkState(!(address.getIpv4Address() == null && address.getIpv6Address() == null), "Invalid address"); + return address.getIpv6Address() != null; + } + + /** + * Parse byte array returned by VPP representing an Ipv6 address. Vpp returns IP byte arrays in natural order. + * + * @return Ipv46ddressNoZone containing string representation of IPv6 address constructed from submitted bytes. No + * change in order. + */ + @Nonnull + default Ipv6AddressNoZone arrayToIpv6AddressNoZoneReversed(@Nonnull byte[] ip) { + checkArgument(ip.length == 16, "Illegal array length"); + + ip = reverseBytes(ip); + + try { + return new Ipv6AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip))); + } catch (UnknownHostException e) { + throw new IllegalArgumentException("Unable to parse ipv6", e); + } + } + + + /** + * Detects whether {@code IpPrefix} is ipv6 + */ + default boolean isIpv6(IpPrefix address) { + checkNotNull(address, "Address cannot be null"); + checkState(!(address.getIpv4Prefix() == null && address.getIpv6Prefix() == null), "Invalid address"); + return address.getIpv6Prefix() != null; + } +} diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/JvppReplyConsumer.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/JvppReplyConsumer.java new file mode 100644 index 000000000..bf62ecd61 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/JvppReplyConsumer.java @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.translate.v3po.util; + +import static com.google.common.base.Preconditions.checkArgument; + +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.InstanceIdentifier; +import org.openvpp.jvpp.VppBaseCallException; +import org.openvpp.jvpp.dto.JVppReply; + +/** + * Trait providing logic for consuming reply's to jvpp api calls + */ +public interface JvppReplyConsumer { + + int DEFAULT_TIMEOUT_IN_SECONDS = 5; + + default <REP extends JVppReply<?>> REP getReplyForWrite(@Nonnull Future<REP> future, + @Nonnull final InstanceIdentifier<?> replyType) + throws VppBaseCallException, WriteTimeoutException { + return getReplyForWrite(future, replyType, DEFAULT_TIMEOUT_IN_SECONDS); + } + + default <REP extends JVppReply<?>> REP getReplyForWrite(@Nonnull Future<REP> future, + @Nonnull final InstanceIdentifier<?> replyType, + @Nonnegative final int timeoutInSeconds) + throws VppBaseCallException, WriteTimeoutException { + try { + return getReply(future, timeoutInSeconds); + } catch (TimeoutException e) { + throw new WriteTimeoutException(replyType, e); + } + } + + default <REP extends JVppReply<?>> REP getReplyForRead(@Nonnull Future<REP> future, + @Nonnull final InstanceIdentifier<?> replyType) + throws VppBaseCallException, ReadTimeoutException { + return getReplyForRead(future, replyType, DEFAULT_TIMEOUT_IN_SECONDS); + } + + default <REP extends JVppReply<?>> REP getReplyForRead(@Nonnull Future<REP> future, + @Nonnull final InstanceIdentifier<?> replyType, + @Nonnegative final int timeoutInSeconds) + throws VppBaseCallException, ReadTimeoutException { + try { + return getReply(future, timeoutInSeconds); + } catch (TimeoutException e) { + throw new ReadTimeoutException(replyType, e); + } + } + + default <REP extends JVppReply<?>> REP getReply(@Nonnull Future<REP> future) + throws TimeoutException, VppBaseCallException { + return getReply(future, DEFAULT_TIMEOUT_IN_SECONDS); + } + + default <REP extends JVppReply<?>> REP getReply(@Nonnull Future<REP> future, + @Nonnegative final int timeoutInSeconds) + throws TimeoutException, VppBaseCallException { + try { + checkArgument(timeoutInSeconds > 0, "Timeout cannot be < 0"); + return future.get(timeoutInSeconds, TimeUnit.SECONDS); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new IllegalStateException("Interrupted", e); + } catch (ExecutionException e) { + // Execution exception could generally contains any exception + // when using exceptions instead of return codes just rethrow it for processing on corresponding place + if (e instanceof ExecutionException && (e.getCause() instanceof VppBaseCallException)) { + throw (VppBaseCallException) (e.getCause()); + } + throw new IllegalStateException(e); + } + } +} diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/MacTranslator.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/MacTranslator.java new file mode 100644 index 000000000..f18a122f2 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/MacTranslator.java @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.translate.v3po.util; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkNotNull; + +import com.google.common.base.Splitter; +import java.util.List; +import java.util.function.BiConsumer; +import javax.annotation.Nonnull; +import org.apache.commons.codec.DecoderException; +import org.apache.commons.codec.binary.Hex; + +/** + * Trait providing logic for translation of ipv4-related data + */ +public interface MacTranslator { + + Splitter COLON_SPLITTER = Splitter.on(':'); + + /** + * Parse string represented mac address (using ":" as separator) into a byte array + */ + @Nonnull + default byte[] parseMac(@Nonnull final String macAddress) { + final List<String> parts = COLON_SPLITTER.splitToList(macAddress); + checkArgument(parts.size() == 6, "Mac address is expected to have 6 parts but was: %s", macAddress); + return parseMacLikeString(parts); + } + + default byte[] parseMacLikeString(final List<String> strings) { + return strings.stream().limit(6).map(this::parseHexByte).collect( + () -> new byte[strings.size()], + new BiConsumer<byte[], Byte>() { + + private int i = -1; + + @Override + public void accept(final byte[] bytes, final Byte aByte) { + bytes[++i] = aByte; + } + }, + (bytes, bytes2) -> { + throw new UnsupportedOperationException("Parallel collect not supported"); + }); + } + + /** + * Converts byte array to address string ,not separated with ":" + */ + default String byteArrayToMacUnseparated(byte[] address) { + checkArgument(address.length == 6, "Illegal array length"); + return Hex.encodeHexString(address); + } + + /** + * Converts byte array to address string ,separated with ":" + */ + default String byteArrayToMacSeparated(byte[] address) { + checkArgument(address.length == 6, "Illegal array length"); + + String unseparatedAddress = Hex.encodeHexString(address); + String separated = ""; + + for (int i = 0; i < unseparatedAddress.length(); i = i + 2) { + if (i == (unseparatedAddress.length() - 2)) { + separated = separated + unseparatedAddress.substring(0 + i, 2 + i); + } else { + separated = separated + unseparatedAddress.substring(0 + i, 2 + i) + ":"; + } + } + + return separated; + } + + /** + * Converts MAC string to byte array + */ + default byte[] macToByteArray(String mac) { + checkNotNull(mac, "MAC cannot be null"); + + mac = mac.replace(":", ""); + + try { + return Hex.decodeHex(mac.toCharArray()); + } catch (DecoderException e) { + throw new IllegalArgumentException("Unable to convert mac", e); + } + } + + default byte parseHexByte(final String aByte) { + return (byte) Integer.parseInt(aByte, 16); + } +} diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/NamingContext.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/NamingContext.java index ead59a803..056a6df2c 100644 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/NamingContext.java +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/NamingContext.java @@ -39,32 +39,31 @@ import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; */ public final class NamingContext implements AutoCloseable { + private static final Collector<Mapping, ?, Mapping> SINGLE_ITEM_COLLECTOR = RWUtils.singleItemCollector(); private final String artificialNamePrefix; private final KeyedInstanceIdentifier<org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.NamingContext, NamingContextKey> - namingContextIid; - - private static final Collector<Mapping, ?, Mapping> SINGLE_ITEM_COLLECTOR = RWUtils.singleItemCollector(); + namingContextIid; /** * Create new naming context * * @param artificialNamePrefix artificial name to be used for items without a name in VPP (or not provided) - * @param instanceName name of this context instance. Will be used as list item identifier within context data tree + * @param instanceName name of this context instance. Will be used as list item identifier within context + * data tree */ public NamingContext(@Nonnull final String artificialNamePrefix, @Nonnull final String instanceName) { this.artificialNamePrefix = artificialNamePrefix; namingContextIid = InstanceIdentifier.create(Contexts.class).child( - org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.NamingContext.class, - new NamingContextKey(instanceName)); + org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.NamingContext.class, + new NamingContextKey(instanceName)); } /** * Retrieve name for mapping stored provided mappingContext instance. If not present, artificial name will be * generated. * - * @param index index of a mapped item + * @param index index of a mapped item * @param mappingContext mapping context providing context data for current transaction - * * @return name mapped to provided index */ @Nonnull @@ -78,16 +77,15 @@ public final class NamingContext implements AutoCloseable { checkState(read.isPresent(), "Mapping for index: %s is not present. But should be", index); return read.get().getMapping().stream() - .filter(mapping -> mapping.getIndex().equals(index)) - .collect(SINGLE_ITEM_COLLECTOR).getName(); + .filter(mapping -> mapping.getIndex().equals(index)) + .collect(SINGLE_ITEM_COLLECTOR).getName(); } /** * Retrieve name for mapping stored provided mappingContext instance. if present * - * @param index index of a mapped item + * @param index index of a mapped item * @param mappingContext mapping context providing context data for current transaction - * * @return name mapped to provided index */ @Nonnull @@ -97,33 +95,32 @@ public final class NamingContext implements AutoCloseable { return read.isPresent() ? Optional.of(read.get().getMapping().stream() - .filter(mapping -> mapping.getIndex().equals(index)) - .collect(SINGLE_ITEM_COLLECTOR) - .getName()) + .filter(mapping -> mapping.getIndex().equals(index)) + .collect(SINGLE_ITEM_COLLECTOR) + .getName()) : Optional.absent(); } /** * Check whether mapping is present for index. * - * @param index index of a mapped item + * @param index index of a mapped item * @param mappingContext mapping context providing context data for current transaction - * * @return true if present, false otherwise */ public synchronized boolean containsName(final int index, @Nonnull final MappingContext mappingContext) { final Optional<Mappings> read = mappingContext.read(namingContextIid.child(Mappings.class)); return read.isPresent() - ? read.get().getMapping().stream().anyMatch(mapping -> mapping.getIndex().equals(index)) - : false; + ? read.get().getMapping().stream().anyMatch(mapping -> mapping.getIndex().equals(index)) + : false; } /** * Add mapping to current context * - * @param index index of a mapped item - * @param name name of a mapped item + * @param index index of a mapped item + * @param name name of a mapped item * @param mappingContext mapping context providing context data for current transaction */ public synchronized void addName(final int index, final String name, final MappingContext mappingContext) { @@ -138,7 +135,7 @@ public final class NamingContext implements AutoCloseable { /** * Remove mapping from current context * - * @param name name of a mapped item + * @param name name of a mapped item * @param mappingContext mapping context providing context data for current transaction */ public synchronized void removeName(final String name, final MappingContext mappingContext) { @@ -148,9 +145,8 @@ public final class NamingContext implements AutoCloseable { /** * Returns index value associated with the given name. * - * @param name the name whose associated index value is to be returned + * @param name the name whose associated index value is to be returned * @param mappingContext mapping context providing context data for current transaction - * * @return integer index value matching supplied name * @throws IllegalArgumentException if name was not found */ @@ -164,9 +160,8 @@ public final class NamingContext implements AutoCloseable { /** * Check whether mapping is present for name. * - * @param name name of a mapped item + * @param name name of a mapped item * @param mappingContext mapping context providing context data for current transaction - * * @return true if present, false otherwise */ public synchronized boolean containsIndex(final String name, final MappingContext mappingContext) { diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/TagRewriteOperation.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/TagRewriteOperation.java index c403b7104..e7c07ed75 100644 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/TagRewriteOperation.java +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/TagRewriteOperation.java @@ -13,6 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ + package io.fd.honeycomb.translate.v3po.util; import com.google.common.base.Preconditions; @@ -39,6 +40,11 @@ public enum TagRewriteOperation { translate_2_to_2(2); private static final int MAX_INDEX = 3; + private static TagRewriteOperation[][] translation = new TagRewriteOperation[][]{ + {disabled, push_1, push_2}, + {pop_1, translate_1_to_1, translate_1_to_2}, + {pop_2, translate_2_to_1, translate_2_to_2} + }; private final int code; private final byte popTags; @@ -47,15 +53,10 @@ public enum TagRewriteOperation { this.popTags = UnsignedBytes.checkedCast(popTags); } - private static TagRewriteOperation[][] translation = new TagRewriteOperation[][] { - {disabled, push_1, push_2}, - {pop_1, translate_1_to_1, translate_1_to_2}, - {pop_2, translate_2_to_1, translate_2_to_2} - }; - /** * Returns VPP tag rewrite operation for given number of tags to pop and tags to push. - * @param toPop number of tags to pop (0..2) + * + * @param toPop number of tags to pop (0..2) * @param toPush number of tags to push (0..2) * @return vpp tag rewrite operation for given input parameters */ @@ -67,6 +68,7 @@ public enum TagRewriteOperation { /** * Returns VPP tag rewrite operation for given operation code. + * * @param code VPP tag rewrite operation code * @return vpp tag rewrite operation for given input parameter */ diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/TranslateUtils.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/TranslateUtils.java deleted file mode 100644 index c1f17ea6c..000000000 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/honeycomb/translate/v3po/util/TranslateUtils.java +++ /dev/null @@ -1,502 +0,0 @@ -/* - * Copyright (c) 2016 Cisco and/or its affiliates. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at: - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package io.fd.honeycomb.translate.v3po.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.base.Splitter; -import com.google.common.net.InetAddresses; -import java.net.UnknownHostException; -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.ExecutionException; -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -import java.util.function.BiConsumer; -import java.util.stream.Collectors; -import javax.annotation.Nonnegative; -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import org.apache.commons.codec.DecoderException; -import org.apache.commons.codec.binary.Hex; -import org.apache.commons.lang3.StringUtils; -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.Ipv4Address; -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.Ipv4Prefix; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.openvpp.jvpp.VppBaseCallException; -import org.openvpp.jvpp.dto.JVppReply; - -public final class TranslateUtils { - - public static final Splitter COLON_SPLITTER = Splitter.on(':'); - public static final int DEFAULT_TIMEOUT_IN_SECONDS = 5; - - private TranslateUtils() { - } - - public static <REP extends JVppReply<?>> REP getReplyForWrite(@Nonnull Future<REP> future, - @Nonnull final InstanceIdentifier<?> replyType) - throws VppBaseCallException, WriteTimeoutException { - return getReplyForWrite(future, replyType, DEFAULT_TIMEOUT_IN_SECONDS); - } - - public static <REP extends JVppReply<?>> REP getReplyForWrite(@Nonnull Future<REP> future, - @Nonnull final InstanceIdentifier<?> replyType, - @Nonnegative final int timeoutInSeconds) - throws VppBaseCallException, WriteTimeoutException { - try { - return getReply(future, timeoutInSeconds); - } catch (TimeoutException e) { - throw new WriteTimeoutException(replyType, e); - } - } - - public static <REP extends JVppReply<?>> REP getReplyForRead(@Nonnull Future<REP> future, - @Nonnull final InstanceIdentifier<?> replyType) - throws VppBaseCallException, ReadTimeoutException { - return getReplyForRead(future, replyType, DEFAULT_TIMEOUT_IN_SECONDS); - } - - public static <REP extends JVppReply<?>> REP getReplyForRead(@Nonnull Future<REP> future, - @Nonnull final InstanceIdentifier<?> replyType, - @Nonnegative final int timeoutInSeconds) - throws VppBaseCallException, ReadTimeoutException { - try { - return getReply(future, timeoutInSeconds); - } catch (TimeoutException e) { - throw new ReadTimeoutException(replyType, e); - } - } - - public static <REP extends JVppReply<?>> REP getReply(@Nonnull Future<REP> future) - throws TimeoutException, VppBaseCallException { - return getReply(future, DEFAULT_TIMEOUT_IN_SECONDS); - } - - public static <REP extends JVppReply<?>> REP getReply(@Nonnull Future<REP> future, - @Nonnegative final int timeoutInSeconds) - throws TimeoutException, VppBaseCallException { - try { - checkArgument(timeoutInSeconds > 0, "Timeout cannot be < 0"); - return future.get(timeoutInSeconds, TimeUnit.SECONDS); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - throw new IllegalStateException("Interrupted", e); - } catch (ExecutionException e) { - // Execution exception could generally contains any exception - // when using exceptions instead of return codes just rethrow it for processing on corresponding place - if (e instanceof ExecutionException && (e.getCause() instanceof VppBaseCallException)) { - throw (VppBaseCallException) (e.getCause()); - } - throw new IllegalStateException(e); - } - } - - public static final byte[] ipAddressToArray(IpAddress address) { - checkNotNull(address, "Cannot resolve null adddress"); - - if (isIpv6(address)) { - return ipv6AddressNoZoneToArray(new Ipv6AddressNoZone(address.getIpv6Address())); - } else { - return ipv4AddressNoZoneToArray(new Ipv4AddressNoZone(address.getIpv4Address())); - } - } - - /** - * Creates address array from address part of {@link Ipv4Prefix} - */ - public static byte[] ipv4AddressPrefixToArray(@Nonnull final Ipv4Prefix ipv4Prefix) { - checkNotNull(ipv4Prefix, "Cannot convert null prefix"); - - byte[] retval = new byte[4]; - String[] address = ipv4Prefix.getValue().substring(0, ipv4Prefix.getValue().indexOf('/')).split("\\."); - - for (int d = 0; d < 4; d++) { - retval[d] = (byte) (Short.parseShort(address[d]) & 0xff); - } - return retval; - } - - /** - * Converts {@link IpAddress} to array representing {@link Ipv4Address} or {@link Ipv6Address} - */ - public static byte[] ipAddressToArray(boolean isIpv6, @Nonnull IpAddress address) { - checkNotNull(address, "Cannot convert null Address"); - - if (isIpv6) { - return ipv6AddressNoZoneToArray(new Ipv6AddressNoZone(address.getIpv6Address())); - } else { - return ipv4AddressNoZoneToArray(new Ipv4AddressNoZone(address.getIpv4Address())); - } - } - - /** - * Converts array bytes to {@link IpAddress} - */ - @Nonnull - public static IpAddress arrayToIpAddress(boolean isIpv6, byte[] ip) { - if (isIpv6) { - return new IpAddress(arrayToIpv6AddressNoZone(ip)); - } else { - return new IpAddress(arrayToIpv4AddressNoZone(ip)); - } - } - - /** - * Extracts {@link Ipv4Prefix} prefix - */ - public static byte extractPrefix(Ipv4Prefix data) { - checkNotNull(data, "Cannot extract from null"); - - return Byte.valueOf(data.getValue().substring(data.getValue().indexOf('/') + 1)); - } - - /** - * Converts byte array to {@link Ipv4Prefix} with specified prefixLength - */ - public static Ipv4Prefix arrayToIpv4Prefix(final byte[] address, byte prefixLength) { - Ipv4AddressNoZone addressPart = arrayToIpv4AddressNoZone(address); - - return new Ipv4Prefix(addressPart.getValue().concat("/").concat(String.valueOf(prefixLength))); - } - - /** - * Transform Ipv6 address to a byte array acceptable by VPP. VPP expects incoming byte array to be in the same order - * as the address. - * - * @return byte array with address bytes - */ - public static byte[] ipv6AddressNoZoneToArray(@Nonnull final Ipv6AddressNoZone ipv6Addr) { - byte[] retval = new byte[16]; - - //splits address and add ommited zeros for easier parsing - List<String> segments = Arrays.asList(ipv6Addr.getValue().split(":")) - .stream() - .map(segment -> StringUtils.repeat('0', 4 - segment.length()) + segment) - .collect(Collectors.toList()); - - byte index = 0; - for (String segment : segments) { - - String firstPart = segment.substring(0, 2); - String secondPart = segment.substring(2); - - //first part should be ommited - if ("00".equals(firstPart)) { - index++; - } else { - retval[index++] = ((byte) Short.parseShort(firstPart, 16)); - } - - retval[index++] = ((byte) Short.parseShort(secondPart, 16)); - } - - return retval; - } - - /** - * Creates address array from address part of {@link Ipv6Prefix} - */ - public static byte[] ipv6AddressPrefixToArray(@Nonnull final Ipv6Prefix ipv4Prefix) { - checkNotNull(ipv4Prefix, "Cannot convert null prefix"); - - return ipv6AddressNoZoneToArray(new Ipv6AddressNoZone( - new Ipv6Address(ipv4Prefix.getValue().substring(0, ipv4Prefix.getValue().indexOf('/'))))); - } - - /** - * Extracts {@link Ipv6Prefix} prefix - */ - public static byte extractPrefix(Ipv6Prefix data) { - checkNotNull(data, "Cannot extract from null"); - - return Byte.valueOf(data.getValue().substring(data.getValue().indexOf('/') + 1)); - } - - /** - * Converts byte array to {@link Ipv6Prefix} with specified prefixLength - */ - public static Ipv6Prefix arrayToIpv6Prefix(final byte[] address, byte prefixLength) { - Ipv6AddressNoZone addressPart = arrayToIpv6AddressNoZone(address); - - return new Ipv6Prefix(addressPart.getValue().concat("/").concat(String.valueOf(prefixLength))); - } - - /** - * Parse byte array returned by VPP representing an Ipv6 address. Vpp returns IP byte arrays in reversed order. - * - * @return Ipv46ddressNoZone containing string representation of IPv6 address constructed from submitted bytes. No - * change in order. - */ - @Nonnull - public static Ipv6AddressNoZone arrayToIpv6AddressNoZone(@Nonnull byte[] ip) { - checkArgument(ip.length == 16, "Illegal array length"); - - try { - return new Ipv6AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip))); - } catch (UnknownHostException e) { - throw new IllegalArgumentException("Unable to parse ipv6", e); - } - } - - - /** - * Parse byte array returned by VPP representing an Ipv6 address. Vpp returns IP byte arrays in natural order. - * - * @return Ipv46ddressNoZone containing string representation of IPv6 address constructed from submitted bytes. No - * change in order. - */ - @Nonnull - public static Ipv6AddressNoZone arrayToIpv6AddressNoZoneReversed(@Nonnull byte[] ip) { - checkArgument(ip.length == 16, "Illegal array length"); - - ip = reverseBytes(ip); - - try { - return new Ipv6AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip))); - } catch (UnknownHostException e) { - throw new IllegalArgumentException("Unable to parse ipv6", e); - } - } - - /** - * Converts byte array to address string ,not separated with ":" - */ - public static String byteArrayToMacUnseparated(byte[] address) { - checkArgument(address.length == 6, "Illegal array length"); - return Hex.encodeHexString(address); - } - - /** - * Converts byte array to address string ,separated with ":" - */ - public static String byteArrayToMacSeparated(byte[] address) { - checkArgument(address.length == 6, "Illegal array length"); - - String unseparatedAddress = Hex.encodeHexString(address); - String separated = ""; - - for (int i = 0; i < unseparatedAddress.length(); i = i + 2) { - if (i == (unseparatedAddress.length() - 2)) { - separated = separated + unseparatedAddress.substring(0 + i, 2 + i); - } else { - separated = separated + unseparatedAddress.substring(0 + i, 2 + i) + ":"; - } - } - - return separated; - } - - /** - * Converts MAC string to byte array - */ - public static byte[] macToByteArray(String mac) { - checkNotNull(mac, "MAC cannot be null"); - - mac = mac.replace(":", ""); - - try { - return Hex.decodeHex(mac.toCharArray()); - } catch (DecoderException e) { - throw new IllegalArgumentException("Unable to convert mac", e); - } - } - - /** - * Detects whether {@code IpAddress} is ipv6 - */ - public static boolean isIpv6(IpAddress address) { - checkNotNull(address, "Address cannot be null"); - - checkState(!(address.getIpv4Address() == null && address.getIpv6Address() == null), "Invalid address"); - return address.getIpv6Address() != null; - } - - /** - * Detects whether {@code IpPrefix} is ipv6 - */ - public static boolean isIpv6(IpPrefix address) { - checkNotNull(address, "Address cannot be null"); - checkState(!(address.getIpv4Prefix() == null && address.getIpv6Prefix() == null), "Invalid address"); - return address.getIpv6Prefix() != null; - } - - - /** - * Transform Ipv4 address to a byte array acceptable by VPP. VPP expects incoming byte array to be in the same order - * as the address. - * - * @return byte array with address bytes - */ - public static byte[] ipv4AddressNoZoneToArray(final Ipv4AddressNoZone ipv4Addr) { - return ipv4AddressNoZoneToArray(ipv4Addr.getValue()); - } - - public static byte[] ipv4AddressNoZoneToArray(final String ipv4Addr) { - byte[] retval = new byte[4]; - String[] dots = ipv4Addr.split("\\."); - - for (int d = 0; d < 4; d++) { - retval[d] = (byte) (Short.parseShort(dots[d]) & 0xff); - } - return retval; - } - - /** - * Parse byte array returned by VPP representing an Ipv4 address. Vpp returns IP byte arrays in reversed order. - * - * @return Ipv4AddressNoZone containing string representation of IPv4 address constructed from submitted bytes. No - * change in order. - */ - @Nonnull - public static Ipv4AddressNoZone arrayToIpv4AddressNoZone(@Nonnull byte[] ip) { - // VPP sends ipv4 in a 16 byte array - if (ip.length == 16) { - ip = Arrays.copyOfRange(ip, 0, 4); - } - try { - // Not reversing the byte array here!! because the IP coming from VPP is in reversed byte order - // compared to byte order it was submitted - return new Ipv4AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip))); - } catch (UnknownHostException e) { - throw new IllegalArgumentException("Unable to parse ipv4", e); - } - } - - /** - * Parse byte array returned by VPP representing an Ipv4 address. Vpp returns IP byte arrays in reversed order. - * - * @return Ipv4AddressNoZone containing string representation of IPv4 address constructed from submitted bytes. No - * change in order. - */ - @Nonnull - public static Ipv4AddressNoZone arrayToIpv4AddressNoZoneReversed(@Nonnull byte[] ip) { - // VPP sends ipv4 in a 16 byte array - - if (ip.length == 16) { - ip = Arrays.copyOfRange(ip, 0, 4); - } - - ip = reverseBytes(ip); - - try { - // Not reversing the byte array here!! because the IP coming from VPP is in reversed byte order - // compared to byte order it was submitted - return new Ipv4AddressNoZone(InetAddresses.toAddrString(InetAddresses.fromLittleEndianByteArray(ip))); - } catch (UnknownHostException e) { - throw new IllegalArgumentException("Unable to parse ipv4", e); - } - } - - /** - * Return (interned) string from byte array while removing \u0000. Strings represented as fixed length byte[] from - * vpp contain \u0000. - */ - public static String toString(final byte[] cString) { - return new String(cString).replaceAll("\\u0000", "").intern(); - } - - /** - * Parse string represented mac address (using ":" as separator) into a byte array - */ - @Nonnull - public static byte[] parseMac(@Nonnull final String macAddress) { - final List<String> parts = COLON_SPLITTER.splitToList(macAddress); - checkArgument(parts.size() == 6, "Mac address is expected to have 6 parts but was: %s", macAddress); - return parseMacLikeString(parts); - } - - private static byte[] parseMacLikeString(final List<String> strings) { - return strings.stream().limit(6).map(TranslateUtils::parseHexByte).collect( - () -> new byte[strings.size()], - new BiConsumer<byte[], Byte>() { - - private int i = -1; - - @Override - public void accept(final byte[] bytes, final Byte aByte) { - bytes[++i] = aByte; - } - }, - (bytes, bytes2) -> { - throw new UnsupportedOperationException("Parallel collect not supported"); - }); - } - - public static byte parseHexByte(final String aByte) { - return (byte) Integer.parseInt(aByte, 16); - } - - /** - * Returns 0 if argument is null or false, 1 otherwise. - * - * @param value Boolean value to be converted - * @return byte value equal to 0 or 1 - */ - public static byte booleanToByte(@Nullable final Boolean value) { - return value != null && value - ? (byte) 1 - : (byte) 0; - } - - /** - * Returns Boolean.TRUE if argument is 0, Boolean.FALSE otherwise. - * - * @param value byte value to be converted - * @return Boolean value - * @throws IllegalArgumentException if argument is neither 0 nor 1 - */ - @Nonnull - public static Boolean byteToBoolean(final byte value) { - if (value == 0) { - return Boolean.FALSE; - } else if (value == 1) { - return Boolean.TRUE; - } - throw new IllegalArgumentException(String.format("0 or 1 was expected but was %d", value)); - } - - /** - * Reverses bytes in the byte array - * - * @param bytes input array - * @return reversed array - */ - public static byte[] reverseBytes(final byte[] bytes) { - final byte[] reversed = new byte[bytes.length]; - int i = 1; - for (byte aByte : bytes) { - reversed[bytes.length - i++] = aByte; - } - - return reversed; - } - - public static IpAddress reverseAddress(@Nonnull final IpAddress address) { - //arrayToIpAdddress internaly reverts order - return arrayToIpAddress(isIpv6(address), ipAddressToArray(address)); - } -} diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/AddressTranslatorTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/AddressTranslatorTest.java new file mode 100644 index 000000000..92f58c933 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/AddressTranslatorTest.java @@ -0,0 +1,20 @@ +package io.fd.honeycomb.translate.v3po.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.Ipv4Address; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address; + +public class AddressTranslatorTest implements AddressTranslator { + + @Test + public void testRevertAddress() { + assertEquals("1.2.168.192", + reverseAddress(new IpAddress(new Ipv4Address("192.168.2.1"))).getIpv4Address().getValue()); + assertEquals("3473:7003:2e8a::a385:b80d:120", + reverseAddress(new IpAddress(new Ipv6Address("2001:db8:85a3:0:0:8a2e:370:7334"))).getIpv6Address() + .getValue()); + } +}
\ No newline at end of file diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/ByteDataTranslatorTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/ByteDataTranslatorTest.java new file mode 100644 index 000000000..86ff5ff77 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/ByteDataTranslatorTest.java @@ -0,0 +1,39 @@ +package io.fd.honeycomb.translate.v3po.util; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +/** + * Created by jsrnicek on 23.9.2016. + */ +public class ByteDataTranslatorTest implements ByteDataTranslator { + + @Test + public void testBooleanToByte() { + assertEquals(0, booleanToByte(null)); + assertEquals(0, booleanToByte(false)); + assertEquals(1, booleanToByte(true)); + } + + @Test + public void testByteToBoolean() { + assertEquals(Boolean.FALSE, byteToBoolean((byte) 0)); + assertEquals(Boolean.TRUE, byteToBoolean((byte) 1)); + } + + @Test(expected = IllegalArgumentException.class) + public void testByteToBooleanFailed() { + byteToBoolean((byte) 123); + } + + @Test + public void testToString() { + final byte[] expected = "test".getBytes(); + final byte[] cString = new byte[expected.length + 10]; + System.arraycopy(expected, 0, cString, 0, expected.length); + final String jString = toString(cString); + assertArrayEquals(expected, jString.getBytes()); + } +}
\ No newline at end of file diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/Ipv4TranslatorTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/Ipv4TranslatorTest.java new file mode 100644 index 000000000..3b1dcd9b1 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/Ipv4TranslatorTest.java @@ -0,0 +1,33 @@ +package io.fd.honeycomb.translate.v3po.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.Ipv4AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix; + +public class Ipv4TranslatorTest implements Ipv4Translator { + + @Test + public void testIpv4NoZone() throws Exception { + final Ipv4AddressNoZone ipv4Addr = new Ipv4AddressNoZone("192.168.1.1"); + byte[] bytes = ipv4AddressNoZoneToArray(ipv4Addr); + assertEquals((byte) 192, bytes[0]); + // Simulating the magic of VPP + bytes = reverseBytes(bytes); + final Ipv4AddressNoZone ipv4AddressNoZone = arrayToIpv4AddressNoZone(bytes); + assertEquals(ipv4Addr, ipv4AddressNoZone); + } + + @Test + public void testIpv4AddressPrefixToArray() { + byte[] ip = ipv4AddressPrefixToArray(new Ipv4Prefix("192.168.2.1/24")); + + assertEquals("1.2.168.192", arrayToIpv4AddressNoZone(ip).getValue()); + } + + @Test + public void testExtractPrefix() { + assertEquals(24, extractPrefix(new Ipv4Prefix("192.168.2.1/24"))); + } +}
\ No newline at end of file diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/Ipv6TranslatorTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/Ipv6TranslatorTest.java new file mode 100644 index 000000000..6f4d39c63 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/Ipv6TranslatorTest.java @@ -0,0 +1,40 @@ +package io.fd.honeycomb.translate.v3po.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.Ipv6AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix; + +public class Ipv6TranslatorTest implements Ipv6Translator { + + @Test + public void testIpv6NoZone() { + final Ipv6AddressNoZone ipv6Addr = new Ipv6AddressNoZone("3ffe:1900:4545:3:200:f8ff:fe21:67cf"); + byte[] bytes = ipv6AddressNoZoneToArray(ipv6Addr); + assertEquals((byte) 63, bytes[0]); + + bytes = reverseBytes(bytes); + final Ipv6AddressNoZone ivp6AddressNoZone = arrayToIpv6AddressNoZone(bytes); + assertEquals(ipv6Addr, ivp6AddressNoZone); + } + + @Test + public void testIpv6AddressPrefixToArray() { + byte[] ip = ipv6AddressPrefixToArray(new Ipv6Prefix("3ffe:1900:4545:3:200:f8ff:fe21:67cf/48")); + + assertEquals("cf67:21fe:fff8:2:300:4545:19:fe3f", arrayToIpv6AddressNoZone(ip).getValue()); + } + + @Test + public void testIpv4AddressPrefixToArray() { + byte[] ip = ipv6AddressPrefixToArray(new Ipv6Prefix("2001:0db8:0a0b:12f0:0000:0000:0000:0001/128")); + + assertEquals("100::f012:b0a:b80d:120", arrayToIpv6AddressNoZone(ip).getValue()); + } + + @Test + public void testExtractPrefix() { + assertEquals(48, extractPrefix(new Ipv6Prefix("3ffe:1900:4545:3:200:f8ff:fe21:67cf/48"))); + } +}
\ No newline at end of file diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/JvppReplyConsumerTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/JvppReplyConsumerTest.java new file mode 100644 index 000000000..dbccef6e2 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/JvppReplyConsumerTest.java @@ -0,0 +1,60 @@ +package io.fd.honeycomb.translate.v3po.util; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Matchers.anyLong; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.junit.Test; +import org.opendaylight.yangtools.yang.binding.DataContainer; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.openvpp.jvpp.dto.JVppReply; + +public class JvppReplyConsumerTest implements JvppReplyConsumer { + + private static class AnDataObject implements DataObject { + @Override + public Class<? extends DataContainer> getImplementedInterface() { + return null; + } + } + + @Test + public void testGetReplyForWriteTimeout() throws Exception { + final Future<JVppReply<?>> future = mock(Future.class); + when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class); + final InstanceIdentifier<AnDataObject> + replyType = InstanceIdentifier.create(AnDataObject.class); + try { + getReplyForWrite(future, replyType); + } catch (WriteTimeoutException e) { + assertTrue(e.getCause() instanceof TimeoutException); + assertEquals(replyType, e.getFailedId()); + return; + } + fail("WriteTimeoutException was expected"); + } + + @Test + public void testGetReplyForReadTimeout() throws Exception { + final Future<JVppReply<?>> future = mock(Future.class); + final InstanceIdentifier<AnDataObject> replyType = + InstanceIdentifier.create(AnDataObject.class); + when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class); + try { + getReplyForRead(future, replyType); + } catch (ReadTimeoutException e) { + assertTrue(e.getCause() instanceof TimeoutException); + assertEquals(replyType, e.getFailedId()); + return; + } + fail("ReadTimeoutException was expected"); + } +}
\ No newline at end of file diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/MacTranslatorTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/MacTranslatorTest.java new file mode 100644 index 000000000..60444204e --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/MacTranslatorTest.java @@ -0,0 +1,73 @@ +package io.fd.honeycomb.translate.v3po.util; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +public class MacTranslatorTest implements MacTranslator { + + @Test + public void testParseMac() throws Exception { + byte[] bytes = parseMac("00:fF:7f:15:5e:A9"); + assertMac(bytes); + } + + private void assertMac(final byte[] bytes) { + assertEquals(6, bytes.length); + assertEquals((byte) 0, bytes[0]); + assertEquals((byte) 255, bytes[1]); + assertEquals((byte) 127, bytes[2]); + assertEquals((byte) 21, bytes[3]); + assertEquals((byte) 94, bytes[4]); + assertEquals((byte) 169, bytes[5]); + } + + @Test(expected = IllegalArgumentException.class) + public void testParseMacLonger() throws Exception { + byte[] bytes = parseMac("00:fF:7f:15:5e:A9:88:77"); + assertMac(bytes); + } + + @Test(expected = IllegalArgumentException.class) + public void testParseMacShorter() throws Exception { + parseMac("00:fF:7f"); + } + + @Test(expected = IllegalArgumentException.class) + public void testParseRandomString() throws Exception { + parseMac("random{}}@$*&*!"); + } + + @Test(expected = NumberFormatException.class) + public void testParseMacNumberFormatEx() throws Exception { + parseMac("00:XX:7f:15:5e:77\""); + } + + @Test + public void testByteArrayToMacUnseparated() { + byte[] address = parseMac("aa:bb:cc:dd:ee:ff"); + + String converted = byteArrayToMacUnseparated(address); + + assertEquals("aabbccddeeff", converted); + } + + @Test + public void testByteArrayToMacSeparated() { + byte[] address = parseMac("aa:bb:cc:dd:ee:ff"); + + String converted = byteArrayToMacSeparated(address); + + assertEquals("aa:bb:cc:dd:ee:ff", converted); + } + + @Test(expected = IllegalArgumentException.class) + public void testByteArrayToMacUnseparatedIllegal() { + byteArrayToMacUnseparated(new byte[]{54, 26, 87, 32, 14}); + } + + @Test(expected = IllegalArgumentException.class) + public void testByteArrayToMacSeparatedIllegal() { + byteArrayToMacSeparated(new byte[]{54, 26, 87, 32, 14}); + } +}
\ No newline at end of file diff --git a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/TranslateUtilsTest.java b/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/TranslateUtilsTest.java deleted file mode 100644 index 3b7efbfc5..000000000 --- a/vpp-common/vpp-translate-utils/src/test/java/io/fd/honeycomb/translate/v3po/util/TranslateUtilsTest.java +++ /dev/null @@ -1,211 +0,0 @@ -package io.fd.honeycomb.translate.v3po.util; - -import static io.fd.honeycomb.translate.v3po.util.TranslateUtils.reverseAddress; -import static io.fd.honeycomb.translate.v3po.util.TranslateUtils.reverseBytes; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; -import static org.mockito.Matchers.anyLong; -import static org.mockito.Matchers.eq; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; - -import java.util.concurrent.Future; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; -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.Ipv4Address; -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.Ipv4Prefix; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone; -import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix; -import org.opendaylight.yangtools.yang.binding.DataContainer; -import org.opendaylight.yangtools.yang.binding.DataObject; -import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import org.openvpp.jvpp.dto.JVppReply; - -public class TranslateUtilsTest { - - private static class AnDataObject implements DataObject { - @Override - public Class<? extends DataContainer> getImplementedInterface() { - return null; - } - } - - @Test - public void testGetReplyForWriteTimeout() throws Exception { - final Future<JVppReply<?>> future = mock(Future.class); - when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class); - final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class); - try { - TranslateUtils.getReplyForWrite(future, replyType); - } catch (WriteTimeoutException e) { - assertTrue(e.getCause() instanceof TimeoutException); - assertEquals(replyType, e.getFailedId()); - return; - } - fail("WriteTimeoutException was expected"); - } - - @Test - public void testGetReplyForReadTimeout() throws Exception { - final Future<JVppReply<?>> future = mock(Future.class); - final InstanceIdentifier<AnDataObject> replyType = InstanceIdentifier.create(AnDataObject.class); - when(future.get(anyLong(), eq(TimeUnit.SECONDS))).thenThrow(TimeoutException.class); - try { - TranslateUtils.getReplyForRead(future, replyType); - } catch (ReadTimeoutException e) { - assertTrue(e.getCause() instanceof TimeoutException); - assertEquals(replyType, e.getFailedId()); - return; - } - fail("ReadTimeoutException was expected"); - } - - @Test - public void testIpv4NoZone() throws Exception { - final Ipv4AddressNoZone ipv4Addr = new Ipv4AddressNoZone("192.168.1.1"); - byte[] bytes = TranslateUtils.ipv4AddressNoZoneToArray(ipv4Addr); - assertEquals((byte) 192, bytes[0]); - // Simulating the magic of VPP - bytes = reverseBytes(bytes); - final Ipv4AddressNoZone ipv4AddressNoZone = TranslateUtils.arrayToIpv4AddressNoZone(bytes); - assertEquals(ipv4Addr, ipv4AddressNoZone); - } - - @Test - public void testToString() { - final byte[] expected = "test".getBytes(); - final byte[] cString = new byte[expected.length + 10]; - System.arraycopy(expected, 0, cString, 0, expected.length); - final String jString = TranslateUtils.toString(cString); - assertArrayEquals(expected, jString.getBytes()); - } - - @Test - public void testParseMac() throws Exception { - byte[] bytes = TranslateUtils.parseMac("00:fF:7f:15:5e:A9"); - assertMac(bytes); - } - - private void assertMac(final byte[] bytes) { - assertEquals(6, bytes.length); - assertEquals((byte) 0, bytes[0]); - assertEquals((byte) 255, bytes[1]); - assertEquals((byte) 127, bytes[2]); - assertEquals((byte) 21, bytes[3]); - assertEquals((byte) 94, bytes[4]); - assertEquals((byte) 169, bytes[5]); - } - - @Test(expected = IllegalArgumentException.class) - public void testParseMacLonger() throws Exception { - byte[] bytes = TranslateUtils.parseMac("00:fF:7f:15:5e:A9:88:77"); - assertMac(bytes); - } - - @Test(expected = IllegalArgumentException.class) - public void testParseMacShorter() throws Exception { - TranslateUtils.parseMac("00:fF:7f"); - } - - @Test(expected = IllegalArgumentException.class) - public void testParseRandomString() throws Exception { - TranslateUtils.parseMac("random{}}@$*&*!"); - } - - @Test(expected = NumberFormatException.class) - public void testParseMacNumberFormatEx() throws Exception { - TranslateUtils.parseMac("00:XX:7f:15:5e:77\""); - } - - @Test - public void testBooleanToByte() { - assertEquals(0, TranslateUtils.booleanToByte(null)); - assertEquals(0, TranslateUtils.booleanToByte(false)); - assertEquals(1, TranslateUtils.booleanToByte(true)); - } - - @Test - public void testByteToBoolean() { - assertEquals(Boolean.FALSE, TranslateUtils.byteToBoolean((byte) 0)); - assertEquals(Boolean.TRUE, TranslateUtils.byteToBoolean((byte) 1)); - } - - @Test(expected = IllegalArgumentException.class) - public void testByteToBooleanFailed() { - TranslateUtils.byteToBoolean((byte) 123); - } - - @Test - public void testIpv6NoZone() { - final Ipv6AddressNoZone ipv6Addr = new Ipv6AddressNoZone("3ffe:1900:4545:3:200:f8ff:fe21:67cf"); - byte[] bytes = TranslateUtils.ipv6AddressNoZoneToArray(ipv6Addr); - assertEquals((byte) 63, bytes[0]); - - bytes = reverseBytes(bytes); - final Ipv6AddressNoZone ivp6AddressNoZone = TranslateUtils.arrayToIpv6AddressNoZone(bytes); - assertEquals(ipv6Addr, ivp6AddressNoZone); - } - - @Test - public void testByteArrayToMacUnseparated() { - byte[] address = TranslateUtils.parseMac("aa:bb:cc:dd:ee:ff"); - - String converted = TranslateUtils.byteArrayToMacUnseparated(address); - - assertEquals("aabbccddeeff", converted); - } - - @Test - public void testByteArrayToMacSeparated() { - byte[] address = TranslateUtils.parseMac("aa:bb:cc:dd:ee:ff"); - - String converted = TranslateUtils.byteArrayToMacSeparated(address); - - assertEquals("aa:bb:cc:dd:ee:ff", converted); - } - - @Test(expected = IllegalArgumentException.class) - public void testByteArrayToMacUnseparatedIllegal() { - TranslateUtils.byteArrayToMacUnseparated(new byte[]{54, 26, 87, 32, 14}); - } - - @Test(expected = IllegalArgumentException.class) - public void testByteArrayToMacSeparatedIllegal() { - TranslateUtils.byteArrayToMacSeparated(new byte[]{54, 26, 87, 32, 14}); - } - - @Test - public void testIpv4AddressPrefixToArray() { - byte[] ip = TranslateUtils.ipv4AddressPrefixToArray(new Ipv4Prefix("192.168.2.1/24")); - - assertEquals("1.2.168.192", TranslateUtils.arrayToIpv4AddressNoZone(ip).getValue()); - } - - @Test - public void testIpv6AddressPrefixToArray() { - byte[] ip = TranslateUtils.ipv6AddressPrefixToArray(new Ipv6Prefix("3ffe:1900:4545:3:200:f8ff:fe21:67cf/48")); - - assertEquals("cf67:21fe:fff8:2:300:4545:19:fe3f", TranslateUtils.arrayToIpv6AddressNoZone(ip).getValue()); - } - - @Test - public void testExtractPrefix() { - assertEquals(24, TranslateUtils.extractPrefix(new Ipv4Prefix("192.168.2.1/24"))); - assertEquals(48, TranslateUtils.extractPrefix(new Ipv6Prefix("3ffe:1900:4545:3:200:f8ff:fe21:67cf/48"))); - } - - @Test - public void testRevertAddress() { - assertEquals("1.2.168.192", - reverseAddress(new IpAddress(new Ipv4Address("192.168.2.1"))).getIpv4Address().getValue()); - assertEquals("3473:7003:2e8a::a385:b80d:120", - reverseAddress(new IpAddress(new Ipv6Address("2001:db8:85a3:0:0:8a2e:370:7334"))).getIpv6Address() - .getValue()); - } -}
\ No newline at end of file |