/** {@inheritDoc} */ @Override public EntityDescriptor resolveSingle(@Nullable final CriteriaSet criteria) throws ResolverException { ComponentSupport.ifNotInitializedThrowUninitializedComponentException(this); EntityDescriptor metadata = null; for (final MetadataResolver resolver : resolvers) { metadata = resolver.resolveSingle(criteria); if (metadata != null) { return metadata; } } return null; }
/** * Proceed to the next composed resolvers that has a response to the resolution query. */ private void proceedToNextResolverIterator() { try { while (resolverIterator.hasNext()) { currentResolver = resolverIterator.next(); currentResolverMetadataIterator = currentResolver.resolve(criteria).iterator(); if (currentResolverMetadataIterator.hasNext()) { return; } } } catch (final ResolverException e) { log.debug("Error encountered attempting to fetch results from resolver", e); } } }
@Override public MetadataResolver resolve(final SamlRegisteredService service) { LOGGER.debug("Resolving metadata for [{}] at [{}].", service.getName(), service.getMetadataLocation()); val k = new SamlRegisteredServiceCacheKey(service); LOGGER.trace("Locating cached metadata resolver using key [{}] for service [{}]", k.getId(), service.getName()); val resolver = this.cache.get(k); LOGGER.debug("Loaded and cached SAML metadata [{}] from [{}]", resolver.getId(), service.getMetadataLocation()); return resolver; } }
final MetadataFilter filter = resolver.getMetadataFilter(); if (filter != null) { if (filter instanceof NodeProcessingMetadataFilter) { resolver.setMetadataFilter(filterToAttach); } else if (filter instanceof MetadataFilterChain) { ((MetadataFilterChain) filter).getFilters().add(filterToAttach); final MetadataFilterChain chain = new MetadataFilterChain(); chain.setFilters(Arrays.asList(filter, filterToAttach)); resolver.setMetadataFilter(chain);
/** {@inheritDoc} */ @Override public MetadataFilter getMetadataFilter() { ComponentSupport.ifNotInitializedThrowUninitializedComponentException(this); ServiceableComponent<MetadataResolver> component = null; try { component = service.getServiceableComponent(); if (null == component) { log.error("RelyingPartyMetadataProvider '{}': Error accessing underlying metadata source: " + "Invalid configuration.", getId()); } else { final MetadataResolver resolver = component.getComponent(); return resolver.getMetadataFilter(); } } finally { if (null != component) { component.unpinComponent(); } } throw new IllegalAccessError("Could not find a valid MetadataResolver"); }
/** {@inheritDoc} */ @Override public boolean isRequireValidMetadata() { ComponentSupport.ifNotInitializedThrowUninitializedComponentException(this); ServiceableComponent<MetadataResolver> component = null; try { component = service.getServiceableComponent(); if (null == component) { log.error("RelyingPartyMetadataProvider '{}': Error accessing underlying metadata source: " + "Invalid configuration.", getId()); } else { final MetadataResolver resolver = component.getComponent(); return resolver.isRequireValidMetadata(); } } finally { if (null != component) { component.unpinComponent(); } } throw new IllegalAccessError("Could not find a valid MetadataResolver"); }
public Map<String,DateTime> getValue() { final Builder mapBuilder = ImmutableMap.<String,DateTime>builder(); final ServiceableComponent<MetadataResolver> component = getService().getServiceableComponent(); if (component != null) { try { for (final MetadataResolver resolver : getMetadataResolvers(component.getComponent())) { if (resolver instanceof RefreshableMetadataResolver && ((RefreshableMetadataResolver) resolver).getLastUpdate() != null) { mapBuilder.put(resolver.getId(), ((RefreshableMetadataResolver) resolver).getLastUpdate()); } } } finally { component.unpinComponent(); } } return mapBuilder.build(); } });
/** * Resolve an entity descriptor based on entityID using the wrapped metadata resolver. * * @param entityID the entityID of the EntityDescriptor to resolve. * @return the resolved EntityDescriptor, or null if not found * @throws ResolverException if there is a problem resolving the EntityDescriptor */ protected EntityDescriptor doGetEntityDescriptor(final String entityID) throws ResolverException { //TODO should perhaps pass through the entire original CriteriaSet return entityDescriptorResolver.resolveSingle(new CriteriaSet(new EntityIdCriterion(entityID))); }
/** {@inheritDoc} */ @Override @Nonnull public Iterable<EntityDescriptor> resolve(@Nullable final CriteriaSet criteria) throws ResolverException { ComponentSupport.ifNotInitializedThrowUninitializedComponentException(this); for (final MetadataResolver resolver : resolvers) { try { final Iterable<EntityDescriptor> descriptors = resolver.resolve(criteria); if (descriptors != null && descriptors.iterator().hasNext()) { return descriptors; } } catch (final ResolverException e) { log.warn("Error retrieving metadata from resolver of type {}, proceeding to next resolver", resolver.getClass().getName(), e); continue; } } return Collections.emptyList(); }
public Map<String,DateTime> getValue() { final Builder mapBuilder = ImmutableMap.<String,DateTime>builder(); final ServiceableComponent<MetadataResolver> component = getService().getServiceableComponent(); if (component != null) { try { for (final MetadataResolver resolver : getMetadataResolvers(component.getComponent())) { if (resolver instanceof RefreshableMetadataResolver && ((RefreshableMetadataResolver) resolver).getLastRefresh() != null) { mapBuilder.put(resolver.getId(), ((RefreshableMetadataResolver) resolver).getLastRefresh()); } } } finally { component.unpinComponent(); } } return mapBuilder.build(); } });
@SneakyThrows private static Optional<SamlRegisteredServiceServiceProviderMetadataFacade> get(final SamlRegisteredServiceCachingMetadataResolver resolver, final SamlRegisteredService registeredService, final String entityID, final CriteriaSet criterions) { LOGGER.debug("Adapting SAML metadata for CAS service [{}] issued by [{}]", registeredService.getName(), entityID); criterions.add(new EntityIdCriterion(entityID), true); LOGGER.debug("Locating metadata for entityID [{}] by attempting to run through the metadata chain...", entityID); val chainingMetadataResolver = resolver.resolve(registeredService); LOGGER.info("Resolved metadata chain for service [{}]. Filtering the chain by entity ID [{}]", registeredService.getServiceId(), entityID); val entityDescriptor = chainingMetadataResolver.resolveSingle(criterions); if (entityDescriptor == null) { LOGGER.warn("Cannot find entity [{}] in metadata provider Ensure the metadata is valid and has not expired.", entityID); return Optional.empty(); } LOGGER.trace("Located entity descriptor in metadata for [{}]", entityID); if (entityDescriptor.getValidUntil() != null && entityDescriptor.getValidUntil().isBeforeNow()) { LOGGER.warn("Entity descriptor in the metadata has expired at [{}]", entityDescriptor.getValidUntil()); return Optional.empty(); } return getServiceProviderSsoDescriptor(entityID, chainingMetadataResolver, entityDescriptor); }
@Nullable @Override public Service lookup(final @Nonnull String serviceURL) { try { final List<EntityDescriptor> entities = Lists.newArrayList(metadataResolver.resolve(criteria(serviceURL))); if (entities.size() > 1) { throw new ResolverException("Multiple results found"); } else if (entities.size() == 1) { return create(serviceURL, entities.get(0)); } } catch (final ResolverException e) { log.warn("Metadata resolution failed for {}", serviceURL, e); } return null; }
@Override protected void buildEntityCriteriaForSigningCredential(final RequestAbstractType profileRequest, final CriteriaSet criteriaSet) { criteriaSet.add(new EntityIdCriterion(casSamlIdPMetadataResolver.getId())); criteriaSet.add(new EntityRoleCriterion(IDPSSODescriptor.DEFAULT_ELEMENT_NAME)); } }
metadataResolver.resolveSingle(new CriteriaSet(new EntityIdCriterion(spNameQualifier))); if (affiliation != null) { final AffiliationDescriptor descriptor = affiliation.getAffiliationDescriptor();
ComponentSupport.ifNotInitializedThrowUninitializedComponentException(this); final Iterable<EntityDescriptor> entityDescriptorsSource = entityDescriptorResolver.resolve(criteria); if (!entityDescriptorsSource.iterator().hasNext()) { log.debug("Resolved no EntityDescriptors via underlying MetadataResolver, returning empty collection");
public Map<String,DateTime> getValue() { final Builder mapBuilder = ImmutableMap.<String,DateTime>builder(); final ServiceableComponent<MetadataResolver> component = getService().getServiceableComponent(); if (component != null) { try { for (final MetadataResolver resolver : getMetadataResolvers(component.getComponent())) { if (resolver instanceof ExtendedBatchMetadataResolver && ((ExtendedBatchMetadataResolver) resolver).getRootValidUntil() != null) { mapBuilder.put(resolver.getId(), ((ExtendedBatchMetadataResolver) resolver).getRootValidUntil()); } } } finally { component.unpinComponent(); } } return mapBuilder.build(); } });
/** {@inheritDoc} */ @Override @Nullable public EntityDescriptor resolveSingle(final CriteriaSet criteria) throws ResolverException { ComponentSupport.ifNotInitializedThrowUninitializedComponentException(this); ServiceableComponent<MetadataResolver> component = null; try { component = service.getServiceableComponent(); if (null == component) { log.error("RelyingPartyMetadataProvider '{}': Error accessing underlying metadata source: " + "Invalid configuration.", getId()); } else { final MetadataResolver resolver = component.getComponent(); return resolver.resolveSingle(criteria); } } catch (final ResolverException e) { log.error("RelyingPartyResolver '{}': Error during resolution", getId(), e); } finally { if (null != component) { component.unpinComponent(); } } return null; }
/** {@inheritDoc} */ @Override @Nonnull public Iterable<EntityDescriptor> resolve(final CriteriaSet criteria) throws ResolverException { ComponentSupport.ifNotInitializedThrowUninitializedComponentException(this); ServiceableComponent<MetadataResolver> component = null; try { component = service.getServiceableComponent(); if (null == component) { log.error("RelyingPartyMetadataProvider '{}': Error accessing underlying metadata source: " + "Invalid configuration.", getId()); } else { final MetadataResolver resolver = component.getComponent(); return resolver.resolve(criteria); } } catch (final ResolverException e) { log.error("RelyingPartyMetadataProvider '{}': Error during resolution", getId(), e); } finally { if (null != component) { component.unpinComponent(); } } return Collections.EMPTY_SET; }
public Map<String,DateTime> getValue() { final Builder mapBuilder = ImmutableMap.<String,DateTime>builder(); final ServiceableComponent<MetadataResolver> component = getService().getServiceableComponent(); if (component != null) { try { for (final MetadataResolver resolver : getMetadataResolvers(component.getComponent())) { if (resolver instanceof ExtendedRefreshableMetadataResolver && ((ExtendedRefreshableMetadataResolver) resolver) .getLastSuccessfulRefresh() != null) { mapBuilder.put(resolver.getId(), ((ExtendedRefreshableMetadataResolver) resolver) .getLastSuccessfulRefresh()); } } } finally { component.unpinComponent(); } } return mapBuilder.build(); } });
@Override public final XMLObject getEntityDescriptorElement() { try { return resolve().resolveSingle(new CriteriaSet(new EntityIdCriterion(this.idpEntityId))); } catch (final ResolverException e) { throw new SAMLException("Error initializing idpMetadataProvider", e); } } }