SHIBUI-1639

.gitignore

@@ -390,4 +390,8 @@ pac4j-module/out/
 r
 
 #Local integration test run shell script wrapper
-rinteg
+rinteg
+
+#Local run with durable H2 shell script wrapper
+**/application-h2durable.properties
+rdurable

backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterServiceImpl.java

@@ -13,6 +13,7 @@
 import edu.internet2.tier.shibboleth.admin.ui.opensaml.OpenSamlObjects;
 import net.shibboleth.ext.spring.resource.ResourceHelper;
 import net.shibboleth.utilities.java.support.component.ComponentInitializationException;
+import net.shibboleth.utilities.java.support.logic.ConstraintViolationException;
 import net.shibboleth.utilities.java.support.resolver.ResolverException;
 import net.shibboleth.utilities.java.support.resource.Resource;
 import org.apache.lucene.index.IndexWriter;
@@ -21,13 +22,10 @@
 import org.opensaml.saml.metadata.resolver.MetadataResolver;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.core.io.ClassPathResource;
-import org.springframework.stereotype.Service;
 
-import javax.validation.ConstraintViolationException;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.net.URL;
 
 import static edu.internet2.tier.shibboleth.admin.util.TokenPlaceholderResolvers.placeholderResolverService;
 
@@ -46,8 +44,8 @@ private OpenSamlFunctionDrivenDynamicHTTPMetadataResolver convertToOpenSamlRepre
         IndexWriter indexWriter = indexWriterService.getIndexWriter(resolver.getResourceId());
 
         OpenSamlFunctionDrivenDynamicHTTPMetadataResolver openSamlResolver = new OpenSamlFunctionDrivenDynamicHTTPMetadataResolver(openSamlObjects.getParserPool(),
-                                                                     indexWriter,
-                                                                     resolver);
+                indexWriter,
+                resolver);
         openSamlResolver.initialize();
         return openSamlResolver;
     }
@@ -68,31 +66,25 @@ private OpenSamlFilesystemMetadataResolver convertToOpenSamlRepresentation(Files
         }
 
         OpenSamlFilesystemMetadataResolver openSamlResolver = new OpenSamlFilesystemMetadataResolver(openSamlObjects.getParserPool(),
-                                                      indexWriter,
-                                                      resolver,
-                                                      metadataFile);
+                indexWriter,
+                resolver,
+                metadataFile);
         openSamlResolver.initialize();
         return openSamlResolver;
     }
 
     private OpenSamlLocalDynamicMetadataResolver convertToOpenSamlRepresentation(LocalDynamicMetadataResolver resolver) throws IOException, ComponentInitializationException {
-        IndexWriter indexWriter = indexWriterService.getIndexWriter(resolver.getResourceId());
-
-        XMLObjectLoadSaveManager manager = null;
-        if (resolver.getDoInitialization()) {
-            try {
-                manager = new FilesystemLoadSaveManager(placeholderResolverService()
-                        .resolveValueFromPossibleTokenPlaceholder(resolver.getSourceDirectory()));
-            } catch (ConstraintViolationException e) {
-                // the base directory string instance was null or empty
-                //TODO: What should we do here? Currently, this causes a test to fail.
-                throw new RuntimeException("An exception occurred while attempting to instantiate a FilesystemLoadSaveManger for the path: " + resolver.getSourceDirectory(), e);
-            }
+        try {
+            IndexWriter indexWriter = indexWriterService.getIndexWriter(resolver.getResourceId());
+            XMLObjectLoadSaveManager manager = new FilesystemLoadSaveManager(new AlwaysExistingVirtualMetadataDirectory(placeholderResolverService()
+                    .resolveValueFromPossibleTokenPlaceholder(resolver.getSourceDirectory())));
+            OpenSamlLocalDynamicMetadataResolver openSamlResolver = new OpenSamlLocalDynamicMetadataResolver(openSamlObjects.getParserPool(), indexWriter, resolver, manager);
+            openSamlResolver.initialize();
+            return openSamlResolver;
+        } catch (ConstraintViolationException e) {
+            // the base directory string instance was null or empty
+            throw new RuntimeException("An exception occurred while attempting to instantiate a FilesystemLoadSaveManger for the path: " + resolver.getSourceDirectory(), e);
         }
-
-        OpenSamlLocalDynamicMetadataResolver openSamlResolver = new OpenSamlLocalDynamicMetadataResolver(openSamlObjects.getParserPool(), indexWriter, resolver, manager);
-        openSamlResolver.initialize();
-        return openSamlResolver;
     }
 
     private OpenSamlResourceBackedMetadataResolver convertToOpenSamlRepresentation(ResourceBackedMetadataResolver resolver) throws IOException, ComponentInitializationException {
@@ -112,9 +104,9 @@ private OpenSamlResourceBackedMetadataResolver convertToOpenSamlRepresentation(R
         }
 
         OpenSamlResourceBackedMetadataResolver openSamlResolver = new OpenSamlResourceBackedMetadataResolver(openSamlObjects.getParserPool(),
-                                                          indexWriter,
-                                                          resolver,
-                                                          resource);
+                indexWriter,
+                resolver,
+                resource);
         openSamlResolver.initialize();
         return openSamlResolver;
     }
@@ -136,4 +128,27 @@ public MetadataResolver convertToOpenSamlRepresentation(edu.internet2.tier.shibb
                 throw new RuntimeException("Unsupported metadata resolver type!");
         }
     }
+
+    /**
+     * Use this class when creating FilesystemLoadSaveManager for OpenSamlLocalDynamicMetadataResolver
+     * as we guard the system from any file-related exceptions during init of open saml object representation.
+     * File with the same name might exist and we don't force the
+     * system to create a directory in this case. Shibboleth Idp would take care of these directory-creating aspects
+     * instead.
+     */
+    private static class AlwaysExistingVirtualMetadataDirectory extends File {
+        public AlwaysExistingVirtualMetadataDirectory(String pathname) {
+            super(pathname);
+        }
+
+        @Override
+        public boolean exists() {
+            return true;
+        }
+
+        @Override
+        public boolean isDirectory() {
+            return true;
+        }
+    }
 }

backend/src/test/groovy/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterServiceImplTests.groovy

@@ -0,0 +1,29 @@
+package edu.internet2.tier.shibboleth.admin.ui.service
+
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicMetadataResolverAttributes
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.LocalDynamicMetadataResolver
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.context.SpringBootTest
+import spock.lang.Specification
+
+@SpringBootTest
+class MetadataResolverConverterServiceImplTests extends Specification {
+
+    @Autowired
+    MetadataResolverConverterService mrConverterServiceUnderTest
+
+    def "conversion to OpenSamlLocalDynamicMetadataResolver with source directory name matching existing file (non-directory) succeeds"() {
+        given:
+        LocalDynamicMetadataResolver mr = new LocalDynamicMetadataResolver().with {
+            it.name = 'SHIBUI-1639'
+            it.sourceDirectory = File.createTempFile('foo', null).absolutePath
+            it.dynamicMetadataResolverAttributes = new DynamicMetadataResolverAttributes()
+            it
+        }
+        when:
+        mrConverterServiceUnderTest.convertToOpenSamlRepresentation(mr)
+
+        then:
+        noExceptionThrown()
+    }
+}