diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/configuration/MetadataResolverConfiguration.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/configuration/MetadataResolverConfiguration.java index cdcd54f02..3b2eab911 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/configuration/MetadataResolverConfiguration.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/configuration/MetadataResolverConfiguration.java @@ -3,27 +3,17 @@ import edu.internet2.tier.shibboleth.admin.ui.opensaml.OpenSamlObjects; 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 net.shibboleth.utilities.java.support.component.ComponentInitializationException; import net.shibboleth.utilities.java.support.resolver.ResolverException; -import org.apache.http.HttpResponse; -import org.apache.http.impl.client.HttpClients; -import org.apache.lucene.document.Document; -import org.apache.lucene.document.Field; -import org.apache.lucene.document.StringField; -import org.apache.lucene.document.TextField; -import org.apache.lucene.index.IndexWriter; -import org.joda.time.DateTime; import org.opensaml.saml.metadata.resolver.ChainingMetadataResolver; import org.opensaml.saml.metadata.resolver.MetadataResolver; -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 org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import javax.annotation.Nullable; import java.io.IOException; import java.util.ArrayList; import java.util.List; @@ -44,6 +34,9 @@ public class MetadataResolverConfiguration { @Autowired MetadataResolverRepository metadataResolverRepository; + @Autowired + MetadataResolverConverterService metadataResolverConverterService; + @Bean public MetadataResolver metadataResolver() throws ResolverException, ComponentInitializationException { ChainingMetadataResolver metadataResolver = new ChainingMetadataResolver(); @@ -51,63 +44,14 @@ public MetadataResolver metadataResolver() throws ResolverException, ComponentIn List resolvers = new ArrayList<>(); - String incommonMRId = "incommonmd"; - // TODO: remove this later when we allow for creation of arbitrary metadata resolvers - FileBackedHTTPMetadataResolver incommonMR = new FileBackedHTTPMetadataResolver(HttpClients.createMinimal(), "http://md.incommon.org/InCommon/InCommon-metadata.xml", "/tmp/incommonmd.xml"){ - @Override - protected void initMetadataResolver() throws ComponentInitializationException { - super.initMetadataResolver(); - - IndexWriter indexWriter; - try { - indexWriter = indexWriterService.getIndexWriter(incommonMRId); - } catch (IOException e) { - throw new ComponentInitializationException(e); - } - - for (String entityId: this.getBackingStore().getIndexedDescriptors().keySet()) { - - Document document = new Document(); - document.add(new StringField("id", entityId, Field.Store.YES)); - document.add(new TextField("content", entityId, Field.Store.YES)); // TODO: change entityId to be content of entity descriptor block - try { - indexWriter.addDocument(document); - } catch (IOException e) { - logger.error(e.getMessage(), e); - } - } - try { - indexWriter.commit(); - } catch (IOException e) { - throw new ComponentInitializationException(e); - } - } - - // TODO: this is probably not the best way to do this - @Nullable - @Override - public DateTime getLastRefresh() { - return null; - } - - // TODO: this is probably not the best way to do this - @Override - protected void processConditionalRetrievalHeaders(HttpResponse response) { - // let's do nothing 'cause we want to allow a refresh + Iterable persistedResolvers = metadataResolverRepository.findAll(); + for (edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver resolver : persistedResolvers) { + try { + MetadataResolver openSamlResolver = metadataResolverConverterService.convertToOpenSamlRepresentation(resolver); + resolvers.add(openSamlResolver); + } catch (IOException e) { + //TODO: do something interesting here? } - }; - incommonMR.setId(incommonMRId); - incommonMR.setParserPool(openSamlObjects.getParserPool()); - incommonMR.setMetadataFilter(new MetadataFilterChain()); - incommonMR.initialize(); - - - resolvers.add(incommonMR); - - if (!metadataResolverRepository.findAll().iterator().hasNext()) { - edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver mr = new edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver(); - mr.setName("incommonmd"); - metadataResolverRepository.save(mr); } metadataResolver.setResolvers(resolvers); diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java index ac1339201..3c97b40f5 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/controller/MetadataResolversController.java @@ -5,13 +5,16 @@ import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolverValidationService; 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 lombok.extern.slf4j.Slf4j; import net.shibboleth.utilities.java.support.component.ComponentInitializationException; +import net.shibboleth.utilities.java.support.resolver.ResolverException; import org.apache.lucene.document.Document; import org.apache.lucene.document.Field; import org.apache.lucene.document.StringField; import org.apache.lucene.index.IndexWriter; +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,6 +39,7 @@ import java.io.IOException; import java.io.StringWriter; import java.net.URI; +import java.util.List; import static edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolverValidator.ValidationResult; @@ -56,6 +60,12 @@ public class MetadataResolversController { @Autowired IndexWriterService indexWriterService; + @Autowired + org.opensaml.saml.metadata.resolver.MetadataResolver chainingMetadataResolver; + + @Autowired + MetadataResolverConverterService metadataResolverConverterService; + @ExceptionHandler({InvalidTypeIdException.class, IOException.class, HttpMessageNotReadableException.class}) public ResponseEntity unableToParseJson(Exception ex) { return ResponseEntity.badRequest().body(new ErrorResponse(HttpStatus.BAD_REQUEST.toString(), ex.getMessage())); @@ -96,7 +106,7 @@ public ResponseEntity getOne(@PathVariable String resourceId) { @PostMapping("/MetadataResolvers") @Transactional - public ResponseEntity create(@RequestBody MetadataResolver newResolver) { + public ResponseEntity create(@RequestBody MetadataResolver newResolver) throws IOException, ResolverException { if (resolverRepository.findByName(newResolver.getName()) != null) { return ResponseEntity.status(HttpStatus.CONFLICT).build(); } @@ -110,13 +120,26 @@ public ResponseEntity create(@RequestBody MetadataResolver newResolver) { MetadataResolver persistedResolver = resolverRepository.save(newResolver); persistedResolver.updateVersion(); + updateChainingMetadataResolver(persistedResolver); + persistedResolver.convertFiltersIntoTransientRepresentationIfNecessary(); return ResponseEntity.created(getResourceUriFor(persistedResolver)).body(persistedResolver); } + private void updateChainingMetadataResolver(MetadataResolver persistedResolver) throws IOException, ResolverException { + org.opensaml.saml.metadata.resolver.MetadataResolver openSamlResolver = metadataResolverConverterService.convertToOpenSamlRepresentation(persistedResolver); + List resolverList = ((ChainingMetadataResolver) chainingMetadataResolver).getResolvers(); + for (org.opensaml.saml.metadata.resolver.MetadataResolver resolver : resolverList) { + if (resolver.getId().equals(persistedResolver.getResourceId())) { + resolverList.remove(resolver); + } + } + resolverList.add(openSamlResolver); + } + @PutMapping("/MetadataResolvers/{resourceId}") @Transactional - public ResponseEntity update(@PathVariable String resourceId, @RequestBody MetadataResolver updatedResolver) { + public ResponseEntity update(@PathVariable String resourceId, @RequestBody MetadataResolver updatedResolver) throws IOException, ResolverException { MetadataResolver existingResolver = resolverRepository.findByResourceId(resourceId); if (existingResolver == null) { return ResponseEntity.notFound().build(); @@ -140,6 +163,8 @@ public ResponseEntity update(@PathVariable String resourceId, @RequestBody Me MetadataResolver persistedResolver = resolverRepository.save(updatedResolver); persistedResolver.updateVersion(); + updateChainingMetadataResolver(persistedResolver); + return ResponseEntity.ok(persistedResolver); } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/DynamicHttpMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/DynamicHttpMetadataResolver.java index 2392c1ac3..d1b3692d2 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/DynamicHttpMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/DynamicHttpMetadataResolver.java @@ -1,32 +1,14 @@ package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers; -import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; import lombok.ToString; -import net.shibboleth.utilities.java.support.component.ComponentInitializationException; -import net.shibboleth.utilities.java.support.resolver.ResolverException; -import org.apache.http.HttpResponse; -import org.apache.http.impl.client.HttpClients; -import org.apache.lucene.document.Document; -import org.apache.lucene.document.Field; -import org.apache.lucene.document.StringField; -import org.apache.lucene.document.TextField; -import org.apache.lucene.index.IndexWriter; -import org.joda.time.DateTime; -import org.opensaml.saml.metadata.resolver.DynamicMetadataResolver; -import org.opensaml.saml.metadata.resolver.impl.FunctionDrivenDynamicHTTPMetadataResolver; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.beans.factory.annotation.Autowired; -import javax.annotation.Nullable; import javax.persistence.ElementCollection; import javax.persistence.Embedded; import javax.persistence.Entity; import javax.persistence.OrderColumn; -import java.io.IOException; import java.util.List; /** @@ -38,11 +20,6 @@ @Setter @ToString public class DynamicHttpMetadataResolver extends MetadataResolver { - private static final Logger logger = LoggerFactory.getLogger(DynamicHttpMetadataResolver.class); - - @Autowired - LuceneMetadataResolverService luceneMetadataResolverService; - public static final String DEFAULT_TIMEOUT = "PT5S"; @Embedded @@ -67,18 +44,4 @@ public DynamicHttpMetadataResolver() { this.httpMetadataResolverAttributes.setSocketTimeout(DEFAULT_TIMEOUT); this.dynamicMetadataResolverAttributes = new DynamicMetadataResolverAttributes(); } - - public FunctionDrivenDynamicHTTPMetadataResolver createOpenSamlResolver(IndexWriter indexWriter) throws ResolverException { - final String resourceId = this.getResourceId(); - - FunctionDrivenDynamicHTTPMetadataResolver openSamlResolver = new FunctionDrivenDynamicHTTPMetadataResolver(HttpClients.createMinimal()) { - @Override - protected void initMetadataResolver() throws ComponentInitializationException { - super.initMetadataResolver(); - - luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), resourceId, indexWriter); - } - }; - return openSamlResolver; - } } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FileBackedHttpMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FileBackedHttpMetadataResolver.java index d044800b0..b6d303fb3 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FileBackedHttpMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FileBackedHttpMetadataResolver.java @@ -1,30 +1,12 @@ package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers; -import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; import lombok.EqualsAndHashCode; import lombok.Getter; -import lombok.NoArgsConstructor; import lombok.Setter; import lombok.ToString; -import net.shibboleth.utilities.java.support.component.ComponentInitializationException; -import net.shibboleth.utilities.java.support.resolver.ResolverException; -import org.apache.http.HttpResponse; -import org.apache.http.impl.client.HttpClients; -import org.apache.lucene.document.Document; -import org.apache.lucene.document.Field; -import org.apache.lucene.document.StringField; -import org.apache.lucene.document.TextField; -import org.apache.lucene.index.IndexWriter; -import org.joda.time.DateTime; -import org.opensaml.saml.metadata.resolver.impl.FileBackedHTTPMetadataResolver; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.beans.factory.annotation.Autowired; -import javax.annotation.Nullable; import javax.persistence.Embedded; import javax.persistence.Entity; -import java.io.IOException; @Entity @EqualsAndHashCode(callSuper = true) @@ -32,11 +14,6 @@ @Setter @ToString public class FileBackedHttpMetadataResolver extends MetadataResolver { - private static final Logger logger = LoggerFactory.getLogger(FileBackedHttpMetadataResolver.class); - - @Autowired - LuceneMetadataResolverService luceneMetadataResolverService; - public FileBackedHttpMetadataResolver() { type = "FileBackedHttpMetadataResolver"; } @@ -55,31 +32,4 @@ public FileBackedHttpMetadataResolver() { @Embedded private HttpMetadataResolverAttributes httpMetadataResolverAttributes; - - public FileBackedHTTPMetadataResolver createOpenSamlResolver(IndexWriter indexWriter) throws ResolverException { - final String resourceId = this.getResourceId(); - - FileBackedHTTPMetadataResolver openSamlResolver = new FileBackedHTTPMetadataResolver(HttpClients.createMinimal(), this.metadataURL, this.backingFile) { - @Override - protected void initMetadataResolver() throws ComponentInitializationException { - super.initMetadataResolver(); - - luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), resourceId, indexWriter); - } - - // TODO: this is still probably not the best way to do this? - @Nullable - @Override - public DateTime getLastRefresh() { - return null; - } - - // TODO: this is still probably not the best way to do this? - @Override - protected void processConditionalRetrievalHeaders(HttpResponse response) { - // let's do nothing 'cause we want to allow a refresh - } - }; - return openSamlResolver; - } } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FilesystemMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FilesystemMetadataResolver.java index 7a081eeae..1370f0881 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FilesystemMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/FilesystemMetadataResolver.java @@ -1,28 +1,12 @@ package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers; -import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; import lombok.ToString; -import net.shibboleth.utilities.java.support.component.ComponentInitializationException; -import net.shibboleth.utilities.java.support.resolver.ResolverException; -import org.apache.http.HttpResponse; -import org.apache.lucene.document.Document; -import org.apache.lucene.document.Field; -import org.apache.lucene.document.StringField; -import org.apache.lucene.document.TextField; -import org.apache.lucene.index.IndexWriter; -import org.joda.time.DateTime; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.beans.factory.annotation.Autowired; -import javax.annotation.Nullable; import javax.persistence.Embedded; import javax.persistence.Entity; -import java.io.File; -import java.io.IOException; /** * @author Bill Smith (wsmith@unicon.net) @@ -33,11 +17,6 @@ @Setter @ToString public class FilesystemMetadataResolver extends MetadataResolver { - private static final Logger logger = LoggerFactory.getLogger(FilesystemMetadataResolver.class); - - @Autowired - LuceneMetadataResolverService luceneMetadataResolverService; - public FilesystemMetadataResolver() { type = "FilesystemMetadataResolver"; } @@ -46,27 +25,4 @@ public FilesystemMetadataResolver() { @Embedded private ReloadableMetadataResolverAttributes reloadableMetadataResolverAttributes; - - public org.opensaml.saml.metadata.resolver.impl.FilesystemMetadataResolver createOpenSamlResolver(IndexWriter indexWriter) throws ResolverException { - File metadataFile = new File(this.metadataFile); - - final String resourceId = this.getResourceId(); - - org.opensaml.saml.metadata.resolver.impl.FilesystemMetadataResolver openSamlResolver = new org.opensaml.saml.metadata.resolver.impl.FilesystemMetadataResolver(metadataFile) { - @Override - protected void initMetadataResolver() throws ComponentInitializationException { - super.initMetadataResolver(); - - luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), resourceId, indexWriter); - } - - // TODO: this is still probably not the best way to do this? - @Nullable - @Override - public DateTime getLastRefresh() { - return null; - } - }; - return openSamlResolver; - } } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/LocalDynamicMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/LocalDynamicMetadataResolver.java index 0db3dae39..20ca36251 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/LocalDynamicMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/LocalDynamicMetadataResolver.java @@ -1,28 +1,12 @@ package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers; -import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; import lombok.ToString; -import net.shibboleth.utilities.java.support.component.ComponentInitializationException; -import net.shibboleth.utilities.java.support.resolver.ResolverException; -import org.apache.lucene.document.Document; -import org.apache.lucene.document.Field; -import org.apache.lucene.document.StringField; -import org.apache.lucene.document.TextField; -import org.apache.lucene.index.IndexWriter; -import org.joda.time.DateTime; -import org.opensaml.core.xml.persist.FilesystemLoadSaveManager; -import org.opensaml.core.xml.persist.XMLObjectLoadSaveManager; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.beans.factory.annotation.Autowired; -import javax.annotation.Nullable; import javax.persistence.Embedded; import javax.persistence.Entity; -import java.io.IOException; @Entity @EqualsAndHashCode(callSuper = true) @@ -30,11 +14,6 @@ @Setter @ToString public class LocalDynamicMetadataResolver extends MetadataResolver { - private static final Logger logger = LoggerFactory.getLogger(LocalDynamicMetadataResolver.class); - - @Autowired - LuceneMetadataResolverService luceneMetadataResolverService; - public LocalDynamicMetadataResolver() { type = "LocalDynamicMetadataResolver"; } @@ -47,21 +26,4 @@ public LocalDynamicMetadataResolver() { @Embedded private DynamicMetadataResolverAttributes dynamicMetadataResolverAttributes; - - public org.opensaml.saml.metadata.resolver.impl.LocalDynamicMetadataResolver createOpenSamlResolver(IndexWriter indexWriter) throws ResolverException { - XMLObjectLoadSaveManager manager = null; - // manager = new .. what? - - final String resourceId = this.getResourceId(); - - org.opensaml.saml.metadata.resolver.impl.LocalDynamicMetadataResolver openSamlResolver = new org.opensaml.saml.metadata.resolver.impl.LocalDynamicMetadataResolver(manager) { - @Override - protected void initMetadataResolver() throws ComponentInitializationException { - super.initMetadataResolver(); - - luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), resourceId, indexWriter); - } - }; - return openSamlResolver; - } } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/ResourceBackedMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/ResourceBackedMetadataResolver.java index 5c2d9f1ac..55c833f2d 100644 --- a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/ResourceBackedMetadataResolver.java +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/ResourceBackedMetadataResolver.java @@ -1,30 +1,13 @@ package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers; -import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; import lombok.ToString; -import net.shibboleth.utilities.java.support.component.ComponentInitializationException; -import net.shibboleth.utilities.java.support.resolver.ResolverException; -import net.shibboleth.utilities.java.support.resource.Resource; -import org.apache.lucene.document.Document; -import org.apache.lucene.document.Field; -import org.apache.lucene.document.StringField; -import org.apache.lucene.document.TextField; -import org.apache.lucene.index.IndexWriter; -import org.joda.time.DateTime; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.core.io.ClassPathResource; -import javax.annotation.Nullable; import javax.persistence.Embedded; import javax.persistence.Entity; -import java.io.IOException; - import static edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ResourceBackedMetadataResolver.ResourceType.CLASSPATH; import static edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ResourceBackedMetadataResolver.ResourceType.SVN; @@ -34,15 +17,10 @@ @Setter @ToString public class ResourceBackedMetadataResolver extends MetadataResolver { - private static final Logger logger = LoggerFactory.getLogger(ResourceBackedMetadataResolver.class); - public ResourceBackedMetadataResolver() { type = "ResourceBackedMetadataResolver"; } - @Autowired - private LuceneMetadataResolverService luceneMetadataResolverService; - @Embedded private ReloadableMetadataResolverAttributes reloadableMetadataResolverAttributes; @@ -72,35 +50,4 @@ public enum ResourceType { CLASSPATH, SVN } - - public org.opensaml.saml.metadata.resolver.impl.ResourceBackedMetadataResolver createOpenSamlResolver(IndexWriter indexWriter) throws ResolverException, IOException { - ResourceType resourceType = this.validateAndDetermineResourceType(); - Resource resource = null; - switch (resourceType) { - case SVN: - // resource = new ... what? - break; - case CLASSPATH: - resource = (Resource) new ClassPathResource(this.classpathMetadataResource.getFile()); - break; - } - final String resourceId = this.getResourceId(); - - org.opensaml.saml.metadata.resolver.impl.ResourceBackedMetadataResolver openSamlResolver = new org.opensaml.saml.metadata.resolver.impl.ResourceBackedMetadataResolver(resource) { - @Override - protected void initMetadataResolver() throws ComponentInitializationException { - super.initMetadataResolver(); - - luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), resourceId, indexWriter); - } - - // TODO: this is still probably not the best way to do this? - @Nullable - @Override - public DateTime getLastRefresh() { - return null; - } - }; - return openSamlResolver; - } } diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFileBackedHTTPMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFileBackedHTTPMetadataResolver.java new file mode 100644 index 000000000..cefc6a88c --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFileBackedHTTPMetadataResolver.java @@ -0,0 +1,82 @@ +package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml; + +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FileBackedHttpMetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; +import net.shibboleth.utilities.java.support.component.ComponentInitializationException; +import net.shibboleth.utilities.java.support.resolver.ResolverException; +import org.apache.http.HttpResponse; +import org.apache.http.client.HttpClient; +import org.apache.http.impl.client.HttpClients; +import org.apache.lucene.index.IndexWriter; +import org.joda.time.DateTime; +import org.opensaml.saml.metadata.resolver.impl.FileBackedHTTPMetadataResolver; + +import javax.annotation.Nullable; +import java.util.Timer; + +/** + * @author Bill Smith (wsmith@unicon.net) + */ +public class OpenSamlFileBackedHTTPMetadataResolver extends FileBackedHTTPMetadataResolver { + private IndexWriter indexWriter; + private LuceneMetadataResolverService luceneMetadataResolverService; + private FileBackedHttpMetadataResolver sourceResolver; + + public OpenSamlFileBackedHTTPMetadataResolver(IndexWriter indexWriter, + LuceneMetadataResolverService luceneMetadataResolverService, + FileBackedHttpMetadataResolver sourceResolver) throws ResolverException { + super(HttpClients.createMinimal(), sourceResolver.getMetadataURL(), sourceResolver.getBackingFile()); + this.indexWriter = indexWriter; + this.luceneMetadataResolverService = luceneMetadataResolverService; + this.sourceResolver = sourceResolver; + //TODO: set other things from the resolver here + } + + public OpenSamlFileBackedHTTPMetadataResolver(HttpClient client, + String metadataURL, + String backupFilePath) throws ResolverException { + super(client, metadataURL, backupFilePath); + } + + public OpenSamlFileBackedHTTPMetadataResolver(Timer backgroundTaskTimer, + HttpClient client, + String metadataURL, + String backupFilePath) throws ResolverException { + super(backgroundTaskTimer, client, metadataURL, backupFilePath); + } + + // TODO: this is still probably not the best way to do this? + @Nullable + @Override + public DateTime getLastRefresh() { + return null; + } + + @Override + protected void initMetadataResolver() throws ComponentInitializationException { + super.initMetadataResolver(); + + luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), + this.sourceResolver.getResourceId(), + indexWriter); + } + + // TODO: this is still probably not the best way to do this? + @Override + protected void processConditionalRetrievalHeaders(HttpResponse response) { + // let's do nothing 'cause we want to allow a refresh + } + + public void setIndexWriter(IndexWriter indexWriter) { + + this.indexWriter = indexWriter; + } + + public void setLuceneMetadataResolverService(LuceneMetadataResolverService luceneMetadataResolverService) { + this.luceneMetadataResolverService = luceneMetadataResolverService; + } + + public void setSourceResolver(FileBackedHttpMetadataResolver sourceResolver) { + this.sourceResolver = sourceResolver; + } +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFilesystemMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFilesystemMetadataResolver.java new file mode 100644 index 000000000..4f3f778ba --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFilesystemMetadataResolver.java @@ -0,0 +1,71 @@ +package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml; + +import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; +import net.shibboleth.utilities.java.support.component.ComponentInitializationException; +import net.shibboleth.utilities.java.support.resolver.ResolverException; +import org.apache.lucene.index.IndexWriter; +import org.joda.time.DateTime; +import org.opensaml.saml.metadata.resolver.impl.FilesystemMetadataResolver; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.io.File; +import java.util.Timer; + +/** + * @author Bill Smith (wsmith@unicon.net) + */ +public class OpenSamlFilesystemMetadataResolver extends FilesystemMetadataResolver { + private IndexWriter indexWriter; + private LuceneMetadataResolverService luceneMetadataResolverService; + private edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FilesystemMetadataResolver sourceResolver; + + public OpenSamlFilesystemMetadataResolver(File metadataFile, + IndexWriter indexWriter, + LuceneMetadataResolverService luceneMetadataResolverService, + edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FilesystemMetadataResolver sourceResolver) throws ResolverException { + super(metadataFile); + this.indexWriter = indexWriter; + this.luceneMetadataResolverService = luceneMetadataResolverService; + this.sourceResolver = sourceResolver; + //TODO: set other things from the resolver here + } + + public OpenSamlFilesystemMetadataResolver(@Nonnull File metadata) throws ResolverException { + super(metadata); + } + + public OpenSamlFilesystemMetadataResolver(@Nullable Timer backgroundTaskTimer, + @Nonnull File metadata) throws ResolverException { + super(backgroundTaskTimer, metadata); + } + + // TODO: this is still probably not the best way to do this? + @Nullable + @Override + public DateTime getLastRefresh() { + return null; + } + + @Override + protected void initMetadataResolver() throws ComponentInitializationException { + super.initMetadataResolver(); + + luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), + this.sourceResolver.getResourceId(), + indexWriter); + } + + public void setIndexWriter(IndexWriter indexWriter) { + + this.indexWriter = indexWriter; + } + + public void setLuceneMetadataResolverService(LuceneMetadataResolverService luceneMetadataResolverService) { + this.luceneMetadataResolverService = luceneMetadataResolverService; + } + + public void setSourceResolver(edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FilesystemMetadataResolver sourceResolver) { + this.sourceResolver = sourceResolver; + } +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFunctionDrivenDynamicHTTPMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFunctionDrivenDynamicHTTPMetadataResolver.java new file mode 100644 index 000000000..8b4039680 --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlFunctionDrivenDynamicHTTPMetadataResolver.java @@ -0,0 +1,62 @@ +package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml; + +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicHttpMetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; +import net.shibboleth.utilities.java.support.component.ComponentInitializationException; +import org.apache.http.client.HttpClient; +import org.apache.http.impl.client.HttpClients; +import org.apache.lucene.index.IndexWriter; +import org.opensaml.saml.metadata.resolver.impl.FunctionDrivenDynamicHTTPMetadataResolver; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.Timer; + +/** + * @author Bill Smith (wsmith@unicon.net) + */ +public class OpenSamlFunctionDrivenDynamicHTTPMetadataResolver extends FunctionDrivenDynamicHTTPMetadataResolver { + private IndexWriter indexWriter; + private LuceneMetadataResolverService luceneMetadataResolverService; + private DynamicHttpMetadataResolver sourceResolver; + + public OpenSamlFunctionDrivenDynamicHTTPMetadataResolver(IndexWriter indexWriter, + LuceneMetadataResolverService luceneMetadataResolverService, + DynamicHttpMetadataResolver sourceResolver) { + super(HttpClients.createMinimal()); + this.indexWriter = indexWriter; + this.luceneMetadataResolverService = luceneMetadataResolverService; + this.sourceResolver = sourceResolver; + //TODO: set other things from the resolver here + } + + public OpenSamlFunctionDrivenDynamicHTTPMetadataResolver(HttpClient client) { + super(client); + } + + public OpenSamlFunctionDrivenDynamicHTTPMetadataResolver(@Nullable Timer backgroundTaskTimer, + @Nonnull HttpClient client) { + super(backgroundTaskTimer, client); + } + + @Override + protected void initMetadataResolver() throws ComponentInitializationException { + super.initMetadataResolver(); + + luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), + this.sourceResolver.getResourceId(), + indexWriter); + } + + public void setIndexWriter(IndexWriter indexWriter) { + this.indexWriter = indexWriter; + } + + public void setLuceneMetadataResolverService(LuceneMetadataResolverService luceneMetadataResolverService) { + this.luceneMetadataResolverService = luceneMetadataResolverService; + } + + public void setSourceResolver(DynamicHttpMetadataResolver sourceResolver) { + this.sourceResolver = sourceResolver; + } +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlLocalDynamicMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlLocalDynamicMetadataResolver.java new file mode 100644 index 000000000..0d248323d --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlLocalDynamicMetadataResolver.java @@ -0,0 +1,71 @@ +package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml; + +import com.google.common.base.Function; +import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; +import net.shibboleth.utilities.java.support.component.ComponentInitializationException; +import net.shibboleth.utilities.java.support.resolver.CriteriaSet; +import org.apache.lucene.index.IndexWriter; +import org.opensaml.core.xml.XMLObject; +import org.opensaml.core.xml.persist.XMLObjectLoadSaveManager; +import org.opensaml.saml.metadata.resolver.impl.LocalDynamicMetadataResolver; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.Timer; + +/** + * @author Bill Smith (wsmith@unicon.net) + */ +public class OpenSamlLocalDynamicMetadataResolver extends LocalDynamicMetadataResolver { + private IndexWriter indexWriter; + private LuceneMetadataResolverService luceneMetadataResolverService; + private edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.LocalDynamicMetadataResolver sourceResolver; + + public OpenSamlLocalDynamicMetadataResolver(@Nonnull XMLObjectLoadSaveManager manager, + IndexWriter indexWriter, + LuceneMetadataResolverService luceneMetadataResolverService, + edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.LocalDynamicMetadataResolver sourceResolver) { + super(manager); + this.indexWriter = indexWriter; + this.luceneMetadataResolverService = luceneMetadataResolverService; + this.sourceResolver = sourceResolver; + //TODO: set other things from the resolver here + } + + public OpenSamlLocalDynamicMetadataResolver(@Nonnull XMLObjectLoadSaveManager manager) { + super(manager); + } + + public OpenSamlLocalDynamicMetadataResolver(@Nonnull XMLObjectLoadSaveManager manager, + @Nullable Function keyGenerator) { + super(manager, keyGenerator); + } + + public OpenSamlLocalDynamicMetadataResolver(@Nullable Timer backgroundTaskTimer, + @Nonnull XMLObjectLoadSaveManager manager, + @Nullable Function keyGenerator) { + super(backgroundTaskTimer, manager, keyGenerator); + } + + @Override + protected void initMetadataResolver() throws ComponentInitializationException { + super.initMetadataResolver(); + + luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), + this.sourceResolver.getResourceId(), + indexWriter); + } + + public void setIndexWriter(IndexWriter indexWriter) { + + this.indexWriter = indexWriter; + } + + public void setLuceneMetadataResolverService(LuceneMetadataResolverService luceneMetadataResolverService) { + this.luceneMetadataResolverService = luceneMetadataResolverService; + } + + public void setSourceResolver(edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.LocalDynamicMetadataResolver sourceResolver) { + this.sourceResolver = sourceResolver; + } +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlResourceBackedMetadataResolver.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlResourceBackedMetadataResolver.java new file mode 100644 index 000000000..94921105f --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/domain/resolvers/opensaml/OpenSamlResourceBackedMetadataResolver.java @@ -0,0 +1,69 @@ +package edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml; + +import edu.internet2.tier.shibboleth.admin.ui.service.LuceneMetadataResolverService; +import net.shibboleth.utilities.java.support.component.ComponentInitializationException; +import net.shibboleth.utilities.java.support.resource.Resource; +import org.apache.lucene.index.IndexWriter; +import org.joda.time.DateTime; +import org.opensaml.saml.metadata.resolver.impl.ResourceBackedMetadataResolver; + +import javax.annotation.Nullable; +import java.io.IOException; +import java.util.Timer; + +/** + * @author Bill Smith (wsmith@unicon.net) + */ +public class OpenSamlResourceBackedMetadataResolver extends ResourceBackedMetadataResolver { + private IndexWriter indexWriter; + private LuceneMetadataResolverService luceneMetadataResolverService; + private edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ResourceBackedMetadataResolver sourceResolver; + + public OpenSamlResourceBackedMetadataResolver(Resource resource, + IndexWriter indexWriter, + LuceneMetadataResolverService luceneMetadataResolverService, + edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ResourceBackedMetadataResolver sourceResolver) throws IOException { + super(resource); + this.indexWriter = indexWriter; + this.luceneMetadataResolverService = luceneMetadataResolverService; + this.sourceResolver = sourceResolver; + //TODO: set other things from the resolver here + } + + public OpenSamlResourceBackedMetadataResolver(Timer timer, Resource resource) throws IOException { + super(timer, resource); + } + + public OpenSamlResourceBackedMetadataResolver(Resource resource) throws IOException { + super(resource); + } + + // TODO: this is still probably not the best way to do this? + @Nullable + @Override + public DateTime getLastRefresh() { + return null; + } + + @Override + protected void initMetadataResolver() throws ComponentInitializationException { + super.initMetadataResolver(); + + luceneMetadataResolverService.addIndexedDescriptorsFromBackingStore(this.getBackingStore(), + this.sourceResolver.getResourceId(), + indexWriter); + } + + public void setIndexWriter(IndexWriter indexWriter) { + + this.indexWriter = indexWriter; + } + + public void setLuceneMetadataResolverService(LuceneMetadataResolverService luceneMetadataResolverService) { + this.luceneMetadataResolverService = luceneMetadataResolverService; + } + + public void setSourceResolver(edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.ResourceBackedMetadataResolver sourceResolver) { + this.sourceResolver = sourceResolver; + } +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterService.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterService.java new file mode 100644 index 000000000..8ac04c154 --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterService.java @@ -0,0 +1,13 @@ +package edu.internet2.tier.shibboleth.admin.ui.service; + +import net.shibboleth.utilities.java.support.resolver.ResolverException; +import org.opensaml.saml.metadata.resolver.MetadataResolver; + +import java.io.IOException; + +/** + * @author Bill Smith (wsmith@unicon.net) + */ +public interface MetadataResolverConverterService { + MetadataResolver convertToOpenSamlRepresentation(edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver resolver) throws IOException, ResolverException; +} diff --git a/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterServiceImpl.java b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterServiceImpl.java new file mode 100644 index 000000000..ed8b40c8a --- /dev/null +++ b/backend/src/main/java/edu/internet2/tier/shibboleth/admin/ui/service/MetadataResolverConverterServiceImpl.java @@ -0,0 +1,106 @@ +package edu.internet2.tier.shibboleth.admin.ui.service; + +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.DynamicHttpMetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.FileBackedHttpMetadataResolver; +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.OpenSamlFileBackedHTTPMetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.OpenSamlFilesystemMetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.OpenSamlFunctionDrivenDynamicHTTPMetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.OpenSamlLocalDynamicMetadataResolver; +import edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.opensaml.OpenSamlResourceBackedMetadataResolver; +import net.shibboleth.utilities.java.support.resolver.ResolverException; +import net.shibboleth.utilities.java.support.resource.Resource; +import org.apache.lucene.index.IndexWriter; +import org.opensaml.core.xml.persist.XMLObjectLoadSaveManager; +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 java.io.File; +import java.io.IOException; + +/** + * @author Bill Smith (wsmith@unicon.net) + */ +@Service +public class MetadataResolverConverterServiceImpl implements MetadataResolverConverterService { + + @Autowired + IndexWriterService indexWriterService; + + @Autowired + LuceneMetadataResolverService luceneMetadataResolverService; + + private OpenSamlFunctionDrivenDynamicHTTPMetadataResolver convertToOpenSamlRepresentation(DynamicHttpMetadataResolver resolver) throws IOException { + IndexWriter indexWriter = indexWriterService.getIndexWriter(resolver.getResourceId()); + + return new OpenSamlFunctionDrivenDynamicHTTPMetadataResolver(indexWriter, + luceneMetadataResolverService, + resolver); + } + + private OpenSamlFileBackedHTTPMetadataResolver convertToOpenSamlRepresentation(FileBackedHttpMetadataResolver resolver) throws IOException, ResolverException { + IndexWriter indexWriter = indexWriterService.getIndexWriter(resolver.getResourceId()); + + return new OpenSamlFileBackedHTTPMetadataResolver(indexWriter, luceneMetadataResolverService, resolver); + } + + private OpenSamlFilesystemMetadataResolver convertToOpenSamlRepresentation(FilesystemMetadataResolver resolver) throws IOException, ResolverException { + IndexWriter indexWriter = indexWriterService.getIndexWriter(resolver.getResourceId()); + File metadataFile = new File(resolver.getMetadataFile()); + + return new OpenSamlFilesystemMetadataResolver(metadataFile, + indexWriter, + luceneMetadataResolverService, + resolver); + } + + private OpenSamlLocalDynamicMetadataResolver convertToOpenSamlRepresentation(LocalDynamicMetadataResolver resolver) throws IOException { + IndexWriter indexWriter = indexWriterService.getIndexWriter(resolver.getResourceId()); + XMLObjectLoadSaveManager manager = null; + //TODO: manager = new .. what? + + return new OpenSamlLocalDynamicMetadataResolver(manager, indexWriter, luceneMetadataResolverService, resolver); + } + + private OpenSamlResourceBackedMetadataResolver convertToOpenSamlRepresentation(ResourceBackedMetadataResolver resolver) throws IOException { + IndexWriter indexWriter = indexWriterService.getIndexWriter(resolver.getResourceId()); + ResourceBackedMetadataResolver.ResourceType resourceType = resolver.validateAndDetermineResourceType(); + Resource resource = null; + switch (resourceType) { + case SVN: + //TODO: resource = new ... what? + break; + case CLASSPATH: + resource = (Resource) new ClassPathResource(resolver.getClasspathMetadataResource() + .getFile()); + break; + } + + return new OpenSamlResourceBackedMetadataResolver(resource, + indexWriter, + luceneMetadataResolverService, + resolver); + } + + @Override + public MetadataResolver convertToOpenSamlRepresentation(edu.internet2.tier.shibboleth.admin.ui.domain.resolvers.MetadataResolver resolver) throws IOException, ResolverException { + switch (resolver.getType()) { + case "LocalDynamicMetadataResolver": + return convertToOpenSamlRepresentation((LocalDynamicMetadataResolver) resolver); + case "FileBackedHttpMetadataResolver": + return convertToOpenSamlRepresentation((FileBackedHttpMetadataResolver) resolver); + case "DynamicHttpMetadataResolver": + return convertToOpenSamlRepresentation((DynamicHttpMetadataResolver) resolver); + case "FilesystemMetadataResolver": + return convertToOpenSamlRepresentation((FilesystemMetadataResolver) resolver); + case "ResourceBackedMetadataResolver": + return convertToOpenSamlRepresentation((ResourceBackedMetadataResolver) resolver); + default: + throw new RuntimeException("Unsupported metadata resolver type!"); + } + } +}