diff options
Diffstat (limited to 'samples')
19 files changed, 1138 insertions, 0 deletions
diff --git a/samples/interfaces/Readme.adoc b/samples/interfaces/Readme.adoc new file mode 100644 index 000000000..6d73df456 --- /dev/null +++ b/samples/interfaces/Readme.adoc @@ -0,0 +1,10 @@ += Openconfig-interfaces sample +This is a sample Honeycomb plugin implementing mapping for openconfig interfaces yang model + +== Data +Only sample data are used, that are not actually handled + +== Notifications +A sample notification was added to the models to showcase notification capabilities + +// TODO provide a groovy version, will be more compact
\ No newline at end of file diff --git a/samples/interfaces/mapping/pom.xml b/samples/interfaces/mapping/pom.xml new file mode 100644 index 000000000..5cd903acd --- /dev/null +++ b/samples/interfaces/mapping/pom.xml @@ -0,0 +1,79 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Copyright (c) 2015 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. +--> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <parent> + <groupId>io.fd.honeycomb.common</groupId> + <artifactId>api-parent</artifactId> + <version>1.0.0-SNAPSHOT</version> + <relativePath>../../../common/api-parent</relativePath> + </parent> + + <modelVersion>4.0.0</modelVersion> + <groupId>io.fd.honeycomb.samples.interfaces</groupId> + <artifactId>interfaces-mapping</artifactId> + <version>1.0.0-SNAPSHOT</version> + <packaging>bundle</packaging> + + <properties> + <guice.version>4.1.0</guice.version> + <guice.config.version>1.2.0</guice.config.version> + </properties> + + <dependencies> + <dependency> + <groupId>${project.groupId}</groupId> + <artifactId>interfaces-models</artifactId> + <version>${project.version}</version> + </dependency> + + <dependency> + <groupId>com.google.inject</groupId> + <artifactId>guice</artifactId> + <version>${guice.version}</version> + </dependency> + <dependency> + <groupId>net.jmob</groupId> + <artifactId>guice.conf</artifactId> + <version>${guice.config.version}</version> + </dependency> + <dependency> + <groupId>com.google.inject.extensions</groupId> + <artifactId>guice-multibindings</artifactId> + <version>${guice.version}</version> + </dependency> + + <dependency> + <groupId>io.fd.honeycomb</groupId> + <artifactId>translate-impl</artifactId> + <version>1.0.0-SNAPSHOT</version> + </dependency> + <dependency> + <groupId>io.fd.honeycomb</groupId> + <artifactId>translate-api</artifactId> + <version>1.0.0-SNAPSHOT</version> + </dependency> + <dependency> + <groupId>io.fd.honeycomb</groupId> + <artifactId>notification-api</artifactId> + <version>1.0.0-SNAPSHOT</version> + </dependency> + <dependency> + <groupId>io.fd.honeycomb</groupId> + <artifactId>cfg-init</artifactId> + <version>1.0.0-SNAPSHOT</version> + </dependency> + </dependencies> +</project> diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/LowerLayerAccess.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/LowerLayerAccess.java new file mode 100644 index 000000000..4b815bf35 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/LowerLayerAccess.java @@ -0,0 +1,71 @@ +/* + * 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.samples.interfaces.mapping; + +import com.google.common.collect.Lists; +import com.google.inject.Inject; +import io.fd.honeycomb.samples.interfaces.mapping.cfgattrs.InterfacesPluginConfiguration; +import io.fd.honeycomb.translate.write.WriteContext; +import java.util.ArrayList; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.Interface; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * This is a sample class representing common resource for readers and writers to access the lower layer + */ +public final class LowerLayerAccess { + + private static final Logger LOG = LoggerFactory.getLogger(LowerLayerAccess.class); + + @Inject + public LowerLayerAccess(@Nonnull final InterfacesPluginConfiguration configuration) { + LOG.info("Creating lower layer access with configuration: {}", configuration); + } + + public void writeInterface(final InstanceIdentifier<Interface> id, final Interface dataAfter, + final WriteContext writeContext) { + LOG.info("Writing interface: {}. to {}", dataAfter, id); + // This is where actual write/propagation happens + dataAfter.getMtu(); + } + + public void deleteInterface(final InstanceIdentifier<Interface> id, final Interface dataBefore, + final WriteContext writeContext) { + LOG.info("Deleting interface: {}. to {}", dataBefore, id); + final String ifcToBeDeleted = id.firstKeyOf(Interface.class).getInterfaceId().getValue(); + // This is where actual write/propagation happens + } + + public long getTotalPacketsForInterface(final String ifcName) { + return 500L; + } + + public long getDroppedPacketsForIfc(final String ifcName) { + return 50L; + } + + public ArrayList<String> getAllInterfaceNames() { + return Lists.newArrayList("ifc1", "ifc2"); + } + + public int getMtuForInterface(final String ifcName) { + return 66; + } +} diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/SampleInterfaceModule.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/SampleInterfaceModule.java new file mode 100644 index 000000000..000113f11 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/SampleInterfaceModule.java @@ -0,0 +1,54 @@ +/* + * 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.samples.interfaces.mapping; + +import com.google.inject.AbstractModule; +import com.google.inject.Singleton; +import com.google.inject.multibindings.Multibinder; +import io.fd.honeycomb.data.init.DataTreeInitializer; +import io.fd.honeycomb.notification.ManagedNotificationProducer; +import io.fd.honeycomb.samples.interfaces.mapping.config.InterfacesWriterFactory; +import io.fd.honeycomb.samples.interfaces.mapping.oper.InterfacesReaderFactory; +import io.fd.honeycomb.samples.interfaces.mapping.cfgattrs.InterfacesPluginConfiguration; +import io.fd.honeycomb.samples.interfaces.mapping.init.InterfacesInitializer; +import io.fd.honeycomb.samples.interfaces.mapping.notification.InterfaceUpNotificationProducer; +import io.fd.honeycomb.translate.read.ReaderFactory; +import io.fd.honeycomb.translate.write.WriterFactory; +import net.jmob.guice.conf.core.ConfigurationModule; + +/** + * This is some glue code necessary for Honeycomb distribution to pick up the plugin classes + */ +public final class SampleInterfaceModule extends AbstractModule { + + @Override + protected void configure() { + // These are plugin specific config attributes + install(ConfigurationModule.create()); + requestInjection(InterfacesPluginConfiguration.class); + + // These are plugin's internal components + bind(LowerLayerAccess.class).in(Singleton.class); + + // Below are classes picked up by HC framework + Multibinder.newSetBinder(binder(), WriterFactory.class).addBinding().to(InterfacesWriterFactory.class); + Multibinder.newSetBinder(binder(), ReaderFactory.class).addBinding().to(InterfacesReaderFactory.class); + Multibinder.newSetBinder(binder(), DataTreeInitializer.class).addBinding().to(InterfacesInitializer.class); + Multibinder.newSetBinder(binder(), ManagedNotificationProducer.class).addBinding() + .to(InterfaceUpNotificationProducer.class); + } +} diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/cfgattrs/InterfacesPluginConfiguration.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/cfgattrs/InterfacesPluginConfiguration.java new file mode 100644 index 000000000..881c18aa0 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/cfgattrs/InterfacesPluginConfiguration.java @@ -0,0 +1,28 @@ +/* + * 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.samples.interfaces.mapping.cfgattrs; + +import net.jmob.guice.conf.core.BindConfig; +import net.jmob.guice.conf.core.InjectConfig; +import net.jmob.guice.conf.core.Syntax; + +@BindConfig(value = "sample-interfaces", syntax = Syntax.JSON) +public class InterfacesPluginConfiguration { + + @InjectConfig("some-config-attribute") + String someConfigAttribute; +} diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/config/InterfaceWriterCustomizer.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/config/InterfaceWriterCustomizer.java new file mode 100644 index 000000000..af185d8b0 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/config/InterfaceWriterCustomizer.java @@ -0,0 +1,80 @@ +/* + * 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.samples.interfaces.mapping.config; + +import io.fd.honeycomb.samples.interfaces.mapping.LowerLayerAccess; +import io.fd.honeycomb.translate.spi.write.ListWriterCustomizer; +import io.fd.honeycomb.translate.write.WriteContext; +import io.fd.honeycomb.translate.write.WriteFailedException; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.Interface; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.InterfaceKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * This is a customizer responsible for writing(updating and also deleting) Interface config data + */ +public class InterfaceWriterCustomizer implements ListWriterCustomizer<Interface, InterfaceKey> { + + private static final Logger LOG = LoggerFactory.getLogger(InterfaceWriterCustomizer.class); + + private final LowerLayerAccess access; + + public InterfaceWriterCustomizer(final LowerLayerAccess access) { + this.access = access; + } + + @Override + public void writeCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final Interface dataAfter, @Nonnull final WriteContext writeContext) + throws WriteFailedException { + try { + // Context can be used just like the context in ReadCustomizer see InterfaceReaderCustomizer + // + it also provides a window into the entire configuration tree before current transaction and during current transaction + // just in case, some additional data is necessary here + access.writeInterface(id, dataAfter, writeContext); + } catch (Exception e) { + throw new WriteFailedException.CreateFailedException(id, dataAfter, e); + } + } + + @Override + public void updateCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final Interface dataBefore, @Nonnull final Interface dataAfter, + @Nonnull final WriteContext writeContext) throws WriteFailedException { + // There are cases when lower layer does not support all of the CRUD operations, in which case, the handler + // should look like this (This will reject configuration from upper layers, returning error/rpc-error): + throw new WriteFailedException.UpdateFailedException(id, dataBefore, dataAfter, + new UnsupportedOperationException("Unable to update interface data, unsupported at lower layer")); + } + + @Override + public void deleteCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final Interface dataBefore, @Nonnull final WriteContext writeContext) + throws WriteFailedException { + try { + // Context can be used just like the context in ReadCustomizer see InterfaceReaderCustomizer + // + it also provides a window into the entire configuration tree before current transaction and during current transaction + // just in case, some additional data is necessary here + access.deleteInterface(id, dataBefore, writeContext); + } catch (Exception e) { + throw new WriteFailedException.DeleteFailedException(id, e); + } + } +} diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/config/InterfacesWriterFactory.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/config/InterfacesWriterFactory.java new file mode 100644 index 000000000..d3b22c345 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/config/InterfacesWriterFactory.java @@ -0,0 +1,54 @@ +/* + * 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.samples.interfaces.mapping.config; + +import com.google.inject.Inject; +import io.fd.honeycomb.samples.interfaces.mapping.LowerLayerAccess; +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.io.fd.honeycomb.samples.interfaces.rev160810.Interfaces; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.Interface; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfacesWriterFactory implements WriterFactory { + + @Nonnull + private final LowerLayerAccess access; + + @Inject + public InterfacesWriterFactory(@Nonnull final LowerLayerAccess access) { + this.access = access; + } + + @Override + public void init(@Nonnull final ModifiableWriterRegistryBuilder registry) { + // ReaderFactory is intended for registering Writers into HC framework + // Writers handle ONLY config (config "true") data coming from upper layers and propagate them into lower layer/device + // they are triggered when RESTCONF PUT/POST on config is invoked or when NETCONF edit-config + commit operation is executed + + // Our model root for operational data is Interfaces + final InstanceIdentifier<Interfaces> root = InstanceIdentifier.create(Interfaces.class); + // But unlike ReaderFactories, there's no need to create a structural writer, we can "ignore" any nodes + // that do not contain actual data (leaves) + + // Next child node is Interface (list) + final InstanceIdentifier<Interface> ifcListId = root.child(Interface.class); + registry.add(new GenericListWriter<>(ifcListId, new InterfaceWriterCustomizer(access))); + } +} diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/init/InterfacesInitializer.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/init/InterfacesInitializer.java new file mode 100644 index 000000000..9aea508c7 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/init/InterfacesInitializer.java @@ -0,0 +1,68 @@ +/* + * 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.samples.interfaces.mapping.init; + +import com.google.inject.Inject; +import com.google.inject.name.Named; +import io.fd.honeycomb.data.init.AbstractDataTreeConverter; +import java.util.stream.Collectors; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.Interfaces; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.InterfacesBuilder; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.InterfacesState; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.InterfaceBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * This is an initializer for interfaces plugin. Its main goal is to revers-engineer configuration data (config "true") + * for interfaces model from operational data. In this case, we are trying to recreate Interfaces container from InterfacesState + * container. Thanks to symmetrical nature of the model, it's pretty straightforward. + * + * This is very useful when the lower layer already contains some data that should be revers-engineer to config data + * in honeycomb in order to get HC and lower layer to sync... It makes life of upper layers much easier + * + * However it's not always possible to perform this task so the initializers are optional for plugins + */ +public class InterfacesInitializer extends AbstractDataTreeConverter<InterfacesState, Interfaces> { + + private static final Logger LOG = LoggerFactory.getLogger(InterfacesInitializer.class); + + @Inject + public InterfacesInitializer(@Named("honeycomb-initializer") final DataBroker bindingDataBroker) { + super(bindingDataBroker, + InstanceIdentifier.create(InterfacesState.class), InstanceIdentifier.create(Interfaces.class)); + } + + @Override + protected Interfaces convert(final InterfacesState operationalData) { + // Just convert operational data into config data + // The operational data are queried from lower layer using readerCustomizers from this plugin + + LOG.info("Initializing interfaces config data from: {}", operationalData); + + return new InterfacesBuilder() + .setInterface(operationalData.getInterface().stream() + .map(oper -> new InterfaceBuilder() + .setMtu(oper.getMtu()) + .setInterfaceId(oper.getInterfaceId()) + .build()) + .collect(Collectors.toList())) + .build(); + } +} diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/notification/InterfaceUpNotificationProducer.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/notification/InterfaceUpNotificationProducer.java new file mode 100644 index 000000000..76d2c5dc8 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/notification/InterfaceUpNotificationProducer.java @@ -0,0 +1,96 @@ +/* + * 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.samples.interfaces.mapping.notification; + +import com.google.inject.Inject; +import io.fd.honeycomb.notification.ManagedNotificationProducer; +import io.fd.honeycomb.notification.NotificationCollector; +import io.fd.honeycomb.samples.interfaces.mapping.LowerLayerAccess; +import java.util.Collection; +import java.util.Collections; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.InterfaceId; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.InterfaceUp; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.InterfaceUpBuilder; +import org.opendaylight.yangtools.yang.binding.Notification; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Notification producer for sample interfaces plugin + */ +public class InterfaceUpNotificationProducer implements ManagedNotificationProducer { + + private static final Logger LOG = LoggerFactory.getLogger(InterfaceUpNotificationProducer.class); + + @Nonnull + private final LowerLayerAccess access; + + private Thread thread; + + @Inject + public InterfaceUpNotificationProducer(@Nonnull final LowerLayerAccess access) { + this.access = access; + } + + @Override + public void start(@Nonnull final NotificationCollector collector) { + LOG.info("Starting notification stream for interfaces"); + + // Simulating notification producer + thread = new Thread(() -> { + while(true) { + if (Thread.currentThread().isInterrupted()) { + return; + } + + try { + Thread.sleep(2000); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + break; + } + + + final InterfaceUp ifc1 = new InterfaceUpBuilder().setInterfaceId(new InterfaceId("ifc1")).build(); + LOG.info("Emitting notification: {}", ifc1); + collector.onNotification(ifc1); + } + }, "NotificationProducer"); + thread.setDaemon(true); + thread.start(); + } + + @Override + public void stop() { + if(thread != null) { + thread.interrupt(); + } + } + + @Nonnull + @Override + public Collection<Class<? extends Notification>> getNotificationTypes() { + // Producing only this single type of notification + return Collections.singleton(InterfaceUp.class); + } + + @Override + public void close() throws Exception { + stop(); + } +} diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/oper/CountersReaderCustomizer.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/oper/CountersReaderCustomizer.java new file mode 100644 index 000000000..b5ec2cbd9 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/oper/CountersReaderCustomizer.java @@ -0,0 +1,71 @@ +/* + * 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.samples.interfaces.mapping.oper; + +import io.fd.honeycomb.samples.interfaces.mapping.LowerLayerAccess; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810._interface.state.Counters; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810._interface.state.CountersBuilder; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.state.Interface; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.state.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.state.InterfaceKey; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * This is a customizer responsible for reading Counters operational data + */ +public class CountersReaderCustomizer implements ReaderCustomizer<Counters, CountersBuilder> { + + private static final Logger LOG = LoggerFactory.getLogger(CountersReaderCustomizer.class); + private final LowerLayerAccess access; + + public CountersReaderCustomizer(final LowerLayerAccess access) { + this.access = access; + } + + + @Nonnull + @Override + public CountersBuilder getBuilder(@Nonnull final InstanceIdentifier<Counters> id) { + return new CountersBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Counters> id, + @Nonnull final CountersBuilder builder, @Nonnull final ReadContext ctx) + throws ReadFailedException { + // Get the information about which interface to get counters for + final InterfaceKey interfaceKey = id.firstKeyOf(Interface.class); + LOG.info("Reading counters for interface: {} at {}", interfaceKey.getInterfaceId(), id); + + // Set some random data + builder.setDroppedPackets(access.getDroppedPacketsForIfc(interfaceKey.getInterfaceId().getValue())); + builder.setTotalPackets(access.getTotalPacketsForInterface(interfaceKey.getInterfaceId().getValue())); + } + + @Override + public void merge(@Nonnull final Builder<? extends DataObject> parentBuilder, @Nonnull final Counters readValue) { + ((InterfaceBuilder) parentBuilder).setCounters(readValue); + } +} diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/oper/InterfaceReaderCustomizer.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/oper/InterfaceReaderCustomizer.java new file mode 100644 index 000000000..7b69005e0 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/oper/InterfaceReaderCustomizer.java @@ -0,0 +1,103 @@ +/* + * 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.samples.interfaces.mapping.oper; + +import io.fd.honeycomb.samples.interfaces.mapping.LowerLayerAccess; +import io.fd.honeycomb.translate.read.ReadContext; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.ListReaderCustomizer; +import java.util.List; +import java.util.stream.Collectors; +import javax.annotation.Nonnull; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.InterfaceId; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.InterfacesStateBuilder; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.state.Interface; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.state.InterfaceBuilder; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.state.InterfaceKey; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * This is a customizer responsible for reading Interface operational data + */ +public class InterfaceReaderCustomizer implements ListReaderCustomizer<Interface, InterfaceKey, InterfaceBuilder> { + + private static final Logger LOG = LoggerFactory.getLogger(InterfaceReaderCustomizer.class); + private final LowerLayerAccess access; + + public InterfaceReaderCustomizer(final LowerLayerAccess access) { + this.access = access; + } + + @Nonnull + @Override + public List<InterfaceKey> getAllIds(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final ReadContext context) throws ReadFailedException { + // context can be used to access cache (lifetime during a transaction) to store any information for + // subsequent invocations or for other customizers + // context.getModificationCache(); + + // context can also be used to access context data. Context data are stored in a persistent data store + // and usually are additional data required to perform the translation in customizers e.g. if underlying layer + // does not recognize interface-ids as string names, but only indices, the mapping between them can should + // be stored in the context data store + // Note: The context datastore is also YANG drive, so context data must be modeled in YANG prior to using them + // context.getMappingContext(); + + // return some sample IDs + return access.getAllInterfaceNames().stream() + .map(InterfaceId::new) + .map(InterfaceKey::new) + .collect(Collectors.toList()); + } + + @Override + public void merge(@Nonnull final Builder<? extends DataObject> builder, @Nonnull final List<Interface> readData) { + // Just set the result of this customizers read into parent builder + // Builder has to be cast properly + ((InterfacesStateBuilder) builder).setInterface(readData); + } + + @Nonnull + @Override + public InterfaceBuilder getBuilder(@Nonnull final InstanceIdentifier<Interface> id) { + // Just providing empty builder + return new InterfaceBuilder(); + } + + @Override + public void readCurrentAttributes(@Nonnull final InstanceIdentifier<Interface> id, + @Nonnull final InterfaceBuilder builder, @Nonnull final ReadContext ctx) + throws ReadFailedException { + // This is where the actual "read" is happening, read attributes for a specific interface + final InterfaceKey k = id.firstKeyOf(Interface.class); + final String ifcId = k.getInterfaceId().getValue(); + LOG.info("Reading data for interface: {} at {}", ifcId, id); + + // Fill in some random values, this is actually the place where communication with lower layer + // would occur to get the real values + builder.setMtu(access.getMtuForInterface(ifcId)); + builder.setInterfaceId(k.getInterfaceId()); + // Counters container is not set here, instead a dedicated customizer is created for it + // It could be set here, if this customizer + its reader were marked as subtree reader in the ReaderFactory + // However its a good practice to provide a dedicated reader+customizer for every complex node + } + +} diff --git a/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/oper/InterfacesReaderFactory.java b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/oper/InterfacesReaderFactory.java new file mode 100644 index 000000000..5e34eea74 --- /dev/null +++ b/samples/interfaces/mapping/src/main/java/io/fd/honeycomb/samples/interfaces/mapping/oper/InterfacesReaderFactory.java @@ -0,0 +1,68 @@ +/* + * 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.samples.interfaces.mapping.oper; + +import com.google.inject.Inject; +import io.fd.honeycomb.samples.interfaces.mapping.LowerLayerAccess; +import io.fd.honeycomb.translate.impl.read.GenericListReader; +import io.fd.honeycomb.translate.impl.read.GenericReader; +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.io.fd.honeycomb.samples.interfaces.rev160810.InterfacesState; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.InterfacesStateBuilder; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810._interface.state.Counters; +import org.opendaylight.yang.gen.v1.io.fd.honeycomb.samples.interfaces.rev160810.interfaces.state.Interface; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class InterfacesReaderFactory implements ReaderFactory { + + @Nonnull + private final LowerLayerAccess access; + + @Inject + public InterfacesReaderFactory(@Nonnull final LowerLayerAccess access) { + this.access = access; + } + + @Override + public void init(@Nonnull final ModifiableReaderRegistryBuilder registry) { + // ReaderFactory is intended for registering Readers into HC framework + // Readers provide ONLY operational (config "false") data straight from underlying device/layer + // they are triggered when RESTCONF GET on operational is invoked or when NETCONF get operation is executed + + // Our model root for operational data is InterfacesState + final InstanceIdentifier<InterfacesState> root = InstanceIdentifier.create(InterfacesState.class); + // Since InterfacesState has no direct data children (leaves) only a structural reader is registered + // This reader just fills in the composite hierarchy of readers + // Honeycomb can't automatically instantiate structural readers and plugins have to help it by invoking as: + registry.addStructuralReader(root, InterfacesStateBuilder.class); + + // Next child node is Interface (list) + final InstanceIdentifier<Interface> ifcListId = root.child(Interface.class); + registry.add(new GenericListReader<>(ifcListId, new InterfaceReaderCustomizer(access))); + + // Next child is a container Counters + final InstanceIdentifier<Counters> countersId = ifcListId.child(Counters.class); + // By adding the reader with addAfter, we can ensure ordering of execution among the readers + // Useful in cases when a certain read has to be invoked before/after another + // In this case, we are ensuring that Counters are read after Interface is read + // "add" could be used instead, leaving the ordering to "nature" + // Same applies for writers + registry.addAfter(new GenericReader<>(countersId, new CountersReaderCustomizer(access)), ifcListId); + } +} diff --git a/samples/interfaces/mapping/src/main/resources/honeycomb-minimal-resources/config/sample-interfaces.json b/samples/interfaces/mapping/src/main/resources/honeycomb-minimal-resources/config/sample-interfaces.json new file mode 100644 index 000000000..69d527a0e --- /dev/null +++ b/samples/interfaces/mapping/src/main/resources/honeycomb-minimal-resources/config/sample-interfaces.json @@ -0,0 +1,3 @@ +{ + "some-config-attribute": "some-value" +}
\ No newline at end of file diff --git a/samples/interfaces/models/pom.xml b/samples/interfaces/models/pom.xml new file mode 100644 index 000000000..d78d6f496 --- /dev/null +++ b/samples/interfaces/models/pom.xml @@ -0,0 +1,75 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Copyright (c) 2015 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. +--> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <parent> + <groupId>io.fd.honeycomb.common</groupId> + <artifactId>api-parent</artifactId> + <version>1.0.0-SNAPSHOT</version> + <relativePath>../../../common/api-parent</relativePath> + </parent> + + <modelVersion>4.0.0</modelVersion> + <groupId>io.fd.honeycomb.samples.interfaces</groupId> + <artifactId>interfaces-models</artifactId> + <version>1.0.0-SNAPSHOT</version> + <packaging>bundle</packaging> + + <dependencyManagement> + <dependencies> + <dependency> + <groupId>org.opendaylight.mdsal.model</groupId> + <artifactId>mdsal-model-artifacts</artifactId> + <version>0.8.2-Beryllium-SR2</version> + <type>pom</type> + <scope>import</scope> + </dependency> + </dependencies> + </dependencyManagement> + + <dependencies> + <!-- Uncomment if iana-if-type model is imported --> + <!--<dependency>--> + <!--<groupId>org.opendaylight.mdsal.model</groupId>--> + <!--<artifactId>iana-if-type-2014-05-08</artifactId>--> + <!--</dependency>--> + + <!-- Uncomment if ietf-yang-types-20130715 model is imported --> + <!--<dependency>--> + <!--<groupId>org.opendaylight.mdsal.model</groupId>--> + <!--<artifactId>ietf-yang-types-20130715</artifactId>--> + <!--</dependency>--> + + <!-- Uncomment if ietf-interfaces model is imported --> + <!--<dependency>--> + <!--<groupId>org.opendaylight.mdsal.model</groupId>--> + <!--<artifactId>ietf-interfaces</artifactId>--> + <!--</dependency>--> + + <!-- Uncomment if ietf-inet-types-2013-07-15 model is imported --> + <!--<dependency>--> + <!--<groupId>org.opendaylight.mdsal.model</groupId>--> + <!--<artifactId>ietf-inet-types-2013-07-15</artifactId>--> + <!--</dependency>--> + + <!-- Uncomment if yang-ext model is imported --> + <!--<dependency>--> + <!--<groupId>org.opendaylight.mdsal.model</groupId>--> + <!--<artifactId>yang-ext</artifactId>--> + <!--</dependency>--> + + <!-- Additional models can be found under >mdsal-model-artifacts --> + </dependencies> +</project> diff --git a/samples/interfaces/models/src/main/yang/openconfig-interfaces-notification.yang b/samples/interfaces/models/src/main/yang/openconfig-interfaces-notification.yang new file mode 100644 index 000000000..456fab4df --- /dev/null +++ b/samples/interfaces/models/src/main/yang/openconfig-interfaces-notification.yang @@ -0,0 +1,60 @@ +module sample-interfaces { + + namespace "io:fd:honeycomb:samples:interfaces"; + + prefix "hc-s-if"; + + description "Sample interface model"; + + revision "2016-08-10" { + description "Initial revision"; + } + + typedef interface-id { + type string; + } + + grouping interface-common { + leaf interface-id { + type interface-id; + } + + leaf mtu { + type uint16; + } + } + + grouping interface-state { + container counters { + leaf total-packets { + type uint32; + } + leaf dropped-packets { + type uint32; + } + } + } + + container interfaces { + list interface { + key "interface-id"; + uses interface-common; + } + } + + container interfaces-state { + config false; + + list interface { + key "interface-id"; + uses interface-common; + uses interface-state; + } + } + + notification interface-up { + leaf interface-id { + type interface-id; + } + } +}
\ No newline at end of file diff --git a/samples/interfaces/pom.xml b/samples/interfaces/pom.xml new file mode 100644 index 000000000..2f87b10bc --- /dev/null +++ b/samples/interfaces/pom.xml @@ -0,0 +1,57 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Copyright (c) 2015 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. +--> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + + <parent> + <groupId>org.opendaylight.odlparent</groupId> + <artifactId>odlparent</artifactId> + <version>1.6.2-Beryllium-SR2</version> + <relativePath/> + </parent> + + <groupId>io.fd.honeycomb.samples.interfaces</groupId> + <artifactId>interfaces-aggregator</artifactId> + <version>1.0.0-SNAPSHOT</version> + <name>honeycomb-infra</name> + <packaging>pom</packaging> + <modelVersion>4.0.0</modelVersion> + <prerequisites> + <maven>3.1.1</maven> + </prerequisites> + <modules> + <module>models</module> + <module>mapping</module> + </modules> + <!-- DO NOT install or deploy the repo root pom as it's only needed to initiate a build --> + <build> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-deploy-plugin</artifactId> + <configuration> + <skip>true</skip> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-install-plugin</artifactId> + <configuration> + <skip>true</skip> + </configuration> + </plugin> + </plugins> + </build> +</project> diff --git a/samples/minimal-distribution/pom.xml b/samples/minimal-distribution/pom.xml new file mode 100644 index 000000000..c8311aead --- /dev/null +++ b/samples/minimal-distribution/pom.xml @@ -0,0 +1,71 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Copyright (c) 2015 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. +--> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + + <parent> + <groupId>io.fd.honeycomb.common</groupId> + <artifactId>minimal-distribution-parent</artifactId> + <version>1.0.0-SNAPSHOT</version> + <relativePath>../../common/minimal-distro-parent</relativePath> + </parent> + + <modelVersion>4.0.0</modelVersion> + <groupId>io.fd.honeycomb.samples.distro</groupId> + <artifactId>minimal-distribution</artifactId> + <version>1.0.0-SNAPSHOT</version> + + <properties> + <exec.parameters>-Xms128m -Xmx128m</exec.parameters> + <main.class>io.fd.honeycomb.samples.distro.Main</main.class> + </properties> + + <build> + <plugins> + <plugin> + <artifactId>maven-compiler-plugin</artifactId> + </plugin> + <plugin> + <groupId>org.codehaus.gmaven</groupId> + <artifactId>groovy-maven-plugin</artifactId> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-jar-plugin</artifactId> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-dependency-plugin</artifactId> + </plugin> + <plugin> + <artifactId>maven-assembly-plugin</artifactId> + </plugin> + </plugins> + </build> + + <dependencies> + <dependency> + <groupId>io.fd.honeycomb.samples.interfaces</groupId> + <artifactId>interfaces-mapping</artifactId> + <version>1.0.0-SNAPSHOT</version> + </dependency> + <dependency> + <groupId>io.fd.honeycomb</groupId> + <artifactId>minimal-distribution</artifactId> + <version>1.0.0-SNAPSHOT</version> + </dependency> + + </dependencies> +</project> diff --git a/samples/minimal-distribution/src/main/java/io/fd/honeycomb/samples/distro/Main.java b/samples/minimal-distribution/src/main/java/io/fd/honeycomb/samples/distro/Main.java new file mode 100644 index 000000000..f6b38aa78 --- /dev/null +++ b/samples/minimal-distribution/src/main/java/io/fd/honeycomb/samples/distro/Main.java @@ -0,0 +1,33 @@ +/* + * 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.samples.distro; + +import com.google.common.collect.Lists; +import com.google.inject.Module; +import io.fd.honeycomb.samples.interfaces.mapping.SampleInterfaceModule; +import java.util.List; + +public class Main { + + public static void main(String[] args) { + final List<Module> sampleModules = Lists.newArrayList(io.fd.honeycomb.infra.distro.Main.BASE_MODULES); + + sampleModules.add(new SampleInterfaceModule()); + + io.fd.honeycomb.infra.distro.Main.init(sampleModules); + } +} diff --git a/samples/pom.xml b/samples/pom.xml new file mode 100644 index 000000000..ee20f602a --- /dev/null +++ b/samples/pom.xml @@ -0,0 +1,57 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Copyright (c) 2015 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. +--> +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + + <parent> + <groupId>org.opendaylight.odlparent</groupId> + <artifactId>odlparent</artifactId> + <version>1.6.2-Beryllium-SR2</version> + <relativePath/> + </parent> + + <groupId>io.fd.honeycomb</groupId> + <artifactId>samples-aggregator</artifactId> + <version>1.0.0-SNAPSHOT</version> + <name>honeycomb-infra</name> + <packaging>pom</packaging> + <modelVersion>4.0.0</modelVersion> + <prerequisites> + <maven>3.1.1</maven> + </prerequisites> + <modules> + <module>interfaces</module> + <module>minimal-distribution</module> + </modules> + <!-- DO NOT install or deploy the repo root pom as it's only needed to initiate a build --> + <build> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-deploy-plugin</artifactId> + <configuration> + <skip>true</skip> + </configuration> + </plugin> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-install-plugin</artifactId> + <configuration> + <skip>true</skip> + </configuration> + </plugin> + </plugins> + </build> +</project> |