diff options
Diffstat (limited to 'vpp-common/vpp-translate-utils/src/main/java')
6 files changed, 255 insertions, 12 deletions
diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/AddressTranslator.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/AddressTranslator.java index eaa966479..170ff43e5 100644 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/AddressTranslator.java +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/AddressTranslator.java @@ -30,6 +30,9 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types. */ public interface AddressTranslator extends Ipv4Translator, Ipv6Translator, MacTranslator { + AddressTranslator INSTANCE = new AddressTranslator() { + }; + default byte[] ipAddressToArray(IpAddress address) { checkNotNull(address, "Cannot resolve null adddress"); diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/ByteDataTranslator.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/ByteDataTranslator.java index a96542623..17aff0e2e 100644 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/ByteDataTranslator.java +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/ByteDataTranslator.java @@ -24,6 +24,12 @@ import javax.annotation.Nullable; */ public interface ByteDataTranslator { + ByteDataTranslator INSTANCE = new ByteDataTranslator() { + }; + + byte BYTE_FALSE = 0; + byte BYTE_TRUE = 1; + /** * Returns 0 if argument is null or false, 1 otherwise. * @@ -32,8 +38,22 @@ public interface ByteDataTranslator { */ default byte booleanToByte(@Nullable final Boolean value) { return value != null && value - ? (byte) 1 - : (byte) 0; + ? BYTE_TRUE + : BYTE_FALSE; + } + + /** + * Converts int to byte + */ + default byte toByte(final int value) { + return Integer.valueOf(value).byteValue(); + } + + /** + * Converts short to byte + */ + default byte toByte(final short value) { + return Short.valueOf(value).byteValue(); } /** @@ -45,9 +65,9 @@ public interface ByteDataTranslator { */ @Nonnull default Boolean byteToBoolean(final byte value) { - if (value == 0) { + if (value == BYTE_FALSE) { return Boolean.FALSE; - } else if (value == 1) { + } else if (value == BYTE_TRUE) { return Boolean.TRUE; } throw new IllegalArgumentException(String.format("0 or 1 was expected but was %d", value)); @@ -76,4 +96,13 @@ public interface ByteDataTranslator { default String toString(final byte[] cString) { return new String(cString).replaceAll("\\u0000", "").intern(); } + + /** + * Converts signed byte(filled with unsigned value from vpp) to java integer + * + * For example unsigned C byte 128 is converted by jvpp to -128, this will return 128 + */ + default int toJavaByte(final byte vppByte) { + return Byte.toUnsignedInt(vppByte); + } } diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv4Translator.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv4Translator.java index 99d1757b4..02f89d9f8 100644 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv4Translator.java +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv4Translator.java @@ -108,4 +108,15 @@ public interface Ipv4Translator extends ByteDataTranslator { } return retval; } + + default Ipv4Prefix toIpv4Prefix(final byte[] address, final int prefix) { + try { + return new Ipv4Prefix( + String.format("%s/%s", InetAddress.getByAddress(address).getHostAddress(), + String.valueOf(prefix))); + } catch (UnknownHostException e) { + throw new IllegalArgumentException( + "Cannot create prefix for address[" + Arrays.toString(address) + "],prefix[" + prefix + "]"); + } + } } diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv6Translator.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv6Translator.java index cb8b2ac87..2d0b51b40 100644 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv6Translator.java +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv6Translator.java @@ -39,17 +39,11 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types. */ 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) { + default byte[] ipv6AddressNoZoneToArray(@Nonnull final String address) { byte[] retval = new byte[16]; //splits address and add ommited zeros for easier parsing - List<String> segments = Arrays.asList(ipv6Addr.getValue().split(":")) + List<String> segments = Arrays.asList(address.split(":")) .stream() .map(segment -> StringUtils.repeat('0', 4 - segment.length()) + segment) .collect(Collectors.toList()); @@ -74,6 +68,16 @@ 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) { + return ipv6AddressNoZoneToArray(ipv6Addr.getValue()); + } + + /** * Creates address array from address part of {@link Ipv6Prefix} */ default byte[] ipv6AddressPrefixToArray(@Nonnull final Ipv6Prefix ipv6Prefix) { @@ -136,4 +140,15 @@ public interface Ipv6Translator extends ByteDataTranslator { checkState(!(address.getIpv4Prefix() == null && address.getIpv6Prefix() == null), "Invalid address"); return address.getIpv6Prefix() != null; } + + default Ipv6Prefix toIpv6Prefix(final byte[] address, final int prefix) { + try { + return new Ipv6Prefix( + String.format("%s/%s", InetAddress.getByAddress(address).getHostAddress(), + String.valueOf(prefix))); + } catch (UnknownHostException e) { + throw new IllegalArgumentException( + "Cannot create prefix for address[" + Arrays.toString(address) + "],prefix[" + prefix + "]"); + } + } } diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/MultiNamingContext.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/MultiNamingContext.java new file mode 100644 index 000000000..6b10881d6 --- /dev/null +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/MultiNamingContext.java @@ -0,0 +1,155 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.common.translate.util; + +import static com.google.common.base.Preconditions.checkArgument; +import static com.google.common.base.Preconditions.checkState; + +import com.google.common.base.Optional; +import io.fd.honeycomb.translate.MappingContext; +import io.fd.honeycomb.translate.util.RWUtils; +import java.util.Collections; +import java.util.stream.Collectors; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.MultiMappingCtxAugmentation; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.multi.naming.contexts.attributes.MultiNamingContexts; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.multi.naming.contexts.attributes.multi.naming.contexts.MultiNaming; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.multi.naming.contexts.attributes.multi.naming.contexts.MultiNamingKey; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.multi.naming.contexts.attributes.multi.naming.contexts.multi.naming.Mappings; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.multi.naming.contexts.attributes.multi.naming.contexts.multi.naming.mappings.Mapping; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.multi.naming.contexts.attributes.multi.naming.contexts.multi.naming.mappings.MappingBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.multi.naming.contexts.attributes.multi.naming.contexts.multi.naming.mappings.MappingKey; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.multi.naming.contexts.attributes.multi.naming.contexts.multi.naming.mappings.mapping.Value; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.multi.naming.context.rev160411.multi.naming.contexts.attributes.multi.naming.contexts.multi.naming.mappings.mapping.ValueBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.Contexts; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; + +/** + * One to many context mapping + */ +public class MultiNamingContext { + + private final KeyedInstanceIdentifier<MultiNaming, MultiNamingKey> + multiNamingContextIid; + + private final int startIndex; + + public MultiNamingContext(@Nonnull final String instanceName, final int startIndex) { + multiNamingContextIid = InstanceIdentifier.create(Contexts.class) + .augmentation(MultiMappingCtxAugmentation.class) + .child(MultiNamingContexts.class) + .child(MultiNaming.class, new MultiNamingKey(instanceName)); + this.startIndex = startIndex; + } + + public synchronized void addChild(@Nonnull final String parentName, final int childIndex, + @Nonnull final String childName, + @Nonnull final MappingContext mappingContext) { + checkArgument(childIndex >= startIndex, "Index cannot be lower than start index %s", startIndex); + final KeyedInstanceIdentifier<Mapping, MappingKey> mappingIid = getMappingIid(parentName); + + //uses merge to preserve previous + mappingContext.merge(mappingIid, + new MappingBuilder().setName(parentName).setValue(Collections.singletonList(new ValueBuilder() + .setIndex(childIndex) + .setName(childName) + .build())).build()); + } + + public synchronized void addChild(@Nonnull final String parentName, + @Nonnull final String childName, + @Nonnull final MappingContext mappingContext) { + addChild(parentName, getNextAvailableChildIndex(parentName, mappingContext), childName, mappingContext); + } + + public synchronized String getChildName(@Nonnull final String parentName, + @Nonnull final int childIndex, + @Nonnull final MappingContext mappingContext) { + final Optional<Mapping> read = mappingContext.read(getMappingIid(parentName)); + + checkState(read.isPresent(), "Mapping not present"); + + return read.get().getValue().stream() + .filter(value -> value.getIndex().equals(childIndex)) + .collect(RWUtils.singleItemCollector()).getName(); + } + + public synchronized int getChildIndex(@Nonnull final String parentName, + @Nonnull final String childName, + @Nonnull final MappingContext mappingContext) { + final Optional<Mapping> read = mappingContext.read(getMappingIid(parentName)); + + checkState(read.isPresent(), "Mapping not present"); + + return read.get().getValue().stream() + .filter(value -> value.getName().equals(childName)) + .collect(RWUtils.singleItemCollector()).getIndex(); + } + + + public synchronized void removeChild(@Nonnull final String parentName, + @Nonnull final String childName, + @Nonnull final MappingContext mappingContext) { + + final Optional<Mapping> read = mappingContext.read(getMappingIid(parentName)); + + // ignore delete's for non-existing parent + if (read.isPresent()) { + final Mapping mapping = read.get(); + + // overrides old data with new(without removed child) + mappingContext.put(getMappingIid(parentName), new MappingBuilder() + .setName(mapping.getName()) + .setKey(mapping.getKey()) + .setValue(mapping.getValue() + .stream() + .filter(value -> !value.getName().equals(childName)) + .collect(Collectors.toList())) + .build()); + } + } + + /** + * Returns next available index for mapping + */ + private int getNextAvailableChildIndex(final String parentName, final MappingContext mappingContext) { + final Optional<Mappings> read = mappingContext.read(mappingIdBase()); + + if (!read.isPresent()) { + return startIndex; + } + + return read.get().getMapping() + .stream() + .filter(mapping -> mapping.getName().equals(parentName)) + .flatMap(mapping -> mapping.getValue().stream()) + .mapToInt(Value::getIndex) + // do not use i++(need increase before, not after + .map(i -> ++i) + .max() + .orElse(startIndex); + } + + private KeyedInstanceIdentifier<Mapping, MappingKey> getMappingIid(final String name) { + return mappingIdBase().child(Mapping.class, new MappingKey(name)); + } + + private InstanceIdentifier<Mappings> mappingIdBase() { + return multiNamingContextIid.child(Mappings.class); + } +} diff --git a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/NamingContext.java b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/NamingContext.java index 393df0898..5e0eea71b 100644 --- a/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/NamingContext.java +++ b/vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/NamingContext.java @@ -128,6 +128,17 @@ public final class NamingContext implements AutoCloseable { mappingContext.put(mappingIid, new MappingBuilder().setIndex(index).setName(name).build()); } + /** + * Add mapping to current context with next available index. + * Suitable for learned data mappings + * + * @param name name of a mapped item + * @param mappingContext mapping context providing context data for current transaction + */ + public synchronized void addName(final String name, final MappingContext mappingContext) { + addName(getNextAvailableIndex(mappingContext), name, mappingContext); + } + private KeyedInstanceIdentifier<Mapping, MappingKey> getMappingIid(final String name) { return namingContextIid.child(Mappings.class).child(Mapping.class, new MappingKey(name)); } @@ -172,6 +183,25 @@ public final class NamingContext implements AutoCloseable { return artificialNamePrefix + index; } + /** + * Returns next available index for mapping + */ + private int getNextAvailableIndex(final MappingContext mappingContext) { + final Optional<Mappings> read = mappingContext.read(namingContextIid.child(Mappings.class)); + + if (!read.isPresent()) { + return 0; + } + + return read.get().getMapping() + .stream() + .mapToInt(Mapping::getIndex) + // do not use i++(need increase before, not after + .map(i -> ++i) + .max() + .orElse(0); + } + @Override public void close() throws Exception { /// Not removing the mapping from backing storage |