feat: made EntityModelManager a non-static class

Author: kristian

src/main/java/io/neonbee/NeonBee.java

@@ -40,6 +40,7 @@
 import io.neonbee.config.NeonBeeConfig;
 import io.neonbee.config.ServerConfig;
 import io.neonbee.data.DataQuery;
+import io.neonbee.entity.EntityModelManager;
 import io.neonbee.entity.EntityWrapper;
 import io.neonbee.hook.HookRegistry;
 import io.neonbee.hook.HookType;
@@ -164,6 +165,8 @@ public class NeonBee {
 
     private final Set<String> localConsumers = new ConcurrentHashSet<>();
 
+    private final EntityModelManager modelManager;
+
     private final CompositeMeterRegistry compositeMeterRegistry;
 
     /**
@@ -516,6 +519,8 @@ private Future<Void> deployModules() {
     NeonBee(Vertx vertx, NeonBeeOptions options, CompositeMeterRegistry compositeMeterRegistry) {
         this.vertx = vertx;
         this.options = options;
+
+        this.modelManager = new EntityModelManager(this);
         this.compositeMeterRegistry = compositeMeterRegistry;
 
         // to be able to retrieve the NeonBee instance from any point you have a Vert.x instance add it to a global map
@@ -644,6 +649,15 @@ public ServerConfig getServerConfig() {
         return new ServerConfig((JsonObject) getLocalMap().get(ServerVerticle.SERVER_CONFIG_KEY));
     }
 
+    /**
+     * Get the {@link EntityModelManager}.
+     *
+     * @return the {@link EntityModelManager}
+     */
+    public EntityModelManager getModelManager() {
+        return modelManager;
+    }
+
     /**
      * Get the {@link CompositeMeterRegistry}.
      *

src/main/java/io/neonbee/endpoint/odatav4/ODataV4Endpoint.java

@@ -5,7 +5,6 @@
 import static com.google.common.base.Strings.nullToEmpty;
 import static io.neonbee.endpoint.odatav4.ODataV4Endpoint.UriConversion.STRICT;
 import static io.neonbee.entity.EntityModelManager.EVENT_BUS_MODELS_LOADED_ADDRESS;
-import static io.neonbee.entity.EntityModelManager.getSharedModels;
 import static io.neonbee.internal.helper.FunctionalHelper.entryConsumer;
 import static io.neonbee.internal.helper.FunctionalHelper.entryFunction;
 import static io.neonbee.internal.helper.StringHelper.EMPTY;
@@ -231,7 +230,7 @@ public Router createEndpointRouter(Vertx vertx, String basePath, JsonObject conf
 
     private static Future<Void> refreshRouter(Vertx vertx, Router router, String basePath, UriConversion uriConversion,
             RegexBlockList exposedEntities, AtomicReference<Map<String, EntityModel>> currentModels) {
-        return getSharedModels(NeonBee.get(vertx)).compose(models -> {
+        return NeonBee.get(vertx).getModelManager().getSharedModels().compose(models -> {
             if (models == currentModels.get()) {
                 return succeededFuture(); // no update needed
             } else {

src/main/java/io/neonbee/entity/EntityModelLoader.java

@@ -8,7 +8,6 @@
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 import java.io.ByteArrayInputStream;
-import java.io.File;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
@@ -20,7 +19,6 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -77,23 +75,23 @@ class EntityModelLoader {
     }
 
     /**
-     * Load models from model directory and classpath and returns a future to an unmodifiable map of all loaded models.
+     * Load models from model directory and class path and return a future to a map of all loaded models.
      *
-     * @return a unmodifiable map of all loaded models
+     * @return a map of all loaded models
      */
     public static Future<Map<String, EntityModel>> load(Vertx vertx) {
-        return new EntityModelLoader(vertx).loadModelsFromModelDirectoryAndClasspath()
+        return new EntityModelLoader(vertx).loadModelsFromModelDirectoryAndClassPath()
                 .map(EntityModelLoader::getModels);
     }
 
     /**
-     * Load models from model directory and classpath, as well as from the maps provided and returns a future to an
-     * unmodifiable map of all loaded models.
+     * Load models from model directory and class path, as well as from the maps provided and return a future to a map
+     * of all loaded models.
      *
-     * @return a unmodifiable map of all loaded models
+     * @return a map of all loaded models
      */
     public static Future<Map<String, EntityModel>> load(Vertx vertx, Collection<EntityModelDefinition> definitions) {
-        return new EntityModelLoader(vertx).loadModelsFromModelDirectoryAndClasspath().compose(loader -> {
+        return new EntityModelLoader(vertx).loadModelsFromModelDirectoryAndClassPath().compose(loader -> {
             return CompositeFuture
                     .all(definitions.stream().map(loader::loadModelsFromDefinition).collect(Collectors.toList()))
                     .map(loader);
@@ -103,18 +101,18 @@ public static Future<Map<String, EntityModel>> load(Vertx vertx, Collection<Enti
     /**
      * Returns a map of all loaded models.
      *
-     * @return a unmodifiable map of all loaded models
+     * @return a map of all loaded models
      */
     public Map<String, EntityModel> getModels() {
-        return Collections.unmodifiableMap(models);
+        return models;
     }
 
     /**
-     * Load models from model directory and classpath.
+     * Load models from model directory and class path.
      *
      * @return a future to the {@link EntityModelLoader} instance
      */
-    public Future<EntityModelLoader> loadModelsFromModelDirectoryAndClasspath() {
+    public Future<EntityModelLoader> loadModelsFromModelDirectoryAndClassPath() {
         NeonBeeOptions options = NeonBee.get(vertx).getOptions();
         return CompositeFuture.all(scanDir(options.getModelsDirectory()),
                 options.shouldIgnoreClassPath() ? succeededFuture() : scanClassPath()).map(this);
@@ -165,7 +163,7 @@ Future<Void> scanClassPath() {
         Future<List<String>> modelFiles = scanner.scanManifestFiles(vertx, NEONBEE_MODELS);
 
         return CompositeFuture.all(csnFiles, modelFiles).compose(scanResult -> CompositeFuture
-                // Use distinct because models mentioned in the manifest could also exists as file.
+                // use distinct because models mentioned in the manifest could also exists as file.
                 .all(Streams.concat(csnFiles.result().stream(), modelFiles.result().stream()).distinct()
                         .map(name -> loadModel(Path.of(name)).otherwise(throwable -> {
                             // models loaded from the class path are non-vital for NeonBee so continue anyways
@@ -180,25 +178,26 @@ Future<Void> loadModel(Path csnFile) {
             return succeededFuture();
         }
 
-        return readCsnModel(csnFile)
-                .compose(
-                        cdsModel -> CompositeFuture
-                                .all(EntityModelDefinition.resolveEdmxPaths(csnFile, cdsModel).stream()
-                                        .map(this::loadEdmxModel).collect(Collectors.toList()))
-                                .onSuccess(compositeFuture -> {
-                                    buildModelMap(cdsModel, compositeFuture.<ServiceMetadata>list());
-                                }))
-                .mapEmpty();
+        return readCsnModel(csnFile).compose(cdsModel -> {
+            return CompositeFuture.all(EntityModelDefinition.resolveEdmxPaths(csnFile, cdsModel).stream()
+                    .map(this::loadEdmxModel).collect(Collectors.toList())).onSuccess(compositeFuture -> {
+                        buildModelMap(cdsModel, compositeFuture.<ServiceMetadata>list());
+                    });
+        }).mapEmpty();
     }
 
-    Future<Void> parseModel(String csnFile, byte[] csnPayload, Map<String, byte[]> extensionModels) {
-        return parseCsnModel(csnPayload).compose(cdsModel -> CompositeFuture.all(EntityModelDefinition
-                .resolveEdmxPaths(Path.of(csnFile), cdsModel).stream().map(Path::toString).map(path -> {
-                    return Optional.ofNullable(extensionModels.get(path)).orElse(extensionModels
-                            .get(path.replace(File.separatorChar, File.separatorChar == '/' ? '\\' : '/')));
-                }).map(this::parseEdmxModel).collect(Collectors.toList())).onSuccess(compositeFuture -> {
-                    buildModelMap(cdsModel, compositeFuture.<ServiceMetadata>list());
-                })).mapEmpty();
+    Future<Void> parseModel(String csnFile, byte[] csnPayload, Map<String, byte[]> associatedModels) {
+        return parseCsnModel(csnPayload)
+                .compose(cdsModel -> CompositeFuture
+                        .all(EntityModelDefinition.resolveEdmxPaths(Path.of(csnFile), cdsModel).stream()
+                                .map(Path::toString).map(path -> {
+                                    // we do not know if the path uses windows / unix path separators, try both!
+                                    return FileSystemHelper.getPathFromMap(associatedModels, path);
+                                }).map(this::parseEdmxModel).collect(Collectors.toList()))
+                        .onSuccess(compositeFuture -> {
+                            buildModelMap(cdsModel, compositeFuture.<ServiceMetadata>list());
+                        }))
+                .mapEmpty();
     }
 
     private void buildModelMap(CdsModel cdsModel, List<ServiceMetadata> edmxModels) {