protected ChainingMetadataResolver initChainingMetadataResolver(final MetadataResolver idpMetadataProvider, final MetadataResolver spMetadataProvider) { final ChainingMetadataResolver metadataManager = new ChainingMetadataResolver(); metadataManager.setId(ChainingMetadataResolver.class.getCanonicalName()); try { final List<MetadataResolver> list = new ArrayList<>(); list.add(idpMetadataProvider); list.add(spMetadataProvider); metadataManager.setResolvers(list); metadataManager.initialize(); } catch (final ResolverException e) { throw new TechnicalException("Error adding idp or sp metadatas to manager", e); } catch (final ComponentInitializationException e) { throw new TechnicalException("Error initializing manager", e); } return metadataManager; }
/** {@inheritDoc} */ @Override @Nullable public EntityDescriptor resolveSingle(@Nullable final CriteriaSet criteria) throws ResolverException { ComponentSupport.ifNotInitializedThrowUninitializedComponentException(this); final Iterable<EntityDescriptor> iterable = resolve(criteria); if (iterable != null) { final Iterator<EntityDescriptor> iterator = iterable.iterator(); if (iterator != null && iterator.hasNext()) { return iterator.next(); } } return null; }
/** * Return the resolvers to report on. * * @param rootResolver root component * * @return resolvers to report on */ @Nonnull @NonnullElements private Iterable<MetadataResolver> getMetadataResolvers( @Nonnull final MetadataResolver rootResolver) { MetadataResolver root = rootResolver; // Step down into wrapping component. if (root instanceof RelyingPartyMetadataProvider) { root = ((RelyingPartyMetadataProvider) root).getEmbeddedResolver(); } if (root instanceof ChainingMetadataResolver) { return ((ChainingMetadataResolver) root).getResolvers(); } else { return Collections.singletonList(root); } }
toProcess = rootResolver; } else if (rootResolver instanceof ChainingMetadataResolver) { for (final MetadataResolver childResolver : ((ChainingMetadataResolver) rootResolver).getResolvers()) { if (Objects.equals(id, childResolver.getId()) && (childResolver instanceof RefreshableMetadataResolver
/** * Gets chaining metadata resolver for all saml services. * * @param servicesManager the services manager * @param entityID the entity id * @param resolver the resolver * @return the chaining metadata resolver for all saml services */ @SneakyThrows @SuppressFBWarnings("PRMC_POSSIBLY_REDUNDANT_METHOD_CALLS") public static MetadataResolver getMetadataResolverForAllSamlServices(final ServicesManager servicesManager, final String entityID, final SamlRegisteredServiceCachingMetadataResolver resolver) { val registeredServices = servicesManager.findServiceBy(SamlRegisteredService.class::isInstance); val chainingMetadataResolver = new ChainingMetadataResolver(); val resolvers = registeredServices.stream() .filter(SamlRegisteredService.class::isInstance) .map(SamlRegisteredService.class::cast) .map(s -> SamlRegisteredServiceServiceProviderMetadataFacade.get(resolver, s, entityID)) .filter(Optional::isPresent) .map(Optional::get) .map(SamlRegisteredServiceServiceProviderMetadataFacade::getMetadataResolver) .collect(Collectors.toList()); LOGGER.debug("Located [{}] metadata resolvers to match against [{}]", resolvers, entityID); chainingMetadataResolver.setResolvers(resolvers); chainingMetadataResolver.setId(entityID); chainingMetadataResolver.initialize(); return chainingMetadataResolver; }
/** * Build metadata resolver aggregate. Loops through metadata resources * and attempts to resolve the metadata. * * @param entityId the entity id */ @Synchronized @SneakyThrows public void buildMetadataResolverAggregate(final String entityId) { LOGGER.debug("Building metadata resolver aggregate"); this.metadataResolver = new ChainingMetadataResolver(); val resolvers = new ArrayList<MetadataResolver>(); val entries = this.metadataResources.entrySet(); entries.forEach(entry -> { val resource = entry.getKey(); LOGGER.debug("Loading [{}]", resource.getFilename()); resolvers.addAll(loadMetadataFromResource(entry.getValue(), resource, entityId)); }); this.metadataResolver.setId(ChainingMetadataResolver.class.getCanonicalName()); this.metadataResolver.setResolvers(resolvers); LOGGER.info("Collected metadata from [{}] resolvers(s). Initializing aggregate resolver...", resolvers.size()); this.metadataResolver.initialize(); LOGGER.info("Metadata aggregate initialized successfully."); }
resolverList.addAll(resolvers); Collections.sort(resolverList); final ChainingMetadataResolver chain = new ChainingMetadataResolver(); try { chain.setResolvers(resolverList); chain.setId("MultiFileResolverFor:"+resolvers.size()+":Resources"); chain.initialize(); final RelyingPartyMetadataProvider result = new RelyingPartyMetadataProvider(); result.setEmbeddedResolver(chain);
public ChainingMetadataResolver load(final SamlRegisteredServiceCacheKey cacheKey) { val metadataResolver = new ChainingMetadataResolver(); val metadataResolvers = new ArrayList<MetadataResolver>(); + " with metadata location " + service.getMetadataLocation()); metadataResolver.setId(ChainingMetadataResolver.class.getCanonicalName()); LOGGER.trace("There are [{}] eligible metadata resolver(s) for this request", availableResolvers.size()); metadataResolver.setResolvers(metadataResolvers); metadataResolver.initialize();