diff options
Diffstat (limited to 'lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx')
6 files changed, 644 insertions, 0 deletions
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeEntryIdentifier.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeEntryIdentifier.java new file mode 100644 index 000000000..466a422e1 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeEntryIdentifier.java @@ -0,0 +1,151 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.lisp.gpe.translate.ctx; + +import io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDumpParams; +import io.fd.hc2vpp.lisp.translate.util.EidTranslator; +import io.fd.vpp.jvpp.core.types.GpeFwdEntry; +import javax.annotation.Nonnull; +import org.apache.commons.lang3.builder.EqualsBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.GpeEntryIdentificator; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.gpe.entry.identificator.LocalEid; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.gpe.entry.identificator.LocalEidBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.gpe.entry.identificator.RemoteEid; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.gpe.entry.identificator.RemoteEidBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.GpeEntry; + + +/** + * Uniquely identifies gpe entry in mapping context + */ +public final class GpeEntryIdentifier implements EidTranslator { + + private final long vni; + private final LocalEid localEid; + private final RemoteEid remoteEid; + + private GpeEntryIdentifier(final long vni, + @Nonnull final LocalEid localEid, + @Nonnull final RemoteEid remoteEid) { + this.vni = vni; + this.localEid = localEid; + this.remoteEid = remoteEid; + } + + public long getVni() { + return vni; + } + + public LocalEid getLocalEid() { + return localEid; + } + + public RemoteEid getRemoteEid() { + return remoteEid; + } + + public boolean isSame(@Nonnull final GpeEntryIdentificator identificator) { + return new EqualsBuilder() + .append(true, compareEids(this.getLocalEid(), identificator.getLocalEid())) + .append(true, compareEids(this.getRemoteEid(), identificator.getRemoteEid())) + .append(this.vni, identificator.getVni().longValue()) + .isEquals(); + } + + public static GpeEntryIdentifier fromEntry(final GpeEntry data) { + return new GpeEntryIdentifier.GpeEntryIdentifierBuilder() + .setLocalEid(data.getLocalEid()) + .setRemoteEid(data.getRemoteEid()) + .setVni(data.getVni()) + .createGpeEntryIdentifier(); + } + + public static GpeEntryIdentifier fromDumpDetail(final GpeFwdEntry entry) { + return new GpeEntryIdentifier.GpeEntryIdentifierBuilder() + .setVni(entry.vni) + .setLocalEid( + INSTANCE.getArrayAsGpeLocalEid(MappingsDumpParams.EidType.valueOf(entry.eidType), entry.leid, + entry.leidPrefixLen, entry.vni)) + .setRemoteEid( + INSTANCE.getArrayAsGpeRemoteEid(MappingsDumpParams.EidType.valueOf(entry.eidType), entry.reid, + entry.reidPrefixLen, entry.vni)) + .createGpeEntryIdentifier(); + } + + public static final class GpeEntryIdentifierBuilder { + private long vni; + private LocalEid localEid; + private RemoteEid remoteEid; + + public GpeEntryIdentifierBuilder setVni(final long vni) { + this.vni = vni; + return this; + } + + public GpeEntryIdentifierBuilder setLocalEid( + @Nonnull final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.gpe.entry.LocalEid localEid) { + this.localEid = new LocalEidBuilder() + .setAddress(localEid.getAddress()) + .setAddressType(localEid.getAddressType()) + .setVirtualNetworkId(localEid.getVirtualNetworkId()) + .build(); + return this; + } + + public GpeEntryIdentifierBuilder setRemoteEid( + @Nonnull final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.gpe.entry.RemoteEid remoteEid) { + this.remoteEid = new RemoteEidBuilder() + .setAddress(remoteEid.getAddress()) + .setAddressType(remoteEid.getAddressType()) + .setVirtualNetworkId(remoteEid.getVirtualNetworkId()) + .build(); + return this; + } + + public GpeEntryIdentifier createGpeEntryIdentifier() { + return new GpeEntryIdentifier(vni, localEid, remoteEid); + } + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + final GpeEntryIdentifier that = (GpeEntryIdentifier) o; + + if (vni != that.vni) { + return false; + } + if (!localEid.equals(that.localEid)) { + return false; + } + return remoteEid.equals(that.remoteEid); + } + + @Override + public int hashCode() { + int result = (int) (vni ^ (vni >>> 32)); + result = 31 * result + localEid.hashCode(); + result = 31 * result + remoteEid.hashCode(); + return result; + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeEntryMappingContext.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeEntryMappingContext.java new file mode 100644 index 000000000..fb8982add --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeEntryMappingContext.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.lisp.gpe.translate.ctx; + +import io.fd.honeycomb.translate.MappingContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.GpeEntryIdentificator; + + +/** + * Provides mapping context for gpe entries + */ +public interface GpeEntryMappingContext { + + /** + * Adds context mapping for specified id to gpe entry + */ + void addMapping(@Nonnull final String id, + @Nonnull final GpeEntryIdentifier identifier, + @Nonnull final MappingContext mappingContext); + + /** + * Remove context mapping for specified id + */ + void removeMapping(@Nonnull final String id, + @Nonnull final MappingContext mappingContext); + + /** + * Returns identificator for specific id + */ + GpeEntryIdentificator getIdentificatorById(@Nonnull final String id, + @Nonnull final MappingContext mappingContext); + + + /** + * Returns id for specified identifier + */ + String getIdByEntryIdentifier(@Nonnull final GpeEntryIdentifier identifier, + @Nonnull final MappingContext mappingContext); +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeEntryMappingContextImpl.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeEntryMappingContextImpl.java new file mode 100644 index 000000000..759931204 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeEntryMappingContextImpl.java @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.lisp.gpe.translate.ctx; + +import static java.lang.String.format; + +import io.fd.honeycomb.translate.MappingContext; +import java.util.Collection; +import java.util.Optional; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.GpeEntryIdentificationCtxAugmentation; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.GpeEntryIdentificationContexts; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.GpeEntryIdentification; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.GpeEntryIdentificationKey; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.Mappings; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.Mapping; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.MappingBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.MappingKey; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.GpeEntryIdentificator; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.GpeEntryIdentificatorBuilder; +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; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class GpeEntryMappingContextImpl implements GpeEntryMappingContext { + + private static final Logger LOG = LoggerFactory.getLogger(GpeEntryMappingContextImpl.class); + + private final KeyedInstanceIdentifier<GpeEntryIdentification, GpeEntryIdentificationKey> + namingContextIid; + + /** + * Create new naming context + * + * @param instanceName name of this context instance. Will be used as list item identifier within context data tree + */ + public GpeEntryMappingContextImpl(@Nonnull final String instanceName) { + namingContextIid = InstanceIdentifier.create(Contexts.class) + .augmentation(GpeEntryIdentificationCtxAugmentation.class) + .child(GpeEntryIdentificationContexts.class) + .child(GpeEntryIdentification.class, new GpeEntryIdentificationKey(instanceName)); + } + + @Override + public void addMapping(@Nonnull final String id, + @Nonnull final GpeEntryIdentifier identifier, + @Nonnull final MappingContext mappingContext) { + LOG.debug("Adding mapping for gpe-entry[id={},entry-identifier={}]", id, identifier); + mappingContext.put(getMappingId(id), getMapping(id, identifier)); + LOG.debug("Mapping for gp-entry[id={}] successfully added", id); + } + + @Override + public void removeMapping(@Nonnull final String id, + @Nonnull final MappingContext mappingContext) { + LOG.debug("Removing mapping for gpe-entry[id={}]", id); + mappingContext.delete(getMappingId(id)); + LOG.debug("Mapping for gpe-entry[id={}] removed", id); + } + + @Override + public GpeEntryIdentificator getIdentificatorById(@Nonnull final String id, + @Nonnull final MappingContext mappingContext) { + final com.google.common.base.Optional<Mappings> read = + mappingContext.read(namingContextIid.child(Mappings.class)); + + if (read.isPresent()) { + return Optional.of(read.get()) + .map(Mappings::getMapping) + .map(Collection::stream) + .map(mappingStream -> mappingStream + .filter(mapping -> mapping.getId().equals(id)) + .map(Mapping::getGpeEntryIdentificator) + .findAny().orElse(null)) + .orElseThrow(() -> new IllegalStateException(format("No mapping for id %s", id))); + + } + throw new IllegalStateException(format("No mapping for id %s", id)); + } + + @Override + public String getIdByEntryIdentifier(@Nonnull final GpeEntryIdentifier identifier, + @Nonnull final MappingContext mappingContext) { + final com.google.common.base.Optional<Mappings> read = + mappingContext.read(namingContextIid.child(Mappings.class)); + + if (read.isPresent()) { + return Optional.of(read.get()) + .map(Mappings::getMapping) + .map(Collection::stream) + .map(mappingStream -> mappingStream + .filter(mapping -> identifier.isSame(mapping.getGpeEntryIdentificator())) + .map(Mapping::getId) + .findAny().orElse(null)) + .orElse(addArtificialMapping(identifier, mappingContext)); + } + + return addArtificialMapping(identifier, mappingContext); + } + + private String addArtificialMapping(@Nonnull final GpeEntryIdentifier identifier, + @Nonnull final MappingContext mappingContext) { + final String artificialName = buildArtificialName(identifier); + addMapping(artificialName, identifier, mappingContext); + return artificialName; + } + + private String buildArtificialName(@Nonnull final GpeEntryIdentifier identifier) { + return format("%s_%s_%s", identifier.getVni(), identifier.getLocalEid().getAddress(), + identifier.getRemoteEid().getAddress()); + } + + private KeyedInstanceIdentifier<Mapping, MappingKey> getMappingId(final String id) { + return namingContextIid.child(Mappings.class).child(Mapping.class, new MappingKey(id)); + } + + private Mapping getMapping(@Nonnull final String id, + @Nonnull final GpeEntryIdentifier identifier) { + return new MappingBuilder() + .setId(id) + .setGpeEntryIdentificator(new GpeEntryIdentificatorBuilder() + .setLocalEid(identifier.getLocalEid()) + .setRemoteEid(identifier.getRemoteEid()) + .setVni(identifier.getVni()) + .build()) + .build(); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeLocatorPair.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeLocatorPair.java new file mode 100644 index 000000000..a5cf13191 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeLocatorPair.java @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.lisp.gpe.translate.ctx; + +import io.fd.hc2vpp.common.translate.util.AddressTranslator; +import io.fd.vpp.jvpp.core.dto.GpeFwdEntryPathDetails; +import java.util.Arrays; +import javax.annotation.Nonnull; +import org.apache.commons.lang3.builder.EqualsBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.mapping.locator.pair.mapping.Pair; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.gpe.entry.LocatorPairs; + +public final class GpeLocatorPair implements AddressTranslator { + + private final IpAddress localAddress; + private final IpAddress remoteAddress; + + private GpeLocatorPair(@Nonnull final IpAddress localAddress, @Nonnull final IpAddress remoteAddress) { + this.localAddress = localAddress; + this.remoteAddress = remoteAddress; + } + + public IpAddress getLocalAddress() { + return localAddress; + } + + public IpAddress getRemoteAddress() { + return remoteAddress; + } + + public boolean isSame(@Nonnull final Pair pair) { + return new EqualsBuilder() + .append(true, Arrays.equals(this.localAddress.getValue(), pair.getLocalAddress().getValue())) + .append(true, Arrays.equals(this.remoteAddress.getValue(), pair.getRemoteAddress().getValue())) + .isEquals(); + } + + public static GpeLocatorPair fromDumpDetail(final GpeFwdEntryPathDetails entry) { + return new GpeLocatorPair.GpeLocatorPairBuilder() + .setLocalAddress( + INSTANCE.arrayToIpAddress(!INSTANCE.byteToBoolean(entry.lclLoc.isIp4), + entry.lclLoc.addr)) + .setRemoteAddress( + INSTANCE.arrayToIpAddress(!INSTANCE.byteToBoolean(entry.rmtLoc.isIp4), + entry.rmtLoc.addr)) + .createGpeLocatorPairIdentifier(); + } + + public static GpeLocatorPair fromLocatorPair(final LocatorPairs locatorPair) { + return new GpeLocatorPair.GpeLocatorPairBuilder() + .setLocalAddress(locatorPair.getLocatorPair().getLocalLocator()) + .setRemoteAddress(locatorPair.getLocatorPair().getRemoteLocator()) + .createGpeLocatorPairIdentifier(); + } + + public static final class GpeLocatorPairBuilder { + private IpAddress localAddress; + private IpAddress remoteAddress; + + public GpeLocatorPairBuilder setLocalAddress(@Nonnull final IpAddress localAddress) { + this.localAddress = localAddress; + return this; + } + + public GpeLocatorPairBuilder setRemoteAddress(@Nonnull final IpAddress remoteAddress) { + this.remoteAddress = remoteAddress; + return this; + } + + public GpeLocatorPair createGpeLocatorPairIdentifier() { + return new GpeLocatorPair(localAddress, remoteAddress); + } + } + + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + final GpeLocatorPair that = (GpeLocatorPair) o; + + if (!localAddress.equals(that.localAddress)) { + return false; + } + return remoteAddress.equals(that.remoteAddress); + } + + @Override + public int hashCode() { + int result = localAddress.hashCode(); + result = 31 * result + remoteAddress.hashCode(); + return result; + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeLocatorPairMappingContext.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeLocatorPairMappingContext.java new file mode 100644 index 000000000..b2226a1b6 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeLocatorPairMappingContext.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.lisp.gpe.translate.ctx; + +import io.fd.honeycomb.translate.MappingContext; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.mapping.LocatorPairMapping; + +/** + * Context mapping of gpe entries to locator pairs + */ +public interface GpeLocatorPairMappingContext { + + /** + * Adds mapping for entry and specified locator + */ + void addMapping(@Nonnull String entryId, + @Nonnull String locatorId, + @Nonnull GpeLocatorPair pair, + @Nonnull MappingContext mappingContext); + + /** + * Remote all mappings for entry + */ + void removeMapping(@Nonnull String entryId, + @Nonnull MappingContext mappingContext); + + /** + * Returns mapping for specified entry and locator + */ + LocatorPairMapping getMapping(@Nonnull String entryId, + @Nonnull GpeLocatorPair pair, + @Nonnull MappingContext mappingContext); + + /** + * Returns mapping for specified entry and locator + */ + LocatorPairMapping getMapping(@Nonnull String entryId, + @Nonnull String locatorId, + @Nonnull MappingContext mappingContext); +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeLocatorPairMappingContextImpl.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeLocatorPairMappingContextImpl.java new file mode 100644 index 000000000..94b19996b --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/gpe/translate/ctx/GpeLocatorPairMappingContextImpl.java @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.hc2vpp.lisp.gpe.translate.ctx; + +import static java.lang.String.format; + +import io.fd.honeycomb.translate.MappingContext; +import java.util.Collections; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.GpeLocatorPairIdentificationCtxAugmentation; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.GpeLocatorPairIdentificationContexts; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.GpeLocatorPairIdentification; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.GpeLocatorPairIdentificationKey; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.Mappings; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.Mapping; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.MappingBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.MappingKey; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.mapping.LocatorPairMapping; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.mapping.LocatorPairMappingBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.mapping.locator.pair.mapping.PairBuilder; +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; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class GpeLocatorPairMappingContextImpl implements GpeLocatorPairMappingContext { + + private static final Logger LOG = LoggerFactory.getLogger(GpeLocatorPairMappingContextImpl.class); + + private final KeyedInstanceIdentifier<GpeLocatorPairIdentification, GpeLocatorPairIdentificationKey> + namingContextIid; + + public GpeLocatorPairMappingContextImpl(@Nonnull final String instanceName) { + namingContextIid = InstanceIdentifier.create(Contexts.class) + .augmentation(GpeLocatorPairIdentificationCtxAugmentation.class) + .child(GpeLocatorPairIdentificationContexts.class) + .child(GpeLocatorPairIdentification.class, new GpeLocatorPairIdentificationKey(instanceName)); + } + + + @Override + public void addMapping(@Nonnull final String entryId, + @Nonnull final String locatorId, + @Nonnull final GpeLocatorPair pair, + @Nonnull final MappingContext mappingContext) { + LOG.debug("Adding mapping for Gpe entry to locator id[entry-id={},locator-pair-id={}]", entryId, locatorId); + mappingContext.merge(getMappingId(entryId), getMappingData(entryId, locatorId, pair)); + LOG.debug("Mapping for Gpe entry to locator id[entry-id={},locator-pair-id={}] successfully added", entryId, + locatorId); + } + + @Override + public void removeMapping(@Nonnull final String entryId, + @Nonnull final MappingContext mappingContext) { + LOG.debug("Removing all mappings for Gpe entry[id={}]", entryId); + mappingContext.delete(getMappingId(entryId)); + LOG.debug("All mappings for Gpe entry[id={}] removed", entryId); + } + + @Override + public LocatorPairMapping getMapping(@Nonnull final String entryId, + @Nonnull final GpeLocatorPair pair, + @Nonnull final MappingContext mappingContext) { + return mappingContext.read(getMappingId(entryId)) + .or(new MappingBuilder().setLocatorPairMapping(Collections.emptyList()).build()) + .getLocatorPairMapping() + .stream() + .filter(mapping -> pair.isSame(mapping.getPair())) + .findAny().orElseGet(() -> { + final String artificialLocatorId = artificialLocatorPairId(entryId, pair); + addMapping(entryId, artificialLocatorId, pair, mappingContext); + return getMapping(entryId, artificialLocatorId, mappingContext); + }); + } + + @Override + public LocatorPairMapping getMapping(@Nonnull final String entryId, + @Nonnull final String locatorId, + @Nonnull final MappingContext mappingContext) { + return mappingContext.read(getMappingId(entryId)) + .or(new MappingBuilder().setLocatorPairMapping(Collections.emptyList()).build()) + .getLocatorPairMapping() + .stream() + .filter(mapping -> mapping.getId().equals(locatorId)) + .findAny().orElseThrow(() -> new IllegalArgumentException( + format("No mapping for entry %s|locator %s", entryId, locatorId))); + } + + private String artificialLocatorPairId(final String entryId, final GpeLocatorPair pair) { + return format("%s_%s_%s", entryId, pair.getLocalAddress(), pair.getRemoteAddress()); + } + + private Mapping getMappingData(final String entryId, + final String locatorId, + final GpeLocatorPair identifier) { + return new MappingBuilder() + .setId(entryId) + .setLocatorPairMapping(Collections.singletonList(new LocatorPairMappingBuilder() + .setId(locatorId) + .setPair(new PairBuilder() + .setLocalAddress(identifier.getLocalAddress()) + .setRemoteAddress(identifier.getRemoteAddress()) + .build()) + .build())).build(); + } + + private KeyedInstanceIdentifier<Mapping, MappingKey> getMappingId(final String id) { + return namingContextIid.child(Mappings.class) + .child(Mapping.class, new MappingKey(id)); + } +} + |