Remove groovy to reduce footprint

Change-Id: I798558e52329c26aa5481d702745c4d46e290615
Signed-off-by: Maros Marsalek <mmarsale@cisco.com>

22 files changed, 543 insertions, 551 deletions

diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/BindingDataBrokerProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/BindingDataBrokerProvider.java
index e73f14932..e17355143 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/BindingDataBrokerProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/BindingDataBrokerProvider.java
@@ -14,26 +14,24 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data
+package io.fd.honeycomb.infra.distro.data;
 
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import org.opendaylight.controller.md.sal.binding.api.DataBroker
-import org.opendaylight.controller.md.sal.binding.impl.BindingDOMDataBrokerAdapter
-import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker
+import com.google.inject.Inject;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.impl.BindingDOMDataBrokerAdapter;
+import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
 
-@Slf4j
-@ToString
-class BindingDataBrokerProvider extends ProviderTrait<DataBroker> {
+public final class BindingDataBrokerProvider extends ProviderTrait<DataBroker> {
 
     @Inject
-    DOMDataBroker domDataBroker
+    private DOMDataBroker domDataBroker;
     @Inject
-    BindingToNormalizedNodeCodec mappingService
+    private BindingToNormalizedNodeCodec mappingService;
 
     @Override
-    def create() { new BindingDOMDataBrokerAdapter(domDataBroker, mappingService) }
+    protected BindingDOMDataBrokerAdapter create() {
+        return new BindingDOMDataBrokerAdapter(domDataBroker, mappingService);
+    }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ConfigAndOperationalPipelineModule.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ConfigAndOperationalPipelineModule.groovy
deleted file mode 100644
index eb17cf36a..000000000
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ConfigAndOperationalPipelineModule.groovy
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * 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.infra.distro.data
-
-import com.google.inject.PrivateModule
-import com.google.inject.Singleton
-import com.google.inject.name.Names
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.data.ModifiableDataManager
-import io.fd.honeycomb.data.ReadableDataManager
-import io.fd.honeycomb.data.init.DataTreeInitializer
-import io.fd.honeycomb.infra.distro.data.config.WriterRegistryProvider
-import io.fd.honeycomb.infra.distro.data.oper.ReadableDTDelegProvider
-import io.fd.honeycomb.infra.distro.data.oper.ReaderRegistryProvider
-import io.fd.honeycomb.infra.distro.initializer.PersistedFileInitializerProvider
-import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder
-import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder
-import org.opendaylight.controller.md.sal.binding.api.DataBroker
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker
-import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter
-import org.opendaylight.controller.sal.core.api.Broker
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree
-
-@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)
-        expose(ModifiableWriterRegistryBuilder)
-        bind(ModifiableReaderRegistryBuilder).toProvider(ReaderRegistryProvider).in(Singleton)
-        expose(ModifiableReaderRegistryBuilder)
-
-        // Non persisting data tree for config
-        bind(DataTree)
-                .annotatedWith(Names.named(HONEYCOMB_CONFIG_NONPERSIST))
-                .toProvider(DataTreeProvider.ConfigDataTreeProvider)
-                .in(Singleton)
-        expose(DataTree).annotatedWith(Names.named(HONEYCOMB_CONFIG_NONPERSIST))
-        // Persisting data tree wrapper for config
-        bind(DataTree)
-                .annotatedWith(Names.named(HONEYCOMB_CONFIG))
-                .toProvider(PersistingDataTreeProvider.ConfigPersistingDataTreeProvider)
-                .in(Singleton)
-        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).toProvider(domBrokerProvider).in(Singleton)
-
-        // 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))
-                .toProvider(PersistedFileInitializerProvider.PersistedConfigInitializerProvider)
-                .in(Singleton)
-        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)
-    }
-}
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ConfigAndOperationalPipelineModule.java b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ConfigAndOperationalPipelineModule.java
new file mode 100644
index 000000000..bac1b3ce0
--- /dev/null
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ConfigAndOperationalPipelineModule.java
@@ -0,0 +1,90 @@
+/*
+ * 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.infra.distro.data;
+
+import com.google.inject.PrivateModule;
+import com.google.inject.Singleton;
+import com.google.inject.name.Names;
+import io.fd.honeycomb.data.ModifiableDataManager;
+import io.fd.honeycomb.data.ReadableDataManager;
+import io.fd.honeycomb.data.init.DataTreeInitializer;
+import io.fd.honeycomb.infra.distro.data.config.WriterRegistryProvider;
+import io.fd.honeycomb.infra.distro.data.oper.ReadableDTDelegProvider;
+import io.fd.honeycomb.infra.distro.data.oper.ReaderRegistryProvider;
+import io.fd.honeycomb.infra.distro.initializer.PersistedFileInitializerProvider;
+import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
+import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter;
+import org.opendaylight.controller.sal.core.api.Broker;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+
+public 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.class).toProvider(WriterRegistryProvider.class).in(Singleton.class);
+        expose(ModifiableWriterRegistryBuilder.class);
+        bind(ModifiableReaderRegistryBuilder.class).toProvider(ReaderRegistryProvider.class).in(Singleton.class);
+        expose(ModifiableReaderRegistryBuilder.class);
+
+        // Non persisting data tree for config
+        bind(DataTree.class).annotatedWith(Names.named(HONEYCOMB_CONFIG_NONPERSIST))
+                .toProvider(DataTreeProvider.ConfigDataTreeProvider.class).in(Singleton.class);
+        expose(DataTree.class).annotatedWith(Names.named(HONEYCOMB_CONFIG_NONPERSIST));
+        // Persisting data tree wrapper for config
+        bind(DataTree.class).annotatedWith(Names.named(HONEYCOMB_CONFIG))
+                .toProvider(PersistingDataTreeProvider.ConfigPersistingDataTreeProvider.class).in(Singleton.class);
+        expose(DataTree.class).annotatedWith(Names.named(HONEYCOMB_CONFIG));
+
+        // Config Data Tree manager working on top of config data tree + writer registry
+        bind(ModifiableDataManager.class).toProvider(ModifiableDTDelegProvider.class).in(Singleton.class);
+        // Operational Data Tree manager working on top of reader registry
+        bind(ReadableDataManager.class).toProvider(ReadableDTDelegProvider.class).in(Singleton.class);
+        expose(ReadableDataManager.class);
+
+        // DOMDataBroker wrapper on top of data tree managers
+        HoneycombDOMDataBrokerProvider domBrokerProvider = new HoneycombDOMDataBrokerProvider();
+        bind(DOMDataBroker.class).toProvider(domBrokerProvider).in(Singleton.class);
+
+        // BA version of data broker
+        bind(DataBroker.class).annotatedWith(Names.named(HONEYCOMB_CONFIG)).toProvider(BindingDataBrokerProvider.class)
+                .in(Singleton.class);
+        expose(DataBroker.class).annotatedWith(Names.named(HONEYCOMB_CONFIG));
+
+        // Create initializer to init persisted config data
+        bind(DataTreeInitializer.class).annotatedWith(Names.named(HONEYCOMB_CONFIG))
+                .toProvider(PersistedFileInitializerProvider.PersistedConfigInitializerProvider.class)
+                .in(Singleton.class);
+        expose(DataTreeInitializer.class).annotatedWith(Names.named(HONEYCOMB_CONFIG));
+
+        configureNotifications();
+    }
+
+    private void configureNotifications() {
+        // Create notification service
+        bind(DOMNotificationRouter.class).toProvider(DOMNotificationServiceProvider.class).in(Singleton.class);
+        expose(DOMNotificationRouter.class);
+        // Wrap notification service, data broker and schema service in a Broker MD-SAL API
+        bind(Broker.class).toProvider(HoneycombDOMBrokerProvider.class).in(Singleton.class);
+        expose(Broker.class);
+    }
+}
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DOMNotificationServiceProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DOMNotificationServiceProvider.java
index f8a1859e2..424393b8d 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DOMNotificationServiceProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DOMNotificationServiceProvider.java
@@ -14,21 +14,20 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data
+package io.fd.honeycomb.infra.distro.data;
 
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.infra.distro.cfgattrs.HoneycombConfiguration
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter
+import com.google.inject.Inject;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import io.fd.honeycomb.infra.distro.cfgattrs.HoneycombConfiguration;
+import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter;
 
-@Slf4j
-@ToString
-class DOMNotificationServiceProvider extends ProviderTrait<DOMNotificationRouter> {
+public final class DOMNotificationServiceProvider extends ProviderTrait<DOMNotificationRouter> {
 
     @Inject
-    HoneycombConfiguration cfg
+    private HoneycombConfiguration cfg;
 
-    def create() { DOMNotificationRouter.create(cfg.notificationServiceQueueDepth) }
+    @Override
+    protected DOMNotificationRouter create() {
+        return DOMNotificationRouter.create(cfg.notificationServiceQueueDepth);
+    }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DataStoreProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DataStoreProvider.java
index 6d075ccc8..5b09f21f8 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DataStoreProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DataStoreProvider.java
@@ -14,27 +14,30 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data
+package io.fd.honeycomb.infra.distro.data;
 
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStoreFactory
-import org.opendaylight.controller.sal.core.api.model.SchemaService
+import com.google.inject.Inject;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
+import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStoreFactory;
+import org.opendaylight.controller.sal.core.api.model.SchemaService;
 
-@Slf4j
-@ToString
-class DataStoreProvider extends ProviderTrait<InMemoryDOMDataStore> {
+public final class DataStoreProvider extends ProviderTrait<InMemoryDOMDataStore> {
 
     @Inject
-    SchemaService schemaService
+    private SchemaService schemaService;
+    private String name;
+    private LogicalDatastoreType type;
 
-    String name
-    LogicalDatastoreType type
+    public DataStoreProvider(final String name,
+                             final LogicalDatastoreType type) {
+        this.name = name;
+        this.type = type;
+    }
 
     @Override
-    def create() { InMemoryDOMDataStoreFactory.create(name, type, schemaService, false, null) }
+    protected InMemoryDOMDataStore create() {
+        return InMemoryDOMDataStoreFactory.create(name, type, schemaService, false, null);
+    }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DataTreeProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DataTreeProvider.java
index bf1f562ec..c5fcc050a 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DataTreeProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/DataTreeProvider.java
@@ -14,44 +14,43 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data
-
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-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 org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree
-import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType
-import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory
-
-@Slf4j
-@ToString
-abstract class DataTreeProvider extends ProviderTrait<DataTree> {
+package io.fd.honeycomb.infra.distro.data;
+
+import com.google.inject.Inject;
+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 org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TipProducingDataTree;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType;
+import org.opendaylight.yangtools.yang.data.impl.schema.tree.InMemoryDataTreeFactory;
+
+public abstract class DataTreeProvider extends ProviderTrait<DataTree> {
 
     @Inject
-    SchemaService schemaService
+    private SchemaService schemaService;
     @Inject
-    HoneycombConfiguration config
+    private HoneycombConfiguration config;
 
-    def create() {
-        def delegate = InMemoryDataTreeFactory.getInstance().create(getType())
-        delegate.setSchemaContext(schemaService.getGlobalContext())
-        delegate
+    public TipProducingDataTree create() {
+        TipProducingDataTree delegate = InMemoryDataTreeFactory.getInstance().create(getType());
+        delegate.setSchemaContext(schemaService.getGlobalContext());
+        return delegate;
     }
 
-    abstract TreeType getType()
+    public abstract TreeType getType();
+
+    public static class ConfigDataTreeProvider extends DataTreeProvider {
+        public TreeType getType() {
+            return TreeType.CONFIGURATION;
+        }
 
-    @Slf4j
-    @ToString
-    static class ConfigDataTreeProvider extends DataTreeProvider {
-        TreeType getType() { TreeType.CONFIGURATION }
     }
 
-    @Slf4j
-    @ToString
-    static class ContextDataTreeProvider extends DataTreeProvider {
-        TreeType getType() { TreeType.OPERATIONAL }
+    public static class ContextDataTreeProvider extends DataTreeProvider {
+        public TreeType getType() {
+            return TreeType.OPERATIONAL;
+        }
+
     }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMBrokerProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMBrokerProvider.java
index dc620b445..eefa1c140 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMBrokerProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMBrokerProvider.java
@@ -14,28 +14,27 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data
+package io.fd.honeycomb.infra.distro.data;
 
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.impl.NorthboundFacadeHoneycombDOMBroker
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker
-import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter
-import org.opendaylight.controller.sal.core.api.Broker
-import org.opendaylight.controller.sal.core.api.model.SchemaService
+import com.google.inject.Inject;
+import io.fd.honeycomb.impl.NorthboundFacadeHoneycombDOMBroker;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.controller.md.sal.dom.broker.impl.DOMNotificationRouter;
+import org.opendaylight.controller.sal.core.api.Broker;
+import org.opendaylight.controller.sal.core.api.model.SchemaService;
 
-@Slf4j
-@ToString
-class HoneycombDOMBrokerProvider extends ProviderTrait<Broker> {
+public final class HoneycombDOMBrokerProvider extends ProviderTrait<Broker> {
 
     @Inject
-    DOMDataBroker domDataBroker
+    private DOMDataBroker domDataBroker;
     @Inject
-    SchemaService schemaService
+    private SchemaService schemaService;
     @Inject
-    DOMNotificationRouter domNotificationService
+    private DOMNotificationRouter domNotificationService;
 
-    def create() { new NorthboundFacadeHoneycombDOMBroker(domDataBroker, schemaService, domNotificationService) }
+    @Override
+    protected NorthboundFacadeHoneycombDOMBroker create() {
+        return new NorthboundFacadeHoneycombDOMBroker(domDataBroker, schemaService, domNotificationService);
+    }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMDataBrokerProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMDataBrokerProvider.groovy
deleted file mode 100644
index a2fec2a60..000000000
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMDataBrokerProvider.groovy
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * 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.infra.distro.data
-
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.data.ModifiableDataManager
-import io.fd.honeycomb.data.ReadableDataManager
-import io.fd.honeycomb.data.impl.DataBroker
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker
-
-@Slf4j
-@ToString
-class HoneycombDOMDataBrokerProvider extends ProviderTrait<DOMDataBroker> {
-
-    @Inject
-    ModifiableDataManager modDataManager
-
-    @Inject
-    ReadableDataManager readDataManager
-
-    def create() {
-        readDataManager ? DataBroker.create(modDataManager, readDataManager) : DataBroker.create(modDataManager)
-    }
-}
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMDataBrokerProvider.java b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMDataBrokerProvider.java
new file mode 100644
index 000000000..92bbc512d
--- /dev/null
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombDOMDataBrokerProvider.java
@@ -0,0 +1,38 @@
+/*
+ * 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.infra.distro.data;
+
+import com.google.inject.Inject;
+import io.fd.honeycomb.data.ModifiableDataManager;
+import io.fd.honeycomb.data.ReadableDataManager;
+import io.fd.honeycomb.data.impl.DataBroker;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+
+public final class HoneycombDOMDataBrokerProvider extends ProviderTrait<DOMDataBroker> {
+
+    @Inject
+    private ModifiableDataManager modDataManager;
+    @Inject(optional = true)
+    private ReadableDataManager readDataManager;
+
+    protected DataBroker create() {
+        return readDataManager != null
+                ? DataBroker.create(modDataManager, readDataManager)
+                : DataBroker.create(modDataManager);
+    }
+}
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombNotificationManagerProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombNotificationManagerProvider.java
index b81a8d784..e25cb1569 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombNotificationManagerProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/HoneycombNotificationManagerProvider.java
@@ -14,47 +14,48 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data
+package io.fd.honeycomb.infra.distro.data;
 
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import io.fd.honeycomb.notification.ManagedNotificationProducer
-import io.fd.honeycomb.notification.NotificationCollector
-import io.fd.honeycomb.notification.impl.HoneycombNotificationCollector
-import io.fd.honeycomb.notification.impl.NotificationProducerRegistry
-import io.fd.honeycomb.notification.impl.NotificationProducerTracker
-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
+import com.google.common.collect.Lists;
+import com.google.inject.Inject;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import io.fd.honeycomb.notification.ManagedNotificationProducer;
+import io.fd.honeycomb.notification.NotificationCollector;
+import io.fd.honeycomb.notification.impl.HoneycombNotificationCollector;
+import io.fd.honeycomb.notification.impl.NotificationProducerRegistry;
+import io.fd.honeycomb.notification.impl.NotificationProducerTracker;
+import java.util.HashSet;
+import java.util.Set;
+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;
 
-@Slf4j
-@ToString
-class HoneycombNotificationManagerProvider extends ProviderTrait<NotificationCollector> {
+public final class HoneycombNotificationManagerProvider extends ProviderTrait<NotificationCollector> {
 
     @Inject
-    DOMNotificationRouter notificationRouter
+    private DOMNotificationRouter notificationRouter;
     @Inject(optional = true)
-    Set<ManagedNotificationProducer> notificationProducers = []
+    private Set<ManagedNotificationProducer> notificationProducers = new HashSet<>();
     @Inject
-    BindingToNormalizedNodeCodec codec
+    private BindingToNormalizedNodeCodec codec;
 
     @Override
-    def create() {
+    protected HoneycombNotificationCollector create() {
         // Create the registry to keep track of what'OPERATIONAL registered
-        def notificationProducerRegistry = new NotificationProducerRegistry(notificationProducers as List);
+        NotificationProducerRegistry notificationProducerRegistry =
+                new NotificationProducerRegistry(Lists.newArrayList(notificationProducers));
 
         // Create BA version of notification service (implementation is free from ODL)
-        def bindingDOMNotificationPublishServiceAdapter =
+        BindingDOMNotificationPublishServiceAdapter bindingDOMNotificationPublishServiceAdapter =
                 new BindingDOMNotificationPublishServiceAdapter(codec, notificationRouter);
 
         // Create Collector on top of BA notification service and registry
-        def honeycombNotificationCollector =
-                new HoneycombNotificationCollector(bindingDOMNotificationPublishServiceAdapter, notificationProducerRegistry);
+        HoneycombNotificationCollector honeycombNotificationCollector =
+                new HoneycombNotificationCollector(bindingDOMNotificationPublishServiceAdapter,
+                        notificationProducerRegistry);
 
         // Create tracker, responsible for starting and stopping registered notification producers whenever necessary
-        def notificationProducerTracker =
+        NotificationProducerTracker notificationProducerTracker =
                 new NotificationProducerTracker(notificationProducerRegistry, honeycombNotificationCollector,
                         notificationRouter);
 
@@ -62,6 +63,6 @@ class HoneycombNotificationManagerProvider extends ProviderTrait<NotificationCol
         // DOMNotificationService is already provided by DOMBroker injected into RESTCONF, however RESTCONF
         // only supports data-change notification, nothing else. So currently its impossible.
 
-        honeycombNotificationCollector
+        return honeycombNotificationCollector;
     }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/InmemoryDOMDataBrokerProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/InmemoryDOMDataBrokerProvider.java
index a04f1a81c..7db2f7856 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/InmemoryDOMDataBrokerProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/InmemoryDOMDataBrokerProvider.java
@@ -14,50 +14,48 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data
-
-import com.google.inject.Inject
-import com.google.inject.name.Named
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitDeadlockException
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker
-import org.opendaylight.controller.md.sal.dom.broker.impl.SerializedDOMDataBroker
-import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore
-import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService
-import org.opendaylight.yangtools.util.concurrent.SpecialExecutors
-
-@Slf4j
-@ToString
-class InmemoryDOMDataBrokerProvider extends ProviderTrait<DOMDataBroker> {
-
-    public static final String CONFIG = "config"
-    public static final String OPERATIONAL = "operational"
+package io.fd.honeycomb.infra.distro.data;
+
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitDeadlockException;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.controller.md.sal.dom.broker.impl.SerializedDOMDataBroker;
+import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
+import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+import org.opendaylight.yangtools.util.concurrent.DeadlockDetectingListeningExecutorService;
+import org.opendaylight.yangtools.util.concurrent.SpecialExecutors;
+
+public final class InmemoryDOMDataBrokerProvider extends ProviderTrait<DOMDataBroker> {
+
+    public static final String CONFIG = "config";
+    public static final String OPERATIONAL = "operational";
 
     @Inject
     @Named(InmemoryDOMDataBrokerProvider.CONFIG)
-    InMemoryDOMDataStore cfgDataStore
-
+    private InMemoryDOMDataStore cfgDataStore;
     @Inject
     @Named(InmemoryDOMDataBrokerProvider.OPERATIONAL)
-    InMemoryDOMDataStore operDataStore
+    private InMemoryDOMDataStore operDataStore;
 
     @Override
-    def create() {
+    protected SerializedDOMDataBroker create() {
         // This Databroker is dedicated for netconf metadata, not expected to be under heavy load
-        def listenableFutureExecutor = SpecialExecutors.newBlockingBoundedCachedThreadPool(1, 100, "commits")
-        def commitExecutor = SpecialExecutors.newBoundedSingleThreadExecutor(100, "WriteTxCommit")
+        ExecutorService listenableFutureExecutor =
+                SpecialExecutors.newBlockingBoundedCachedThreadPool(1, 100, "commits");
+        ExecutorService commitExecutor = SpecialExecutors.newBoundedSingleThreadExecutor(100, "WriteTxCommit");
         // TODO try to provide more lightweight implementation of DataBroker, maybe a single executor would be enough
 
-        def map = [:]
-        map.put(LogicalDatastoreType.CONFIGURATION, cfgDataStore)
-        map.put(LogicalDatastoreType.OPERATIONAL, operDataStore)
+        Map<LogicalDatastoreType, DOMStore> map = new LinkedHashMap<>();
+        map.put(LogicalDatastoreType.CONFIGURATION, cfgDataStore);
+        map.put(LogicalDatastoreType.OPERATIONAL, operDataStore);
 
-        new SerializedDOMDataBroker(map,
-                new DeadlockDetectingListeningExecutorService(commitExecutor,
-                        TransactionCommitDeadlockException.DEADLOCK_EXCEPTION_SUPPLIER,
-                        listenableFutureExecutor))
+        return new SerializedDOMDataBroker(map, new DeadlockDetectingListeningExecutorService(commitExecutor,
+                TransactionCommitDeadlockException.DEADLOCK_EXCEPTION_SUPPLIER, listenableFutureExecutor));
     }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ModifiableDTDelegProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ModifiableDTDelegProvider.java
index cd4d9c624..edd4faadb 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ModifiableDTDelegProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/ModifiableDTDelegProvider.java
@@ -14,36 +14,36 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data
+package io.fd.honeycomb.infra.distro.data;
 
-import com.google.inject.Inject
-import com.google.inject.name.Named
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-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
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+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 io.fd.honeycomb.translate.write.registry.WriterRegistryBuilder;
+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;
 
-@Slf4j
-@ToString
-class ModifiableDTDelegProvider extends ProviderTrait<ModifiableDataManager> {
+public final class ModifiableDTDelegProvider extends ProviderTrait<ModifiableDataManager> {
 
     @Inject
-    BindingToNormalizedNodeCodec serializer
+    private BindingToNormalizedNodeCodec serializer;
     @Inject
     @Named(ConfigAndOperationalPipelineModule.HONEYCOMB_CONFIG)
-    DataTree dataTree
+    private DataTree dataTree;
     @Inject
-    ModifiableWriterRegistryBuilder registry
+    private ModifiableWriterRegistryBuilder registry;
     @Inject
     @Named(ContextPipelineModule.HONEYCOMB_CONTEXT)
-    DataBroker contextBroker
+    private DataBroker contextBroker;
 
     @Override
-    def create() { new ModifiableDataTreeDelegator(serializer, dataTree, registry.build(), contextBroker) }
+    protected ModifiableDataTreeDelegator create() {
+        return new ModifiableDataTreeDelegator(serializer, dataTree,
+                ((WriterRegistryBuilder) registry).build(), contextBroker);
+    }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/PersistingDataTreeProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/PersistingDataTreeProvider.groovy
deleted file mode 100644
index 6c41ad69f..000000000
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/PersistingDataTreeProvider.groovy
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * 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.infra.distro.data
-
-import com.google.inject.Inject
-import com.google.inject.name.Named
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-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
-
-import java.nio.file.Paths
-
-@Slf4j
-@ToString
-abstract class PersistingDataTreeProvider extends ProviderTrait<DataTree> {
-
-    @Inject
-    SchemaService schemaService
-    @Inject
-    HoneycombConfiguration config
-
-    def create() {
-        new PersistingDataTreeAdapter(delegate, schemaService, Paths.get(path))
-    }
-
-    abstract String getPath()
-    abstract TreeType getType()
-    abstract DataTree getDelegate()
-
-    static class ConfigPersistingDataTreeProvider extends PersistingDataTreeProvider {
-
-        @Inject
-        @Named(ConfigAndOperationalPipelineModule.HONEYCOMB_CONFIG_NONPERSIST)
-        DataTree delegate
-
-        String getPath() { config.peristConfigPath }
-        TreeType getType() { TreeType.CONFIGURATION }
-        DataTree getDelegate() { return delegate }
-    }
-
-    static class ContextPersistingDataTreeProvider extends PersistingDataTreeProvider {
-
-        @Inject
-        @Named(ContextPipelineModule.HONEYCOMB_CONTEXT_NOPERSIST)
-        DataTree delegate
-
-        String getPath() { config.peristContextPath }
-        TreeType getType() { TreeType.OPERATIONAL }
-        DataTree getDelegate() { return delegate }
-    }
-}
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/PersistingDataTreeProvider.java b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/PersistingDataTreeProvider.java
new file mode 100644
index 000000000..fb4ebc69d
--- /dev/null
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/PersistingDataTreeProvider.java
@@ -0,0 +1,84 @@
+/*
+ * 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.infra.distro.data;
+
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+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 java.nio.file.Paths;
+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;
+
+public abstract class PersistingDataTreeProvider extends ProviderTrait<DataTree> {
+
+    @Inject
+    private SchemaService schemaService;
+    @Inject
+    protected HoneycombConfiguration config;
+
+    public PersistingDataTreeAdapter create() {
+        return new PersistingDataTreeAdapter(getDelegate(), schemaService, Paths.get(getPath()));
+    }
+
+    public abstract String getPath();
+
+    public abstract TreeType getType();
+
+    public abstract DataTree getDelegate();
+
+    public static final class ConfigPersistingDataTreeProvider extends PersistingDataTreeProvider {
+
+        @Inject
+        @Named(ConfigAndOperationalPipelineModule.HONEYCOMB_CONFIG_NONPERSIST)
+        private DataTree delegate;
+
+        public String getPath() {
+            return config.peristConfigPath;
+        }
+
+        public TreeType getType() {
+            return TreeType.CONFIGURATION;
+        }
+
+        public DataTree getDelegate() {
+            return delegate;
+        }
+    }
+
+    public static final class ContextPersistingDataTreeProvider extends PersistingDataTreeProvider {
+
+        @Inject
+        @Named(ContextPipelineModule.HONEYCOMB_CONTEXT_NOPERSIST)
+        private DataTree delegate;
+
+        public String getPath() {
+            return config.peristContextPath;
+        }
+
+        public TreeType getType() {
+            return TreeType.OPERATIONAL;
+        }
+
+        public DataTree getDelegate() {
+            return delegate;
+        }
+    }
+}
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/config/WriterRegistryProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/config/WriterRegistryProvider.java
index 3c94812ef..f3e8ce200 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/config/WriterRegistryProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/config/WriterRegistryProvider.java
@@ -14,26 +14,27 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data.config
+package io.fd.honeycomb.infra.distro.data.config;
 
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import io.fd.honeycomb.translate.util.write.registry.FlatWriterRegistryBuilder
-import io.fd.honeycomb.translate.write.WriterFactory
-import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder
+import com.google.inject.Inject;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import io.fd.honeycomb.translate.util.write.registry.FlatWriterRegistryBuilder;
+import io.fd.honeycomb.translate.write.WriterFactory;
+import io.fd.honeycomb.translate.write.registry.ModifiableWriterRegistryBuilder;
+import java.util.HashSet;
+import java.util.Set;
 
-@Slf4j
-@ToString
-class WriterRegistryProvider extends ProviderTrait<ModifiableWriterRegistryBuilder> {
+public final class WriterRegistryProvider extends ProviderTrait<ModifiableWriterRegistryBuilder> {
 
     @Inject(optional = true)
-    Set<WriterFactory> writerFactories = []
+    private Set<WriterFactory> writerFactories = new HashSet<>();
 
-    def create() {
-        def builder = new FlatWriterRegistryBuilder()
-        writerFactories.forEach { it.init(builder) }
-        builder
+    @Override
+    protected FlatWriterRegistryBuilder create() {
+        final FlatWriterRegistryBuilder builder = new FlatWriterRegistryBuilder();
+        writerFactories
+                .stream()
+                .forEach(it -> it.init(builder));
+        return builder;
     }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ContextPipelineModule.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ContextPipelineModule.groovy
deleted file mode 100644
index a4cf73162..000000000
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ContextPipelineModule.groovy
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * 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.infra.distro.data.context
-
-import com.google.inject.PrivateModule
-import com.google.inject.Singleton
-import com.google.inject.name.Names
-import io.fd.honeycomb.data.ModifiableDataManager
-import io.fd.honeycomb.data.init.DataTreeInitializer
-import io.fd.honeycomb.infra.distro.data.BindingDataBrokerProvider
-import io.fd.honeycomb.infra.distro.data.DataTreeProvider
-import io.fd.honeycomb.infra.distro.data.PersistingDataTreeProvider
-import io.fd.honeycomb.infra.distro.initializer.PersistedFileInitializerProvider
-import io.fd.honeycomb.translate.MappingContext
-import org.opendaylight.controller.md.sal.binding.api.DataBroker
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree
-
-class ContextPipelineModule extends PrivateModule {
-
-    public static final String HONEYCOMB_CONTEXT_NOPERSIST = "honeycomb-context-nopersist"
-    public static final String HONEYCOMB_CONTEXT = "honeycomb-context"
-
-    protected void configure() {
-        // Non persisting data tree for context
-        def noPersistDataTreeProvider = new DataTreeProvider.ContextDataTreeProvider()
-        bind(DataTree)
-                .annotatedWith(Names.named(HONEYCOMB_CONTEXT_NOPERSIST))
-                .toProvider(noPersistDataTreeProvider)
-                .in(Singleton)
-        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)
-
-        // 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).toProvider(domBrokerProvider).in(Singleton)
-
-        // 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))
-                .toProvider(PersistedFileInitializerProvider.PersistedContextInitializerProvider)
-                .in(Singleton)
-        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))
-                .toProvider(RealtimeMappingContextProvider)
-                .in(Singleton.class)
-        expose(MappingContext).annotatedWith(Names.named(HONEYCOMB_CONTEXT))
-    }
-
-}
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ContextPipelineModule.java b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ContextPipelineModule.java
new file mode 100644
index 000000000..b0ded35bd
--- /dev/null
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ContextPipelineModule.java
@@ -0,0 +1,74 @@
+/*
+ * 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.infra.distro.data.context;
+
+import com.google.inject.PrivateModule;
+import com.google.inject.Singleton;
+import com.google.inject.name.Names;
+import io.fd.honeycomb.data.ModifiableDataManager;
+import io.fd.honeycomb.data.init.DataTreeInitializer;
+import io.fd.honeycomb.infra.distro.data.BindingDataBrokerProvider;
+import io.fd.honeycomb.infra.distro.data.DataTreeProvider;
+import io.fd.honeycomb.infra.distro.data.PersistingDataTreeProvider;
+import io.fd.honeycomb.infra.distro.initializer.PersistedFileInitializerProvider;
+import io.fd.honeycomb.translate.MappingContext;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
+
+public class ContextPipelineModule extends PrivateModule {
+
+    public static final String HONEYCOMB_CONTEXT_NOPERSIST = "honeycomb-context-nopersist";
+    public static final String HONEYCOMB_CONTEXT = "honeycomb-context";
+
+    @Override
+    protected void configure() {
+        // Non persisting data tree for context
+        DataTreeProvider.ContextDataTreeProvider noPersistDataTreeProvider =
+                new DataTreeProvider.ContextDataTreeProvider();
+        bind(DataTree.class).annotatedWith(Names.named(HONEYCOMB_CONTEXT_NOPERSIST))
+                .toProvider(noPersistDataTreeProvider).in(Singleton.class);
+        expose(DataTree.class).annotatedWith(Names.named(HONEYCOMB_CONTEXT_NOPERSIST));
+        // Persisting data tree wrapper for context
+        PersistingDataTreeProvider.ContextPersistingDataTreeProvider dataTreeProvider =
+                new PersistingDataTreeProvider.ContextPersistingDataTreeProvider();
+        bind(DataTree.class).toProvider(dataTreeProvider).in(Singleton.class);
+
+        // Data Tree manager (without any delegation) on top of context data tree
+        bind(ModifiableDataManager.class).toProvider(ModifiableDTMgrProvider.class).in(Singleton.class);
+
+        // DOMDataBroker interface on top of data tree manager
+        HoneycombContextDOMDataBrokerProvider domBrokerProvider = new HoneycombContextDOMDataBrokerProvider();
+        bind(DOMDataBroker.class).toProvider(domBrokerProvider).in(Singleton.class);
+
+        // BA version of data broker for context
+        bind(DataBroker.class).annotatedWith(Names.named(HONEYCOMB_CONTEXT)).toProvider(BindingDataBrokerProvider.class)
+                .in(Singleton.class);
+        expose(DataBroker.class).annotatedWith(Names.named(HONEYCOMB_CONTEXT));
+
+        // Create initializer to init persisted config data
+        bind(DataTreeInitializer.class).annotatedWith(Names.named(HONEYCOMB_CONTEXT))
+                .toProvider(PersistedFileInitializerProvider.PersistedContextInitializerProvider.class)
+                .in(Singleton.class);
+        expose(DataTreeInitializer.class).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.class).annotatedWith(Names.named(HONEYCOMB_CONTEXT))
+                .toProvider(RealtimeMappingContextProvider.class).in(Singleton.class);
+        expose(MappingContext.class).annotatedWith(Names.named(HONEYCOMB_CONTEXT));
+    }
+}
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/HoneycombContextDOMDataBrokerProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/HoneycombContextDOMDataBrokerProvider.java
index eecd87e42..8e178203d 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/HoneycombContextDOMDataBrokerProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/HoneycombContextDOMDataBrokerProvider.java
@@ -14,23 +14,20 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data.context
+package io.fd.honeycomb.infra.distro.data.context;
 
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.data.ModifiableDataManager
-import io.fd.honeycomb.data.impl.DataBroker
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker
+import com.google.inject.Inject;
+import io.fd.honeycomb.data.ModifiableDataManager;
+import io.fd.honeycomb.data.impl.DataBroker;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
 
-@Slf4j
-@ToString
-class HoneycombContextDOMDataBrokerProvider extends ProviderTrait<DOMDataBroker> {
+public final class HoneycombContextDOMDataBrokerProvider extends ProviderTrait<DOMDataBroker> {
 
     @Inject
-    ModifiableDataManager modDataManager
-
-    def create() { DataBroker.create(modDataManager) }
+    private ModifiableDataManager modDataManager;
 
+    public DataBroker create() {
+        return DataBroker.create(modDataManager);
+    }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ModifiableDTMgrProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ModifiableDTMgrProvider.java
index 01d854b28..9da97a8e4 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ModifiableDTMgrProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/ModifiableDTMgrProvider.java
@@ -14,23 +14,21 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data.context
+package io.fd.honeycomb.infra.distro.data.context;
 
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.data.ModifiableDataManager
-import io.fd.honeycomb.data.impl.ModifiableDataTreeManager
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree
+import com.google.inject.Inject;
+import io.fd.honeycomb.data.ModifiableDataManager;
+import io.fd.honeycomb.data.impl.ModifiableDataTreeManager;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTree;
 
-@Slf4j
-@ToString
-class ModifiableDTMgrProvider extends ProviderTrait<ModifiableDataManager> {
+public final class ModifiableDTMgrProvider extends ProviderTrait<ModifiableDataManager> {
 
     @Inject
-    DataTree dataTree
+    private DataTree dataTree;
 
     @Override
-    def create() { new ModifiableDataTreeManager(dataTree) }
+    public ModifiableDataTreeManager create() {
+        return new ModifiableDataTreeManager(dataTree);
+    }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/RealtimeMappingContextProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/RealtimeMappingContextProvider.java
index c6afd92fc..cc1a8b1b8 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/RealtimeMappingContextProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/context/RealtimeMappingContextProvider.java
@@ -14,27 +14,24 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data.context
+package io.fd.honeycomb.infra.distro.data.context;
 
-import com.google.inject.Inject
-import com.google.inject.name.Named
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import io.fd.honeycomb.translate.MappingContext
-import io.fd.honeycomb.translate.util.RealtimeMappingContext
-import org.opendaylight.controller.md.sal.binding.api.DataBroker
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.util.RealtimeMappingContext;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 
-@Slf4j
-@ToString
-class RealtimeMappingContextProvider extends ProviderTrait<MappingContext> {
+public final class RealtimeMappingContextProvider extends ProviderTrait<MappingContext> {
 
     @Inject
     @Named(ContextPipelineModule.HONEYCOMB_CONTEXT)
-    DataBroker contextDataBroker
+    private DataBroker contextDataBroker;
 
     @Override
-    def create() {
-        new RealtimeMappingContext(contextDataBroker)
+    public RealtimeMappingContext create() {
+        return new RealtimeMappingContext(contextDataBroker);
     }
+
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/oper/ReadableDTDelegProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/oper/ReadableDTDelegProvider.java
index 11eaf49a4..13e82e85f 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/oper/ReadableDTDelegProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/oper/ReadableDTDelegProvider.java
@@ -14,36 +14,35 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data.oper
+package io.fd.honeycomb.infra.distro.data.oper;
 
-import com.google.inject.Inject
-import com.google.inject.name.Named
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-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
-import org.opendaylight.controller.sal.core.api.model.SchemaService
+import com.google.inject.Inject;
+import com.google.inject.name.Named;
+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 io.fd.honeycomb.translate.read.registry.ReaderRegistryBuilder;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.controller.sal.core.api.model.SchemaService;
 
-@Slf4j
-@ToString
-class ReadableDTDelegProvider extends ProviderTrait<ReadableDataManager> {
+public final class ReadableDTDelegProvider extends ProviderTrait<ReadableDataManager> {
 
     @Inject
-    BindingToNormalizedNodeCodec serializer
+    private BindingToNormalizedNodeCodec serializer;
     @Inject
-    SchemaService schemaService
+    private SchemaService schemaService;
     @Inject
-    ModifiableReaderRegistryBuilder registry
+    private ModifiableReaderRegistryBuilder registry;
     @Inject
     @Named(ContextPipelineModule.HONEYCOMB_CONTEXT)
-    DataBroker contextBroker
+    private DataBroker contextBroker;
 
-    def create() {
-        new ReadableDataTreeDelegator(serializer, schemaService.getGlobalContext(), registry.build(), contextBroker)
+    @Override
+    protected ReadableDataTreeDelegator create() {
+        return new ReadableDataTreeDelegator(serializer, schemaService.getGlobalContext(),
+                ((ReaderRegistryBuilder) registry).build(), contextBroker);
     }
 }
diff --git a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/oper/ReaderRegistryProvider.groovy b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/oper/ReaderRegistryProvider.java
index 36f74d948..ef09e0e97 100644
--- a/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/oper/ReaderRegistryProvider.groovy
+++ b/infra/minimal-distribution/src/main/java/io/fd/honeycomb/infra/distro/data/oper/ReaderRegistryProvider.java
@@ -14,26 +14,27 @@
  * limitations under the License.
  */
 
-package io.fd.honeycomb.infra.distro.data.oper
+package io.fd.honeycomb.infra.distro.data.oper;
 
-import com.google.inject.Inject
-import groovy.transform.ToString
-import groovy.util.logging.Slf4j
-import io.fd.honeycomb.infra.distro.ProviderTrait
-import io.fd.honeycomb.translate.read.ReaderFactory
-import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder
-import io.fd.honeycomb.translate.util.read.registry.CompositeReaderRegistryBuilder
+import com.google.inject.Inject;
+import io.fd.honeycomb.infra.distro.ProviderTrait;
+import io.fd.honeycomb.translate.read.ReaderFactory;
+import io.fd.honeycomb.translate.read.registry.ModifiableReaderRegistryBuilder;
+import io.fd.honeycomb.translate.util.read.registry.CompositeReaderRegistryBuilder;
+import java.util.HashSet;
+import java.util.Set;
 
-@Slf4j
-@ToString
-class ReaderRegistryProvider extends ProviderTrait<ModifiableReaderRegistryBuilder> {
+public final class ReaderRegistryProvider extends ProviderTrait<ModifiableReaderRegistryBuilder> {
 
     @Inject(optional = true)
-    Set<ReaderFactory> readerFactories = []
+    private Set<ReaderFactory> readerFactories = new HashSet<>();
 
-    def create() {
-        def builder = new CompositeReaderRegistryBuilder()
-        readerFactories.forEach { it.init(builder) }
-        builder
+    @Override
+    protected CompositeReaderRegistryBuilder create() {
+        final CompositeReaderRegistryBuilder builder = new CompositeReaderRegistryBuilder();
+        readerFactories.stream()
+                .forEach(it -> it.init(builder));
+        return builder;
     }
+
 }