/*
* Copyright 2017-present Open Networking Laboratory
*
* 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 org.onosproject.drivers.lisp.extensions;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import org.onlab.packet.IpAddress;
import org.onlab.packet.IpPrefix;
import org.onlab.packet.MacAddress;
import org.onosproject.codec.CodecContext;
import org.onosproject.lisp.ctl.ExtensionMappingAddressInterpreter;
import org.onosproject.lisp.msg.types.LispAfiAddress;
import org.onosproject.lisp.msg.types.LispDistinguishedNameAddress;
import org.onosproject.lisp.msg.types.LispIpv4Address;
import org.onosproject.lisp.msg.types.LispIpv6Address;
import org.onosproject.lisp.msg.types.LispMacAddress;
import org.onosproject.lisp.msg.types.lcaf.LispAppDataLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispAsLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispGeoCoordinateLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispListLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispMulticastLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispNatLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispNonceLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispSegmentLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispSourceDestLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispTeLcafAddress;
import org.onosproject.lisp.msg.types.lcaf.LispTeRecord;
import org.onosproject.mapping.addresses.ExtensionMappingAddress;
import org.onosproject.mapping.addresses.ExtensionMappingAddressResolver;
import org.onosproject.mapping.addresses.ExtensionMappingAddressType;
import org.onosproject.mapping.addresses.IPMappingAddress;
import org.onosproject.mapping.addresses.MappingAddress;
import org.onosproject.mapping.addresses.MappingAddresses;
import org.onosproject.net.driver.AbstractHandlerBehaviour;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.List;
import static com.google.common.base.Preconditions.checkNotNull;
import static org.onlab.util.Tools.nullIsIllegal;
import static org.onosproject.mapping.addresses.ExtensionMappingAddressType.ExtensionMappingAddressTypes.*;
/**
* Interpreter for mapping address extension.
*/
public class LispExtensionMappingAddressInterpreter extends AbstractHandlerBehaviour
implements ExtensionMappingAddressInterpreter, ExtensionMappingAddressResolver {
private static final Logger log = LoggerFactory.getLogger(
LispExtensionMappingAddressInterpreter.class);
private static final int IPV4_PREFIX_LENGTH = 32;
private static final int IPV6_PREFIX_LENGTH = 128;
protected static final String LISP_LIST_ADDRESS = "listAddress";
protected static final String LISP_SEGMENT_ADDRESS = "segmentAddress";
protected static final String LISP_AS_ADDRESS = "asAddress";
protected static final String LISP_APPLICATION_DATA_ADDRESS = "applicationDataAddress";
protected static final String LISP_GEO_COORDINATE_ADDRESS = "geoCoordinateAddress";
protected static final String LISP_NAT_ADDRESS = "natAddress";
protected static final String LISP_NONCE_ADDRESS = "nonceAddress";
protected static final String LISP_MULTICAST_ADDRESS = "multicastAddress";
protected static final String LISP_TRAFFIC_ENGINEERING_ADDRESS = "trafficEngineeringAddress";
protected static final String LISP_SOURCE_DEST_ADDRESS = "sourceDestAddress";
private static final String TYPE = "type";
private static final String MISSING_MEMBER_MESSAGE =
" member is required in LispExtensionMappingAddressInterpreter";
@Override
public boolean supported(ExtensionMappingAddressType type) {
if (type.equals(LIST_ADDRESS.type())) {
return true;
}
if (type.equals(SEGMENT_ADDRESS.type())) {
return true;
}
if (type.equals(AS_ADDRESS.type())) {
return true;
}
if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
return true;
}
if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
return true;
}
if (type.equals(NAT_ADDRESS.type())) {
return true;
}
if (type.equals(NONCE_ADDRESS.type())) {
return true;
}
if (type.equals(MULTICAST_ADDRESS.type())) {
return true;
}
if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
return true;
}
if (type.equals(SOURCE_DEST_ADDRESS.type())) {
return true;
}
return false;
}
@Override
public LispLcafAddress mapMappingAddress(ExtensionMappingAddress mappingAddress) {
ExtensionMappingAddressType type = mappingAddress.type();
if (type.equals(LIST_ADDRESS.type())) {
LispListAddress listAddress = (LispListAddress) mappingAddress;
LispAfiAddress ipv4 = mapping2afi(listAddress.getIpv4());
LispAfiAddress ipv6 = mapping2afi(listAddress.getIpv6());
if (ipv4 != null && ipv6 != null) {
return new LispListLcafAddress(ImmutableList.of(ipv4, ipv6));
} else {
return new LispListLcafAddress(ImmutableList.of());
}
}
if (type.equals(SEGMENT_ADDRESS.type())) {
LispSegmentAddress segmentAddress = (LispSegmentAddress) mappingAddress;
return new LispSegmentLcafAddress.SegmentAddressBuilder()
.withInstanceId(segmentAddress.getInstanceId())
.withAddress(getAfiAddress(segmentAddress.getAddress()))
.build();
}
if (type.equals(AS_ADDRESS.type())) {
LispAsAddress asAddress = (LispAsAddress) mappingAddress;
return new LispAsLcafAddress.AsAddressBuilder()
.withAsNumber(asAddress.getAsNumber())
.withAddress(getAfiAddress(asAddress.getAddress()))
.build();
}
if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
LispAppDataAddress appDataAddress = (LispAppDataAddress) mappingAddress;
return new LispAppDataLcafAddress.AppDataAddressBuilder()
.withProtocol(appDataAddress.getProtocol())
.withIpTos(appDataAddress.getIpTos())
.withLocalPortLow(appDataAddress.getLocalPortLow())
.withLocalPortHigh(appDataAddress.getLocalPortHigh())
.withRemotePortLow(appDataAddress.getRemotePortLow())
.withRemotePortHigh(appDataAddress.getRemotePortHigh())
.withAddress(getAfiAddress(appDataAddress.getAddress()))
.build();
}
if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
LispGcAddress gcAddress = (LispGcAddress) mappingAddress;
return new LispGeoCoordinateLcafAddress.GeoCoordinateAddressBuilder()
.withIsNorth(gcAddress.isNorth())
.withLatitudeDegree(gcAddress.getLatitudeDegree())
.withLatitudeMinute(gcAddress.getLatitudeMinute())
.withLatitudeSecond(gcAddress.getLatitudeSecond())
.withIsEast(gcAddress.isEast())
.withLongitudeDegree(gcAddress.getLongitudeDegree())
.withLongitudeMinute(gcAddress.getLongitudeMinute())
.withLongitudeSecond(gcAddress.getLongitudeSecond())
.withAltitude(gcAddress.getAltitude())
.withAddress(getAfiAddress(gcAddress.getAddress()))
.build();
}
if (type.equals(NAT_ADDRESS.type())) {
LispNatAddress natAddress = (LispNatAddress) mappingAddress;
List<LispAfiAddress> aas = Lists.newArrayList();
natAddress.getRtrRlocAddresses()
.forEach(rtr -> aas.add(getAfiAddress(rtr)));
return new LispNatLcafAddress.NatAddressBuilder()
.withMsUdpPortNumber(natAddress.getMsUdpPortNumber())
.withEtrUdpPortNumber(natAddress.getEtrUdpPortNumber())
.withMsRlocAddress(getAfiAddress(natAddress.getMsRlocAddress()))
.withGlobalEtrRlocAddress(
getAfiAddress(natAddress.getGlobalEtrRlocAddress()))
.withPrivateEtrRlocAddress(
getAfiAddress(natAddress.getPrivateEtrRlocAddress()))
.withRtrRlocAddresses(aas)
.build();
}
if (type.equals(NONCE_ADDRESS.type())) {
LispNonceAddress nonceAddress = (LispNonceAddress) mappingAddress;
return new LispNonceLcafAddress.NonceAddressBuilder()
.withNonce(nonceAddress.getNonce())
.withAddress(getAfiAddress(nonceAddress.getAddress()))
.build();
}
if (type.equals(MULTICAST_ADDRESS.type())) {
LispMulticastAddress multicastAddress = (LispMulticastAddress) mappingAddress;
return new LispMulticastLcafAddress.MulticastAddressBuilder()
.withInstanceId(multicastAddress.getInstanceId())
.withSrcAddress(getAfiAddress(multicastAddress.getSrcAddress()))
.withSrcMaskLength(multicastAddress.getSrcMaskLength())
.withGrpAddress(getAfiAddress(multicastAddress.getGrpAddress()))
.withGrpMaskLength(multicastAddress.getGrpMaskLength())
.build();
}
if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
LispTeAddress teAddress = (LispTeAddress) mappingAddress;
List<LispTeRecord> records = Lists.newArrayList();
teAddress.getTeRecords().forEach(record -> {
LispTeRecord teRecord =
new LispTeRecord.TeRecordBuilder()
.withIsLookup(record.isLookup())
.withIsRlocProbe(record.isRlocProbe())
.withIsStrict(record.isStrict())
.withRtrRlocAddress(getAfiAddress(
record.getAddress()))
.build();
records.add(teRecord);
});
return new LispTeLcafAddress.TeAddressBuilder()
.withTeRecords(records)
.build();
}
if (type.equals(SOURCE_DEST_ADDRESS.type())) {
LispSrcDstAddress srcDstAddress = (LispSrcDstAddress) mappingAddress;
return new LispSourceDestLcafAddress.SourceDestAddressBuilder()
.withSrcPrefix(getAfiAddress(srcDstAddress.getSrcPrefix()))
.withSrcMaskLength(srcDstAddress.getSrcMaskLength())
.withDstPrefix(getAfiAddress(srcDstAddress.getDstPrefix()))
.withDstMaskLength(srcDstAddress.getDstMaskLength())
.build();
}
log.error("Unsupported extension mapping address type {}", mappingAddress.type());
return null;
}
@Override
public ExtensionMappingAddress mapLcafAddress(LispLcafAddress lcafAddress) {
switch (lcafAddress.getType()) {
case LIST:
LispListLcafAddress lcafListAddress = (LispListLcafAddress) lcafAddress;
MappingAddress ipv4Ma =
afi2mapping(lcafListAddress.getAddresses().get(0));
MappingAddress ipv6Ma =
afi2mapping(lcafListAddress.getAddresses().get(1));
return new LispListAddress.Builder()
.withIpv4(ipv4Ma)
.withIpv6(ipv6Ma)
.build();
case SEGMENT:
LispSegmentLcafAddress segmentLcafAddress =
(LispSegmentLcafAddress) lcafAddress;
return new LispSegmentAddress.Builder()
.withInstanceId(segmentLcafAddress.getInstanceId())
.withAddress(getMappingAddress(segmentLcafAddress.getAddress()))
.build();
case AS:
LispAsLcafAddress asLcafAddress = (LispAsLcafAddress) lcafAddress;
return new org.onosproject.drivers.lisp.extensions.LispAsAddress.Builder()
.withAsNumber(asLcafAddress.getAsNumber())
.withAddress(getMappingAddress(asLcafAddress.getAddress()))
.build();
case APPLICATION_DATA:
LispAppDataLcafAddress appLcafAddress = (LispAppDataLcafAddress) lcafAddress;
return new LispAppDataAddress.Builder()
.withProtocol(appLcafAddress.getProtocol())
.withIpTos(appLcafAddress.getIpTos())
.withLocalPortLow(appLcafAddress.getLocalPortLow())
.withLocalPortHigh(appLcafAddress.getLocalPortHigh())
.withRemotePortLow(appLcafAddress.getRemotePortLow())
.withRemotePortHigh(appLcafAddress.getRemotePortHigh())
.withAddress(getMappingAddress(appLcafAddress.getAddress()))
.build();
case GEO_COORDINATE:
LispGeoCoordinateLcafAddress gcLcafAddress =
(LispGeoCoordinateLcafAddress) lcafAddress;
return new LispGcAddress.Builder()
.withIsNorth(gcLcafAddress.isNorth())
.withLatitudeDegree(gcLcafAddress.getLatitudeDegree())
.withLatitudeMinute(gcLcafAddress.getLatitudeMinute())
.withLatitudeSecond(gcLcafAddress.getLatitudeSecond())
.withIsEast(gcLcafAddress.isEast())
.withLongitudeDegree(gcLcafAddress.getLongitudeDegree())
.withLongitudeMinute(gcLcafAddress.getLongitudeMinute())
.withLongitudeSecond(gcLcafAddress.getLongitudeSecond())
.withAltitude(gcLcafAddress.getAltitude())
.withAddress(getMappingAddress(gcLcafAddress.getAddress()))
.build();
case NAT:
LispNatLcafAddress natLcafAddress = (LispNatLcafAddress) lcafAddress;
List<MappingAddress> mas = Lists.newArrayList();
natLcafAddress.getRtrRlocAddresses()
.forEach(rtr -> mas.add(getMappingAddress(rtr)));
return new LispNatAddress.Builder()
.withMsUdpPortNumber(natLcafAddress.getMsUdpPortNumber())
.withEtrUdpPortNumber(natLcafAddress.getEtrUdpPortNumber())
.withMsRlocAddress(getMappingAddress(natLcafAddress.getMsRlocAddress()))
.withGlobalEtrRlocAddress(
getMappingAddress(natLcafAddress.getGlobalEtrRlocAddress()))
.withPrivateEtrRlocAddress(
getMappingAddress(natLcafAddress.getPrivateEtrRlocAddress()))
.withRtrRlocAddresses(mas)
.build();
case NONCE:
LispNonceLcafAddress nonceLcafAddress = (LispNonceLcafAddress) lcafAddress;
return new LispNonceAddress.Builder()
.withNonce(nonceLcafAddress.getNonce())
.withAddress(getMappingAddress(nonceLcafAddress.getAddress()))
.build();
case MULTICAST:
LispMulticastLcafAddress multiLcafAddress =
(LispMulticastLcafAddress) lcafAddress;
return new LispMulticastAddress.Builder()
.withInstanceId(multiLcafAddress.getInstanceId())
.withSrcAddress(getMappingAddress(multiLcafAddress.getSrcAddress()))
.withSrcMaskLength(multiLcafAddress.getSrcMaskLength())
.withGrpAddress(getMappingAddress(multiLcafAddress.getGrpAddress()))
.withGrpMaskLength(multiLcafAddress.getGrpMaskLength())
.build();
case TRAFFIC_ENGINEERING:
LispTeLcafAddress teLcafAddress = (LispTeLcafAddress) lcafAddress;
List<LispTeAddress.TeRecord> records = Lists.newArrayList();
teLcafAddress.getTeRecords().forEach(record -> {
LispTeAddress.TeRecord teRecord =
new LispTeAddress.TeRecord.Builder()
.withIsLookup(record.isLookup())
.withIsRlocProbe(record.isRlocProbe())
.withIsStrict(record.isStrict())
.withRtrRlocAddress(getMappingAddress(
record.getRtrRlocAddress()))
.build();
records.add(teRecord);
});
return new LispTeAddress.Builder()
.withTeRecords(records)
.build();
case SECURITY:
// TODO: need to implement security type later
log.warn("security type will be implemented later");
return null;
case SOURCE_DEST:
LispSourceDestLcafAddress srcDstLcafAddress =
(LispSourceDestLcafAddress) lcafAddress;
return new LispSrcDstAddress.Builder()
.withSrcPrefix(getMappingAddress(srcDstLcafAddress.getSrcPrefix()))
.withSrcMaskLength(srcDstLcafAddress.getSrcMaskLength())
.withDstPrefix(getMappingAddress(srcDstLcafAddress.getDstPrefix()))
.withDstMaskLength(srcDstLcafAddress.getDstMaskLength())
.build();
case UNSPECIFIED:
case UNKNOWN:
default:
log.error("Unsupported LCAF type {}", lcafAddress.getType());
return null;
}
}
@Override
public ExtensionMappingAddress getExtensionMappingAddress(
ExtensionMappingAddressType type) {
if (type.equals(LIST_ADDRESS.type())) {
return new LispListAddress();
}
if (type.equals(SEGMENT_ADDRESS.type())) {
return new LispSegmentAddress();
}
if (type.equals(AS_ADDRESS.type())) {
return new LispAsAddress();
}
if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
return new LispAppDataAddress();
}
if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
return new LispGcAddress();
}
if (type.equals(NAT_ADDRESS.type())) {
return new LispNatAddress();
}
if (type.equals(NONCE_ADDRESS.type())) {
return new LispNonceAddress();
}
if (type.equals(MULTICAST_ADDRESS.type())) {
return new LispMulticastAddress();
}
if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
return new LispTeAddress();
}
if (type.equals(SOURCE_DEST_ADDRESS.type())) {
return new LispSrcDstAddress();
}
return null;
}
/**
* Converts AFI address to generalized mapping address.
*
* @param afi IP typed AFI address
* @return generalized mapping address
*/
private MappingAddress afi2mapping(LispAfiAddress afi) {
switch (afi.getAfi()) {
case IP4:
IpAddress ipv4Address = ((LispIpv4Address) afi).getAddress();
IpPrefix ipv4Prefix = IpPrefix.valueOf(ipv4Address, IPV4_PREFIX_LENGTH);
return MappingAddresses.ipv4MappingAddress(ipv4Prefix);
case IP6:
IpAddress ipv6Address = ((LispIpv6Address) afi).getAddress();
IpPrefix ipv6Prefix = IpPrefix.valueOf(ipv6Address, IPV6_PREFIX_LENGTH);
return MappingAddresses.ipv6MappingAddress(ipv6Prefix);
default:
log.warn("Only support to convert IP address type");
break;
}
return null;
}
/**
* Converts mapping address to AFI address.
*
* @param address generalized mapping address
* @return IP typed AFI address
*/
private LispAfiAddress mapping2afi(MappingAddress address) {
switch (address.type()) {
case IPV4:
IpPrefix ipv4Prefix = ((IPMappingAddress) address).ip();
return new LispIpv4Address(ipv4Prefix.address());
case IPV6:
IpPrefix ipv6Prefix = ((IPMappingAddress) address).ip();
return new LispIpv6Address(ipv6Prefix.address());
default:
log.warn("Only support to convert IP address type");
break;
}
return null;
}
/**
* Converts LispAfiAddress into abstracted mapping address.
*
* @param address LispAfiAddress
* @return abstracted mapping address
*/
private MappingAddress getMappingAddress(LispAfiAddress address) {
if (address == null) {
log.warn("Address is not specified.");
return null;
}
switch (address.getAfi()) {
case IP4:
return afi2mapping(address);
case IP6:
return afi2mapping(address);
case AS:
int asNum = ((org.onosproject.lisp.msg.types.LispAsAddress) address).getASNum();
return MappingAddresses.asMappingAddress(String.valueOf(asNum));
case DISTINGUISHED_NAME:
String dn = ((LispDistinguishedNameAddress)
address).getDistinguishedName();
return MappingAddresses.dnMappingAddress(dn);
case MAC:
MacAddress macAddress = ((LispMacAddress) address).getAddress();
return MappingAddresses.ethMappingAddress(macAddress);
case LCAF:
LispLcafAddress lcafAddress = (LispLcafAddress) address;
return MappingAddresses.extensionMappingAddressWrapper(mapLcafAddress(lcafAddress));
default:
log.warn("Unsupported address AFI type {}", address.getAfi());
break;
}
return null;
}
/**
* Converts mapping address into afi address.
*
* @param address mapping address
* @return afi address
*/
private LispAfiAddress getAfiAddress(MappingAddress address) {
if (address == null) {
log.warn("Address is not specified.");
return null;
}
switch (address.type()) {
case IPV4:
return mapping2afi(address);
case IPV6:
return mapping2afi(address);
case AS:
int asNum = ((org.onosproject.lisp.msg.types.LispAsAddress) address).getASNum();
return new org.onosproject.lisp.msg.types.LispAsAddress(asNum);
case DN:
String dn = ((LispDistinguishedNameAddress) address).getDistinguishedName();
return new LispDistinguishedNameAddress(dn);
case ETH:
MacAddress macAddress = ((LispMacAddress) address).getAddress();
return new LispMacAddress(macAddress);
case EXTENSION:
ExtensionMappingAddress extAddress = (ExtensionMappingAddress) address;
return mapMappingAddress(extAddress);
default:
log.warn("Unsupported address type {}", address.type());
break;
}
return null;
}
@Override
public ObjectNode encode(ExtensionMappingAddress mappingAddress, CodecContext context) {
checkNotNull(mappingAddress, "Extension mapping address cannot be null");
ExtensionMappingAddressType type = mappingAddress.type();
ObjectNode root = context.mapper().createObjectNode();
if (type.equals(LIST_ADDRESS.type())) {
LispListAddress listAddress = (LispListAddress) mappingAddress;
root.set(LISP_LIST_ADDRESS,
context.codec(LispListAddress.class).encode(listAddress, context));
}
if (type.equals(SEGMENT_ADDRESS.type())) {
LispSegmentAddress segmentAddress = (LispSegmentAddress) mappingAddress;
root.set(LISP_SEGMENT_ADDRESS,
context.codec(LispSegmentAddress.class).encode(segmentAddress, context));
}
if (type.equals(AS_ADDRESS.type())) {
LispAsAddress asAddress = (LispAsAddress) mappingAddress;
root.set(LISP_AS_ADDRESS,
context.codec(LispAsAddress.class).encode(asAddress, context));
}
if (type.equals(APPLICATION_DATA_ADDRESS.type())) {
LispAppDataAddress appDataAddress = (LispAppDataAddress) mappingAddress;
root.set(LISP_APPLICATION_DATA_ADDRESS,
context.codec(LispAppDataAddress.class).encode(appDataAddress, context));
}
if (type.equals(GEO_COORDINATE_ADDRESS.type())) {
LispGcAddress gcAddress = (LispGcAddress) mappingAddress;
root.set(LISP_GEO_COORDINATE_ADDRESS,
context.codec(LispGcAddress.class).encode(gcAddress, context));
}
if (type.equals(NAT_ADDRESS.type())) {
LispNatAddress natAddress = (LispNatAddress) mappingAddress;
root.set(LISP_NAT_ADDRESS,
context.codec(LispNatAddress.class).encode(natAddress, context));
}
if (type.equals(NONCE_ADDRESS.type())) {
LispNonceAddress nonceAddress = (LispNonceAddress) mappingAddress;
root.set(LISP_NONCE_ADDRESS, context.codec(LispNonceAddress.class).encode(nonceAddress, context));
}
if (type.equals(MULTICAST_ADDRESS.type())) {
LispMulticastAddress multicastAddress = (LispMulticastAddress) mappingAddress;
root.set(LISP_MULTICAST_ADDRESS,
context.codec(LispMulticastAddress.class).encode(multicastAddress, context));
}
if (type.equals(TRAFFIC_ENGINEERING_ADDRESS.type())) {
LispTeAddress teAddress = (LispTeAddress) mappingAddress;
root.set(LISP_TRAFFIC_ENGINEERING_ADDRESS,
context.codec(LispTeAddress.class).encode(teAddress, context));
}
if (type.equals(SOURCE_DEST_ADDRESS.type())) {
LispSrcDstAddress srcDstAddress = (LispSrcDstAddress) mappingAddress;
root.set(LISP_SOURCE_DEST_ADDRESS,
context.codec(LispSrcDstAddress.class).encode(srcDstAddress, context));
}
return root;
}
@Override
public ExtensionMappingAddress decode(ObjectNode json, CodecContext context) {
if (json == null || !json.isObject()) {
return null;
}
// parse extension type
String typeString = nullIsIllegal(json.get(TYPE),
TYPE + MISSING_MEMBER_MESSAGE).asText();
if (typeString.equals(LIST_ADDRESS.name())) {
return context.codec(LispListAddress.class)
.decode(get(json, LISP_LIST_ADDRESS), context);
}
if (typeString.equals(SEGMENT_ADDRESS.name())) {
return context.codec(LispSegmentAddress.class)
.decode(get(json, LISP_SEGMENT_ADDRESS), context);
}
if (typeString.equals(AS_ADDRESS.name())) {
return context.codec(LispAsAddress.class)
.decode(get(json, LISP_AS_ADDRESS), context);
}
if (typeString.equals(APPLICATION_DATA_ADDRESS.name())) {
return context.codec(LispAppDataAddress.class)
.decode(get(json, LISP_APPLICATION_DATA_ADDRESS), context);
}
if (typeString.equals(GEO_COORDINATE_ADDRESS.name())) {
return context.codec(LispGcAddress.class)
.decode(get(json, LISP_GEO_COORDINATE_ADDRESS), context);
}
if (typeString.equals(NAT_ADDRESS.name())) {
return context.codec(LispNatAddress.class)
.decode(get(json, LISP_NAT_ADDRESS), context);
}
if (typeString.equals(NONCE_ADDRESS.name())) {
return context.codec(LispNonceAddress.class)
.decode(get(json, LISP_NONCE_ADDRESS), context);
}
if (typeString.equals(MULTICAST_ADDRESS.name())) {
return context.codec(LispMulticastAddress.class)
.decode(get(json, LISP_MULTICAST_ADDRESS), context);
}
if (typeString.equals(TRAFFIC_ENGINEERING_ADDRESS.name())) {
return context.codec(LispTeAddress.class)
.decode(get(json, LISP_TRAFFIC_ENGINEERING_ADDRESS), context);
}
if (typeString.equals(SOURCE_DEST_ADDRESS.name())) {
return context.codec(LispSrcDstAddress.class)
.decode(get(json, LISP_SOURCE_DEST_ADDRESS), context);
}
throw new UnsupportedOperationException(
"Driver does not support extension type " + typeString);
}
/**
* Gets a child Object Node from a parent by name. If the child is not found
* or does nor represent an object, null is returned.
*
* @param parent parent object
* @param childName name of child to query
* @return child object if found, null if not found or if not an object
*/
private static ObjectNode get(ObjectNode parent, String childName) {
JsonNode node = parent.path(childName);
return node.isObject() && !node.isNull() ? (ObjectNode) node : null;
}
}