Package org.opensaml.saml.metadata.resolver.impl

Class AbstractMetadataResolver

    • Field Detail

      • log

        private final org.slf4j.Logger log
        Class logger.

      • unmarshallerFactory

        private UnmarshallerFactory unmarshallerFactory
        Unmarshaller factory used to get an unmarshaller for the metadata DOM.

      • requireValidMetadata

        private boolean requireValidMetadata
        Whether metadata is required to be valid.

      • mdFilter

        private MetadataFilter mdFilter
        Filter applied to all metadata.

      • logPrefix

        private String logPrefix
        Logging prefix.

      • failFastInitialization

        private boolean failFastInitialization
        Whether problems during initialization should cause the provider to fail or go on without metadata. The assumption being that in most cases a provider will recover at some point in the future. Default: true.

      • parser

        private ParserPool parser
        Pool of parsers used to process XML.

      • satisfyAnyPredicates

        private boolean satisfyAnyPredicates
        Flag which determines whether predicates used in filtering are connected by a logical 'OR' (true) or by logical 'AND' (false). Defaults to false.

      • useDefaultPredicateRegistry

        private boolean useDefaultPredicateRegistry
        Flag which determines whether the default predicate registry will be used if one is not supplied explicitly. Defaults to true.

    • Constructor Detail

      • AbstractMetadataResolver

        public AbstractMetadataResolver()
        Constructor.

    • Method Detail

      • isFailFastInitialization

        public boolean isFailFastInitialization()
        Gets whether problems during initialization should cause the provider to fail or go on without metadata. The assumption being that in most cases a provider will recover at some point in the future.
        Returns:
        whether problems during initialization should cause the provider to fail

      • setFailFastInitialization

        public void setFailFastInitialization​(boolean failFast)
        Sets whether problems during initialization should cause the provider to fail or go on without metadata. The assumption being that in most cases a provider will recover at some point in the future.
        Parameters:
        failFast - whether problems during initialization should cause the provider to fail

      • getParserPool

        @Nonnull
public ParserPool getParserPool()
        Gets the pool of parsers to use to parse XML.
        Returns:
        pool of parsers to use to parse XML

      • setParserPool

        public void setParserPool​(@Nonnull
                          ParserPool pool)
        Sets the pool of parsers to use to parse XML.
        Parameters:
        pool - pool of parsers to use to parse XML

      • isSatisfyAnyPredicates

        public boolean isSatisfyAnyPredicates()
        Get the flag indicating whether resolved credentials may satisfy any predicates (i.e. connected by logical 'OR') or all predicates (connected by logical 'AND').

        Defaults to false.

        Returns:
        true if must satisfy all, false otherwise

      • setSatisfyAnyPredicates

        public void setSatisfyAnyPredicates​(boolean flag)
        Set the flag indicating whether resolved credentials may satisfy any predicates (i.e. connected by logical 'OR') or all predicates (connected by logical 'AND').

        Defaults to false.

        Parameters:
        flag - true if must satisfy all, false otherwise

      • setCriterionPredicateRegistry

        public void setCriterionPredicateRegistry​(@Nullable
                                          CriterionPredicateRegistry<EntityDescriptor> registry)
        Set the registry used in resolving predicates from criteria.
        Parameters:
        registry - the registry instance to use

      • isUseDefaultPredicateRegistry

        public boolean isUseDefaultPredicateRegistry()
        Get the flag which determines whether the default predicate registry will be used if one is not supplied explicitly.

        Defaults to true.

        Returns:
        true if should use default registry, false otherwise

      • setUseDefaultPredicateRegistry

        public void setUseDefaultPredicateRegistry​(boolean flag)
        Set the flag which determines whether the default predicate registry will be used if one is not supplied explicitly.

        Defaults to true.

        Parameters:
        flag - true if should use default registry, false otherwise

      • getUnmarshallerFactory

        protected UnmarshallerFactory getUnmarshallerFactory()
        Get the XMLObject unmarshaller factory to use.
        Returns:
        the unmarshaller factory instance to use

      • initMetadataResolver

        protected void initMetadataResolver()
                             throws ComponentInitializationException
        Subclasses should override this method to perform any initialization logic necessary. Default implementation is a no-op.
        Throws:
        ComponentInitializationException - thrown if there is a problem initializing the provider

      • unmarshallMetadata

        @Nonnull
protected XMLObject unmarshallMetadata​(@Nonnull
                                       InputStream metadataInput)
                                throws UnmarshallingException
        Unmarshalls the metadata from the given stream. The stream is closed by this method and the returned metadata released its DOM representation.
        Parameters:
        metadataInput - the input reader to the metadata.
        Returns:
        the unmarshalled metadata
        Throws:
        UnmarshallingException - thrown if the metadata can no be unmarshalled

      • filterMetadata

        @Nullable
protected XMLObject filterMetadata​(@Nullable
                                   XMLObject metadata)
                            throws FilterException
        Filters the given metadata.
        Parameters:
        metadata - the metadata to be filtered
        Returns:
        the filtered metadata
        Throws:
        FilterException - thrown if there is an error filtering the metadata

      • newFilterContext

        @Nonnull
protected MetadataFilterContext newFilterContext()
        Get a new instance of MetadataFilterContext to be used when filtering metadata.

        This default implementation will just return an empty context. Subclasses would override to add contextual info specific to the implementation.

        Returns:
        the new filter context instance

      • releaseMetadataDOM

        protected void releaseMetadataDOM​(@Nullable
                                  XMLObject metadata)
        Releases the DOM representation from the metadata object.
        Parameters:
        metadata - the metadata object

      • isValid

        protected boolean isValid​(@Nullable
                          XMLObject descriptor)
        Returns whether the given descriptor is valid. If valid metadata is not required this method always returns true.
        Parameters:
        descriptor - the descriptor to check
        Returns:
        true if valid metadata is not required or the given descriptor is valid, false otherwise

      • lookupIndexedEntityID

        @Nonnull
@NonnullElements
protected List<EntityDescriptor> lookupIndexedEntityID​(@Nonnull @NotEmpty
                                                       String entityID)
        Lookup the specified entityID from the index. The returned list will be a copy of what is stored in the backing index, and is safe to be manipulated by callers.
        Parameters:
        entityID - the entityID to lookup
        Returns:
        list copy of indexed entityID's, may be empty, will never be null

      • createNewBackingStore

        @Nonnull
protected AbstractMetadataResolver.EntityBackingStore createNewBackingStore()
        Create a new backing store instance for EntityDescriptor data. Subclasses may override to return a more specialized subclass type. Note this method does not make the returned backing store the effective one in use. The caller is responsible for calling setBackingStore(EntityBackingStore) to make it the effective instance in use.
        Returns:
        the new backing store instance

      • getBackingStore

        @Nonnull
protected AbstractMetadataResolver.EntityBackingStore getBackingStore()
        Get the EntityDescriptor backing store currently in use by the metadata resolver.
        Returns:
        the current effective entity backing store

      • setBackingStore

        protected void setBackingStore​(@Nonnull
                               AbstractMetadataResolver.EntityBackingStore newBackingStore)
        Set the EntityDescriptor backing store currently in use by the metadata resolver.
        Parameters:
        newBackingStore - the new entity backing store

      • preProcessEntityDescriptor

        protected void preProcessEntityDescriptor​(@Nonnull
                                          EntityDescriptor entityDescriptor,
                                          @Nonnull
                                          AbstractMetadataResolver.EntityBackingStore backingStore)
        Pre-process the specified entity descriptor, updating the specified entity backing store instance as necessary.
        Parameters:
        entityDescriptor - the target entity descriptor to process
        backingStore - the backing store instance to update

      • removeByEntityID

        protected void removeByEntityID​(@Nonnull
                                String entityID,
                                @Nonnull
                                AbstractMetadataResolver.EntityBackingStore backingStore)
        Remove from the backing store all metadata for the entity with the given entity ID.
        Parameters:
        entityID - the entity ID of the metadata to remove
        backingStore - the backing store instance to update

      • indexEntityDescriptor

        protected void indexEntityDescriptor​(@Nonnull
                                     EntityDescriptor entityDescriptor,
                                     @Nonnull
                                     AbstractMetadataResolver.EntityBackingStore backingStore)
        Index the specified entity descriptor, updating the specified entity backing store instance as necessary.
        Parameters:
        entityDescriptor - the target entity descriptor to process
        backingStore - the backing store instance to update

      • preProcessEntitiesDescriptor

        protected void preProcessEntitiesDescriptor​(@Nonnull
                                            EntitiesDescriptor entitiesDescriptor,
                                            AbstractMetadataResolver.EntityBackingStore backingStore)
        Pre-process the specified entities descriptor, updating the specified entity backing store instance as necessary.
        Parameters:
        entitiesDescriptor - the target entities descriptor to process
        backingStore - the backing store instance to update

      • predicateFilterCandidates

        protected Iterable<EntityDescriptor> predicateFilterCandidates​(@Nonnull
                                                               Iterable<EntityDescriptor> candidates,
                                                               @Nonnull
                                                               CriteriaSet criteria,
                                                               boolean onEmptyPredicatesReturnEmpty)
                                                        throws ResolverException
        Filter the supplied candidates by resolving predicates from the supplied criteria and applying the predicates to return a filtered Iterable.
        Parameters:
        candidates - the candidates to evaluate
        criteria - the criteria set to evaluate
        onEmptyPredicatesReturnEmpty - if true and no predicates are supplied, then return an empty iterable; otherwise return the original input candidates
        Returns:
        an iterable of the candidates filtered by the resolved predicates
        Throws:
        ResolverException - if there is a fatal error during resolution

      • getLogPrefix

        @Nonnull
@NotEmpty
protected String getLogPrefix()
        Return a prefix for logging messages for this component.
        Returns:
        a string for insertion at the beginning of any log messages