control plane > add information on adapters and extensions

Author: DC2-DanielKrueger

hivemq-edge/src/main/java/com/hivemq/HiveMQEdgeBootstrap.java

@@ -64,6 +64,7 @@ public class HiveMQEdgeBootstrap {
     private @Nullable GeneralBootstrapServiceImpl generalBootstrapService;
     private @Nullable PersistenceBootstrapService persistenceBootstrapService;
     private @Nullable Injector injector;
+    private CompleteBootstrapService completeBootstrapService;
 
     public HiveMQEdgeBootstrap(
             final @NotNull MetricRegistry metricRegistry,
@@ -151,6 +152,8 @@ private void bootstrapInjector() {
                 .restComponentService(restComponentsService)
                 .restComponentsHolder(genericAPIHolder)
                 .connectionPersistence(connectionPersistence)
+                .commercialModuleDiscovery(commercialModuleLoaderDiscovery)
+                .completeBootstrapService(completeBootstrapService)
                 .hivemqId(hivemqId)
                 .build();
         log.trace("Initialized injector in {}ms", (System.currentTimeMillis() - startDagger));
@@ -159,7 +162,7 @@ private void bootstrapInjector() {
     private void bootstrapCoreComponents() {
         log.info("Integrating Core Modules");
         // configService is always set in caller
-        assert configService != null;
+        Preconditions.checkNotNull(configService);
 
         try {
             commercialModuleLoaderDiscovery = new CommercialModuleLoaderDiscovery(moduleLoader);
@@ -198,7 +201,7 @@ private void finishBootstrap() {
         Preconditions.checkNotNull(persistenceBootstrapService);
 
         try {
-            final CompleteBootstrapService completeBootstrapService = CompleteBootstrapServiceImpl.decorate(
+            completeBootstrapService = CompleteBootstrapServiceImpl.decorate(
                     persistenceBootstrapService,
                     persistences,
                     restComponentsService,

hivemq-edge/src/main/java/com/hivemq/HiveMQEdgeGateway.java

@@ -66,12 +66,14 @@ public void start(final @Nullable EmbeddedExtension embeddedExtension) throws Hi
         try {
             extensionBootstrap.startExtensionSystem(embeddedExtension).get();
             bridgeService.updateBridges();
-            protocolAdapterManager.start();
+            protocolAdapterManager.start().get();
 
             final List<ListenerStartupInformation> startupInformation = nettyBootstrap.bootstrapServer().get();
             Checkpoints.checkpoint("listener-started");
             new StartupListenerVerifier(startupInformation).verifyAndPrint();
 
+
+
             ((AdminServiceImpl) adminService).hivemqStarted();
         } catch (Exception e) {
             throw new HiveMQEdgeStartupException(e);

hivemq-edge/src/main/java/com/hivemq/HiveMQEdgeMain.java

@@ -17,8 +17,12 @@
 
 import com.codahale.metrics.MetricFilter;
 import com.codahale.metrics.MetricRegistry;
+import com.google.common.base.Preconditions;
 import com.hivemq.bootstrap.LoggingBootstrap;
 import com.hivemq.bootstrap.ioc.Injector;
+import com.hivemq.bootstrap.ioc.Persistences;
+import com.hivemq.bootstrap.services.AfterHiveMQStartBootstrapService;
+import com.hivemq.bootstrap.services.AfterHiveMQStartBootstrapServiceImpl;
 import com.hivemq.common.shutdown.ShutdownHooks;
 import com.hivemq.configuration.info.SystemInformation;
 import com.hivemq.configuration.info.SystemInformationImpl;
@@ -137,9 +141,28 @@ protected void stopApiServer() {
     }
 
     protected void afterStart() {
+        afterHiveMQStartBootstrap();
         //hook method
     }
 
+    private void afterHiveMQStartBootstrap() {
+        Preconditions.checkNotNull(injector);
+        final Persistences persistences = injector.persistences();
+        Preconditions.checkNotNull(persistences);
+        Preconditions.checkNotNull(configService);
+
+        try {
+            final AfterHiveMQStartBootstrapService afterHiveMQStartBootstrapService =
+                    AfterHiveMQStartBootstrapServiceImpl.decorate(injector.completeBootstrapService(),
+                            injector.protocolAdapterManager(),
+                            injector.services().modulesAndExtensionsService());
+            injector.commercialModuleLoaderDiscovery().afterHiveMQStart(afterHiveMQStartBootstrapService);
+        } catch (Exception e) {
+            log.warn("Error on bootstraping persistences.", e);
+            throw new HiveMQEdgeStartupException(e);
+        }
+    }
+
     public void start(final @Nullable EmbeddedExtension embeddedExtension)
             throws InterruptedException, HiveMQEdgeStartupException {
         shutdownThread = new Thread(this::stop, "shutdown-thread");

hivemq-edge/src/main/java/com/hivemq/bootstrap/ioc/Injector.java

@@ -20,6 +20,7 @@
 import com.hivemq.api.ioc.ApiModule;
 import com.hivemq.api.resources.GenericAPIHolder;
 import com.hivemq.bootstrap.netty.ioc.NettyModule;
+import com.hivemq.bootstrap.services.CompleteBootstrapService;
 import com.hivemq.bridge.ioc.BridgeModule;
 import com.hivemq.common.executors.ioc.ExecutorsModule;
 import com.hivemq.common.shutdown.ShutdownHooks;
@@ -33,6 +34,7 @@
 import com.hivemq.edge.modules.api.adapters.ModuleServices;
 import com.hivemq.edge.modules.ioc.ModulesModule;
 import com.hivemq.edge.modules.ioc.RemoteServiceModule;
+import com.hivemq.extensions.core.CommercialModuleLoaderDiscovery;
 import com.hivemq.extensions.core.HandlerService;
 import com.hivemq.extensions.core.PersistencesService;
 import com.hivemq.extensions.core.RestComponentsService;
@@ -45,6 +47,7 @@
 import com.hivemq.persistence.PersistenceStartup;
 import com.hivemq.persistence.connection.ConnectionPersistence;
 import com.hivemq.persistence.ioc.PersistenceModule;
+import com.hivemq.protocols.ProtocolAdapterManager;
 import com.hivemq.security.ioc.SecurityModule;
 import com.hivemq.throttling.ioc.ThrottlingModule;
 import com.hivemq.uns.ioc.UnsServiceModule;
@@ -96,6 +99,12 @@ public interface Injector {
 
     Services services();
 
+    CommercialModuleLoaderDiscovery commercialModuleLoaderDiscovery();
+
+    CompleteBootstrapService completeBootstrapService();
+
+    ProtocolAdapterManager protocolAdapterManager();
+
 //    UnsServiceModule uns();
 
 //    ExecutorsModule executors();
@@ -142,6 +151,13 @@ interface Builder {
         @BindsInstance
         Builder hivemqId(HivemqId hivemqId);
 
+        @BindsInstance
+        Builder commercialModuleDiscovery(CommercialModuleLoaderDiscovery commercialModuleLoaderDiscovery);
+
+        @BindsInstance
+        Builder completeBootstrapService(CompleteBootstrapService completeBootstrapService);
+
+
         Injector build();
     }
 

hivemq-edge/src/main/java/com/hivemq/bootstrap/ioc/Services.java

@@ -17,6 +17,7 @@
 
 import com.hivemq.bridge.BridgeService;
 import com.hivemq.edge.HiveMQCapabilityService;
+import com.hivemq.edge.ModulesAndExtensionsService;
 import com.hivemq.extension.sdk.api.annotations.NotNull;
 import com.hivemq.extensions.core.HandlerService;
 import com.hivemq.persistence.SingleWriterService;
@@ -25,21 +26,24 @@
 
 public class Services {
 
-
     private final @NotNull HiveMQCapabilityService capabilityService;
     private final @NotNull BridgeService bridgeService;
     private final @NotNull SingleWriterService singleWriterService;
     private final @NotNull HandlerService handlerService;
+    private final @NotNull ModulesAndExtensionsService modulesAndExtensionsService;
 
     @Inject
-    public Services(final @NotNull HiveMQCapabilityService capabilityService,
-                    final @NotNull BridgeService bridgeService,
-                    final @NotNull SingleWriterService singleWriterService,
-                    final @NotNull HandlerService handlerService) {
+    public Services(
+            final @NotNull HiveMQCapabilityService capabilityService,
+            final @NotNull BridgeService bridgeService,
+            final @NotNull SingleWriterService singleWriterService,
+            final @NotNull HandlerService handlerService,
+            final @NotNull ModulesAndExtensionsService modulesAndExtensionsService) {
         this.capabilityService = capabilityService;
         this.bridgeService = bridgeService;
         this.singleWriterService = singleWriterService;
         this.handlerService = handlerService;
+        this.modulesAndExtensionsService = modulesAndExtensionsService;
     }
 
     public @NotNull HiveMQCapabilityService capabilityService() {
@@ -57,4 +61,8 @@ public Services(final @NotNull HiveMQCapabilityService capabilityService,
     public @NotNull HandlerService handlerService() {
         return handlerService;
     }
+
+    public @NotNull ModulesAndExtensionsService modulesAndExtensionsService() {
+        return modulesAndExtensionsService;
+    }
 }

hivemq-edge/src/main/java/com/hivemq/bootstrap/services/AfterHiveMQStartBootstrapService.java

@@ -0,0 +1,12 @@
+package com.hivemq.bootstrap.services;
+
+import com.hivemq.edge.ModulesAndExtensionsService;
+import com.hivemq.extension.sdk.api.annotations.NotNull;
+import com.hivemq.protocols.ProtocolAdapterManager;
+
+public interface AfterHiveMQStartBootstrapService extends CompleteBootstrapService {
+
+    @NotNull ProtocolAdapterManager protocolAdapterManager();
+
+    @NotNull ModulesAndExtensionsService modulesAndExtensionsService();
+}

hivemq-edge/src/main/java/com/hivemq/bootstrap/services/AfterHiveMQStartBootstrapServiceImpl.java

@@ -0,0 +1,102 @@
+package com.hivemq.bootstrap.services;
+
+import com.codahale.metrics.MetricRegistry;
+import com.hivemq.bootstrap.ioc.Persistences;
+import com.hivemq.common.shutdown.ShutdownHooks;
+import com.hivemq.configuration.HivemqId;
+import com.hivemq.configuration.info.SystemInformation;
+import com.hivemq.configuration.service.ConfigurationService;
+import com.hivemq.edge.HiveMQCapabilityService;
+import com.hivemq.edge.ModulesAndExtensionsService;
+import com.hivemq.extension.sdk.api.annotations.NotNull;
+import com.hivemq.extensions.core.HandlerService;
+import com.hivemq.extensions.core.PersistencesService;
+import com.hivemq.extensions.core.RestComponentsService;
+import com.hivemq.protocols.ProtocolAdapterManager;
+
+public class AfterHiveMQStartBootstrapServiceImpl implements AfterHiveMQStartBootstrapService {
+
+    private final @NotNull CompleteBootstrapService delegate;
+    private final @NotNull ProtocolAdapterManager protocolAdapterManager;
+    private final @NotNull ModulesAndExtensionsService modulesAndExtensionsService;
+
+    public AfterHiveMQStartBootstrapServiceImpl(
+            final @NotNull CompleteBootstrapService delegate,
+            final @NotNull ProtocolAdapterManager protocolAdapterManager,
+            final @NotNull ModulesAndExtensionsService modulesAndExtensionsService) {
+        this.delegate = delegate;
+        this.protocolAdapterManager = protocolAdapterManager;
+        this.modulesAndExtensionsService = modulesAndExtensionsService;
+    }
+
+    @Override
+    public @NotNull MetricRegistry metricRegistry() {
+        return delegate.metricRegistry();
+    }
+
+    @Override
+    public @NotNull SystemInformation systemInformation() {
+        return delegate.systemInformation();
+    }
+
+    @Override
+    public @NotNull ShutdownHooks shutdownHooks() {
+        return delegate.shutdownHooks();
+    }
+
+    @Override
+    public @NotNull ConfigurationService configurationService() {
+        return delegate.configurationService();
+    }
+
+    @Override
+    public @NotNull HivemqId getHivemqId() {
+        return delegate.getHivemqId();
+    }
+
+    @Override
+    public @NotNull PersistencesService persistenceService() {
+        return delegate.persistenceService();
+    }
+
+    @Override
+    public @NotNull HiveMQCapabilityService capabilityService() {
+        return delegate.capabilityService();
+    }
+
+    @Override
+    public @NotNull Persistences persistences() {
+        return delegate.persistences();
+    }
+
+    @Override
+    public @NotNull RestComponentsService restComponentsService() {
+        return delegate.restComponentsService();
+    }
+
+    @Override
+    public @NotNull HandlerService handlerService() {
+        return delegate.handlerService();
+    }
+
+    @Override
+    public @NotNull ProtocolAdapterManager protocolAdapterManager() {
+        return protocolAdapterManager;
+    }
+
+    @Override
+    public @NotNull ModulesAndExtensionsService modulesAndExtensionsService() {
+        return modulesAndExtensionsService;
+    }
+
+    public static @NotNull AfterHiveMQStartBootstrapService decorate(
+            final @NotNull CompleteBootstrapService completeBootstrapService,
+            final @NotNull ProtocolAdapterManager protocolAdapterManager,
+            final @NotNull ModulesAndExtensionsService modulesAndExtensionsService) {
+        return new AfterHiveMQStartBootstrapServiceImpl(completeBootstrapService,
+                protocolAdapterManager,
+                modulesAndExtensionsService);
+    }
+
+
+}

hivemq-edge/src/main/java/com/hivemq/bootstrap/services/PersistenceBootstrapService.java

@@ -14,7 +14,7 @@ public interface PersistenceBootstrapService extends GeneralBootstrapService {
     @NotNull HiveMQCapabilityService capabilityService();
 
 
-    static PersistenceBootstrapService decorate(
+     static PersistenceBootstrapService decorate(
             final @NotNull GeneralBootstrapService generalBootstrapService,
             final @NotNull PersistencesService persistencesService,
             final @NotNull HiveMQCapabilityService capabilityService) {

hivemq-edge/src/main/java/com/hivemq/edge/impl/ModulesAndExtensionsServiceImpl.java

@@ -24,18 +24,20 @@
 import com.hivemq.extensions.HiveMQExtensions;
 
 import javax.inject.Inject;
+import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 /**
  * @author Simon L Johnson
  */
 public class ModulesAndExtensionsServiceImpl implements ModulesAndExtensionsService {
 
-    private @NotNull final HiveMQExtensions hiveMQExtensions;
-    private @NotNull final HiveMQEdgeRemoteService hiveMQEdgeRemoteConfigurationService;
+    private final @NotNull HiveMQExtensions hiveMQExtensions;
+    private final @NotNull HiveMQEdgeRemoteService hiveMQEdgeRemoteConfigurationService;
 
     @Inject
     public ModulesAndExtensionsServiceImpl(final @NotNull HiveMQExtensions hiveMQExtensions,
@@ -44,32 +46,29 @@ public ModulesAndExtensionsServiceImpl(final @NotNull HiveMQExtensions hiveMQExt
         this.hiveMQEdgeRemoteConfigurationService = hiveMQEdgeRemoteConfigurationService;
     }
 
-    public List<Extension> getExtensions(){
+    public @NotNull List<Extension> getExtensions(){
 
         //-- Add discovered extensions
-        HashSet<Extension> extensions = new HashSet<>();
         List<Extension> availableExtensions = hiveMQEdgeRemoteConfigurationService.getConfiguration().getExtensions();
-        extensions.addAll(availableExtensions);
+        HashSet<Extension> extensions = new HashSet<>(availableExtensions);
 
         //-- Add installed extensions
         Map<String, HiveMQExtension> extensionsMap = hiveMQExtensions.getEnabledHiveMQExtensions();
-        extensions.addAll(extensionsMap.values().stream().map(e -> convertExtension(e)).collect(Collectors.toList()));
-        return extensions.stream().collect(Collectors.toList());
+        extensions.addAll(extensionsMap.values().stream().map(ModulesAndExtensionsServiceImpl::convertExtension).collect(Collectors.toList()));
+        return new ArrayList<>(extensions);
     }
 
-    public List<Module> getModules(){
-        HashSet<Module> modules = new HashSet<>();
+    public @NotNull List<Module> getModules(){
         List<Module> availableModules = hiveMQEdgeRemoteConfigurationService.getConfiguration().getModules();
-        modules.addAll(availableModules);
-        return modules.stream().collect(Collectors.toList());
+        HashSet<Module> modules = new HashSet<>(availableModules);
+        return new ArrayList<>(modules);
     }
 
     private static Extension convertExtension(HiveMQExtension extension){
         return new Extension(extension.getId(),
                 extension.getVersion(),
                 extension.getName(),
-                null,
-                extension.getAuthor(),
+                null, Objects.requireNonNullElse(extension.getAuthor(), "unknown"),
                 extension.getPriority(),
                 true,
                 null);

hivemq-edge/src/main/java/com/hivemq/extensions/core/CommercialModuleLoaderDiscovery.java

@@ -72,6 +72,18 @@ public void completeBootstrap(final @NotNull CompleteBootstrapService completeBo
     }
 
 
+    public void afterHiveMQStart(final @NotNull CompleteBootstrapService completeBootstrapService) {
+        try {
+            for (ModuleLoaderMain instance : instances) {
+                instance.afterPersistenceBootstrap(completeBootstrapService);
+            }
+        } catch (Exception e) {
+            log.error("Error when completing bootstrap ", e);
+        }
+    }
+
+
+
 }