<properties>
<nexusproxy>http://nexus.fd.io/content</nexusproxy>
<!--<main.class>Main</main.class>-->
- <exec.parameters>-XX:+PrintFlagsFinal -client -Xms64m -Xmx64m -XX:MaxMetaspaceSize=64m -Xss512k -XX:+UseSerialGC -Djava.compiler=NONE -Xverify:none -noverify</exec.parameters>
+ <exec.parameters>-Xms64m -Xmx128m -XX:MaxMetaspaceSize=128m</exec.parameters>
+ <exec.parameters.minimal>-client -Xms64m -Xmx64m -XX:MaxMetaspaceSize=64m -Xss512k -XX:+UseSerialGC -Djava.compiler=NONE -Xverify:none -noverify</exec.parameters.minimal>
<guice.version>4.1.0</guice.version>
<guice.config.version>1.2.0</guice.config.version>
+++ /dev/null
-/*
- * 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.data.init;
-
-/**
- * Type of operation to use when writing restored data
- */
-public enum RestorationType {
- Put, Merge
-}
@Override
public void close() {}
+
+ /**
+ * Type of operation to use when writing restored data
+ */
+ public static enum RestorationType {
+ Put, Merge
+ }
}
final RestConnector instance = injector.getInstance(RestConnector.class);
if (cfgAttributes.isRestconfHttpEnabled()) {
- injector.getInstance(Key.get(ServerConnector.class, Names.named("restconf-http")));
+ injector.getInstance(Key.get(ServerConnector.class, Names.named(RestconfModule.RESTCONF_HTTP)));
}
if (cfgAttributes.isRestconfHttpsEnabled()) {
- injector.getInstance(Key.get(ServerConnector.class, Names.named("restconf-https")));
+ injector.getInstance(Key.get(ServerConnector.class, Names.named(RestconfModule.RESTCONF_HTTPS)));
}
try {
}
if (cfgAttributes.isNetconfEnabled()) {
- LOG.info("Starting NETCONF");
- injector.getInstance(
- Key.get(NetconfOperationServiceFactory.class, Names.named("netconf-mapper-honeycomb")));
- injector.getInstance(
- Key.get(NetconfOperationServiceFactory.class, Names.named("netconf-mapper-notification")));
- injector.getInstance(
- Key.get(NetconfOperationServiceFactory.class, Names.named("netconf-mapper-monitoring")));
+ LOG.info("Starting HONEYCOMB_NETCONF");
+ injector.getInstance(Key.get(NetconfOperationServiceFactory.class,
+ Names.named(NetconfModule.HONEYCOMB_NETCONF_MAPPER_CORE)));
+ injector.getInstance(Key.get(NetconfOperationServiceFactory.class,
+ Names.named(NetconfModule.HONEYCOMB_NETCONF_MAPPER_NOTIF)));
+ injector.getInstance(Key.get(NetconfOperationServiceFactory.class,
+ Names.named(NetconfModule.HONEYCOMB_NETCONF_MAPPER_OPER)));
if (cfgAttributes.isNetconfTcpEnabled()) {
- LOG.info("Starting NETCONF TCP");
+ LOG.info("Starting HONEYCOMB_NETCONF TCP");
injector.getInstance(NetconfTcpServerProvider.NetconfTcpServer.class);
}
if (cfgAttributes.isNetconfSshEnabled()) {
- LOG.info("Starting NETCONF SSH");
+ LOG.info("Starting HONEYCOMB_NETCONF SSH");
injector.getInstance(NetconfSshServerProvider.NetconfSshServer.class);
}
injector.getInstance(HoneycombNotification2NetconfProvider.HoneycombNotification2Netconf.class);
try {
LOG.info("Initializing configuration");
- injector.getInstance(Key.get(InitializerRegistry.class, Names.named("honeycomb-initializer"))).initialize();
+ injector.getInstance(Key.get(InitializerRegistry.class,
+ Names.named(InitializerPipelineModule.HONEYCOMB_INITIALIZER))).initialize();
LOG.info("Configuration initialized successfully");
} catch (DataTreeInitializer.InitializeException e) {
LOG.error("Unable to initialize configuration", e);
import groovy.util.logging.Slf4j
import net.jmob.guice.conf.core.ConfigurationModule
+/**
+ * Load the configuration from json into HoneycombConfiguration and make it available.
+ */
@Slf4j
class CfgAttrsModule extends AbstractModule {
import net.jmob.guice.conf.core.InjectConfig
import net.jmob.guice.conf.core.Syntax
+/**
+ * This is the Java equivalent for honeyconb.json file.
+ * We use guice-config library to load all the config attributes into this class instance.
+ *
+ * The BindConfig annotation tells that honeycomb.json file should be looked up on classpath root.
+ */
@ToString(includeNames = true)
@BindConfig(value = "honeycomb", syntax = Syntax.JSON)
class HoneycombConfiguration {
Optional<String> restconfHttpsBindingAddress
@InjectConfig("restconf-https-port")
Optional<Integer> restconfHttpsPort
-
+ /**
+ * Restconf keystore file name.
+ * It will be loaded from the classpath so must be present in one of the folders packaged with the distribution e.g. cert/
+ */
+ @InjectConfig("restconf-keystore")
+ Optional<String> restconfKeystore = Optional.of("/honeycomb-keystore")
+ @InjectConfig("restconf-keystore-password")
+ Optional<String> keystorePassword
+ @InjectConfig("restconf-keystore-manager-password")
+ Optional<String> keystoreManagerPassword
+ /**
+ * Restconf truststore file name.
+ * It will be loaded from the classpath so must be present in one of the folders packaged with the distribution e.g. cert/
+ */
+ @InjectConfig("restconf-truststore")
+ Optional<String> restconfTruststore
+ @InjectConfig("restconf-truststore-password")
+ Optional<String> truststorePassword
+
+ // This is the way for optional attributes with default values to work
@InjectConfig("restconf-websocket-port")
Optional<Integer> restconfWebsocketPort = Optional.of(7779)
boolean isRestconfHttpsEnabled() { Boolean.valueOf(restconfHttps) }
boolean isRestconfEnabled() { isRestconfHttpEnabled() || isRestconfHttpsEnabled() }
- // NETCONF
+ // HONEYCOMB_NETCONF
@InjectConfig("netconf-netty-threads")
Integer netconfNettyThreads
- // NETCONF TCP
+ // HONEYCOMB_NETCONF TCP
@InjectConfig("netconf-tcp-enabled")
String netconfTcp
@InjectConfig("netconf-tcp-binding-address")
@InjectConfig("netconf-tcp-binding-port")
Optional<Integer> netconfTcpBindingPort
- // NETCONF SSH
+ // HONEYCOMB_NETCONF SSH
@InjectConfig("netconf-ssh-enabled")
String netconfSsh
@InjectConfig("netconf-ssh-binding-address")
@Slf4j
class ConfigAndOperationalPipelineModule extends PrivateModule {
+ public static final String HONEYCOMB_CONFIG_NONPERSIST = "honeycomb-config-nopersist"
+ public static final String HONEYCOMB_CONFIG = "honeycomb-config"
+
protected void configure() {
// Expose registries for plugin reader/writer factories
bind(ModifiableWriterRegistryBuilder).toProvider(WriterRegistryProvider).in(Singleton)
bind(ModifiableReaderRegistryBuilder).toProvider(ReaderRegistryProvider).in(Singleton)
expose(ModifiableReaderRegistryBuilder)
- // Non persisting data tree
+ // Non persisting data tree for config
bind(DataTree)
- .annotatedWith(Names.named("honeycomb-config-nopersist"))
+ .annotatedWith(Names.named(HONEYCOMB_CONFIG_NONPERSIST))
.toProvider(DataTreeProvider.ConfigDataTreeProvider)
.in(Singleton)
- expose(DataTree).annotatedWith(Names.named("honeycomb-config-nopersist"))
- // Persisting data tree wrapper
+ expose(DataTree).annotatedWith(Names.named(HONEYCOMB_CONFIG_NONPERSIST))
+ // Persisting data tree wrapper for config
bind(DataTree)
- .annotatedWith(Names.named("honeycomb-config"))
+ .annotatedWith(Names.named(HONEYCOMB_CONFIG))
.toProvider(PersistingDataTreeProvider.ConfigPersistingDataTreeProvider)
.in(Singleton)
- expose(DataTree).annotatedWith(Names.named("honeycomb-config"))
+ expose(DataTree).annotatedWith(Names.named(HONEYCOMB_CONFIG))
+ // Config Data Tree manager working on top of config data tree + writer registry
bind(ModifiableDataManager).toProvider(ModifiableDTDelegProvider).in(Singleton)
+ // Operational Data Tree manager working on top of reader registry
bind(ReadableDataManager).toProvider(ReadableDTDelegProvider).in(Singleton)
expose(ReadableDataManager)
+ // DOMDataBroker wrapper on top of data tree managers
def domBrokerProvider = new HoneycombDOMDataBrokerProvider()
-// bind(DOMDataBroker).annotatedWith(Names.named("honeycomb-config")).toProvider(domBrokerProvider).in(Singleton)
- // Bind also without annotation for easy private injection
bind(DOMDataBroker).toProvider(domBrokerProvider).in(Singleton)
- bind(DataBroker).annotatedWith(Names.named("honeycomb-config")).toProvider(BindingDataBrokerProvider).in(Singleton)
- expose(DataBroker).annotatedWith(Names.named("honeycomb-config"))
+ // BA version of data broker
+ bind(DataBroker).annotatedWith(Names.named(HONEYCOMB_CONFIG)).toProvider(BindingDataBrokerProvider).in(Singleton)
+ expose(DataBroker).annotatedWith(Names.named(HONEYCOMB_CONFIG))
+ // Create initializer to init persisted config data
bind(DataTreeInitializer)
- .annotatedWith(Names.named("honeycomb-config"))
+ .annotatedWith(Names.named(HONEYCOMB_CONFIG))
.toProvider(PersistedFileInitializerProvider.PersistedConfigInitializerProvider)
.in(Singleton)
- expose(DataTreeInitializer).annotatedWith(Names.named("honeycomb-config"))
+ expose(DataTreeInitializer).annotatedWith(Names.named(HONEYCOMB_CONFIG))
configureNotifications()
}
protected void configureNotifications() {
+ // Create notification service
bind(DOMNotificationRouter).toProvider(DOMNotificationServiceProvider).in(Singleton)
expose(DOMNotificationRouter)
+ // Wrap notification service, data broker and schema service in a Broker MD-SAL API
bind(Broker).toProvider(HoneycombDOMBrokerProvider).in(Singleton)
expose(Broker)
}
class HoneycombDOMBrokerProvider extends ProviderTrait<Broker> {
@Inject
-// @Named("honeycomb-config")
DOMDataBroker domDataBroker
@Inject
SchemaService schemaService
import org.opendaylight.controller.md.sal.binding.impl.BindingDOMNotificationPublishServiceAdapter
import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec
import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter
-/**
- * Mirror of org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.notification.impl.rev160601.HoneycombNotificationManagerModule
- */
+
@Slf4j
@ToString
class HoneycombNotificationManagerProvider extends ProviderTrait<NotificationCollector> {
import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore
import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService
import org.opendaylight.yangtools.util.concurrent.SpecialExecutors
-/**
- * Mirror of org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModule
- */
+
@Slf4j
@ToString
class InmemoryDOMDataBrokerProvider extends ProviderTrait<DOMDataBroker> {
import io.fd.honeycomb.data.ModifiableDataManager
import io.fd.honeycomb.data.impl.ModifiableDataTreeDelegator
import io.fd.honeycomb.infra.distro.ProviderTrait
+import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule
import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder
import org.opendaylight.controller.md.sal.binding.api.DataBroker
import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec
@Inject
BindingToNormalizedNodeCodec serializer
@Inject
- @Named("honeycomb-config")
+ @Named(ConfigAndOperationalPipelineModule.HONEYCOMB_CONFIG)
DataTree dataTree
@Inject
ModifiableWriterRegistryBuilder registry
@Inject
- @Named("honeycomb-context")
+ @Named(ContextPipelineModule.HONEYCOMB_CONTEXT)
DataBroker contextBroker
@Override
import io.fd.honeycomb.data.impl.PersistingDataTreeAdapter
import io.fd.honeycomb.infra.distro.ProviderTrait
import io.fd.honeycomb.infra.distro.cfgattrs.HoneycombConfiguration
+import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule
import org.opendaylight.controller.sal.core.api.model.SchemaService
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree
import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType
static class ConfigPersistingDataTreeProvider extends PersistingDataTreeProvider {
@Inject
- @Named("honeycomb-config-nopersist")
+ @Named(ConfigAndOperationalPipelineModule.HONEYCOMB_CONFIG_NONPERSIST)
DataTree delegate
String getPath() { config.peristConfigPath }
static class ContextPersistingDataTreeProvider extends PersistingDataTreeProvider {
@Inject
- @Named("honeycomb-context-nopersist")
+ @Named(ContextPipelineModule.HONEYCOMB_CONTEXT_NOPERSIST)
DataTree delegate
String getPath() { config.peristContextPath }
class ContextPipelineModule extends PrivateModule {
- protected void configure() {
- // Bind also without annotation for easy private injection
+ public static final String HONEYCOMB_CONTEXT_NOPERSIST = "honeycomb-context-nopersist"
+ public static final String HONEYCOMB_CONTEXT = "honeycomb-context"
- // Non persisting data tree
+ protected void configure() {
+ // Non persisting data tree for context
def noPersistDataTreeProvider = new DataTreeProvider.ContextDataTreeProvider()
bind(DataTree)
- .annotatedWith(Names.named("honeycomb-context-nopersist"))
+ .annotatedWith(Names.named(HONEYCOMB_CONTEXT_NOPERSIST))
.toProvider(noPersistDataTreeProvider)
.in(Singleton)
- expose(DataTree).annotatedWith(Names.named("honeycomb-context-nopersist"))
- // Persisting data tree wrapper
+ expose(DataTree).annotatedWith(Names.named(HONEYCOMB_CONTEXT_NOPERSIST))
+ // Persisting data tree wrapper for context
def dataTreeProvider = new PersistingDataTreeProvider.ContextPersistingDataTreeProvider()
bind(DataTree).toProvider(dataTreeProvider).in(Singleton)
-// bind(DataTree).annotatedWith(Names.named("honeycomb-context")).toProvider(dataTreeProvider).in(Singleton)
-// expose(DataTree).annotatedWith(Names.named("honeycomb-context"))
+ // Data Tree manager (without any delegation) on top of context data tree
bind(ModifiableDataManager).toProvider(ModifiableDTMgrProvider).in(Singleton)
+ // DOMDataBroker interface on top of data tree manager
def domBrokerProvider = new HoneycombContextDOMDataBrokerProvider()
-// bind(DOMDataBroker).annotatedWith(Names.named("honeycomb-context")).toProvider(domBrokerProvider).in(Singleton)
- // Bind also without annotation for easy private injection
bind(DOMDataBroker).toProvider(domBrokerProvider).in(Singleton)
-// expose(DOMDataBroker).annotatedWith(Names.named("honeycomb-context"))
- bind(DataBroker).annotatedWith(Names.named("honeycomb-context")).toProvider(BindingDataBrokerProvider).in(Singleton)
- expose(DataBroker).annotatedWith(Names.named("honeycomb-context"))
+ // BA version of data broker for context
+ bind(DataBroker).annotatedWith(Names.named(HONEYCOMB_CONTEXT)).toProvider(BindingDataBrokerProvider).in(Singleton)
+ expose(DataBroker).annotatedWith(Names.named(HONEYCOMB_CONTEXT))
+ // Create initializer to init persisted config data
bind(DataTreeInitializer)
- .annotatedWith(Names.named("honeycomb-context"))
+ .annotatedWith(Names.named(HONEYCOMB_CONTEXT))
.toProvider(PersistedFileInitializerProvider.PersistedContextInitializerProvider)
.in(Singleton)
- expose(DataTreeInitializer).annotatedWith(Names.named("honeycomb-context"))
+ expose(DataTreeInitializer).annotatedWith(Names.named(HONEYCOMB_CONTEXT))
+ // Mapping context is just a small adapter on top of BA data broker to simplify CRUD of context data
bind(MappingContext)
- .annotatedWith(Names.named("honeycomb-context"))
+ .annotatedWith(Names.named(HONEYCOMB_CONTEXT))
.toProvider(RealtimeMappingContextProvider)
.in(Singleton.class)
- expose(MappingContext).annotatedWith(Names.named("honeycomb-context"))
+ expose(MappingContext).annotatedWith(Names.named(HONEYCOMB_CONTEXT))
}
}
class RealtimeMappingContextProvider extends ProviderTrait<MappingContext> {
@Inject
- @Named("honeycomb-context")
+ @Named(ContextPipelineModule.HONEYCOMB_CONTEXT)
DataBroker contextDataBroker
@Override
import io.fd.honeycomb.data.ReadableDataManager
import io.fd.honeycomb.data.impl.ReadableDataTreeDelegator
import io.fd.honeycomb.infra.distro.ProviderTrait
+import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule
import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder
import org.opendaylight.controller.md.sal.binding.api.DataBroker
import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec
@Inject
ModifiableReaderRegistryBuilder registry
@Inject
- @Named("honeycomb-context")
+ @Named(ContextPipelineModule.HONEYCOMB_CONTEXT)
DataBroker contextBroker
def create() {
@Slf4j
class InitializerPipelineModule extends PrivateModule {
+
+ public static final String HONEYCOMB_INITIALIZER = "honeycomb-initializer"
+
protected void configure() {
+ // Create data tree manager on top of non-persisting config data tree
bind(ModifiableDataManager).toProvider(ModifiableDTDelegInitProvider).in(Singleton)
+ // Wrap as DOMDataBroker
bind(DOMDataBroker).toProvider(HoneycombDOMDataBrokerProvider).in(Singleton)
- bind(DataBroker).annotatedWith(Names.named("honeycomb-initializer")).toProvider(BindingDataBrokerProvider).in(Singleton)
- expose(DataBroker).annotatedWith(Names.named("honeycomb-initializer"))
+ // Wrap as BA data broker
+ bind(DataBroker).annotatedWith(Names.named(HONEYCOMB_INITIALIZER)).toProvider(BindingDataBrokerProvider).in(Singleton)
+ expose(DataBroker).annotatedWith(Names.named(HONEYCOMB_INITIALIZER))
+ // Create initializer registry so that plugins can provide their initializers
bind(InitializerRegistry)
- .annotatedWith(Names.named("honeycomb-initializer"))
+ .annotatedWith(Names.named(HONEYCOMB_INITIALIZER))
.toProvider(InitializerRegistryProvider)
.in(Singleton)
expose(InitializerRegistry)
- .annotatedWith(Names.named("honeycomb-initializer"))
+ .annotatedWith(Names.named(HONEYCOMB_INITIALIZER))
}
}
import io.fd.honeycomb.data.init.InitializerRegistry
import io.fd.honeycomb.data.init.InitializerRegistryImpl
import io.fd.honeycomb.infra.distro.ProviderTrait
+import io.fd.honeycomb.infra.distro.data.ConfigAndOperationalPipelineModule
+import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule
@Slf4j
@ToString
class InitializerRegistryProvider extends ProviderTrait<InitializerRegistry> {
@Inject
- @Named("honeycomb-context")
+ @Named(ContextPipelineModule.HONEYCOMB_CONTEXT)
DataTreeInitializer contextInitializer
@Inject
- @Named("honeycomb-config")
+ @Named(ConfigAndOperationalPipelineModule.HONEYCOMB_CONFIG)
DataTreeInitializer configInitializer
@Inject(optional = true)
Set<DataTreeInitializer> pluginInitializers = []
import io.fd.honeycomb.data.ModifiableDataManager
import io.fd.honeycomb.data.impl.ModifiableDataTreeDelegator
import io.fd.honeycomb.infra.distro.ProviderTrait
+import io.fd.honeycomb.infra.distro.data.ConfigAndOperationalPipelineModule
+import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule
import io.fd.honeycomb.translate.util.write.NoopWriterRegistry
import org.opendaylight.controller.md.sal.binding.api.DataBroker
import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree
-/**
- * Similar to ModifiableDTDelegProvider, but uses noop writer registry
- */
@Slf4j
@ToString
class ModifiableDTDelegInitProvider extends ProviderTrait<ModifiableDataManager> {
@Inject
BindingToNormalizedNodeCodec serializer
@Inject
- @Named("honeycomb-config-nopersist")
+ @Named(ConfigAndOperationalPipelineModule.HONEYCOMB_CONFIG_NONPERSIST)
DataTree dataTree
@Inject
- @Named("honeycomb-context")
+ @Named(ContextPipelineModule.HONEYCOMB_CONTEXT)
DataBroker contextBroker
@Override
import com.google.inject.Inject
import groovy.transform.ToString
import groovy.util.logging.Slf4j
-import io.fd.honeycomb.data.init.RestorationType
+
import io.fd.honeycomb.data.init.RestoringInitializer
import io.fd.honeycomb.infra.distro.ProviderTrait
import io.fd.honeycomb.infra.distro.cfgattrs.HoneycombConfiguration
import org.opendaylight.controller.sal.core.api.model.SchemaService
import java.nio.file.Paths
-/**
- * Mirror of org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.data.initializer.rev160407.PersistedFileInitializerModule
- */
+
@Slf4j
@ToString
abstract class PersistedFileInitializerProvider extends ProviderTrait<RestoringInitializer> {
@Override
def create() {
new RestoringInitializer(schemaService, Paths.get(getPersistPath()),
- domDataBroker, RestorationType.valueOf(restorationType), getDataStoreType())
+ domDataBroker, RestoringInitializer.RestorationType.valueOf(restorationType), getDataStoreType())
}
abstract String getPersistPath()
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netconf.notification._1._0.rev080714.StreamNameType
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.netmod.notification.rev080714.netconf.streams.StreamBuilder
import org.opendaylight.yangtools.yang.model.api.SchemaPath
-/**
- * Mirror of org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.notification.impl.rev160601.HoneycombNotificationToNetconfTranslatorModule
- */
+
@Slf4j
@ToString
class HoneycombNotification2NetconfProvider extends ProviderTrait<HoneycombNotification2Netconf> {
@Inject
NetconfNotificationCollector netconfNotificationCollector
- // TODO refactor HoneycombNotificationToNetconfTranslatorModule for easier reuse here
-
@Override
def create() {
def streamType = new StreamNameType(cfgAttributes.netconfNotificationStreamName.get());
- // Register as NETCONF notification publisher under configured name
+ // Register as HONEYCOMB_NETCONF notification publisher under configured name
def netconfNotifReg = netconfNotificationCollector.registerNotificationPublisher(new StreamBuilder()
.setName(streamType)
.setReplaySupport(false)
.setDescription(cfgAttributes.netconfNotificationStreamName.get()).build());
- // Notification Translator, get notification from HC producers and put into NETCONF notification collector
+ // Notification Translator, get notification from HC producers and put into HONEYCOMB_NETCONF notification collector
def domNotificationListener = { notif ->
- log.debug "Propagating notification: {} into NETCONF", notif.type
+ log.debug "Propagating notification: {} into HONEYCOMB_NETCONF", notif.type
netconfNotifReg.onNotification(streamType, TranslationUtil.notificationToXml(notif, schemaService.globalContext))
}
// NotificationManager is used to provide list of available notifications (which are all of the notifications registered)
- // TODO make available notifications configurable here so that any number of notification streams for NETCONF
+ // TODO make available notifications configurable here so that any number of notification streams for HONEYCOMB_NETCONF
// can be configured on top of a single notification manager
- log.debug "Current notifications to be exposed over NETCONF: {}", hcNotificationCollector.notificationTypes
+ log.debug "Current notifications to be exposed over HONEYCOMB_NETCONF: {}", hcNotificationCollector.notificationTypes
def currentNotificationSchemaPaths = hcNotificationCollector.notificationTypes
.collect {SchemaPath.create(true, NotificationProducerRegistry.getQName(it))}
// Register as listener to HC'OPERATIONAL DOM notification service
- // TODO This should only be triggered when NETCONF notifications are activated
+ // TODO This should only be triggered when HONEYCOMB_NETCONF notifications are activated
// Because this way we actually start all notification producers
// final Collection<QName> notificationQNames =
def domNotifListenerReg = notificationRouter
.registerNotificationListener(domNotificationListener, currentNotificationSchemaPaths);
- log.info "Exposing NETCONF notification stream: {}", streamType.value
+ log.info "Exposing HONEYCOMB_NETCONF notification stream: {}", streamType.value
new HoneycombNotification2Netconf(domNotifListenerReg: domNotifListenerReg, netconfNotifReg: netconfNotifReg)
}
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker
import io.fd.honeycomb.impl.FakeBindingAwareBroker
-/**
- * Mirror of {@link org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.honeycomb.impl.rev141210.NetconfBindingBrokerModule}
- */
@Slf4j
@ToString
class NetconfBindingBrokerProvider extends ProviderTrait<BindingAwareBroker> {
@Inject
- @Named("netconf")
+ @Named(NetconfModule.HONEYCOMB_NETCONF)
DataBroker dataBroker
@Override
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener
import org.opendaylight.netconf.mdsal.connector.MdsalNetconfOperationServiceFactory
import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext
-/**
- * Mirror of org.opendaylight.controller.config.yang.netconf.mdsal.mapper.NetconfMdsalMapperModule
- */
+
@Slf4j
@ToString
class NetconfMdsalMapperProvider extends ProviderTrait<NetconfOperationServiceFactory> {
class NetconfModule extends PrivateModule {
+
+ public static final String HONEYCOMB_NETCONF = "honeycomb-netconf"
+ public static final String HONEYCOMB_NETCONF_MAPPER_AGGR = "netconf-mapper-aggregator"
+ public static final String HONEYCOMB_NETCONF_MAPPER_NOTIF = "netconf-mapper-notification"
+ public static final String HONEYCOMB_NETCONF_MAPPER_CORE = "netconf-mapper-honeycomb"
+ public static final String HONEYCOMB_NETCONF_MAPPER_OPER = "netconf-mapper-monitoring"
+
@Override
protected void configure() {
+ // Create inmemory data store for HONEYCOMB_NETCONF config metadata
bind(InMemoryDOMDataStore)
.annotatedWith(Names.named(CONFIG))
.toProvider(new DataStoreProvider(type: LogicalDatastoreType.CONFIGURATION, name: CONFIG))
.in(Singleton)
+ // Create inmemory data store for HONEYCOMB_NETCONF operational metadata
bind(InMemoryDOMDataStore)
.annotatedWith(Names.named(OPERATIONAL))
.toProvider(new DataStoreProvider(type: LogicalDatastoreType.OPERATIONAL, name: OPERATIONAL))
.in(Singleton)
+ // Wrap datastores as DOMDataBroker
bind(DOMDataBroker).toProvider(InmemoryDOMDataBrokerProvider).in(Singleton)
+ // Wrap DOMDataBroker as BA data broker
bind(DataBroker)
- .annotatedWith(Names.named("netconf"))
+ .annotatedWith(Names.named(HONEYCOMB_NETCONF))
.toProvider(BindingDataBrokerProvider)
.in(Singleton)
- expose(DataBroker).annotatedWith(Names.named("netconf"))
+ expose(DataBroker).annotatedWith(Names.named(HONEYCOMB_NETCONF))
+
+ // Wrap BA data broker as BindingAwareBroker (requied by HONEYCOMB_NETCONF)
bind(BindingAwareBroker)
- .annotatedWith(Names.named("netconf"))
+ .annotatedWith(Names.named(HONEYCOMB_NETCONF))
.toProvider(NetconfBindingBrokerProvider)
.in(Singleton)
- // Mirror of org.opendaylight.controller.config.yang.config.netconf.northbound.impl.NetconfMapperAggregatorModule
+ // Create netconf operation service factory aggregator to aggregate different services
def factory = new AggregatedNetconfOperationServiceFactory()
bind(NetconfOperationServiceFactory)
- .annotatedWith(Names.named("netconf-mapper-aggregator"))
+ .annotatedWith(Names.named(HONEYCOMB_NETCONF_MAPPER_AGGR))
.toInstance(factory)
bind(NetconfOperationServiceFactoryListener).toInstance(factory)
- // Mirror of org.opendaylight.controller.config.yang.netconf.northbound.notification.impl.NetconfNotificationManagerModule
+ // Create netconf notification manager
def manager = new NetconfNotificationManager()
bind(NetconfNotificationCollector).toInstance(manager)
bind(NetconfNotificationRegistry).toInstance(manager)
bind(NetconfNotificationListener).toInstance(manager)
- // Netconf notification part
+ // Netconf notification service factory
bind(NetconfOperationServiceFactory)
- .annotatedWith(Names.named("netconf-mapper-notification"))
+ .annotatedWith(Names.named(HONEYCOMB_NETCONF_MAPPER_NOTIF))
.toProvider(NetconfNotificationMapperProvider)
.in(Singleton)
- expose(NetconfOperationServiceFactory).annotatedWith(Names.named("netconf-mapper-notification"))
+ expose(NetconfOperationServiceFactory).annotatedWith(Names.named(HONEYCOMB_NETCONF_MAPPER_NOTIF))
// Netconf core part - mapping between Honeycomb and Netconf
bind(NetconfOperationServiceFactory)
- .annotatedWith(Names.named("netconf-mapper-honeycomb"))
+ .annotatedWith(Names.named(HONEYCOMB_NETCONF_MAPPER_CORE))
.toProvider(NetconfMdsalMapperProvider)
.in(Singleton)
- expose(NetconfOperationServiceFactory).annotatedWith(Names.named("netconf-mapper-honeycomb"))
+ expose(NetconfOperationServiceFactory).annotatedWith(Names.named(HONEYCOMB_NETCONF_MAPPER_CORE))
- // Netconf monitoring part
+ // Netconf monitoring service factory
bind(NetconfMonitoringService).toProvider(NetconfMonitoringServiceProvider).in(Singleton)
bind(NetconfOperationServiceFactory)
- .annotatedWith(Names.named("netconf-mapper-monitoring"))
+ .annotatedWith(Names.named(HONEYCOMB_NETCONF_MAPPER_OPER))
.toProvider(NetconfMonitoringMapperProvider)
.in(Singleton)
- expose(NetconfOperationServiceFactory).annotatedWith(Names.named("netconf-mapper-monitoring"))
+ expose(NetconfOperationServiceFactory).annotatedWith(Names.named(HONEYCOMB_NETCONF_MAPPER_OPER))
+ // Create HC notification manager + HC2Netconf translator
bind(NotificationCollector).toProvider(HoneycombNotificationManagerProvider).in(Singleton)
bind(HoneycombNotification2NetconfProvider.HoneycombNotification2Netconf)
.toProvider(HoneycombNotification2NetconfProvider)
configureServer()
}
+ /**
+ * Provide HONEYCOMB_NETCONF TCP and SSH servers
+ */
def configureServer() {
bind(NioEventLoopGroup).toProvider(NettyThreadGroupProvider).in(Singleton)
bind(Timer).toProvider(NettyTimerProvider).in(Singleton)
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactoryListener
-/**
- * Mirror of org.opendaylight.controller.config.yang.netconf.mdsal.monitoring.NetconfMdsalMonitoringMapperModule
- */
+
@Slf4j
@ToString
class NetconfMonitoringMapperProvider extends ProviderTrait<NetconfOperationServiceFactory> {
@Inject
- @Named("netconf")
+ @Named(NetconfModule.HONEYCOMB_NETCONF)
BindingAwareBroker bindingAwareBroker
@Inject
NetconfOperationServiceFactoryListener aggregator
class NetconfMonitoringReaderFactoryProvider extends ProviderTrait<ReaderFactory> {
@Inject
- @Named("netconf")
+ @Named(NetconfModule.HONEYCOMB_NETCONF)
DataBroker netconfDataBroker
def create() { new NetconfMonitoringReaderFactory(netconfDataBroker) }
import org.opendaylight.netconf.api.monitoring.NetconfMonitoringService
import org.opendaylight.netconf.impl.osgi.NetconfMonitoringServiceImpl
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory
-/**
- * Mirror of org.opendaylight.controller.config.yang.config.netconf.northbound.impl.NetconfServerMonitoringModule
- */
+
@Slf4j
@ToString
class NetconfMonitoringServiceProvider extends ProviderTrait<NetconfMonitoringService> {
@Inject
- @Named("netconf-mapper-aggregator")
+ @Named(NetconfModule.HONEYCOMB_NETCONF_MAPPER_AGGR)
NetconfOperationServiceFactory aggregator
@Override
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.NetconfState
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.netconf.monitoring.rev101004.netconf.state.Capabilities
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
-/**
- * Mirror of org.opendaylight.controller.config.yang.netconf.mdsal.notification.NetconfMdsalNotificationMapperModule
- */
+
@Slf4j
@ToString
class NetconfNotificationMapperProvider extends ProviderTrait<NetconfOperationServiceFactory> {
@Inject
NetconfNotificationRegistry notificationRegistry
@Inject
- @Named("netconf")
+ @Named(NetconfModule.HONEYCOMB_NETCONF)
BindingAwareBroker bindingAwareBroker
@Inject
- @Named("netconf")
+ @Named(NetconfModule.HONEYCOMB_NETCONF)
DataBroker dataBroker
@Inject
NetconfOperationServiceFactoryListener aggregator
import javax.annotation.Nonnull
-// TODO backport to karaf distro
@Slf4j
@ToString
class NetconfNotificationsReaderFactoryProvider extends ProviderTrait<ReaderFactory> {
@Inject
- @Named("netconf")
+ @Named(NetconfModule.HONEYCOMB_NETCONF)
DataBroker netconfDataBroker
def create() {
protected void configure() {
// This should be part of NetconfModule, but that one is Private and Multibinders + private BASE_MODULES
// do not work together, that's why there's a dedicated module here
+ // https://github.com/google/guice/issues/906
Multibinder.newSetBinder(binder(), ReaderFactory.class).with {
addBinding().toProvider(NetconfMonitoringReaderFactoryProvider).in(Singleton)
addBinding().toProvider(NetconfNotificationsReaderFactoryProvider).in(Singleton)
import org.opendaylight.netconf.mapping.api.NetconfOperationServiceFactory
import java.util.concurrent.TimeUnit
-/**
- * Mirror of org.opendaylight.controller.config.yang.config.netconf.northbound.impl.NetconfServerDispatcherModule
- */
+
@Slf4j
@ToString
class NetconfServerDispatcherProvider extends ProviderTrait<NetconfServerDispatcher> {
private static final long CONNECTION_TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(20)
@Inject
- @Named("netconf-mapper-aggregator")
+ @Named(NetconfModule.HONEYCOMB_NETCONF_MAPPER_AGGR)
NetconfOperationServiceFactory aggregator
@Inject
NetconfMonitoringService monitoringService
import java.util.concurrent.Executors
import java.util.concurrent.ScheduledExecutorService
-/**
- * Mirror of org.opendaylight.controller.config.yang.netconf.northbound.ssh.NetconfNorthboundSshModule
- */
+
@Slf4j
@ToString
class NetconfSshServerProvider extends ProviderTrait<NetconfSshServer> {
@Inject
NioEventLoopGroup nettyThreadgroup
- // TODO merge with other executors .. one of the brokers creates also 2 internal executors
private ScheduledExecutorService pool =
Executors.newScheduledThreadPool(1, new ThreadFactoryBuilder().setNameFormat("netconf-ssh-%d").build())
import io.netty.channel.ChannelFuture
import io.netty.util.concurrent.GenericFutureListener
import org.opendaylight.netconf.api.NetconfServerDispatcher
-/**
- * Mirror of org.opendaylight.controller.config.yang.netconf.northbound.tcp.NetconfNorthboundTcpModule
- */
+
@Slf4j
@ToString
class NetconfTcpServerProvider extends ProviderTrait<NetconfTcpServer> {
import io.fd.honeycomb.infra.distro.ProviderTrait
import io.fd.honeycomb.infra.distro.cfgattrs.HoneycombConfiguration
import io.netty.channel.nio.NioEventLoopGroup
-/**
- * Mirror of org.opendaylight.controller.config.yang.netty.threadgroup.NettyThreadgroupModule
- */
+
@Slf4j
@ToString
class NettyThreadGroupProvider extends ProviderTrait<NioEventLoopGroup> {
import io.fd.honeycomb.infra.distro.ProviderTrait
import io.netty.util.HashedWheelTimer
import io.netty.util.Timer
-/**
- * Mirror of org.opendaylight.controller.config.yang.netty.timer.HashedWheelTimerModule
- */
+
@Slf4j
@ToString
class NettyTimerProvider extends ProviderTrait<Timer> {
class HttpsConnectorProvider extends ProviderTrait<ServerConnector> {
- public static final String KEYSTORE_PASSWORD = "OBF:1v9s1unr1unn1vv51zlk1t331vg91x1b1vgl1t331zly1vu51uob1uo71v8u"
- public static final String KEYSTORE_NAME = "/honeycomb-keystore"
-
@Inject
HoneycombConfiguration cfg
@Inject
// openssl pkcs12 -inkey honeycomb.key -in honeycomb.crt -export -out honeycomb.pkcs12
// keytool -importkeystore -srckeystore honeycomb.pkcs12 -srcstoretype PKCS12 -destkeystore honeycomb-keystore
def sslContextFactory = new SslContextFactory()
- def keystoreURL = getClass().getResource(KEYSTORE_NAME)
+ def keystoreURL = getClass().getResource(cfg.restconfKeystore.get())
sslContextFactory.setKeyStorePath(keystoreURL.path)
- sslContextFactory.setKeyStorePassword(KEYSTORE_PASSWORD)
- sslContextFactory.setKeyManagerPassword(KEYSTORE_PASSWORD)
- sslContextFactory.setTrustStorePath(keystoreURL.path)
- sslContextFactory.setTrustStorePassword(KEYSTORE_PASSWORD)
+ sslContextFactory.setKeyStorePassword(cfg.keystorePassword.get())
+ sslContextFactory.setKeyManagerPassword((cfg.keystoreManagerPassword.get()))
+ def truststoreURL = getClass().getResource(cfg.restconfTruststore.get())
+ sslContextFactory.setTrustStorePath(truststoreURL.path)
+ sslContextFactory.setTrustStorePassword((cfg.truststorePassword.get()))
+ // TODO make this more configurable
sslContextFactory.setExcludeCipherSuites(
"SSL_RSA_WITH_DES_CBC_SHA",
"SSL_DHE_RSA_WITH_DES_CBC_SHA",
// Load Realm for basic auth
def service = new HashLoginService(REALM)
// Reusing the name as role
- // TODO make this more configurable
service.putUser(cfg.username, new Password(cfg.password), cfg.username)
server.addBean(service)
@Slf4j
class RestconfModule extends AbstractModule {
+ public static final String RESTCONF_HTTP = "restconf-http"
+ public static final String RESTCONF_HTTPS = "restconf-https"
+
protected void configure() {
bind(Server).toProvider(JettyServerProvider).in(Singleton)
- bind(ServerConnector).annotatedWith(Names.named("restconf-http")).toProvider(HttpConnectorProvider).in(Singleton)
- bind(ServerConnector).annotatedWith(Names.named("restconf-https")).toProvider(HttpsConnectorProvider).in(Singleton)
+ bind(ServerConnector).annotatedWith(Names.named(RESTCONF_HTTP)).toProvider(HttpConnectorProvider).in(Singleton)
+ bind(ServerConnector).annotatedWith(Names.named(RESTCONF_HTTPS)).toProvider(HttpsConnectorProvider).in(Singleton)
bind(RestConnector).toProvider(RestconfProvider).in(Singleton)
}
}
import com.google.inject.multibindings.Multibinder
import groovy.util.logging.Slf4j
import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider
+
/**
* Load all YangModelBindingProvider classes from classpath.
* <p/>
"notification-service-queue-depth": 1,
- "restconf-http-enabled": "false",
+ "restconf-http-enabled": "true",
"restconf-root-path": "/restconf",
"restconf-binding-address": "127.0.0.1",
"restconf-port": 8181,
- "restconf-https-enabled": "false",
+ "restconf-https-enabled": "true",
"restconf-https-binding-address": "0.0.0.0",
"restconf-https-port": 8443,
+ "restconf-keystore": "/honeycomb-keystore",
+ "restconf-keystore-password": "OBF:1v9s1unr1unn1vv51zlk1t331vg91x1b1vgl1t331zly1vu51uob1uo71v8u",
+ "restconf-keystore-manager-password": "OBF:1v9s1unr1unn1vv51zlk1t331vg91x1b1vgl1t331zly1vu51uob1uo71v8u",
+ "restconf-truststore": "/honeycomb-keystore",
+ "restconf-truststore-password": "OBF:1v9s1unr1unn1vv51zlk1t331vg91x1b1vgl1t331zly1vu51uob1uo71v8u",
"restconf-websocket-port": 7779,
"restconf-pool-max-size": 10,
"restconf-pool-min-size": 1,
"netconf-tcp-enabled" : "true",
"netconf-tcp-binding-address": "127.0.0.1",
"netconf-tcp-binding-port": 7777,
- "netconf-ssh-enabled" : "false",
+ "netconf-ssh-enabled" : "true",
"netconf-ssh-binding-address": "0.0.0.0",
"netconf-ssh-binding-port": 2831,
"netconf-notification-stream-name": "honeycomb",
<properties>
<guice.version>4.1.0</guice.version>
<guice.config.version>1.2.0</guice.config.version>
+ <honeycomb.infra.version>1.0.0-SNAPSHOT</honeycomb.infra.version>
</properties>
<dependencies>
<dependency>
<groupId>io.fd.honeycomb</groupId>
<artifactId>translate-impl</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>${honeycomb.infra.version}</version>
</dependency>
<dependency>
<groupId>io.fd.honeycomb</groupId>
<artifactId>translate-api</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>${honeycomb.infra.version}</version>
</dependency>
<dependency>
<groupId>io.fd.honeycomb</groupId>
<artifactId>notification-api</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>${honeycomb.infra.version}</version>
</dependency>
<dependency>
<groupId>io.fd.honeycomb</groupId>
<artifactId>cfg-init</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>${honeycomb.infra.version}</version>
</dependency>
</dependencies>
</project>
<properties>
<exec.parameters>-Xms128m -Xmx128m</exec.parameters>
<main.class>io.fd.honeycomb.samples.distro.Main</main.class>
+ <interfaces.mapping.version>1.0.0-SNAPSHOT</interfaces.mapping.version>
+ <honeycomb.min.distro.version>1.0.0-SNAPSHOT</honeycomb.min.distro.version>
</properties>
<build>
<dependency>
<groupId>io.fd.honeycomb.samples.interfaces</groupId>
<artifactId>interfaces-mapping</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>${interfaces.mapping.version}</version>
</dependency>
<dependency>
<groupId>io.fd.honeycomb</groupId>
<artifactId>minimal-distribution</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>${honeycomb.min.distro.version}</version>
</dependency>
</dependencies>
<version>${project.version}</version>
</dependency>
- <!-- Keepalives -->
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>config-util</artifactId>
- <version>0.4.2-Beryllium-SR2</version>
- </dependency>
- <dependency>
- <groupId>org.opendaylight.controller</groupId>
- <artifactId>threadpool-config-api</artifactId>
- <version>0.4.2-Beryllium-SR2</version>
- </dependency>
- <!---->
-
<dependency>
<groupId>io.fd.honeycomb</groupId>
<artifactId>translate-impl</artifactId>
<version>${project.version}</version>
</dependency>
- <dependency>
- <groupId>io.fd.honeycomb.vpp</groupId>
- <artifactId>vpp-jvpp-cfg</artifactId>
- <version>${project.version}</version>
- </dependency>
<dependency>
<groupId>io.fd.honeycomb</groupId>
<artifactId>cfg-init</artifactId>
import io.fd.honeycomb.translate.read.ReaderFactory;
import io.fd.honeycomb.translate.v3po.cfgattrs.V3poConfiguration;
import io.fd.honeycomb.translate.v3po.initializers.InterfacesInitializer;
-import io.fd.honeycomb.translate.v3po.initializers.VppClasifierInitializer;
+import io.fd.honeycomb.translate.v3po.initializers.VppClassifierInitializer;
import io.fd.honeycomb.translate.v3po.initializers.VppInitializer;
import io.fd.honeycomb.translate.v3po.notification.InterfaceChangeNotificationProducer;
import io.fd.honeycomb.translate.v3po.util.NamingContext;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import net.jmob.guice.conf.core.ConfigurationModule;
-import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
public class V3poModule extends AbstractModule {
.toInstance(new NamingContext("classify-table-", "classify-table-context"));
// Executor needed for keepalives
- // TODO-minimal remove the funny wrapper. it is only here because of config subsystem
- final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
- bind(ScheduledThreadPool.class).toInstance(new ScheduledThreadPool() {
- @Override
- public ScheduledExecutorService getExecutor() {
- return executor;
- }
-
- @Override
- public int getMaxThreadCount() {
- return 1;
- }
- });
+ bind(ScheduledExecutorService.class).toInstance(Executors.newScheduledThreadPool(1));
// Readers
final Multibinder<ReaderFactory> readerFactoryBinder = Multibinder.newSetBinder(binder(), ReaderFactory.class);
final Multibinder<DataTreeInitializer> initializerBinder =
Multibinder.newSetBinder(binder(), DataTreeInitializer.class);
initializerBinder.addBinding().to(InterfacesInitializer.class);
- initializerBinder.addBinding().to(VppClasifierInitializer.class);
+ initializerBinder.addBinding().to(VppClassifierInitializer.class);
initializerBinder.addBinding().to(VppInitializer.class);
// Notifications
import io.fd.honeycomb.translate.v3po.vppstate.BridgeDomainCustomizer;
import io.fd.honeycomb.translate.v3po.vppstate.L2FibEntryCustomizer;
import io.fd.honeycomb.translate.v3po.vppstate.VersionCustomizer;
-import org.opendaylight.controller.config.threadpool.ScheduledThreadPool;
+import java.util.concurrent.ScheduledExecutorService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppState;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppStateBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.fib.attributes.L2FibTable;
private final FutureJVpp jVpp;
private final NamingContext ifcCtx;
private final NamingContext bdCtx;
- private final ScheduledThreadPool keepaliveExecutor;
+ private final ScheduledExecutorService keepaliveExecutor;
@Inject
public VppStateHoneycombReaderFactory(final FutureJVpp jVpp,
@Named("interface-context") final NamingContext ifcCtx,
@Named("bridge-domain-context") final NamingContext bdCtx,
- final ScheduledThreadPool keepaliveExecutorDependency) {
+ final ScheduledExecutorService keepaliveExecutorDependency) {
this.jVpp = jVpp;
this.ifcCtx = ifcCtx;
this.bdCtx = bdCtx;
// is truly generic
registry.add(new KeepaliveReaderWrapper<>(
new GenericReader<>(vppStateId.child(Version.class), new VersionCustomizer(jVpp)),
- keepaliveExecutor.getExecutor(), ReadTimeoutException.class, 30,
+ keepaliveExecutor, ReadTimeoutException.class, 30,
// FIXME-minimal trigger jvpp reinitialization here
() -> LOG.error("Keepalive failed. VPP is probably DOWN!")));
// BridgeDomains(Structural)
/**
* Initializes vpp-classfier node in config data tree based on operational state.
*/
-public final class VppClasifierInitializer extends AbstractDataTreeConverter<VppClassifierState, VppClassifier> {
+public final class VppClassifierInitializer extends AbstractDataTreeConverter<VppClassifierState, VppClassifier> {
private static final InstanceIdentifier<VppClassifierState> OPER_ID =
InstanceIdentifier.create(VppClassifierState.class);
private static final InstanceIdentifier<VppClassifier> CFG_ID = InstanceIdentifier.create(VppClassifier.class);
@Inject
- public VppClasifierInitializer(@Named("honeycomb-initializer") @Nonnull final DataBroker bindingDataBroker) {
+ public VppClassifierInitializer(@Named("honeycomb-initializer") @Nonnull final DataBroker bindingDataBroker) {
super(bindingDataBroker, OPER_ID, CFG_ID);
}
<properties>
<main.class>io.fd.honeycomb.vpp.distro.Main</main.class>
+ <honeycomb.min.distro.version>1.0.0-SNAPSHOT</honeycomb.min.distro.version>
</properties>
<build>
<dependency>
<groupId>io.fd.honeycomb</groupId>
<artifactId>minimal-distribution</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>${honeycomb.min.distro.version}</version>
</dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>naming-context-impl</artifactId>
<version>${project.version}</version>
</dependency>
- <dependency>
- <groupId>${project.groupId}</groupId>
- <artifactId>vpp-jvpp-cfg</artifactId>
- <version>${project.version}</version>
- </dependency>
<dependency>
<groupId>io.fd.vpp</groupId>
<artifactId>jvpp</artifactId>
import groovy.transform.ToString
import groovy.util.logging.Slf4j
import io.fd.honeycomb.infra.distro.ProviderTrait
+import io.fd.honeycomb.infra.distro.data.context.ContextPipelineModule
import io.fd.honeycomb.translate.read.ReaderFactory
import org.opendaylight.controller.md.sal.binding.api.DataBroker
import io.fd.honeycomb.vpp.context.ContextsReaderFactory
class ContextsReaderFactoryProvider extends ProviderTrait<ReaderFactory> {
@Inject
- @Named("honeycomb-context")
+ @Named(ContextPipelineModule.HONEYCOMB_CONTEXT)
DataBroker contextDataBroker
def create() { new ContextsReaderFactory(contextDataBroker) }
import org.openvpp.jvpp.future.FutureJVpp
import org.openvpp.jvpp.future.FutureJVppFacade
+/**
+ * This must be a singleton due to shutdown hook usage.
+ */
@Slf4j
@ToString
class JVppProvider extends ProviderTrait<FutureJVpp> {
def jVpp = new JVppImpl(connection)
// Closing JVpp connection with shutdown hook to erase the connection from VPP so HC will be able
- // to connect next time
- // TODO is there a safer way than a shutdown hook ?
+ // to connect next time. If JVM is force closed, this will not be executed and VPP connection
+ // with name from config will stay open and prevent next startup of HC to success
Runtime.addShutdownHook {
log.info("Disconnecting from VPP")
jVpp.close()
bind(FutureJVpp).toProvider(JVppProvider).in(Singleton)
- // Naming contexts reader exposing context storage over REST/NETCONF
+ // Naming contexts reader exposing context storage over REST/HONEYCOMB_NETCONF
Multibinder.newSetBinder(binder(), ReaderFactory.class).with {
addBinding().toProvider(ContextsReaderFactoryProvider).in(Singleton)
}
<properties>
<main.class>io.fd.honeycomb.vpp.integration.distro.Main</main.class>
+ <v3po.version>1.0.0-SNAPSHOT</v3po.version>
+ <vpp.common.min.distro.version>1.0.0-SNAPSHOT</vpp.common.min.distro.version>
</properties>
<build>
<dependency>
<groupId>io.fd.honeycomb.vpp</groupId>
<artifactId>minimal-distribution</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>${vpp.common.min.distro.version}</version>
</dependency>
<dependency>
<groupId>io.fd.honeycomb.v3po</groupId>
<artifactId>v3po2vpp</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>${v3po.version}</version>
</dependency>
</dependencies>