diff options
Diffstat (limited to 'ioam/impl/src/main/java/io/fd/honeycomb')
5 files changed, 353 insertions, 0 deletions
diff --git a/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/VppIoamModule.java b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/VppIoamModule.java new file mode 100755 index 000000000..34975d71d --- /dev/null +++ b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/VppIoamModule.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.fd.honeycomb.vppioam.impl; + +import com.google.common.annotations.VisibleForTesting; +import com.google.inject.AbstractModule; +import com.google.inject.Singleton; +import com.google.inject.multibindings.Multibinder; +import com.google.inject.name.Names; +import com.google.inject.Provider; +import io.fd.honeycomb.data.init.DataTreeInitializer; +import io.fd.honeycomb.translate.read.ReaderFactory; +import io.fd.honeycomb.translate.write.WriterFactory; +import io.fd.honeycomb.vppioam.impl.config.VppIoamWriterFactory; +import io.fd.honeycomb.vppioam.impl.util.JVppIoamProvider; +import io.fd.vpp.jvpp.ioamtrace.future.FutureJVppIoamtrace; +import io.fd.vpp.jvpp.ioamtrace.future.FutureJVppIoamtraceFacade; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Glue code necessary for Honeycomb distribution to pick up the plugin classes + */ +public final class VppIoamModule extends AbstractModule { + + private static final Logger LOG = LoggerFactory.getLogger(VppIoamModule.class); + private final Class<? extends Provider<FutureJVppIoamtraceFacade>> jvppIoamProviderClass; + + public VppIoamModule() { + this(JVppIoamProvider.class); + } + + @VisibleForTesting + VppIoamModule(Class<? extends Provider<FutureJVppIoamtraceFacade>> jvppIoamProvider) { + this.jvppIoamProviderClass = jvppIoamProvider; + } + + @Override + protected void configure() { + LOG.debug("Installing iOAM module"); + + // Bind to Plugin's JVPP. + bind(FutureJVppIoamtrace.class).toProvider(jvppIoamProviderClass).in(Singleton.class); + + // Below are classes picked up by HC framework + Multibinder.newSetBinder(binder(), WriterFactory.class).addBinding().to(VppIoamWriterFactory.class); + + LOG.debug("Module iOAM successfully configured"); + } +} diff --git a/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/config/IoamTraceWriterCustomizer.java b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/config/IoamTraceWriterCustomizer.java new file mode 100755 index 000000000..8a45e87df --- /dev/null +++ b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/config/IoamTraceWriterCustomizer.java @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.fd.honeycomb.vppioam.impl.config; + +import static com.google.common.base.Preconditions.checkNotNull; +import static com.google.common.base.Preconditions.checkState; + +import io.fd.honeycomb.translate.MappingContext; +import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer; +import io.fd.honeycomb.translate.vpp.util.ByteDataTranslator; +import io.fd.honeycomb.translate.vpp.util.JvppReplyConsumer; +import io.fd.honeycomb.translate.vpp.util.NamingContext; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.honeycomb.vppioam.impl.util.FutureJVppIoamCustomizer; + +import io.fd.vpp.jvpp.ioamtrace.dto.TraceProfileAdd; +import io.fd.vpp.jvpp.ioamtrace.dto.TraceProfileAddReply; +import io.fd.vpp.jvpp.ioamtrace.dto.TraceProfileDel; +import io.fd.vpp.jvpp.ioamtrace.dto.TraceProfileDelReply; +import io.fd.vpp.jvpp.ioamtrace.future.FutureJVppIoamtrace; + +import java.util.concurrent.CompletionStage; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.ioam.sb.trace.rev160512.IoamTraceConfig; +import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.ioam.sb.trace.rev160512.ioam.trace.config.TraceConfig; +import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.ioam.sb.trace.rev160512.ioam.trace.config.TraceConfig.TraceOp; +import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.ioam.sb.trace.rev160512.ioam.trace.config.trace.config.NodeInterfaces; +import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.ioam.sb.trace.rev160512.ioam.trace.config.TraceConfigKey; +import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.ioam.sb.trace.rev160512.ioam.trace.config.trace.config.NodeInterfaces; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Writer customizer responsible for Ioam Trace create/delete. + */ +public class IoamTraceWriterCustomizer extends FutureJVppIoamCustomizer + implements ListWriterCustomizer<TraceConfig, TraceConfigKey>, ByteDataTranslator, JvppReplyConsumer { + + private static final Logger LOG = LoggerFactory.getLogger(IoamTraceWriterCustomizer.class); + + public IoamTraceWriterCustomizer(@Nonnull final FutureJVppIoamtrace futureJVppIoam) { + super(futureJVppIoam); + } + + @Override + public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<TraceConfig> id, + @Nonnull final TraceConfig dataCurr, + @Nonnull final WriteContext writeContext) + throws WriteFailedException { + + try { + addTraceConfig(dataCurr, writeContext, id); + } catch (Exception exCreate) { + LOG.error("Add Trace Configuration failed", exCreate); + throw new WriteFailedException.CreateFailedException(id, dataCurr, exCreate); + } + + LOG.debug("Trace config added iid={}, added {}", id, dataCurr); + } + + @Override + public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<TraceConfig> id, + @Nonnull final TraceConfig dataBefore, + @Nonnull final TraceConfig dataAfter, + @Nonnull final WriteContext ctx) throws WriteFailedException { + try { + deleteTraceConfig(dataBefore, id); + addTraceConfig(dataAfter, ctx, id); + } catch (Exception exUpdate) { + LOG.error("Update Trace Configuration failed", exUpdate); + throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, exUpdate); + } + + LOG.debug("Trace config updated {}", dataAfter); + } + + @Override + public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<TraceConfig> id, + @Nonnull final TraceConfig dataBefore, + @Nonnull final WriteContext ctx) throws WriteFailedException { + try { + deleteTraceConfig(dataBefore, id); + } catch (Exception exDelete) { + LOG.error("Delete Trace Configuration failed", exDelete); + throw new WriteFailedException.DeleteFailedException(id, exDelete); + } + + LOG.debug("Trace config deleted:iid={} dataBefore={}", id, dataBefore); + } + + public TraceProfileAddReply addTraceConfig(TraceConfig traceConfig, + WriteContext ctx, + final InstanceIdentifier<TraceConfig> id) throws Exception { + + TraceProfileAdd traceProfileAdd = new TraceProfileAdd(); + traceProfileAdd.traceType = (byte) traceConfig.getTraceType().byteValue(); //trace type + traceProfileAdd.numElts = (byte) traceConfig.getTraceNumElt().byteValue(); //num of elts + traceProfileAdd.traceTsp = (byte) traceConfig.getTraceTsp().getIntValue(); // tsp + traceProfileAdd.appData = (int) traceConfig.getTraceAppData().intValue(); // appdata + traceProfileAdd.nodeId = (int) traceConfig.getNodeId().intValue(); // nodeid + + /* Write to VPP */ + final TraceProfileAddReply reply = getReplyForWrite((getFutureJVppIoam(). + traceProfileAdd(traceProfileAdd). + toCompletableFuture()), id); + return reply; + } + + public TraceProfileDelReply deleteTraceConfig(TraceConfig dataBefore, + final InstanceIdentifier<TraceConfig> id) throws Exception { + TraceProfileDel del = new TraceProfileDel(); + + /* Write to VPP */ + TraceProfileDelReply reply = getReplyForWrite((getFutureJVppIoam(). + traceProfileDel(del).toCompletableFuture()), id); + + return reply; + } +} diff --git a/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/config/VppIoamWriterFactory.java b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/config/VppIoamWriterFactory.java new file mode 100755 index 000000000..40311cd8c --- /dev/null +++ b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/config/VppIoamWriterFactory.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.vppioam.impl.config; + +import com.google.common.collect.Sets; +import com.google.inject.Inject; +import com.google.inject.name.Named; +import io.fd.honeycomb.translate.impl.write.GenericListWriter; +import io.fd.honeycomb.translate.vpp.util.NamingContext; +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.cisco.params.xml.ns.yang.ioam.sb.trace.rev160512.IoamTraceConfig; +import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.ioam.sb.trace.rev160512.ioam.trace.config.TraceConfig; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import io.fd.vpp.jvpp.ioamtrace.future.FutureJVppIoamtrace; + +public class VppIoamWriterFactory implements WriterFactory { + + @Nonnull + private final FutureJVppIoamtrace jvppIoam; + + @Inject + public VppIoamWriterFactory(@Nonnull final FutureJVppIoamtrace jvppIoam) { + this.jvppIoam = jvppIoam; + } + + @Override + public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) { + // TraceConfig + final InstanceIdentifier<TraceConfig> trId = + InstanceIdentifier.create(IoamTraceConfig.class).child(TraceConfig.class); + registry.add(new GenericListWriter<>(trId, new IoamTraceWriterCustomizer(jvppIoam))); + } +} diff --git a/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/util/FutureJVppIoamCustomizer.java b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/util/FutureJVppIoamCustomizer.java new file mode 100755 index 000000000..b60581a1b --- /dev/null +++ b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/util/FutureJVppIoamCustomizer.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2016 Cisco and/or its affiliates. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package io.fd.honeycomb.vppioam.impl.util; + +import com.google.common.annotations.Beta; +import com.google.common.base.Preconditions; +import io.fd.vpp.jvpp.ioamtrace.future.FutureJVppIoamtrace; +import javax.annotation.Nonnull; + +/** + * Abstract utility to hold the IoamApi reference. + */ +@Beta +public abstract class FutureJVppIoamCustomizer { + + private final FutureJVppIoamtrace futureJVppIoam; + + public FutureJVppIoamCustomizer(@Nonnull final FutureJVppIoamtrace futureJVppIoam) { + this.futureJVppIoam = Preconditions.checkNotNull(futureJVppIoam, + "futureJVppIoam should not be null"); + } + + /** + * Get IoamApi reference + * + * @return IoamApi reference + */ + public FutureJVppIoamtrace getFutureJVppIoam() { + return futureJVppIoam; + } +} diff --git a/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/util/JVppIoamProvider.java b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/util/JVppIoamProvider.java new file mode 100755 index 000000000..d95266457 --- /dev/null +++ b/ioam/impl/src/main/java/io/fd/honeycomb/vppioam/impl/util/JVppIoamProvider.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2016 Cisco and 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.honeycomb.vppioam.impl.util; + +import com.google.inject.Inject; +import com.google.inject.Provider; +import io.fd.honeycomb.infra.distro.ProviderTrait; +import java.io.IOException; +import io.fd.vpp.jvpp.JVppRegistry; +import io.fd.vpp.jvpp.ioamtrace.future.FutureJVppIoamtrace; +import io.fd.vpp.jvpp.ioamtrace.future.FutureJVppIoamtraceFacade; +import io.fd.vpp.jvpp.ioamtrace.JVppIoamtraceImpl; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Provides future API for jvpp-ioam plugin. Must be a singleton due to shutdown hook usage. + * Registers shutdown hook to free plugin's resources on shutdown. + */ +public final class JVppIoamProvider extends ProviderTrait<FutureJVppIoamtraceFacade> { + + private static final Logger LOG = LoggerFactory.getLogger(JVppIoamProvider.class); + + @Inject + private JVppRegistry registry; + + @Override + protected FutureJVppIoamtraceFacade create() { + try { + final JVppIoamtraceImpl jVppIoamTr = new JVppIoamtraceImpl(); + // Free jvpp-ioam plugin's resources on shutdown + Runtime.getRuntime().addShutdownHook(new Thread() { + @Override + public void run() { + LOG.info("Unloading jvpp-ioam plugin"); + jVppIoamTr.close(); + LOG.info("Successfully unloaded jvpp-ioam plugin"); + } + }); + + LOG.debug("Successfully loaded jvpp-ioam plugin"); + return new FutureJVppIoamtraceFacade(registry, jVppIoamTr); + } catch (IOException e) { + throw new IllegalStateException("Unable to open VPP management connection", e); + } + } +} + |