Fix merge conflicts

TIER · Sep 17, 2018 · 427f509 · 427f509
2 parents 3620e0a + 497f437
commit 427f509
Show file tree

Hide file tree

Showing 18 changed files with 196 additions and 93 deletions.
diff --git a/...oovy/edu/internet2/tier/shibboleth/admin/ui/service/JPAMetadataResolverServiceImpl.groovy b/...oovy/edu/internet2/tier/shibboleth/admin/ui/service/JPAMetadataResolverServiceImpl.groovy
@@ -11,18 +11,16 @@ import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FileBackedHttpMet
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FilesystemMetadataResolver
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.LocalDynamicMetadataResolver
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ResourceBackedMetadataResolver
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.OpenSamlChainingMetadataResolver
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.Refilterable
 import edu.internet2.tier.shibboleth.admin.ui.opensaml.OpenSamlObjects
 import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository
 import groovy.util.logging.Slf4j
 import groovy.xml.DOMBuilder
 import groovy.xml.MarkupBuilder
-import net.shibboleth.utilities.java.support.logic.ScriptedPredicate
-import net.shibboleth.utilities.java.support.resolver.ResolverException
 import net.shibboleth.utilities.java.support.scripting.EvaluableScript
 import org.opensaml.saml.common.profile.logic.EntityIdPredicate
-import org.opensaml.saml.metadata.resolver.ChainingMetadataResolver
 import org.opensaml.saml.metadata.resolver.MetadataResolver
-import org.opensaml.saml.metadata.resolver.RefreshableMetadataResolver
 import org.opensaml.saml.metadata.resolver.filter.MetadataFilter
 import org.opensaml.saml.metadata.resolver.filter.MetadataFilterChain
 import org.opensaml.saml.saml2.core.Attribute
@@ -52,10 +50,10 @@ class JPAMetadataResolverServiceImpl implements MetadataResolverService {
 
     // TODO: enhance
     @Override
-    void reloadFilters(String metadataResolverName) {
-        ChainingMetadataResolver chainingMetadataResolver = (ChainingMetadataResolver) metadataResolver
-        MetadataResolver targetMetadataResolver = chainingMetadataResolver.getResolvers().find { it.id == metadataResolverName }
-        edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver jpaMetadataResolver = metadataResolverRepository.findByName(metadataResolverName)
+    void reloadFilters(String metadataResolverResourceId) {
+        OpenSamlChainingMetadataResolver chainingMetadataResolver = (OpenSamlChainingMetadataResolver) metadataResolver
+        MetadataResolver targetMetadataResolver = chainingMetadataResolver.getResolvers().find { it.id == metadataResolverResourceId }
+        edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver jpaMetadataResolver = metadataResolverRepository.findByResourceId(metadataResolverResourceId)
 
         if (targetMetadataResolver && targetMetadataResolver.getMetadataFilter() instanceof MetadataFilterChain) {
             MetadataFilterChain metadataFilterChain = (MetadataFilterChain) targetMetadataResolver.getMetadataFilter()
@@ -94,12 +92,11 @@ class JPAMetadataResolverServiceImpl implements MetadataResolverService {
             metadataFilterChain.setFilters(metadataFilters)
         }
 
-        if (metadataResolver instanceof RefreshableMetadataResolver) {
-            try {
-                ((RefreshableMetadataResolver) metadataResolver).refresh()
-            } catch (ResolverException e) {
-                log.warn("error refreshing metadataResolver " + metadataResolverName, e)
-            }
+        if (targetMetadataResolver != null && targetMetadataResolver instanceof Refilterable) {
+            (Refilterable) targetMetadataResolver.refilter()
+        } else {
+            //TODO: Do something here if we need to refilter other non-Batch resolvers
+            log.warn("Target resolver is not a Refilterable resolver. Skipping refilter()")
         }
     }
 

diff --git a/...ernet2/tier/shibboleth/admin/ui/configuration/MetadataResolverConverterConfiguration.java b/...ernet2/tier/shibboleth/admin/ui/configuration/MetadataResolverConverterConfiguration.java
@@ -0,0 +1,17 @@
+package edu.internet2.tier.shibboleth.admin.ui.configuration;
+
+import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverConverterService;
+import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverConverterServiceImpl;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * @author Bill Smith (wsmith@unicon.net)
+ */
+@Configuration
+public class MetadataResolverConverterConfiguration {
+    @Bean
+    public MetadataResolverConverterService metadataResolverConverterService() {
+        return new MetadataResolverConverterServiceImpl();
+    }
+}
diff --git a/...ain/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersController.java b/...ain/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataFiltersController.java
@@ -88,8 +88,7 @@ public ResponseEntity<?> create(@PathVariable String metadataResolverId, @Reques
         MetadataResolver persistedMr = repository.save(metadataResolver);
 
         // we reload the filters here after save
-        metadataResolverService.reloadFilters(persistedMr.getName());
-        refreshOrInitResolver(metadataResolver);
+        metadataResolverService.reloadFilters(persistedMr.getResourceId());
 
         MetadataFilter persistedFilter = newlyPersistedFilter(persistedMr.getMetadataFilters().stream(), createdFilter.getResourceId());
 
@@ -98,33 +97,6 @@ public ResponseEntity<?> create(@PathVariable String metadataResolverId, @Reques
                 .body(persistedFilter);
     }
 
-    private void refreshOrInitResolver(MetadataResolver resolver) {
-        List<org.opensaml.saml.metadata.resolver.MetadataResolver> resolvers = ((ChainingMetadataResolver) chainingMetadataResolver).getResolvers();
-        resolvers.stream().filter(it -> it.getId().equals(resolver.getResourceId())).forEach(it -> {
-            if (it instanceof RefreshableMetadataResolver) {
-                try {
-                    ((RefreshableMetadataResolver) it).refresh();
-                } catch (ResolverException e) {
-                    //TODO what should we do if we can't refresh?
-                }
-            } else if (it instanceof OpenSamlFunctionDrivenDynamicHTTPMetadataResolver) {
-                try {
-                    ((OpenSamlFunctionDrivenDynamicHTTPMetadataResolver) it).refresh();
-                } catch (ComponentInitializationException e) {
-                    //TODO what should we do if we can't refresh?
-                }
-            } else if (it instanceof OpenSamlLocalDynamicMetadataResolver) {
-                try {
-                    ((OpenSamlLocalDynamicMetadataResolver) it).refresh();
-                } catch (ComponentInitializationException e) {
-                    //TODO what should we do if we can't refresh?
-                }
-            } else {
-                //TODO we shouldn't get here, but if we do... throw exception?
-            }
-        });
-    }
-
     @PutMapping("/Filters/{resourceId}")
     public ResponseEntity<?> update(@PathVariable String metadataResolverId,
                                     @PathVariable String resourceId,
@@ -158,8 +130,7 @@ public ResponseEntity<?> update(@PathVariable String metadataResolverId,
         MetadataFilter persistedFilter = filterRepository.save(filterTobeUpdated);
 
         // TODO: this is wrong
-        metadataResolverService.reloadFilters(metadataResolver.getName());
-        refreshOrInitResolver(metadataResolver);
+        metadataResolverService.reloadFilters(metadataResolver.getResourceId());
 
         return ResponseEntity.ok().body(persistedFilter);
     }

diff --git a/...n/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java b/...n/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java
@@ -3,15 +3,16 @@
 import com.fasterxml.jackson.databind.exc.InvalidTypeIdException;
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver;
 import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolverValidationService;
+import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.OpenSamlChainingMetadataResolver;
 import edu.internet2.tier.shibboleth.admin.ui.repository.MetadataResolverRepository;
 import edu.internet2.tier.shibboleth.admin.ui.service.IndexWriterService;
 import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverConverterService;
 import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolverService;
 import edu.internet2.tier.shibboleth.admin.ui.service.MetadataResolversPositionOrderContainerService;
+import edu.internet2.tier.shibboleth.admin.util.OpenSamlChainingMetadataResolverUtil;
 import lombok.extern.slf4j.Slf4j;
 import net.shibboleth.utilities.java.support.component.ComponentInitializationException;
 import net.shibboleth.utilities.java.support.resolver.ResolverException;
-import org.opensaml.saml.metadata.resolver.ChainingMetadataResolver;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -36,7 +37,6 @@
 import java.io.IOException;
 import java.io.StringWriter;
 import java.net.URI;
-import java.util.ArrayList;
 import java.util.List;
 
 import static edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolverValidator.ValidationResult;
@@ -118,19 +118,14 @@ public ResponseEntity<?> create(@RequestBody MetadataResolver newResolver) throw
         MetadataResolver persistedResolver = resolverRepository.save(newResolver);
         positionOrderContainerService.appendPositionOrderForNew(persistedResolver);
 
-        updateChainingMetadataResolver(persistedResolver);
+        //TODO: currently, the update call might explode, but the save works.. in which case, the UI never gets
+        // n valid response. This operation is not atomic. Should we return an error here?
+        org.opensaml.saml.metadata.resolver.MetadataResolver openSamlRepresentation = metadataResolverConverterService.convertToOpenSamlRepresentation(persistedResolver);
+        OpenSamlChainingMetadataResolverUtil.updateChainingMetadataResolver((OpenSamlChainingMetadataResolver) chainingMetadataResolver, openSamlRepresentation);
 
         return ResponseEntity.created(getResourceUriFor(persistedResolver)).body(persistedResolver);
     }
 
-    private void updateChainingMetadataResolver(MetadataResolver persistedResolver) throws IOException, ResolverException, ComponentInitializationException {
-        org.opensaml.saml.metadata.resolver.MetadataResolver openSamlResolver = metadataResolverConverterService.convertToOpenSamlRepresentation(persistedResolver);
-        List<org.opensaml.saml.metadata.resolver.MetadataResolver> resolverList = new ArrayList<>(((ChainingMetadataResolver) chainingMetadataResolver).getResolvers());
-        resolverList.removeIf(resolver -> resolver.getId().equals(persistedResolver.getResourceId()));
-        resolverList.add(openSamlResolver);
-        ((ChainingMetadataResolver) chainingMetadataResolver).setResolvers(resolverList);
-    }
-
     @PutMapping("/MetadataResolvers/{resourceId}")
     @Transactional
     public ResponseEntity<?> update(@PathVariable String resourceId, @RequestBody MetadataResolver updatedResolver) throws IOException, ResolverException, ComponentInitializationException {
@@ -153,7 +148,8 @@ public ResponseEntity<?> update(@PathVariable String resourceId, @RequestBody Me
 
         MetadataResolver persistedResolver = resolverRepository.save(updatedResolver);
 
-        updateChainingMetadataResolver(persistedResolver);
+        org.opensaml.saml.metadata.resolver.MetadataResolver openSamlRepresentation = metadataResolverConverterService.convertToOpenSamlRepresentation(persistedResolver);
+        OpenSamlChainingMetadataResolverUtil.updateChainingMetadataResolver((OpenSamlChainingMetadataResolver) chainingMetadataResolver, openSamlRepresentation);
 
         return ResponseEntity.ok(persistedResolver);
     }

diff --git a/.../tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlChainingMetadataResolver.java b/.../tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlChainingMetadataResolver.java
@@ -29,7 +29,7 @@ public class OpenSamlChainingMetadataResolver extends ChainingMetadataResolver {
     @Nonnull @NonnullElements private List<MetadataResolver> mutableResolvers;
 
     public OpenSamlChainingMetadataResolver() {
-        this.mutableResolvers = Collections.emptyList();
+        this.mutableResolvers = new ArrayList<>();
     }
 
     public OpenSamlChainingMetadataResolver(@Nonnull List<MetadataResolver> mutableResolvers) {
@@ -39,7 +39,7 @@ public OpenSamlChainingMetadataResolver(@Nonnull List<MetadataResolver> mutableR
     @Override
     public void setResolvers(@Nonnull @NonnullElements final List<? extends MetadataResolver> newResolvers) {
         if (newResolvers == null || newResolvers.isEmpty()) {
-            mutableResolvers = Collections.emptyList();
+            mutableResolvers = new ArrayList<>();
             return;
         }
 
@@ -78,7 +78,7 @@ protected void doInitialize() throws ComponentInitializationException {
         super.doInitialize();
         if (mutableResolvers == null) {
             log.warn("OpenSamlChainingMetadataResolver was not configured with any member MetadataResolvers");
-            mutableResolvers = Collections.emptyList();
+            mutableResolvers = new ArrayList<>();
         }
     }
 

diff --git a/...shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFileBackedHTTPMetadataResolver.java b/...shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFileBackedHTTPMetadataResolver.java
@@ -8,7 +8,11 @@
 import org.apache.http.impl.client.HttpClients;
 import org.apache.lucene.index.IndexWriter;
 import org.joda.time.DateTime;
+import org.opensaml.saml.metadata.resolver.filter.FilterException;
+import org.opensaml.saml.metadata.resolver.filter.MetadataFilterChain;
 import org.opensaml.saml.metadata.resolver.impl.FileBackedHTTPMetadataResolver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import javax.annotation.Nullable;
 
@@ -18,7 +22,10 @@
 /**
  * @author Bill Smith (wsmith@unicon.net)
  */
-public class OpenSamlFileBackedHTTPMetadataResolver extends FileBackedHTTPMetadataResolver {
+public class OpenSamlFileBackedHTTPMetadataResolver extends FileBackedHTTPMetadataResolver implements Refilterable {
+
+    private static final Logger logger = LoggerFactory.getLogger(OpenSamlFileBackedHTTPMetadataResolver.class);
+
     private IndexWriter indexWriter;
     private FileBackedHttpMetadataResolver sourceResolver;
 
@@ -46,6 +53,8 @@ public OpenSamlFileBackedHTTPMetadataResolver(ParserPool parserPool,
 
         this.setInitializeFromBackupFile(sourceResolver.getInitializeFromBackupFile());
 
+        this.setMetadataFilter(new MetadataFilterChain());
+
         //TODO: Where does this get set in OpenSAML land?
         // sourceResolver.getMetadataURL();
     }
@@ -72,4 +81,15 @@ protected void initMetadataResolver() throws ComponentInitializationException {
                                                        this.sourceResolver.getResourceId(),
                                                        indexWriter);
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void refilter() {
+        try {
+            this.getBackingStore().setCachedFilteredMetadata(filterMetadata(getCachedOriginalMetadata()));
+        } catch (FilterException e) {
+            logger.error("An error occurred while attempting to filter metadata!", e);
+        }
+    }
 }
diff --git a/...ier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFilesystemMetadataResolver.java b/...ier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFilesystemMetadataResolver.java
@@ -5,15 +5,22 @@
 import net.shibboleth.utilities.java.support.xml.ParserPool;
 import org.apache.lucene.index.IndexWriter;
 import org.joda.time.DateTime;
+import org.opensaml.saml.metadata.resolver.filter.FilterException;
+import org.opensaml.saml.metadata.resolver.filter.MetadataFilterChain;
 import org.opensaml.saml.metadata.resolver.impl.FilesystemMetadataResolver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import javax.annotation.Nullable;
 import java.io.File;
 
 /**
  * @author Bill Smith (wsmith@unicon.net)
  */
-public class OpenSamlFilesystemMetadataResolver extends FilesystemMetadataResolver {
+public class OpenSamlFilesystemMetadataResolver extends FilesystemMetadataResolver implements Refilterable {
+
+    private static final Logger logger = LoggerFactory.getLogger(OpenSamlFilesystemMetadataResolver.class);
+
     private IndexWriter indexWriter;
     private edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FilesystemMetadataResolver sourceResolver;
     private OpenSamlMetadataResolverDelegate delegate;
@@ -31,6 +38,8 @@ public OpenSamlFilesystemMetadataResolver(ParserPool parserPool,
 
         OpenSamlMetadataResolverConstructorHelper.updateOpenSamlMetadataResolverFromReloadableMetadataResolverAttributes(
                 this, sourceResolver.getReloadableMetadataResolverAttributes(), parserPool);
+
+        this.setMetadataFilter(new MetadataFilterChain());
     }
 
     // TODO: this is still probably not the best way to do this?
@@ -48,4 +57,15 @@ protected void initMetadataResolver() throws ComponentInitializationException {
                                                        this.sourceResolver.getResourceId(),
                                                        indexWriter);
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void refilter() {
+        try {
+            this.getBackingStore().setCachedFilteredMetadata(filterMetadata(getCachedOriginalMetadata()));
+        } catch (FilterException e) {
+            logger.error("An error occurred while attempting to filter metadata!", e);
+        }
+    }
 }
diff --git a/...shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlResourceBackedMetadataResolver.java b/...shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlResourceBackedMetadataResolver.java
@@ -5,15 +5,22 @@
 import net.shibboleth.utilities.java.support.xml.ParserPool;
 import org.apache.lucene.index.IndexWriter;
 import org.joda.time.DateTime;
+import org.opensaml.saml.metadata.resolver.filter.FilterException;
+import org.opensaml.saml.metadata.resolver.filter.MetadataFilterChain;
 import org.opensaml.saml.metadata.resolver.impl.ResourceBackedMetadataResolver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import javax.annotation.Nullable;
 import java.io.IOException;
 
 /**
  * @author Bill Smith (wsmith@unicon.net)
  */
-public class OpenSamlResourceBackedMetadataResolver extends ResourceBackedMetadataResolver {
+public class OpenSamlResourceBackedMetadataResolver extends ResourceBackedMetadataResolver implements Refilterable {
+
+    private static final Logger logger = LoggerFactory.getLogger(OpenSamlResourceBackedMetadataResolver.class);
+
     private IndexWriter indexWriter;
     private edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ResourceBackedMetadataResolver sourceResolver;
     private OpenSamlMetadataResolverDelegate delegate;
@@ -31,6 +38,9 @@ public OpenSamlResourceBackedMetadataResolver(ParserPool parserPool,
 
         OpenSamlMetadataResolverConstructorHelper.updateOpenSamlMetadataResolverFromReloadableMetadataResolverAttributes(
                 this, sourceResolver.getReloadableMetadataResolverAttributes(), parserPool);
+
+        //TODO: check if this is the right thing to do
+        this.setMetadataFilter(new MetadataFilterChain());
     }
 
     // TODO: this is still probably not the best way to do this?
@@ -48,4 +58,15 @@ protected void initMetadataResolver() throws ComponentInitializationException {
                                                        this.sourceResolver.getResourceId(),
                                                        indexWriter);
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void refilter() {
+        try {
+            this.getBackingStore().setCachedFilteredMetadata(filterMetadata(getCachedOriginalMetadata()));
+        } catch (FilterException e) {
+            logger.error("An error occurred while attempting to filter metadata!", e);
+        }
+    }
 }
diff --git a/...n/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/Refilterable.java b/...n/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/Refilterable.java
@@ -0,0 +1,16 @@
+package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml;
+
+/**
+ * Indicates that the resolver implementing this interface is a resolver that allows for its metadata to be
+ * filtered multiple times.
+ *
+ * @author Bill Smith (wsmith@unicon.net)
+ */
+public interface Refilterable {
+
+    /**
+     * Reapply this resolver's filters to its cached, unfiltered metadata, and set the result back to its cached,
+     * filtered metadata.
+     */
+    void refilter();
+}
diff --git a/.../edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterServiceImpl.java b/.../edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterServiceImpl.java
@@ -33,7 +33,6 @@
 /**
  * @author Bill Smith (wsmith@unicon.net)
  */
-@Service
 public class MetadataResolverConverterServiceImpl implements MetadataResolverConverterService {
 
     @Autowired