Add Customizer and Initializer for MicroStream

Author: rdebusscher

microstream-api/src/main/java/be/atbash/runtime/data/microstream/config/EmbeddedStorageFoundationCustomizer.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2021-2022 Rudy De Busscher (https://www.atbash.be)
+ *
+ * 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 be.atbash.runtime.data.microstream.config;
+
+
+import one.microstream.storage.embedded.types.EmbeddedStorageFoundation;
+
+public interface EmbeddedStorageFoundationCustomizer {
+
+    void customize(EmbeddedStorageFoundation<?> embeddedStorageFoundation);
+}

microstream-api/src/main/java/be/atbash/runtime/data/microstream/config/StorageManagerInitializer.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2021-2022 Rudy De Busscher (https://www.atbash.be)
+ *
+ * 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 be.atbash.runtime.data.microstream.config;
+
+
+import one.microstream.storage.types.StorageManager;
+
+public interface StorageManagerInitializer {
+
+    void initialize(StorageManager storageManager);
+}

microstream-module/src/main/java/be/atbash/runtime/data/microstream/MicroStreamModule.java

@@ -16,6 +16,7 @@
 package be.atbash.runtime.data.microstream;
 
 import be.atbash.runtime.config.mp.module.MPConfigModule;
+import be.atbash.runtime.core.data.RuntimeConfiguration;
 import be.atbash.runtime.core.data.Specification;
 import be.atbash.runtime.core.data.deployment.ArchiveDeployment;
 import be.atbash.runtime.core.data.module.Module;
@@ -29,16 +30,22 @@
 import java.util.Collections;
 import java.util.List;
 
+import static be.atbash.runtime.config.mp.MPConfigModuleConstant.ENABLED_FORCED;
+import static be.atbash.runtime.config.mp.module.MPConfigModule.MP_CONFIG_MODULE_NAME;
 
-public class MicroStreamModule implements Module<Void> {
+
+public class MicroStreamModule implements Module<RuntimeConfiguration> {
 
     public static final String MICROSTREAM_MODULE_NAME = "microstream";
 
+    private RuntimeConfiguration configuration;
+
     @Override
     public String name() {
         return MICROSTREAM_MODULE_NAME;
     }
 
+
     @Override
     public String[] dependencies() {
         return new String[]{MPConfigModule.MP_CONFIG_MODULE_NAME, JerseyModule.JERSEY_MODULE_NAME};
@@ -77,9 +84,21 @@ private void addJAXRSProviders(Object payload) {
         ExtraPackagesUtil.addPackages(deployment, "be.atbash.runtime.data.microstream.jaxrs");
     }
 
+    @Override
+    public Class<RuntimeConfiguration> getModuleConfigClass() {
+        return RuntimeConfiguration.class;
+    }
+
+    @Override
+    public void setConfig(RuntimeConfiguration configuration) {
+        this.configuration = configuration;
+    }
 
     @Override
     public void run() {
+        // We force that MPConfig module is always active .
+        configuration.getConfig().getModules().writeConfigValue(MP_CONFIG_MODULE_NAME, ENABLED_FORCED, "true");
+
     }
 
     @Override

microstream-module/src/main/java/be/atbash/runtime/data/microstream/cdi/StorageBean.java

@@ -17,11 +17,13 @@
 
 
 import be.atbash.runtime.data.microstream.cdi.spi.AbstractBean;
+import be.atbash.runtime.data.microstream.config.StorageManagerInitializer;
 import be.atbash.runtime.data.microstream.exception.StorageTypeException;
 import jakarta.enterprise.context.spi.CreationalContext;
 import jakarta.enterprise.inject.Any;
 import jakarta.enterprise.inject.Default;
 import jakarta.enterprise.inject.spi.AnnotatedType;
+import jakarta.enterprise.inject.spi.Bean;
 import jakarta.enterprise.inject.spi.BeanManager;
 import jakarta.enterprise.inject.spi.InjectionPoint;
 import one.microstream.reflect.XReflect;
@@ -88,6 +90,17 @@ public T create(CreationalContext<T> context) {
             }
         }
         injectDependencies(result);
+
+        Set<Bean<?>> initializerBeans = beanManager.getBeans(StorageManagerInitializer.class);
+        for (Bean<?> initializerBean : initializerBeans)
+        {
+            StorageManagerInitializer initializer = (StorageManagerInitializer) beanManager.getReference(initializerBean
+                    , initializerBean.getBeanClass()
+                    , beanManager.createCreationalContext(initializerBean));
+
+            initializer.initialize(manager);
+        }
+
         return result;
     }
 

microstream-module/src/main/java/be/atbash/runtime/data/microstream/cdi/spi/MicroStreamExtension.java

@@ -126,4 +126,10 @@ void addAnnotatedType(BeforeBeanDiscovery event, BeanManager beanManager, Class<
         event.addAnnotatedType(beanManager.createAnnotatedType(type), id);
     }
 
+    public boolean hasStorageRoot()
+    {
+        return !storageRoot.isEmpty();
+    }
+
+
 }

microstream-module/src/main/java/be/atbash/runtime/data/microstream/cdi/spi/StorageManagerProducer.java

@@ -17,13 +17,17 @@
 package be.atbash.runtime.data.microstream.cdi.spi;
 
 
+import be.atbash.runtime.data.microstream.config.EmbeddedStorageFoundationCustomizer;
+import be.atbash.runtime.data.microstream.config.StorageManagerInitializer;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.enterprise.inject.Disposes;
+import jakarta.enterprise.inject.Instance;
 import jakarta.enterprise.inject.Produces;
 import jakarta.inject.Inject;
 import one.microstream.reflect.ClassLoaderProvider;
 import one.microstream.storage.embedded.configuration.types.EmbeddedStorageConfigurationBuilder;
 import one.microstream.storage.embedded.types.EmbeddedStorageFoundation;
+import one.microstream.storage.embedded.types.EmbeddedStorageManager;
 import one.microstream.storage.types.StorageManager;
 import org.eclipse.microprofile.config.Config;
 
@@ -41,6 +45,15 @@ class StorageManagerProducer {
     @Inject
     private Config config;
 
+    @Inject
+    private MicroStreamExtension storageExtension;
+
+    @Inject
+    private Instance<EmbeddedStorageFoundationCustomizer> customizers;
+
+    @Inject
+    private Instance<StorageManagerInitializer> initializers;
+
     @Produces
     @ApplicationScoped
     public StorageManager getStoreManager() {
@@ -63,10 +76,23 @@ public StorageManager getStoreManager() {
         embeddedStorageFoundation.onConnectionFoundation(cf -> cf.setClassLoaderProvider(ClassLoaderProvider.New(
                 Thread.currentThread().getContextClassLoader())));
 
-        return embeddedStorageFoundation.start();
+        customizers.stream()
+                .forEach(customizer -> customizer.customize(embeddedStorageFoundation));
+
+        EmbeddedStorageManager storageManager = embeddedStorageFoundation.start();
+
+        if (!storageExtension.hasStorageRoot())
+        {
+            // Only execute at this point when no storage root bean has defined with @Storage
+            // Initializers are called from StorageBean.create if user has defined @Storage and root is read.
+            initializers.stream()
+                    .forEach(initializer -> initializer.initialize(storageManager));
+        }
+
+        return storageManager;
     }
 
-    public void dispose(@Disposes final StorageManager manager) {
+    public void dispose(@Disposes StorageManager manager) {
         LOGGER.info("Closing the default StorageManager");
         manager.close();
     }