Merge pull request #205 from bci-oss/202-fix-model-resolution

Fix model resolution

Author: atextor

core/sds-aspect-model-resolver/src/main/java/io/openmanufacturing/sds/aspectmodel/resolver/AspectModelResolver.java

@@ -2,7 +2,7 @@
  * Copyright (c) 2021 Robert Bosch Manufacturing Solutions GmbH
  *
  * See the AUTHORS file(s) distributed with this work for additional
- * information regarding authorship. 
+ * information regarding authorship.
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -15,31 +15,31 @@
 
 import java.io.FileNotFoundException;
 import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
+import java.util.Stack;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.apache.jena.rdf.model.Model;
 import org.apache.jena.rdf.model.ModelFactory;
-import org.apache.jena.rdf.model.Resource;
-import org.apache.jena.rdf.model.ResourceFactory;
-import org.apache.jena.rdf.model.Statement;
+import org.apache.jena.rdf.model.Property;
+import org.apache.jena.rdf.model.RDFNode;
 import org.apache.jena.vocabulary.RDF;
+import org.apache.jena.vocabulary.XSD;
 
-import com.google.common.collect.Sets;
 import com.google.common.collect.Streams;
 
 import io.openmanufacturing.sds.aspectmodel.VersionNumber;
 import io.openmanufacturing.sds.aspectmodel.resolver.services.VersionedModel;
 import io.openmanufacturing.sds.aspectmodel.urn.AspectModelUrn;
+import io.openmanufacturing.sds.aspectmodel.urn.ElementType;
 import io.openmanufacturing.sds.aspectmodel.urn.UrnSyntaxException;
 import io.openmanufacturing.sds.aspectmodel.versionupdate.MigratorFactory;
 import io.openmanufacturing.sds.aspectmodel.versionupdate.MigratorService;
 import io.openmanufacturing.sds.aspectmodel.versionupdate.MigratorServiceLoader;
-import io.vavr.Tuple;
-import io.vavr.Tuple2;
-import io.vavr.Value;
 import io.vavr.control.Option;
 import io.vavr.control.Try;
 
@@ -57,7 +57,7 @@ public class AspectModelResolver {
     * @param model The RDF model
     * @return The set of URNs
     */
-   public static Set<AspectModelUrn> getAllUrnsInModel( final Model model ) {
+   public static Set<String> getAllUrnsInModel( final Model model ) {
       return Streams.stream( model.listStatements().mapWith( statement -> {
          final Stream<String> subjectUri = statement.getSubject().isURIResource() ?
                Stream.of( statement.getSubject().getURI() ) : Stream.empty();
@@ -66,26 +66,10 @@ public static Set<AspectModelUrn> getAllUrnsInModel( final Model model ) {
                Stream.of( statement.getObject().asResource().getURI() ) : Stream.empty();
 
          return Stream.of( subjectUri, propertyUri, objectUri )
-                      .flatMap( Function.identity() )
-                      .map( AspectModelResolver::getAspectModelUrn )
-                      .flatMap( Value::toJavaStream );
+               .flatMap( Function.identity() );
       } ) ).flatMap( Function.identity() ).collect( Collectors.toSet() );
    }
 
-   /**
-    * Parses an Aspect (meta) model URN into an {@link AspectModelUrn}
-    *
-    * @param uri The Aspect (meta) model URN
-    * @return The {@link AspectModelUrn} if parsing succeeds, an {@link UrnSyntaxException} otherwise
-    */
-   private static Try<AspectModelUrn> getAspectModelUrn( final String uri ) {
-      try {
-         return Try.success( AspectModelUrn.fromUrn( uri ) );
-      } catch ( final UrnSyntaxException exception ) {
-         return Try.failure( exception );
-      }
-   }
-
    /**
     * Method to resolve a given {@link AspectModelUrn} using a suitable {@link ResolutionStrategy}.
     * This creates the closure (merged model) of all referenced models and the corresponding meta model.
@@ -95,14 +79,11 @@ private static Try<AspectModelUrn> getAspectModelUrn( final String uri ) {
     * @return The resolved model on success
     */
    public Try<VersionedModel> resolveAspectModel( final ResolutionStrategy resolver, final AspectModelUrn input ) {
-
-      final Tuple2<Try<Model>, Set<AspectModelUrn>> resolutionResult =
-            resolve( ModelFactory.createDefaultModel(), input, resolver, Set.of() );
-      final Try<Model> mergedModel = resolutionResult._1();
+      final Try<Model> mergedModel = resolve( input.toString(), resolver );
 
       if ( mergedModel.isFailure() ) {
          if ( mergedModel.getCause() instanceof FileNotFoundException ) {
-            return Try.failure( new ModelResolutionException( mergedModel.getCause() ) );
+            return Try.failure( new ModelResolutionException( "While trying to resolve " + input + ": " + mergedModel.getCause() ) );
          }
          return Try.failure( mergedModel.getCause() );
       }
@@ -112,7 +93,7 @@ public Try<VersionedModel> resolveAspectModel( final ResolutionStrategy resolver
 
       final Set<VersionNumber> usedMetaModelVersions =
             mergedModel.map( resourceResolver::getUsedMetaModelVersions )
-                       .getOrElse( Collections.emptySet() );
+                  .getOrElse( Collections.emptySet() );
 
       if ( usedMetaModelVersions.isEmpty() ) {
          return Try.failure( new ModelResolutionException( "Could not determine used meta model version" ) );
@@ -121,7 +102,7 @@ public Try<VersionedModel> resolveAspectModel( final ResolutionStrategy resolver
       if ( usedMetaModelVersions.size() == 1 && migratorService.getMigratorFactory().isEmpty() ) {
          return mergedModel.flatMap( model ->
                migratorService.getSdsMigratorFactory().createAspectMetaModelResourceResolver()
-                              .mergeMetaModelIntoRawModel( model, usedMetaModelVersions.iterator().next() ) );
+                     .mergeMetaModelIntoRawModel( model, usedMetaModelVersions.iterator().next() ) );
       }
 
       final Try<VersionNumber> oldestVersion =
@@ -130,85 +111,116 @@ public Try<VersionedModel> resolveAspectModel( final ResolutionStrategy resolver
       return mergedModel.flatMap( model ->
             oldestVersion.flatMap( oldest ->
                   migratorService.getSdsMigratorFactory()
-                                 .createAspectMetaModelResourceResolver()
-                                 .mergeMetaModelIntoRawModel( model, oldest )
-                                 .orElse( () -> migratorService.getMigratorFactory()
-                                                               .map( MigratorFactory::createAspectMetaModelResourceResolver )
-                                                               .map( Try::success )
-                                                               .orElseThrow()
-                                                               .flatMap( metaResolver -> metaResolver.mergeMetaModelIntoRawModel( model, oldest ) ) )
-                                 .flatMap( migratorService::updateMetaModelVersion ) ) );
+                        .createAspectMetaModelResourceResolver()
+                        .mergeMetaModelIntoRawModel( model, oldest )
+                        .orElse( () -> migratorService.getMigratorFactory()
+                              .map( MigratorFactory::createAspectMetaModelResourceResolver )
+                              .map( Try::success )
+                              .orElseThrow()
+                              .flatMap( metaResolver -> metaResolver.mergeMetaModelIntoRawModel( model, oldest ) ) )
+                        .flatMap( migratorService::updateMetaModelVersion ) ) );
    }
 
    /**
-    * Checks if a given model contains the definition of a model element. This is determined by checking whether the
-    * statement "modelElement rdf:type *" or "modelElement bamm:refines *" exists.
+    * Checks if a given model contains the definition of a model element.
     *
     * @param model the model
     * @param urn the URN of the model element
     * @return true if the model contains the definition of the model element
     */
    public static boolean containsDefinition( final Model model, final AspectModelUrn urn ) {
-      return Streams.stream( model.listStatements() )
-                    .anyMatch( statement -> isBammElementDefinition( urn, statement ) );
+      return model.contains( model.createResource( urn.toString() ), RDF.type, (RDFNode) null );
    }
 
-   private static boolean isBammElementDefinition( final AspectModelUrn urn, final Statement statement ) {
-      final Resource resource = ResourceFactory.createResource( urn.getUrn().toString() );
-      final String bammRefinesRegex = ".*\\bmeta-model:\\b.*\\b#refines";
-      return resource.equals( statement.getSubject() ) &&
-            (RDF.type.equals( statement.getPredicate() ) ||
-                  statement.getPredicate().toString().matches( bammRefinesRegex ));
-   }
+   /**
+    * The main model resolution method that takes an Aspect Model element URN and a resolution strategy as input.
+    * The strategy is applied to the URN to load a model, and then repeated for all URNs in the loaded model that
+    * have not yet been loaded.
+    * @param urn the Aspect Model element URN
+    * @param resolutionStrategy the resolution strategy that knowns how to turn a URN into a Model
+    * @return the fully resolved model, or a failure if one of the transitively referenced elements can't be found
+    */
+   private Try<Model> resolve( final String urn, final ResolutionStrategy resolutionStrategy ) {
+      final Model result = ModelFactory.createDefaultModel();
+      final Stack<String> unresolvedUrns = new Stack<>();
+      final Set<Model> mergedModels = new HashSet<>();
+      unresolvedUrns.push( urn );
+
+      while ( !unresolvedUrns.isEmpty() ) {
+         final String urnToResolve = unresolvedUrns.pop();
+         final Try<Model> resolvedModel = getModelForUrn( urnToResolve, resolutionStrategy );
+         if ( resolvedModel.isFailure() ) {
+            return resolvedModel;
+         }
+         final Model model = resolvedModel.get();
+         final Property refines = model.createProperty( "urn:bamm:io.openmanufacturing:meta-model:1.0.0#refines" );
+
+         // Merge the resolved model into the target if it was not already merged before.
+         // It could have been merged before when the model contains another model definition that was already resolved
+         if ( !mergedModels.contains( model ) ) {
+            mergeModels( result, model );
+            mergedModels.add( model );
+         }
+         for ( final String element : getAllUrnsInModel( model ) ) {
+            if ( !result.contains( model.createResource( element ), RDF.type, (RDFNode) null )
+                  // Backwards compatibility with BAMM 1.0.0
+                  && !result.contains( model.createResource( element ), refines, (RDFNode) null )
+                  && !unresolvedUrns.contains( element ) ) {
+               unresolvedUrns.push( element );
+            }
+         }
+      }
 
-   private Tuple2<Try<Model>, Set<AspectModelUrn>> resolve( final Model targetModel,
-         final AspectModelUrn urn,
-         final ResolutionStrategy resolver, final Set<AspectModelUrn> resolvedUrns ) {
+      return Try.success( result );
+   }
 
-      if ( resolvedUrns.contains( urn ) ) {
-         return Tuple.of( Try.success( targetModel ), resolvedUrns );
-      }
+   private final Model EMPTY_MODEL = ModelFactory.createDefaultModel();
 
-      final Set<AspectModelUrn> updatedResolvedUrns = Sets.union( resolvedUrns, Set.of( urn ) );
-      if ( containsDefinition( targetModel, urn ) ) {
-         return Tuple.of( Try.success( targetModel ), updatedResolvedUrns );
+   /**
+    * Applies a {@link ResolutionStrategy} to a URI to be resolved, but only if the URI is actually a valid {@link AspectModelUrn}.
+    * For meta model elements or other URIs, an empty model is returned. This method returns only a failure, when the used resolution
+    * strategy fails.
+    * @param urn the URN to resolve
+    * @param resolutionStrategy the resolution strategy to apply
+    * @return the model containing the defintion of the given model element
+    */
+   private Try<Model> getModelForUrn( final String urn, final ResolutionStrategy resolutionStrategy ) {
+      if ( urn.startsWith( RDF.getURI() ) || urn.startsWith( XSD.getURI() ) ) {
+         return Try.success( EMPTY_MODEL );
       }
 
-      final Try<Model> loadedModel = resolver.apply( urn );
-      if ( loadedModel.isFailure() ) {
-         return Tuple.of( loadedModel, updatedResolvedUrns );
+      try {
+         final AspectModelUrn aspectModelUrn = AspectModelUrn.fromUrn( urn );
+         if ( aspectModelUrn.getElementType() != ElementType.NONE ) {
+            return Try.success( EMPTY_MODEL );
+         }
+         return resolutionStrategy.apply( aspectModelUrn ).flatMap( model -> {
+            if ( !model.contains( model.createResource( urn ), RDF.type, (RDFNode) null ) ) {
+               return Try.failure( new ModelResolutionException( "Resolution strategy returned a model which does contain element definition for " + urn ) );
+            }
+            return Try.success( model );
+         } );
+      } catch ( final UrnSyntaxException e ) {
+         // If it's no valid Aspect Model URN but some other URI (e.g., a bamm:see value), there is nothing
+         // to resolve, so we return just an empty model
+         return Try.success( EMPTY_MODEL );
       }
-
-      addModelWithoutOverwritingEmptyPrefix( targetModel, loadedModel.get() );
-      return getAllUrnsInModel( loadedModel.get() )
-            .stream()
-            .filter( modelUrn -> !modelUrn.isBammUrn() )
-            .reduce( Tuple.of( Try.success( targetModel ), updatedResolvedUrns ),
-                  (( tuple, aspectModelUrn ) ->
-                        resolve( targetModel, aspectModelUrn, resolver, updatedResolvedUrns )),
-                  ( tuple, tuple2 ) -> {
-                     final Try<Model> mergedModels = tuple._1().flatMap( model ->
-                           tuple2._1().map( model2 -> addModelWithoutOverwritingEmptyPrefix( model, model2 ) ) );
-                     final Set<AspectModelUrn> mergedSets = Sets.union( tuple._2(), tuple2._2() );
-                     return Tuple.of( mergedModels, mergedSets );
-                  } );
    }
 
-   private Model addModelWithoutOverwritingEmptyPrefix( final Model target, final Model modelToAdd ) {
-      if ( !target.getNsPrefixMap().containsKey( "" ) && modelToAdd.getNsPrefixMap().containsKey( "" ) ) {
-         target.setNsPrefix( "", modelToAdd.getNsPrefixURI( "" ) );
+   /**
+    * Merge a model into an existing target model. Prefixes are only added when they are not already present, i.e.,
+    * a model won't overwrite the empty prefix of the target model.
+    *
+    * @param target the model to merge into
+    * @param other the model to be merged
+    */
+   private void mergeModels( final Model target, final Model other ) {
+      for ( final Map.Entry<String, String> prefixEntry : other.getNsPrefixMap().entrySet() ) {
+         if ( !target.getNsPrefixMap().containsKey( prefixEntry.getKey() ) ) {
+            target.setNsPrefix( prefixEntry.getKey(), prefixEntry.getValue() );
+         }
       }
 
-      modelToAdd.getNsPrefixMap().entrySet().stream().filter( entry -> !"".equals( entry.getKey() ) )
-                .forEach( entry -> target.setNsPrefix( entry.getKey(), entry.getValue() ) );
-
-      migratorService.getMigratorFactory().map( MigratorFactory::createAspectMetaModelResourceResolver ).stream()
-                     .flatMap(
-                           aspectMetaModelResourceResolver -> aspectMetaModelResourceResolver
-                                 .listAspectStatements( modelToAdd, target ) ).forEach( target::add );
-
-      migratorService.getSdsMigratorFactory().createAspectMetaModelResourceResolver()
-                     .listAspectStatements( modelToAdd, target ).forEach( target::add );
-      return target;
+      other.listStatements().forEach( target::add );
    }
 }

core/sds-aspect-model-resolver/src/main/java/io/openmanufacturing/sds/aspectmodel/resolver/ClasspathStrategy.java

@@ -173,6 +173,6 @@ public Try<Model> apply( final AspectModelUrn aspectModelUrn ) {
                   .getOrElse( false ) )
             .findFirst()
             .orElse( Try.failure( new FileNotFoundException(
-                  "The AspectModel: " + aspectModelUrn + " could not be found in directory: " + directory ) ) );
+                  "The model file " + aspectModelUrn + " could not be found in directory: " + directory ) ) );
    }
 }

core/sds-aspect-model-resolver/src/main/java/io/openmanufacturing/sds/aspectmodel/resolver/FileSystemStrategy.java

@@ -2,7 +2,7 @@
  * Copyright (c) 2021 Robert Bosch Manufacturing Solutions GmbH
  *
  * See the AUTHORS file(s) distributed with this work for additional
- * information regarding authorship. 
+ * information regarding authorship.
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -80,17 +80,16 @@ public Try<Model> apply( final AspectModelUrn aspectModelUrn ) {
             aspectModelUrn.getName(), directory );
 
       return Arrays.stream( Optional.ofNullable( directory.toFile().listFiles() ).orElse( new File[] {} ) )
-                   .filter( File::isFile )
-                   .filter( file -> file.getName().endsWith( ".ttl" ) )
-                   .map( File::toURI )
-                   .sorted()
-                   .map( this::loadFromUri )
-                   .filter( tryModel -> tryModel
-                         .map( model -> AspectModelResolver.containsDefinition( model, aspectModelUrn ) )
-                         .getOrElse( false ) )
-                   .findFirst()
-                   .orElse( Try.failure( new FileNotFoundException(
-                         "The AspectModel: " + aspectModelUrn.toString() + " could not be found in directory: "
-                               + directory ) ) );
+            .filter( File::isFile )
+            .filter( file -> file.getName().endsWith( ".ttl" ) )
+            .map( File::toURI )
+            .sorted()
+            .map( this::loadFromUri )
+            .filter( tryModel -> tryModel
+                  .map( model -> AspectModelResolver.containsDefinition( model, aspectModelUrn ) )
+                  .getOrElse( false ) )
+            .findFirst()
+            .orElse( Try.failure( new FileNotFoundException(
+                  "The model file " + aspectModelUrn.toString() + " could not be found in directory: " + directory ) ) );
    }
 }