diff options
Diffstat (limited to 'lisp/lisp2vpp/src/main/java')
18 files changed, 982 insertions, 13 deletions
diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/LispModule.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/LispModule.java index 90ca83343..5e674f52b 100644 --- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/LispModule.java +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/LispModule.java @@ -35,10 +35,12 @@ import io.fd.hc2vpp.lisp.translate.read.factory.EidTableReaderFactory; import io.fd.hc2vpp.lisp.translate.read.factory.LispStateReaderFactory; import io.fd.hc2vpp.lisp.translate.read.factory.LocatorSetReaderFactory; import io.fd.hc2vpp.lisp.translate.read.factory.MapResolverReaderFactory; +import io.fd.hc2vpp.lisp.translate.read.factory.MapServerReaderFactory; import io.fd.hc2vpp.lisp.translate.write.factory.EidTableWriterFactory; import io.fd.hc2vpp.lisp.translate.write.factory.LispWriterFactory; import io.fd.hc2vpp.lisp.translate.write.factory.LocatorSetWriterFactory; import io.fd.hc2vpp.lisp.translate.write.factory.MapResolverWriterFactory; +import io.fd.hc2vpp.lisp.translate.write.factory.MapServerWriterFactory; import io.fd.honeycomb.translate.read.ReaderFactory; import io.fd.honeycomb.translate.write.WriterFactory; import net.jmob.guice.conf.core.ConfigurationModule; @@ -81,6 +83,7 @@ public class LispModule extends AbstractModule { readerFactoryBinder.addBinding().to(EidTableReaderFactory.class); readerFactoryBinder.addBinding().to(LocatorSetReaderFactory.class); readerFactoryBinder.addBinding().to(MapResolverReaderFactory.class); + readerFactoryBinder.addBinding().to(MapServerReaderFactory.class); LOG.info("Reader factories binded"); LOG.info("Binding writer factories"); @@ -89,6 +92,7 @@ public class LispModule extends AbstractModule { writerFactoryBinder.addBinding().to(EidTableWriterFactory.class); writerFactoryBinder.addBinding().to(LocatorSetWriterFactory.class); writerFactoryBinder.addBinding().to(MapResolverWriterFactory.class); + writerFactoryBinder.addBinding().to(MapServerWriterFactory.class); LOG.info("Writer factories binded"); final Multibinder<ReaderFactory> readerBinder = Multibinder.newSetBinder(binder(), ReaderFactory.class); diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/AbstractLispInfraFactoryBase.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/AbstractLispInfraFactoryBase.java index eeda656bc..022ea19ed 100644 --- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/AbstractLispInfraFactoryBase.java +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/AbstractLispInfraFactoryBase.java @@ -27,11 +27,16 @@ import com.google.inject.name.Named; import io.fd.hc2vpp.common.translate.util.NamingContext; import io.fd.hc2vpp.lisp.context.util.AdjacenciesMappingContext; import io.fd.hc2vpp.lisp.context.util.EidMappingContext; +import io.fd.honeycomb.translate.impl.write.GenericWriter; +import io.fd.honeycomb.translate.spi.write.WriterCustomizer; import io.fd.vpp.jvpp.core.future.FutureJVppCore; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.LispState; +import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import javax.annotation.Nonnull; + /** * Basic attributes for lisp writer factories @@ -68,4 +73,10 @@ public abstract class AbstractLispInfraFactoryBase { @Inject @Named(ADJACENCIES_IDENTIFICATION_CONTEXT) protected AdjacenciesMappingContext adjacenciesMappingContext; + + @Nonnull + protected <D extends DataObject> GenericWriter<D> writer(@Nonnull final InstanceIdentifier<D> type, + @Nonnull final WriterCustomizer<D> customizer) { + return new GenericWriter<>(type, customizer); + } } diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizer.java index 44f5f2dd2..69df09c80 100755 --- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizer.java +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizer.java @@ -35,6 +35,7 @@ import io.fd.vpp.jvpp.core.dto.LispEidTableDetailsReplyDump; import io.fd.vpp.jvpp.core.future.FutureJVppCore; import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.eid.mapping.context.rev160801.contexts.eid.mapping.context.mappings.mapping.Eid; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.HmacKeyType; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MappingId; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.LocalMappings; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.LocalMappingsBuilder; @@ -42,6 +43,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.LocalMappingBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.LocalMappingKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.VniTable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.hmac.key.grouping.HmacKeyBuilder; import org.opendaylight.yangtools.concepts.Builder; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -133,6 +135,16 @@ public class LocalMappingCustomizer builder.setLocatorSet(locatorSetContext.getName(details.locatorSetIndex, ctx.getMappingContext())); builder.setKey(new LocalMappingKey(new MappingId(id.firstKeyOf(LocalMapping.class).getId()))); builder.setEid(getArrayAsEidLocal(valueOf(details.eidType), details.eid, details.vni)); + + if (details.key != null) { + builder.setHmacKey( + new HmacKeyBuilder() + .setKey(toString(details.key)) + .setKeyType(HmacKeyType.forValue(details.keyId)) + .build()); + } else { + builder.setHmacKey(new HmacKeyBuilder().setKeyType(HmacKeyType.NoKey).build()); + } } private Address getAddressFromDumpDetail(final LispEidTableDetails detail) { diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRegisterCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRegisterCustomizer.java new file mode 100644 index 000000000..e94bb92f0 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRegisterCustomizer.java @@ -0,0 +1,78 @@ +/* + * 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.translate.read; + +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.Initialized; +import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.ShowLispMapRegisterState; +import io.fd.vpp.jvpp.core.dto.ShowLispMapRegisterStateReply; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegisterBuilder; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapRegisterCustomizer extends FutureJVppCustomizer + implements InitializingReaderCustomizer<MapRegister, MapRegisterBuilder>, ByteDataTranslator, + JvppReplyConsumer, LispInitPathsMapper { + + public MapRegisterCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + } + + @Nonnull + @Override + public MapRegisterBuilder getBuilder(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier) { + return new MapRegisterBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier, + @Nonnull MapRegisterBuilder mapRegisterBuilder, + @Nonnull ReadContext readContext) throws ReadFailedException { + final ShowLispMapRegisterStateReply read = getReplyForRead(getFutureJVpp() + .showLispMapRegisterState(new ShowLispMapRegisterState()).toCompletableFuture(), instanceIdentifier); + + if (read != null) { + mapRegisterBuilder.setEnabled(byteToBoolean(read.isEnabled)); + } + } + + @Override + public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull MapRegister mapRegister) { + LispFeatureDataBuilder.class.cast(builder).setMapRegister(mapRegister); + } + + @Nonnull + @Override + public Initialized<? extends DataObject> init(@Nonnull final InstanceIdentifier<MapRegister> instanceIdentifier, + @Nonnull final MapRegister mapRegister, + @Nonnull final ReadContext readContext) { + return Initialized.create(lispFeaturesBasePath().child(MapRegister.class), mapRegister); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRequestModeCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRequestModeCustomizer.java new file mode 100644 index 000000000..9de5b5c68 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapRequestModeCustomizer.java @@ -0,0 +1,79 @@ +/* + * 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.translate.read; + +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.Initialized; +import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.ShowLispMapRequestMode; +import io.fd.vpp.jvpp.core.dto.ShowLispMapRequestModeReply; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestModeBuilder; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapRequestModeCustomizer extends FutureJVppCustomizer + implements InitializingReaderCustomizer<MapRequestMode, MapRequestModeBuilder>, + JvppReplyConsumer, LispInitPathsMapper { + + public MapRequestModeCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + } + + @Nonnull + @Override + public MapRequestModeBuilder getBuilder(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier) { + return new MapRequestModeBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, + @Nonnull MapRequestModeBuilder mapRequestModeBuilder, + @Nonnull ReadContext readContext) throws ReadFailedException { + final ShowLispMapRequestModeReply reply = getReplyForRead( + getFutureJVpp().showLispMapRequestMode(new ShowLispMapRequestMode()).toCompletableFuture(), + instanceIdentifier); + + if (reply != null) { + mapRequestModeBuilder.setMode( + org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MapRequestMode + .forValue(reply.mode)); + } + } + + @Override + public void merge(@Nonnull Builder<? extends DataObject> builder, + @Nonnull MapRequestMode mapRequestMode) { + LispFeatureDataBuilder.class.cast(builder).setMapRequestMode(mapRequestMode); + } + + @Nonnull + @Override + public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, + @Nonnull MapRequestMode mapRequestMode, + @Nonnull ReadContext readContext) { + return Initialized.create(lispFeaturesBasePath().child(MapRequestMode.class), mapRequestMode); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapServerCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapServerCustomizer.java new file mode 100644 index 000000000..8e53f265d --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/MapServerCustomizer.java @@ -0,0 +1,131 @@ +/* + * 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.translate.read; + +import static io.fd.honeycomb.translate.util.read.cache.EntityDumpExecutor.NO_PARAMS; + +import com.google.common.base.Optional; +import io.fd.hc2vpp.common.translate.util.AddressTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.Initialized; +import io.fd.honeycomb.translate.spi.read.InitializingListReaderCustomizer; +import io.fd.honeycomb.translate.util.RWUtils; +import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager; +import io.fd.honeycomb.translate.util.read.cache.DumpCacheManager.DumpCacheManagerBuilder; +import io.fd.vpp.jvpp.core.dto.LispMapServerDetails; +import io.fd.vpp.jvpp.core.dto.LispMapServerDetailsReplyDump; +import io.fd.vpp.jvpp.core.dto.LispMapServerDump; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; +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.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServers; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServersBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerKey; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapServerCustomizer extends FutureJVppCustomizer + implements InitializingListReaderCustomizer<MapServer, MapServerKey, MapServerBuilder>, JvppReplyConsumer, + AddressTranslator { + + private final DumpCacheManager<LispMapServerDetailsReplyDump, Void> dumpManager; + + public MapServerCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + dumpManager = new DumpCacheManagerBuilder<LispMapServerDetailsReplyDump, Void>() + .acceptOnly(LispMapServerDetailsReplyDump.class) + .withExecutor((instanceIdentifier, aVoid) -> + getReplyForRead(getFutureJVpp() + .lispMapServerDump(new LispMapServerDump()).toCompletableFuture(), instanceIdentifier)) + .build(); + } + + @Nonnull + @Override + public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, + @Nonnull MapServer mapServer, + @Nonnull ReadContext readContext) { + final InstanceIdentifier<MapServer> configId = InstanceIdentifier.create(Lisp.class) + .child(LispFeatureData.class) + .child(MapServers.class) + .child(MapServer.class, instanceIdentifier.firstKeyOf(MapServer.class)); + + return Initialized.create(configId, mapServer); + } + + @Nonnull + @Override + public List<MapServerKey> getAllIds(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, + @Nonnull ReadContext readContext) throws ReadFailedException { + + final Optional<LispMapServerDetailsReplyDump> dump = + dumpManager.getDump(instanceIdentifier, readContext.getModificationCache(), NO_PARAMS); + + if (dump.isPresent() && dump.get().lispMapServerDetails != null) { + return dump.get().lispMapServerDetails.stream() + .map(detail -> arrayToIpAddress(byteToBoolean(detail.isIpv6), detail.ipAddress)) + .map(MapServerKey::new) + .collect(Collectors.toList()); + } + + return Collections.emptyList(); + } + + @Override + public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull List<MapServer> list) { + MapServersBuilder.class.cast(builder).setMapServer(list); + } + + @Nonnull + @Override + public MapServerBuilder getBuilder(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier) { + return new MapServerBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, + @Nonnull MapServerBuilder mapServerBuilder, @Nonnull ReadContext readContext) + throws ReadFailedException { + final Optional<LispMapServerDetailsReplyDump> dump = + dumpManager.getDump(instanceIdentifier, readContext.getModificationCache(), NO_PARAMS); + + if (dump.isPresent() && dump.get().lispMapServerDetails != null) { + final IpAddress currentAddress = instanceIdentifier.firstKeyOf(MapServer.class).getIpAddress(); + + final LispMapServerDetails currentDetail = dump.get().lispMapServerDetails.stream() + .filter(detail -> Arrays.equals(currentAddress.getValue(), + arrayToIpAddress(byteToBoolean(detail.isIpv6), detail.ipAddress).getValue())) + .collect(RWUtils.singleItemCollector()); + + mapServerBuilder + .setIpAddress(arrayToIpAddress(byteToBoolean(currentDetail.isIpv6), currentDetail.ipAddress)); + + } + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/PetrCfgCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/PetrCfgCustomizer.java new file mode 100644 index 000000000..0e27a0ee8 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/PetrCfgCustomizer.java @@ -0,0 +1,77 @@ +/* + * 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.translate.read; + +import io.fd.hc2vpp.common.translate.util.AddressTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.Initialized; +import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.ShowLispUsePetr; +import io.fd.vpp.jvpp.core.dto.ShowLispUsePetrReply; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfgBuilder; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class PetrCfgCustomizer extends FutureJVppCustomizer + implements InitializingReaderCustomizer<PetrCfg, PetrCfgBuilder>, JvppReplyConsumer, + AddressTranslator, LispInitPathsMapper { + + public PetrCfgCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + } + + @Nonnull + @Override + public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, + @Nonnull PetrCfg petrCfg, + @Nonnull ReadContext readContext) { + return Initialized.create(lispFeaturesBasePath().child(PetrCfg.class), petrCfg); + } + + @Nonnull + @Override + public PetrCfgBuilder getBuilder(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier) { + return new PetrCfgBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, + @Nonnull PetrCfgBuilder petrCfgBuilder, + @Nonnull ReadContext readContext) throws ReadFailedException { + final ShowLispUsePetrReply read = getReplyForRead(getFutureJVpp().showLispUsePetr(new ShowLispUsePetr()) + .toCompletableFuture(), instanceIdentifier); + + if (read != null && read.status != 0) { + // TODO - https://jira.fd.io/browse/VPP-660 - returns address back in bad form + petrCfgBuilder.setPetrAddress(arrayToIpAddress(!byteToBoolean(read.isIp4), read.address)); + } + } + + @Override + public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull PetrCfg petrCfg) { + LispFeatureDataBuilder.class.cast(builder).setPetrCfg(petrCfg); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/RlocProbeCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/RlocProbeCustomizer.java new file mode 100644 index 000000000..bd0070141 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/RlocProbeCustomizer.java @@ -0,0 +1,76 @@ +/* + * 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.translate.read; + +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.hc2vpp.lisp.translate.read.init.LispInitPathsMapper; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.Initialized; +import io.fd.honeycomb.translate.spi.read.InitializingReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.ShowLispRlocProbeState; +import io.fd.vpp.jvpp.core.dto.ShowLispRlocProbeStateReply; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbeBuilder; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class RlocProbeCustomizer extends FutureJVppCustomizer + implements InitializingReaderCustomizer<RlocProbe, RlocProbeBuilder>, JvppReplyConsumer, ByteDataTranslator, + LispInitPathsMapper { + + public RlocProbeCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + } + + @Nonnull + @Override + public RlocProbeBuilder getBuilder(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier) { + return new RlocProbeBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, + @Nonnull RlocProbeBuilder rlocProbeBuilder, + @Nonnull ReadContext readContext) throws ReadFailedException { + final ShowLispRlocProbeStateReply read = getReplyForRead(getFutureJVpp() + .showLispRlocProbeState(new ShowLispRlocProbeState()).toCompletableFuture(), instanceIdentifier); + + if (read != null) { + rlocProbeBuilder.setEnabled(byteToBoolean(read.isEnabled)); + } + } + + @Override + public void merge(@Nonnull Builder<? extends DataObject> builder, @Nonnull RlocProbe rlocProbe) { + LispFeatureDataBuilder.class.cast(builder).setRlocProbe(rlocProbe); + } + + @Nonnull + @Override + public Initialized<? extends DataObject> init(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, + @Nonnull RlocProbe rlocProbe, + @Nonnull ReadContext readContext) { + return Initialized.create(lispFeaturesBasePath().child(RlocProbe.class), rlocProbe); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/LispStateReaderFactory.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/LispStateReaderFactory.java index 345fe46ad..b7bd37588 100755 --- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/LispStateReaderFactory.java +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/LispStateReaderFactory.java @@ -18,18 +18,25 @@ package io.fd.hc2vpp.lisp.translate.read.factory; import io.fd.hc2vpp.lisp.translate.AbstractLispInfraFactoryBase; import io.fd.hc2vpp.lisp.translate.read.LispStateCustomizer; +import io.fd.hc2vpp.lisp.translate.read.MapRegisterCustomizer; +import io.fd.hc2vpp.lisp.translate.read.MapRequestModeCustomizer; +import io.fd.hc2vpp.lisp.translate.read.PetrCfgCustomizer; import io.fd.hc2vpp.lisp.translate.read.PitrCfgCustomizer; +import io.fd.hc2vpp.lisp.translate.read.RlocProbeCustomizer; import io.fd.honeycomb.translate.impl.read.GenericInitReader; import io.fd.honeycomb.translate.read.ReaderFactory; import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder; +import javax.annotation.Nonnull; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.LispState; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.pitr.cfg.grouping.PitrCfg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfg; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import javax.annotation.Nonnull; - /** * Initialize readers for {@link LispState} @@ -37,6 +44,8 @@ import javax.annotation.Nonnull; public class LispStateReaderFactory extends AbstractLispInfraFactoryBase implements ReaderFactory { private static final InstanceIdentifier<LispState> lispStateId = InstanceIdentifier.create(LispState.class); + static final InstanceIdentifier<LispFeatureData> + LISP_FEATURE_ID = lispStateId.child(LispFeatureData.class); @Override public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) { @@ -44,7 +53,19 @@ public class LispStateReaderFactory extends AbstractLispInfraFactoryBase impleme registry.add(new GenericInitReader<>(lispStateId, new LispStateCustomizer(vppApi))); registry.addStructuralReader(lispStateId.child(LispFeatureData.class), LispFeatureDataBuilder.class); - registry.add(new GenericInitReader<>(lispStateId.child(LispFeatureData.class).child(PitrCfg.class), + registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(PitrCfg.class), new PitrCfgCustomizer(vppApi))); + + registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(RlocProbe.class), + new RlocProbeCustomizer(vppApi))); + + registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(PetrCfg.class), + new PetrCfgCustomizer(vppApi))); + + registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(MapRegister.class), + new MapRegisterCustomizer(vppApi))); + + registry.add(new GenericInitReader<>(LISP_FEATURE_ID.child(MapRequestMode.class), + new MapRequestModeCustomizer(vppApi))); } } diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/MapServerReaderFactory.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/MapServerReaderFactory.java new file mode 100644 index 000000000..1af8f939f --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/read/factory/MapServerReaderFactory.java @@ -0,0 +1,43 @@ +/* + * 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.translate.read.factory; + + +import static io.fd.hc2vpp.lisp.translate.read.factory.LispStateReaderFactory.LISP_FEATURE_ID; + +import io.fd.hc2vpp.lisp.translate.AbstractLispInfraFactoryBase; +import io.fd.hc2vpp.lisp.translate.read.MapServerCustomizer; +import io.fd.honeycomb.translate.impl.read.GenericInitListReader; +import io.fd.honeycomb.translate.read.ReaderFactory; +import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServers; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServersBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapServerReaderFactory extends AbstractLispInfraFactoryBase implements ReaderFactory { + + private static final InstanceIdentifier<MapServers> MAP_SERVERS_ID = LISP_FEATURE_ID.child(MapServers.class); + + @Override + public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) { + registry.addStructuralReader(MAP_SERVERS_ID, MapServersBuilder.class); + registry.add(new GenericInitListReader<>(MAP_SERVERS_ID.child(MapServer.class), + new MapServerCustomizer(vppApi))); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizer.java index e2943c670..494afd3cb 100755 --- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizer.java +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizer.java @@ -22,26 +22,28 @@ import static io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDump import static io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDumpParams.EidType.IPV6; import static java.nio.charset.StandardCharsets.UTF_8; +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; import io.fd.hc2vpp.lisp.context.util.EidMappingContext; import io.fd.hc2vpp.lisp.translate.read.trait.MappingProducer; import io.fd.hc2vpp.lisp.translate.util.EidTranslator; import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer; -import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; -import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; -import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; import io.fd.honeycomb.translate.write.WriteContext; import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.VppBaseCallException; +import io.fd.vpp.jvpp.core.dto.LispAddDelLocalEid; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; import java.io.UnsupportedEncodingException; +import java.nio.charset.StandardCharsets; import java.util.concurrent.TimeoutException; import javax.annotation.Nonnull; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MappingId; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.LocalMapping; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.LocalMappingKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.VniTable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.hmac.key.grouping.HmacKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import io.fd.vpp.jvpp.VppBaseCallException; -import io.fd.vpp.jvpp.core.dto.LispAddDelLocalEid; -import io.fd.vpp.jvpp.core.future.FutureJVppCore; /** @@ -129,6 +131,14 @@ public class LocalMappingCustomizer extends FutureJVppCustomizer request.prefixLen = (byte) 128; } + final HmacKey hmacKey = data.getHmacKey(); + if (hmacKey != null) { + request.key = checkNotNull(hmacKey.getKey(), "HMAC key not specified") + .getBytes(StandardCharsets.UTF_8); + request.keyId = (byte) checkNotNull(hmacKey.getKeyType(), + "HMAC key type not specified").getIntValue(); + } + getReply(getFutureJVpp().lispAddDelLocalEid(request).toCompletableFuture()); } diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRegisterCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRegisterCustomizer.java new file mode 100644 index 000000000..1dac298a3 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRegisterCustomizer.java @@ -0,0 +1,66 @@ +/* + * 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.translate.write; + +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.spi.write.WriterCustomizer; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.LispMapRegisterEnableDisable; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import javax.annotation.Nonnull; + +public class MapRegisterCustomizer extends FutureJVppCustomizer + implements WriterCustomizer<MapRegister>, ByteDataTranslator, JvppReplyConsumer { + + public MapRegisterCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + } + + @Override + public void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier, + @Nonnull MapRegister mapRegister, + @Nonnull WriteContext writeContext) throws WriteFailedException { + enableDisableMapRegister(mapRegister.isEnabled(), instanceIdentifier); + } + + @Override + public void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier, + @Nonnull MapRegister mapRegisterBefore, + @Nonnull MapRegister mapRegisterAfter, @Nonnull + WriteContext writeContext) throws WriteFailedException { + enableDisableMapRegister(mapRegisterAfter.isEnabled(), instanceIdentifier); + } + + @Override + public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRegister> instanceIdentifier, + @Nonnull MapRegister mapRegister, + @Nonnull WriteContext writeContext) throws WriteFailedException { + enableDisableMapRegister(false, instanceIdentifier); + } + + private void enableDisableMapRegister(final boolean enable, @Nonnull final InstanceIdentifier<MapRegister> id) throws WriteFailedException { + LispMapRegisterEnableDisable request = new LispMapRegisterEnableDisable(); + request.isEnabled = booleanToByte(enable); + getReplyForWrite(getFutureJVpp().lispMapRegisterEnableDisable(request).toCompletableFuture(), id); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRequestModeCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRequestModeCustomizer.java new file mode 100644 index 000000000..0e069504d --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapRequestModeCustomizer.java @@ -0,0 +1,76 @@ +/* + * 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.translate.write; + +import static com.google.common.base.Preconditions.checkNotNull; + +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.spi.write.WriterCustomizer; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.LispMapRequestMode; +import io.fd.vpp.jvpp.core.dto.LispMapRequestModeReply; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import java.util.concurrent.CompletableFuture; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class MapRequestModeCustomizer extends FutureJVppCustomizer + implements WriterCustomizer<MapRequestMode>, JvppReplyConsumer { + + private static final Logger LOG = LoggerFactory.getLogger(MapRequestModeCustomizer.class); + + public MapRequestModeCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + } + + @Override + public void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, + @Nonnull MapRequestMode mapRequestMode, + @Nonnull WriteContext writeContext) throws WriteFailedException { + getReplyForWrite(mapRequestModeRequestFuture(mapRequestMode), instanceIdentifier); + } + + @Override + public void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, + @Nonnull MapRequestMode mapRequestModeBefore, + @Nonnull MapRequestMode mapRequestModeAfter, @Nonnull WriteContext writeContext) + throws WriteFailedException { + getReplyForUpdate(mapRequestModeRequestFuture(mapRequestModeAfter), instanceIdentifier, + mapRequestModeBefore, mapRequestModeAfter); + } + + @Override + public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapRequestMode> instanceIdentifier, + @Nonnull MapRequestMode mapRequestMode, + @Nonnull WriteContext writeContext) throws WriteFailedException { + //TODO - after HC2VPP-115 - change to throw UnsupportedOperationException + LOG.error("Map request mode cannot be deleted, ignoring"); + } + + private CompletableFuture<LispMapRequestModeReply> mapRequestModeRequestFuture( + @Nonnull final MapRequestMode mapRequestMode) { + LispMapRequestMode request = new LispMapRequestMode(); + request.mode = (byte) checkNotNull(mapRequestMode.getMode(), + "Mode not specified").getIntValue(); + return getFutureJVpp().lispMapRequestMode(request).toCompletableFuture(); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapServerCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapServerCustomizer.java new file mode 100644 index 000000000..9697e16bc --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/MapServerCustomizer.java @@ -0,0 +1,76 @@ +/* + * 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.translate.write; + +import io.fd.hc2vpp.common.translate.util.AddressTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.LispAddDelMapServer; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +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.lisp.rev170315.map.servers.grouping.map.servers.MapServer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import javax.annotation.Nonnull; + +public class MapServerCustomizer extends FutureJVppCustomizer + implements ListWriterCustomizer<MapServer, MapServerKey>, AddressTranslator, + JvppReplyConsumer { + + public MapServerCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + } + + @Override + public void writeCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, + @Nonnull MapServer mapServer, + @Nonnull WriteContext writeContext) throws WriteFailedException { + addDelMapServer(true, instanceIdentifier, mapServer); + } + + @Override + public void updateCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, + @Nonnull MapServer mapServerBefore, + @Nonnull MapServer mapServerAfter, + @Nonnull WriteContext writeContext) throws WriteFailedException { + throw new WriteFailedException.UpdateFailedException(instanceIdentifier, mapServerBefore, mapServerAfter, + new UnsupportedOperationException("Not supported")); + } + + @Override + public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<MapServer> instanceIdentifier, @Nonnull MapServer mapServer, @Nonnull WriteContext writeContext) throws WriteFailedException { + addDelMapServer(false, instanceIdentifier, mapServer); + } + + private void addDelMapServer(final boolean add, + @Nonnull final InstanceIdentifier<MapServer> id, + @Nonnull final MapServer data) throws WriteFailedException { + LispAddDelMapServer request = new LispAddDelMapServer(); + + final IpAddress ipAddress = data.getIpAddress(); + + request.isAdd = booleanToByte(add); + request.isIpv6 = booleanToByte(isIpv6(ipAddress)); + request.ipAddress = ipAddressToArray(ipAddress); + + getReplyForWrite(getFutureJVpp().lispAddDelMapServer(request).toCompletableFuture(), id); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/PetrCfgCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/PetrCfgCustomizer.java new file mode 100644 index 000000000..d3a381490 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/PetrCfgCustomizer.java @@ -0,0 +1,82 @@ +/* + * 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.translate.write; + +import io.fd.hc2vpp.common.translate.util.AddressTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.spi.write.WriterCustomizer; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.LispUsePetr; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +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.lisp.rev170315.use.petr.cfg.grouping.PetrCfg; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import javax.annotation.Nonnull; + +import static com.google.common.base.Preconditions.checkNotNull; + +public class PetrCfgCustomizer extends FutureJVppCustomizer + implements WriterCustomizer<PetrCfg>, AddressTranslator, JvppReplyConsumer { + + public PetrCfgCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + } + + @Override + public void writeCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, + @Nonnull PetrCfg petrCfg, + @Nonnull WriteContext writeContext) throws WriteFailedException { + enablePetrCfg(instanceIdentifier, petrCfg); + } + + @Override + public void updateCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, + @Nonnull PetrCfg petrCfgBefore, + @Nonnull PetrCfg petrCfgAfter, + @Nonnull WriteContext writeContext) throws WriteFailedException { + if (petrCfgAfter.getPetrAddress() != null) { + enablePetrCfg(instanceIdentifier, petrCfgAfter); + } else { + disablePetrCfg(instanceIdentifier); + } + } + + @Override + public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<PetrCfg> instanceIdentifier, @Nonnull PetrCfg petrCfg, @Nonnull WriteContext writeContext) throws WriteFailedException { + disablePetrCfg(instanceIdentifier); + } + + private void enablePetrCfg(@Nonnull final InstanceIdentifier<PetrCfg> id, @Nonnull final PetrCfg data) throws WriteFailedException { + LispUsePetr request = new LispUsePetr(); + + final IpAddress petrAddress = checkNotNull(data.getPetrAddress(), "PETR address not defined"); + request.isAdd = 1; + request.address = ipAddressToArray(petrAddress); + request.isIp4 = booleanToByte(!isIpv6(petrAddress)); + getReplyForWrite(getFutureJVpp().lispUsePetr(request).toCompletableFuture(), id); + } + + private void disablePetrCfg(@Nonnull final InstanceIdentifier<PetrCfg> id) throws WriteFailedException { + LispUsePetr request = new LispUsePetr(); + request.isAdd = 0; + getReplyForDelete(getFutureJVpp().lispUsePetr(request).toCompletableFuture(), id); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/RlocProbeCustomizer.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/RlocProbeCustomizer.java new file mode 100644 index 000000000..b240d1d2e --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/RlocProbeCustomizer.java @@ -0,0 +1,68 @@ +/* + * 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.translate.write; + +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.hc2vpp.common.translate.util.FutureJVppCustomizer; +import io.fd.hc2vpp.common.translate.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.spi.write.WriterCustomizer; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.LispRlocProbeEnableDisable; +import io.fd.vpp.jvpp.core.future.FutureJVppCore; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import javax.annotation.Nonnull; + +public class RlocProbeCustomizer extends FutureJVppCustomizer + implements WriterCustomizer<RlocProbe>, ByteDataTranslator, JvppReplyConsumer { + + public RlocProbeCustomizer(@Nonnull FutureJVppCore futureJVppCore) { + super(futureJVppCore); + } + + @Override + public void writeCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, + @Nonnull RlocProbe rlocProbe, + @Nonnull WriteContext writeContext) throws WriteFailedException { + enableDisableRlocProbe(rlocProbe.isEnabled(), instanceIdentifier); + } + + @Override + public void updateCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, + @Nonnull RlocProbe rlocProbeBefore, + @Nonnull RlocProbe rlocProbeAfter, + @Nonnull WriteContext writeContext) throws WriteFailedException { + enableDisableRlocProbe(rlocProbeAfter.isEnabled(), instanceIdentifier); + } + + @Override + public void deleteCurrentAttributes(@Nonnull InstanceIdentifier<RlocProbe> instanceIdentifier, + @Nonnull RlocProbe rlocProbe, + @Nonnull WriteContext writeContext) throws WriteFailedException { + enableDisableRlocProbe(false, instanceIdentifier); + } + + private void enableDisableRlocProbe(final boolean enable, @Nonnull final InstanceIdentifier<RlocProbe> id) throws WriteFailedException { + LispRlocProbeEnableDisable request = new LispRlocProbeEnableDisable(); + + request.isEnabled = booleanToByte(enable); + + getReplyForWrite(getFutureJVpp().lispRlocProbeEnableDisable(request).toCompletableFuture(), id); + } +} diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/LispWriterFactory.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/LispWriterFactory.java index b2ce44e82..ed7d2122a 100755 --- a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/LispWriterFactory.java +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/LispWriterFactory.java @@ -21,14 +21,22 @@ import static io.fd.hc2vpp.lisp.translate.write.factory.LocatorSetWriterFactory. import io.fd.hc2vpp.lisp.translate.AbstractLispInfraFactoryBase; import io.fd.hc2vpp.lisp.translate.write.LispCustomizer; +import io.fd.hc2vpp.lisp.translate.write.MapRegisterCustomizer; +import io.fd.hc2vpp.lisp.translate.write.MapRequestModeCustomizer; +import io.fd.hc2vpp.lisp.translate.write.PetrCfgCustomizer; import io.fd.hc2vpp.lisp.translate.write.PitrCfgCustomizer; +import io.fd.hc2vpp.lisp.translate.write.RlocProbeCustomizer; import io.fd.honeycomb.translate.impl.write.GenericWriter; import io.fd.honeycomb.translate.write.WriterFactory; import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder; import javax.annotation.Nonnull; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.pitr.cfg.grouping.PitrCfg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfg; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -36,13 +44,27 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; * Initialize writers for {@link Lisp} */ public final class LispWriterFactory extends AbstractLispInfraFactoryBase implements WriterFactory { - private final InstanceIdentifier<Lisp> lispInstanceIdentifier = InstanceIdentifier.create(Lisp.class); + private static final InstanceIdentifier<Lisp> LISP_INSTANCE_IDENTIFIER = InstanceIdentifier.create(Lisp.class); + private static final InstanceIdentifier<LispFeatureData> LISP_FEATURE_IDENTIFIER = + LISP_INSTANCE_IDENTIFIER.child(LispFeatureData.class); @Override public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) { - registry.add(new GenericWriter<>(lispInstanceIdentifier, new LispCustomizer(vppApi))); + registry.add(new GenericWriter<>(LISP_INSTANCE_IDENTIFIER, new LispCustomizer(vppApi))); - registry.addAfter(new GenericWriter<>(lispInstanceIdentifier.child(LispFeatureData.class).child(PitrCfg.class), - new PitrCfgCustomizer(vppApi)),LOCATOR_SET_ID); + registry.addAfter(writer(LISP_FEATURE_IDENTIFIER.child(PitrCfg.class), + new PitrCfgCustomizer(vppApi)), LOCATOR_SET_ID); + + registry.add(writer(LISP_FEATURE_IDENTIFIER.child(MapRegister.class), + new MapRegisterCustomizer(vppApi))); + + registry.add(writer(LISP_FEATURE_IDENTIFIER.child(MapRequestMode.class), + new MapRequestModeCustomizer(vppApi))); + + registry.add(writer(LISP_FEATURE_IDENTIFIER.child(PetrCfg.class), + new PetrCfgCustomizer(vppApi))); + + registry.add(writer(LISP_FEATURE_IDENTIFIER.child(RlocProbe.class), + new RlocProbeCustomizer(vppApi))); } } diff --git a/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/MapServerWriterFactory.java b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/MapServerWriterFactory.java new file mode 100644 index 000000000..fc0cc4d10 --- /dev/null +++ b/lisp/lisp2vpp/src/main/java/io/fd/hc2vpp/lisp/translate/write/factory/MapServerWriterFactory.java @@ -0,0 +1,37 @@ +/* + * 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.translate.write.factory; + +import io.fd.hc2vpp.lisp.translate.AbstractLispInfraFactoryBase; +import io.fd.hc2vpp.lisp.translate.write.MapServerCustomizer; +import io.fd.honeycomb.translate.impl.write.GenericListWriter; +import io.fd.honeycomb.translate.write.WriterFactory; +import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServers; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer; + +public class MapServerWriterFactory extends AbstractLispInfraFactoryBase implements WriterFactory { + + @Override + public void init(@Nonnull ModifiableWriterRegistryBuilder registry) { + registry.add(new GenericListWriter<>( + LISP_CONFIG_IDENTIFIER.child(LispFeatureData.class).child(MapServers.class).child(MapServer.class), + new MapServerCustomizer(vppApi))); + } +} |