summaryrefslogtreecommitdiffstats
path: root/vpp-common/vpp-translate-utils/src/main/java
diff options
context:
space:
mode:
Diffstat (limited to 'vpp-common/vpp-translate-utils/src/main/java')
-rw-r--r--vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/AddressTranslator.java3
-rw-r--r--vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/ByteDataTranslator.java37
-rw-r--r--vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv4Translator.java11
-rw-r--r--vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/Ipv6Translator.java31
-rw-r--r--vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/MultiNamingContext.java155
-rw-r--r--vpp-common/vpp-translate-utils/src/main/java/io/fd/hc2vpp/common/translate/util/NamingContext.java30
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