AbstractDynamicMetadataResolver (OpenSAML :: SAML Provider Implementations 3.4.2 API)

java.lang.Object
- net.shibboleth.utilities.java.support.component.AbstractInitializableComponent
- - net.shibboleth.utilities.java.support.component.AbstractIdentifiedInitializableComponent
  - - net.shibboleth.utilities.java.support.component.AbstractIdentifiableInitializableComponent
    - - org.opensaml.saml.metadata.resolver.impl.AbstractMetadataResolver
      - org.opensaml.saml.metadata.resolver.impl.AbstractDynamicMetadataResolver

All Implemented Interfaces:

Component, DestructableComponent, IdentifiableComponent, IdentifiedComponent, InitializableComponent, Resolver<EntityDescriptor,CriteriaSet>, ClearableMetadataResolver, DynamicMetadataResolver, MetadataResolver

Direct Known Subclasses:

AbstractDynamicHTTPMetadataResolver, LocalDynamicMetadataResolver
```
public abstract class AbstractDynamicMetadataResolver
extends AbstractMetadataResolver
implements DynamicMetadataResolver, ClearableMetadataResolver
```
Abstract subclass for metadata resolvers that resolve metadata dynamically, as needed and on demand.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`AbstractDynamicMetadataResolver.BackingStoreCleanupSweeper` Background maintenance task which cleans expired and idle metadata from the backing store, and removes orphaned entity management data.
`static class`	`AbstractDynamicMetadataResolver.DefaultCacheKeyGenerator` Default function for generating a cache key for loading and saving an `EntityDescriptor` using a `XMLObjectLoadSaveManager`.
`protected class`	`AbstractDynamicMetadataResolver.DynamicEntityBackingStore` Specialized entity backing store implementation for dynamic metadata resolvers.
`protected class`	`AbstractDynamicMetadataResolver.EntityManagementData` Class holding per-entity management data.
`static class`	`AbstractDynamicMetadataResolver.PersistentCacheInitializationMetrics` Class used to track metrics related to the initialization from the persistent cache.

Nested classes/interfaces inherited from class org.opensaml.saml.metadata.resolver.impl.AbstractMetadataResolver
AbstractMetadataResolver.EntityBackingStore

Field Summary

Fields
Modifier and Type	Field and Description
`private Long`	`backgroundInitializationFromCacheDelay` The delay in milliseconds after which to schedule the background initialization from the persistent cache.
`private AbstractDynamicMetadataResolver.BackingStoreCleanupSweeper`	`cleanupTask` The backing store cleanup sweeper background task.
`private Long`	`cleanupTaskInterval` The interval in milliseconds at which the cleanup task should run.
`private boolean`	`createdOwnTaskTimer` Whether we created our own task timer during object construction.
`private Long`	`expirationWarningThreshold` Impending expiration warning threshold for metadata refresh, in milliseconds.
`private com.codahale.metrics.Gauge<Integer>`	`gaugeNumLiveEntityIDs` Metrics Gauge for the number of live entityIDs.
`private com.codahale.metrics.Gauge<AbstractDynamicMetadataResolver.PersistentCacheInitializationMetrics>`	`gaugePersistentCacheInit` Metrics Gauge for the persistent cache initialization.
`private Set<MetadataIndex>`	`indexes` The set of indexes configured.
`private com.google.common.base.Predicate<EntityDescriptor>`	`initializationFromCachePredicate` Predicate which determines whether a given entity should be loaded from the persistent cache at resolver initialization time.
`private boolean`	`initializeFromPersistentCacheInBackground` Flag indicating whether should initialize from the persistent cache in the background.
`private boolean`	`initializing` Flag used to track state of whether currently initializing or not.
`private org.slf4j.Logger`	`log` Class logger.
`private Long`	`maxCacheDuration` Maximum cache duration.
`private Long`	`maxIdleEntityData` The maximum idle time in milliseconds for which the resolver will keep data for a given entityID, before it is removed.
`static String`	`METRIC_GAUGE_NUM_LIVE_ENTITYIDS` Metric name for the gauge of the number of live entityIDs.
`static String`	`METRIC_GAUGE_PERSISTENT_CACHE_INIT` Metric name for the gauge of the persistent cache initialization metrics.
`static String`	`METRIC_RATIOGAUGE_FETCH_TO_RESOLVE` Metric name for the ratio gauge of fetches to resolve requests.
`static String`	`METRIC_TIMER_FETCH_FROM_ORIGIN_SOURCE` Metric name for the timer for `fetchFromOriginSource(CriteriaSet)`.
`static String`	`METRIC_TIMER_RESOLVE` Metric name for the timer for `resolve(CriteriaSet)`.
`private String`	`metricsBaseName` Base name for Metrics instrumentation names.
`private Long`	`minCacheDuration` Minimum cache duration.
`private Long`	`negativeLookupCacheDuration` Negative lookup cache duration.
`private AbstractDynamicMetadataResolver.PersistentCacheInitializationMetrics`	`persistentCacheInitMetrics` Object tracking metrics related to the persistent cache initialization.
`private com.google.common.base.Function<EntityDescriptor,String>`	`persistentCacheKeyGenerator` Function for generating the String key used with the cache manager.
`private org.opensaml.core.xml.persist.XMLObjectLoadSaveManager<EntityDescriptor>`	`persistentCacheManager` The manager for the persistent cache store for resolved metadata.
`private com.codahale.metrics.RatioGauge`	`ratioGaugeFetchToResolve` Metrics RatioGauge for count of origin fetches to resolves.
`private Float`	`refreshDelayFactor` Factor used to compute when the next refresh interval will occur.
`private boolean`	`removeIdleEntityData` Flag indicating whether idle entity data should be removed.
`private Timer`	`taskTimer` Timer used to schedule background metadata update tasks.
`private com.codahale.metrics.Timer`	`timerFetchFromOriginSource` Metrics Timer for `fetchFromOriginSource(CriteriaSet)`.
`private com.codahale.metrics.Timer`	`timerResolve` Metrics Timer for `resolve(CriteriaSet)`.

Constructor Summary

Constructors
Constructor and Description

AbstractDynamicMetadataResolver(Timer backgroundTaskTimer)
Constructor.

Constructors
Constructor and Description
`AbstractDynamicMetadataResolver(Timer backgroundTaskTimer)` Constructor.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`clear()`
`void`	`clear(String entityID)`
`protected org.joda.time.DateTime`	`computeExpirationTime(EntityDescriptor entityDescriptor, org.joda.time.DateTime now)` Compute the effective expiration time for the specified metadata.
`protected org.joda.time.DateTime`	`computeRefreshTriggerTime(org.joda.time.DateTime expirationTime, org.joda.time.DateTime nowDateTime)` Compute the refresh trigger time.
`protected AbstractDynamicMetadataResolver.DynamicEntityBackingStore`	`createNewBackingStore()` Create a new backing store instance for EntityDescriptor data.
`protected void`	`doDestroy()`
`protected abstract org.opensaml.core.xml.XMLObject`	`fetchFromOriginSource(CriteriaSet criteria)` Fetch the metadata from the origin source.
`Long`	`getBackgroundInitializationFromCacheDelay()` Get the delay in milliseconds after which to schedule the background initialization from the persistent cache.
`protected AbstractDynamicMetadataResolver.DynamicEntityBackingStore`	`getBackingStore()` Get the EntityDescriptor backing store currently in use by the metadata resolver.
`Long`	`getCleanupTaskInterval()` Get the interval in milliseconds at which the cleanup task should run.
`Long`	`getExpirationWarningThreshold()` Gets the impending expiration warning threshold used at refresh time.
`Set<MetadataIndex>`	`getIndexes()` Get the configured indexes.
`com.google.common.base.Predicate<EntityDescriptor>`	`getInitializationFromCachePredicate()` Get the predicate which determines whether a given entity should be loaded from the persistent cache at resolver initialization time.
`Long`	`getMaxCacheDuration()` Get the maximum cache duration for metadata.
`Long`	`getMaxIdleEntityData()` Get the maximum idle time in milliseconds for which the resolver will keep data for a given entityID, before it is removed.
`String`	`getMetricsBaseName()` Get the base name for Metrics instrumentation.
`Long`	`getMinCacheDuration()` Get the minimum cache duration for metadata.
`Long`	`getNegativeLookupCacheDuration()` Get the negative lookup cache duration for metadata.
`com.google.common.base.Function<EntityDescriptor,String>`	`getPersistentCacheKeyGenerator()` Get the function for generating the String key used with the persistent cache manager.
`org.opensaml.core.xml.persist.XMLObjectLoadSaveManager<EntityDescriptor>`	`getPersistentCacheManager()` Get the manager for the persistent cache store for resolved metadata.
`Float`	`getRefreshDelayFactor()` Gets the delay factor used to compute the next refresh time.
`protected void`	`indexEntityDescriptor(EntityDescriptor entityDescriptor, AbstractMetadataResolver.EntityBackingStore backingStore)` Index the specified entity descriptor, updating the specified entity backing store instance as necessary.
`protected boolean`	`indexesEnabled()` Return whether secondary indexing is effectively active.
`protected void`	`initializeFromPersistentCache()` Initialize the resolver with data from the persistent cache manager, if enabled.
`private void`	`initializeMetricsInstrumentation()` Initialize the Metrics-based instrumentation.
`protected void`	`initMetadataResolver()` Subclasses should override this method to perform any initialization logic necessary.
`boolean`	`isInitializeFromPersistentCacheInBackground()` Get the flag indicating whether should initialize from the persistent cache in the background.
`boolean`	`isPersistentCachingEnabled()` Get the flag indicating whether persistent caching of the resolved metadata is enabled.
`boolean`	`isRemoveIdleEntityData()` Get the flag indicating whether idle entity data should be removed.
`private void`	`logMetadataExpiration(EntityDescriptor descriptor, org.joda.time.DateTime now, org.joda.time.DateTime nextRefresh)` Check metadata for expiration or pending expiration and log appropriately.
`protected Iterable<EntityDescriptor>`	`lookupCriteria(CriteriaSet criteria)` Lookup and return all EntityDescriptors currently available in the resolver cache which match either entityID or secondary-indexed criteria.
`protected List<EntityDescriptor>`	`lookupEntityID(String entityID)` Get list of descriptors matching an entityID.
`protected org.opensaml.core.xml.XMLObject`	`prepareForFiltering(org.opensaml.core.xml.XMLObject input)` Prepare the object for filtering: If persistent caching is enabled, return a clone of the object in case the configured filter mutates the object.
`protected void`	`preProcessEntityDescriptor(EntityDescriptor entityDescriptor, AbstractMetadataResolver.EntityBackingStore backingStore)` Pre-process the specified entity descriptor, updating the specified entity backing store instance as necessary.
`protected void`	`processNewMetadata(org.opensaml.core.xml.XMLObject root, String expectedEntityID)` Process the specified new metadata document, including metadata filtering, and store the processed metadata in the backing store.
`protected void`	`processNewMetadata(org.opensaml.core.xml.XMLObject root, String expectedEntityID, boolean fromPersistentCache)` Process the specified new metadata document, including metadata filtering, and store the processed metadata in the backing store.
`protected List<EntityDescriptor>`	`processNonEntityIDFetchedEntittiesDescriptor(EntitiesDescriptor entities)` Process an EntitiesDescriptor received from a non-entityID-based fetch.
`protected List<EntityDescriptor>`	`processNonEntityIDFetchedEntityDescriptor(EntityDescriptor entity)` Process an EntityDescriptor received from a non-entityID-based fetch.
`protected void`	`processPersistentCacheEntry(String currentKey, EntityDescriptor descriptor)` Process an entry loaded from the persistent cache.
`protected void`	`removeByEntityID(String entityID, AbstractMetadataResolver.EntityBackingStore backingStore)` Remove from the backing store all metadata for the entity with the given entity ID.
`Iterable<EntityDescriptor>`	`resolve(CriteriaSet criteria)`
`protected String`	`resolveEntityID(CriteriaSet criteria)` Attempt to resolve the single entityID for the operation from the criteria set.
`protected Set<String>`	`resolveEntityIDs(CriteriaSet criteria)` Attempt to resolve all the entityIDs represented by the criteria set.
`protected Iterable<EntityDescriptor>`	`resolveFromOriginSource(CriteriaSet criteria)` Deprecated. instead use `resolveFromOriginSource(CriteriaSet, String)`
`protected Iterable<EntityDescriptor>`	`resolveFromOriginSource(CriteriaSet criteria, String entityID)` Fetch metadata from an origin source based on the input criteria, store it in the backing store and then return it.
`protected Iterable<EntityDescriptor>`	`resolveFromOriginSourceWithEntityID(CriteriaSet criteria, String entityID)` Fetch metadata from an origin source based on the input criteria when the entityID is known, store it in the backing store and then return it.
`protected Iterable<EntityDescriptor>`	`resolveFromOriginSourceWithoutEntityID(CriteriaSet criteria)` Fetch metadata from an origin source based on the input criteria when the entityID is not known, store it in the backing store and then return it.
`void`	`setBackgroundInitializationFromCacheDelay(Long delay)` Set the delay in milliseconds after which to schedule the background initialization from the persistent cache.
`void`	`setCleanupTaskInterval(Long interval)` Set the interval in milliseconds at which the cleanup task should run.
`void`	`setExpirationWarningThreshold(Long threshold)` Sets the impending expiration warning threshold used at refresh time.
`void`	`setIndexes(Set<MetadataIndex> newIndexes)` Set the configured indexes.
`void`	`setInitializationFromCachePredicate(com.google.common.base.Predicate<EntityDescriptor> predicate)` Set the predicate which determines whether a given entity should be loaded from the persistent cache at resolver initialization time.
`void`	`setInitializeFromPersistentCacheInBackground(boolean flag)` Set the flag indicating whether should initialize from the persistent cache in the background.
`void`	`setMaxCacheDuration(Long duration)` Set the maximum cache duration for metadata.
`void`	`setMaxIdleEntityData(Long max)` Set the maximum idle time in milliseconds for which the resolver will keep data for a given entityID, before it is removed.
`void`	`setMetricsBaseName(String baseName)` Set the base name for Metrics instrumentation.
`void`	`setMinCacheDuration(Long duration)` Set the minimum cache duration for metadata.
`void`	`setNegativeLookupCacheDuration(Long duration)` Set the negative lookup cache duration for metadata.
`void`	`setPersistentCacheKeyGenerator(com.google.common.base.Function<EntityDescriptor,String> generator)` Set the function for generating the String key used with the persistent cache manager.
`void`	`setPersistentCacheManager(org.opensaml.core.xml.persist.XMLObjectLoadSaveManager<EntityDescriptor> manager)` Set the manager for the persistent cache store for resolved metadata.
`void`	`setRefreshDelayFactor(Float factor)` Sets the delay factor used to compute the next refresh time.
`void`	`setRemoveIdleEntityData(boolean flag)` Set the flag indicating whether idle entity data should be removed.
`protected boolean`	`shouldAttemptRefresh(AbstractDynamicMetadataResolver.EntityManagementData mgmtData)` Determine whether should attempt to refresh the metadata, based on stored refresh trigger time.

Methods inherited from class net.shibboleth.utilities.java.support.component.AbstractIdentifiableInitializableComponent
setId

Methods inherited from class net.shibboleth.utilities.java.support.component.AbstractIdentifiedInitializableComponent
getId

Methods inherited from class net.shibboleth.utilities.java.support.component.AbstractInitializableComponent
destroy, initialize, isDestroyed, isInitialized

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.opensaml.saml.metadata.resolver.MetadataResolver
getMetadataFilter, isRequireValidMetadata, setMetadataFilter, setRequireValidMetadata

Methods inherited from interface net.shibboleth.utilities.java.support.resolver.Resolver
resolveSingle

Methods inherited from interface net.shibboleth.utilities.java.support.component.IdentifiedComponent
getId

- Field Detail
  - METRIC_TIMER_FETCH_FROM_ORIGIN_SOURCE
```
public static final String METRIC_TIMER_FETCH_FROM_ORIGIN_SOURCE
```
    Metric name for the timer for fetchFromOriginSource(CriteriaSet).
    
    See Also:
    
    Constant Field Values
  - METRIC_TIMER_RESOLVE
```
public static final String METRIC_TIMER_RESOLVE
```
    Metric name for the timer for resolve(CriteriaSet).
    
    See Also:
    
    Constant Field Values
  - METRIC_RATIOGAUGE_FETCH_TO_RESOLVE
```
public static final String METRIC_RATIOGAUGE_FETCH_TO_RESOLVE
```
    Metric name for the ratio gauge of fetches to resolve requests.
    
    See Also:
    
    Constant Field Values
  - METRIC_GAUGE_NUM_LIVE_ENTITYIDS
```
public static final String METRIC_GAUGE_NUM_LIVE_ENTITYIDS
```
    Metric name for the gauge of the number of live entityIDs.
    
    See Also:
    
    Constant Field Values
  - METRIC_GAUGE_PERSISTENT_CACHE_INIT
```
public static final String METRIC_GAUGE_PERSISTENT_CACHE_INIT
```
    Metric name for the gauge of the persistent cache initialization metrics.
    
    See Also:
    
    Constant Field Values
  - log
```
private final org.slf4j.Logger log
```
    Class logger.
  - metricsBaseName
```
@NonnullAfterInit
private String metricsBaseName
```
    Base name for Metrics instrumentation names.
  - timerResolve
```
@Nullable
private com.codahale.metrics.Timer timerResolve
```
    Metrics Timer for resolve(CriteriaSet).
  - timerFetchFromOriginSource
```
@Nullable
private com.codahale.metrics.Timer timerFetchFromOriginSource
```
    Metrics Timer for fetchFromOriginSource(CriteriaSet).
  - ratioGaugeFetchToResolve
```
@Nullable
private com.codahale.metrics.RatioGauge ratioGaugeFetchToResolve
```
    Metrics RatioGauge for count of origin fetches to resolves.
  - gaugeNumLiveEntityIDs
```
@Nullable
private com.codahale.metrics.Gauge<Integer> gaugeNumLiveEntityIDs
```
    Metrics Gauge for the number of live entityIDs.
  - gaugePersistentCacheInit
```
@Nullable
private com.codahale.metrics.Gauge<AbstractDynamicMetadataResolver.PersistentCacheInitializationMetrics> gaugePersistentCacheInit
```
    Metrics Gauge for the persistent cache initialization.
  - taskTimer
```
private Timer taskTimer
```
    Timer used to schedule background metadata update tasks.
  - createdOwnTaskTimer
```
private boolean createdOwnTaskTimer
```
    Whether we created our own task timer during object construction.
  - minCacheDuration
```
@Duration
 @Positive
private Long minCacheDuration
```
    Minimum cache duration.
  - maxCacheDuration
```
@Duration
 @Positive
private Long maxCacheDuration
```
    Maximum cache duration.
  - negativeLookupCacheDuration
```
@Duration
 @Positive
private Long negativeLookupCacheDuration
```
    Negative lookup cache duration.
  - refreshDelayFactor
```
@Positive
private Float refreshDelayFactor
```
    Factor used to compute when the next refresh interval will occur. Default value: 0.75
  - maxIdleEntityData
```
@Duration
 @Positive
private Long maxIdleEntityData
```
    The maximum idle time in milliseconds for which the resolver will keep data for a given entityID, before it is removed.
  - removeIdleEntityData
```
private boolean removeIdleEntityData
```
    Flag indicating whether idle entity data should be removed.
  - expirationWarningThreshold
```
@Duration
 @Positive
private Long expirationWarningThreshold
```
    Impending expiration warning threshold for metadata refresh, in milliseconds. Default value: 0ms (disabled).
  - cleanupTaskInterval
```
@Duration
 @Positive
private Long cleanupTaskInterval
```
    The interval in milliseconds at which the cleanup task should run.
  - cleanupTask
```
private AbstractDynamicMetadataResolver.BackingStoreCleanupSweeper cleanupTask
```
    The backing store cleanup sweeper background task.
  - persistentCacheManager
```
private org.opensaml.core.xml.persist.XMLObjectLoadSaveManager<EntityDescriptor> persistentCacheManager
```
    The manager for the persistent cache store for resolved metadata.
  - persistentCacheKeyGenerator
```
private com.google.common.base.Function<EntityDescriptor,String> persistentCacheKeyGenerator
```
    Function for generating the String key used with the cache manager.
  - initializeFromPersistentCacheInBackground
```
private boolean initializeFromPersistentCacheInBackground
```
    Flag indicating whether should initialize from the persistent cache in the background.
  - backgroundInitializationFromCacheDelay
```
@Duration
 @Positive
private Long backgroundInitializationFromCacheDelay
```
    The delay in milliseconds after which to schedule the background initialization from the persistent cache.
  - initializationFromCachePredicate
```
private com.google.common.base.Predicate<EntityDescriptor> initializationFromCachePredicate
```
    Predicate which determines whether a given entity should be loaded from the persistent cache at resolver initialization time.
  - persistentCacheInitMetrics
```
@NonnullAfterInit
private AbstractDynamicMetadataResolver.PersistentCacheInitializationMetrics persistentCacheInitMetrics
```
    Object tracking metrics related to the persistent cache initialization.
  - indexes
```
private Set<MetadataIndex> indexes
```
    The set of indexes configured.
  - initializing
```
private boolean initializing
```
    Flag used to track state of whether currently initializing or not.
- Constructor Detail
  - AbstractDynamicMetadataResolver
```
public AbstractDynamicMetadataResolver(@Nullable
                                       Timer backgroundTaskTimer)
```
    Constructor.
    
    Parameters:
    
    backgroundTaskTimer - the Timer instance used to run resolver background management tasks
- Method Detail
  - isInitializeFromPersistentCacheInBackground
```
public boolean isInitializeFromPersistentCacheInBackground()
```
    Get the flag indicating whether should initialize from the persistent cache in the background.
    Defaults to: true.
    
    Returns:
    
    true if should init from the cache in background, false otherwise
  - setInitializeFromPersistentCacheInBackground
```
public void setInitializeFromPersistentCacheInBackground(boolean flag)
```
    Set the flag indicating whether should initialize from the persistent cache in the background.
    Defaults to: true.
    
    Parameters:
    
    flag - true if should init from the cache in the background, false otherwise
  - getBackgroundInitializationFromCacheDelay
```
@Nonnull
public Long getBackgroundInitializationFromCacheDelay()
```
    Get the delay in milliseconds after which to schedule the background initialization from the persistent cache.
    Defaults to: 2 seconds.
    
    Returns:
    
    the delay in milliseconds
    
    Since:
    
    3.3.0
  - setBackgroundInitializationFromCacheDelay
```
public void setBackgroundInitializationFromCacheDelay(@Nonnull
                                                      Long delay)
```
    Set the delay in milliseconds after which to schedule the background initialization from the persistent cache.
    Defaults to: 2 seconds.
    
    Parameters:
    
    delay - the delay in milliseconds
    
    Since:
    
    3.3.0
  - getPersistentCacheManager
```
@Nullable
public org.opensaml.core.xml.persist.XMLObjectLoadSaveManager<EntityDescriptor> getPersistentCacheManager()
```
    Get the manager for the persistent cache store for resolved metadata.
    
    Returns:
    
    the cache manager if configured, or null
  - setPersistentCacheManager
```
public void setPersistentCacheManager(@Nullable
                                      org.opensaml.core.xml.persist.XMLObjectLoadSaveManager<EntityDescriptor> manager)
```
    Set the manager for the persistent cache store for resolved metadata.
    
    Parameters:
    
    manager - the cache manager, may be null
  - isPersistentCachingEnabled
```
public boolean isPersistentCachingEnabled()
```
    Get the flag indicating whether persistent caching of the resolved metadata is enabled.
    
    Returns:
    
    true if enabled, false otherwise
  - getPersistentCacheKeyGenerator
```
@NonnullAfterInit
public com.google.common.base.Function<EntityDescriptor,String> getPersistentCacheKeyGenerator()
```
    Get the function for generating the String key used with the persistent cache manager.
    
    Returns:
    
    the key generator or null
  - setPersistentCacheKeyGenerator
```
public void setPersistentCacheKeyGenerator(@Nullable
                                           com.google.common.base.Function<EntityDescriptor,String> generator)
```
    Set the function for generating the String key used with the persistent cache manager.
    
    Parameters:
    
    generator - the new generator to set, may be null
  - getInitializationFromCachePredicate
```
@NonnullAfterInit
public com.google.common.base.Predicate<EntityDescriptor> getInitializationFromCachePredicate()
```
    Get the predicate which determines whether a given entity should be loaded from the persistent cache at resolver initialization time.
    
    Returns:
    
    the cache initialization predicate
  - setInitializationFromCachePredicate
```
public void setInitializationFromCachePredicate(@Nullable
                                                com.google.common.base.Predicate<EntityDescriptor> predicate)
```
    Set the predicate which determines whether a given entity should be loaded from the persistent cache at resolver initialization time.
    
    Parameters:
    
    predicate - the cache initialization predicate
  - getMinCacheDuration
```
@Nonnull
public Long getMinCacheDuration()
```
    Get the minimum cache duration for metadata.
    Defaults to: 10 minutes.
    
    Returns:
    
    the minimum cache duration, in milliseconds
  - setMinCacheDuration
```
public void setMinCacheDuration(@Nonnull
                                Long duration)
```
    Set the minimum cache duration for metadata.
    Defaults to: 10 minutes.
    
    Parameters:
    
    duration - the minimum cache duration, in milliseconds
  - getMaxCacheDuration
```
@Nonnull
public Long getMaxCacheDuration()
```
    Get the maximum cache duration for metadata.
    Defaults to: 8 hours.
    
    Returns:
    
    the maximum cache duration, in milliseconds
  - setMaxCacheDuration
```
public void setMaxCacheDuration(@Nonnull
                                Long duration)
```
    Set the maximum cache duration for metadata.
    Defaults to: 8 hours.
    
    Parameters:
    
    duration - the maximum cache duration, in milliseconds
  - getNegativeLookupCacheDuration
```
@Nonnull
public Long getNegativeLookupCacheDuration()
```
    Get the negative lookup cache duration for metadata.
    Defaults to: 10 minutes.
    
    Returns:
    
    the negative lookup cache duration, in milliseconds
  - setNegativeLookupCacheDuration
```
public void setNegativeLookupCacheDuration(@Nonnull
                                           Long duration)
```
    Set the negative lookup cache duration for metadata.
    Defaults to: 10 minutes.
    
    Parameters:
    
    duration - the negative lookup cache duration, in milliseconds
  - getRefreshDelayFactor
```
public Float getRefreshDelayFactor()
```
    Gets the delay factor used to compute the next refresh time.
    Defaults to: 0.75.
    
    Returns:
    
    delay factor used to compute the next refresh time
  - setRefreshDelayFactor
```
public void setRefreshDelayFactor(Float factor)
```
    Sets the delay factor used to compute the next refresh time. The delay must be between 0.0 and 1.0, exclusive.
    Defaults to: 0.75.
    
    Parameters:
    
    factor - delay factor used to compute the next refresh time
  - isRemoveIdleEntityData
```
public boolean isRemoveIdleEntityData()
```
    Get the flag indicating whether idle entity data should be removed.
    
    Returns:
    
    true if idle entity data should be removed, false otherwise
  - setRemoveIdleEntityData
```
public void setRemoveIdleEntityData(boolean flag)
```
    Set the flag indicating whether idle entity data should be removed.
    
    Parameters:
    
    flag - true if idle entity data should be removed, false otherwise
  - getMaxIdleEntityData
```
@Nonnull
public Long getMaxIdleEntityData()
```
    Get the maximum idle time in milliseconds for which the resolver will keep data for a given entityID, before it is removed.
    Defaults to: 8 hours.
    
    Returns:
    
    return the maximum idle time in milliseconds
  - setMaxIdleEntityData
```
public void setMaxIdleEntityData(@Nonnull
                                 Long max)
```
    Set the maximum idle time in milliseconds for which the resolver will keep data for a given entityID, before it is removed.
    Defaults to: 8 hours.
    
    Parameters:
    
    max - the maximum entity data idle time, in milliseconds
  - getExpirationWarningThreshold
```
@Duration
 @Nonnull
public Long getExpirationWarningThreshold()
```
    Gets the impending expiration warning threshold used at refresh time.
    
    Returns:
    
    threshold for logging a warning if live metadata will soon expire
  - setExpirationWarningThreshold
```
@Duration
public void setExpirationWarningThreshold(@Nullable @Duration @Positive
                                                    Long threshold)
```
    Sets the impending expiration warning threshold used at refresh time.
    
    Parameters:
    
    threshold - the threshold for logging a warning if live metadata will soon expire
  - getCleanupTaskInterval
```
@Nonnull
public Long getCleanupTaskInterval()
```
    Get the interval in milliseconds at which the cleanup task should run.
    Defaults to: 30 minutes.
    
    Returns:
    
    return the interval, in milliseconds
  - setCleanupTaskInterval
```
public void setCleanupTaskInterval(@Nonnull
                                   Long interval)
```
    Set the interval in milliseconds at which the cleanup task should run.
    Defaults to: 30 minutes.
    
    Parameters:
    
    interval - the interval to set, in milliseconds
  - getMetricsBaseName
```
@NonnullAfterInit
public String getMetricsBaseName()
```
    Get the base name for Metrics instrumentation.
    
    Returns:
    
    the Metrics base name
  - setMetricsBaseName
```
public void setMetricsBaseName(@Nullable
                               String baseName)
```
    Set the base name for Metrics instrumentation.
    
    Parameters:
    
    baseName - the Metrics base name
  - getIndexes
```
@Nonnull
 @NonnullElements
 @Unmodifiable
 @NotLive
public Set<MetadataIndex> getIndexes()
```
    Get the configured indexes.
    
    Returns:
    
    the set of configured indexes
  - setIndexes
```
public void setIndexes(@Nullable
                       Set<MetadataIndex> newIndexes)
```
    Set the configured indexes.
    
    Parameters:
    
    newIndexes - the new indexes to set
  - indexesEnabled
```
protected boolean indexesEnabled()
```
    Return whether secondary indexing is effectively active.
    
    Returns:
    
    true if active, false if not.
  - clear
```
public void clear()
           throws ResolverException
```
    Specified by:
    
    clear in interface ClearableMetadataResolver
    
    Throws:
    
    ResolverException
  - clear
```
public void clear(@Nonnull
                  String entityID)
           throws ResolverException
```
    Specified by:
    
    clear in interface ClearableMetadataResolver
    
    Throws:
    
    ResolverException
  - resolve
```
@Nonnull
public Iterable<EntityDescriptor> resolve(@Nonnull
                                                   CriteriaSet criteria)
                                            throws ResolverException
```
    Specified by:
    
    resolve in interface Resolver<EntityDescriptor,CriteriaSet>
    
    Throws:
    
    ResolverException
  - resolveEntityID
```
@Nullable
protected String resolveEntityID(@Nonnull
                                           CriteriaSet criteria)
```
    Attempt to resolve the single entityID for the operation from the criteria set.
    If an EntityIdCriterion is present, that will be used. If not present, then a single entityID will be resolved via the secondary index manager of the backing store.
    
    Parameters:
    
    criteria - the criteria set on which to operate
    
    Returns:
    
    the resolve entityID, or null if a single entityID could not be resolved
  - resolveEntityIDs
```
@Nonnull
protected Set<String> resolveEntityIDs(@Nonnull
                                                CriteriaSet criteria)
```
    Attempt to resolve all the entityIDs represented by the criteria set.
    If an EntityIdCriterion is present, that will be used. If not present, then entityIDs will be resolved via the secondary index manager of the backing store.
    
    Parameters:
    
    criteria - the criteria set on which to operate
    
    Returns:
    
    the resolved entityIDs, may be empty
  - resolveFromOriginSource
```
@Deprecated
 @Nonnull
 @NonnullElements
protected Iterable<EntityDescriptor> resolveFromOriginSource(@Nonnull
                                                                                                     CriteriaSet criteria)
                                                                                              throws ResolverException
```
    Deprecated. instead use resolveFromOriginSource(CriteriaSet, String)
    
    Fetch metadata from an origin source based on the input criteria, store it in the backing store and then return it.
    
    Parameters:
    
    criteria - the input criteria set
    
    Returns:
    
    the resolved metadata
    
    Throws:
    
    ResolverException - if there is a fatal error attempting to resolve the metadata
  - resolveFromOriginSource
```
@Nonnull
 @NonnullElements
protected Iterable<EntityDescriptor> resolveFromOriginSource(@Nonnull
                                                                                        CriteriaSet criteria,
                                                                                        @Nullable
                                                                                        String entityID)
                                                                                 throws ResolverException
```
    Fetch metadata from an origin source based on the input criteria, store it in the backing store and then return it.
    
    Parameters:
    
    criteria - the input criteria set
    
    entityID - the previously resolved single entityID
    
    Returns:
    
    the resolved metadata
    
    Throws:
    
    ResolverException - if there is a fatal error attempting to resolve the metadata
  - resolveFromOriginSourceWithEntityID
```
@Nonnull
 @NonnullElements
protected Iterable<EntityDescriptor> resolveFromOriginSourceWithEntityID(@Nonnull
                                                                                                    CriteriaSet criteria,
                                                                                                    @Nonnull
                                                                                                    String entityID)
                                                                                             throws ResolverException
```
    Fetch metadata from an origin source based on the input criteria when the entityID is known, store it in the backing store and then return it.
    
    Parameters:
    
    criteria - the input criteria set
    
    entityID - the entityID known to be represented by the criteria set
    
    Returns:
    
    the resolved metadata
    
    Throws:
    
    ResolverException - if there is a fatal error attempting to resolve the metadata
  - resolveFromOriginSourceWithoutEntityID
```
@Nonnull
 @NonnullElements
protected Iterable<EntityDescriptor> resolveFromOriginSourceWithoutEntityID(@Nonnull
                                                                                                       CriteriaSet criteria)
                                                                                                throws ResolverException
```
    Fetch metadata from an origin source based on the input criteria when the entityID is not known, store it in the backing store and then return it.
    
    Parameters:
    
    criteria - the input criteria set
    
    Returns:
    
    the resolved metadata
    
    Throws:
    
    ResolverException - if there is a fatal error attempting to resolve the metadata
  - lookupCriteria
```
@Nonnull
 @NonnullElements
protected Iterable<EntityDescriptor> lookupCriteria(@Nonnull
                                                                               CriteriaSet criteria)
                                                                        throws ResolverException
```
    Lookup and return all EntityDescriptors currently available in the resolver cache which match either entityID or secondary-indexed criteria.
    
    Parameters:
    
    criteria - the input criteria set
    
    Returns:
    
    the resolved metadata
    
    Throws:
    
    ResolverException - if there is a fatal error attempting to resolve the metadata
  - processNonEntityIDFetchedEntittiesDescriptor
```
@Nullable
protected List<EntityDescriptor> processNonEntityIDFetchedEntittiesDescriptor(@Nonnull
                                                                                        EntitiesDescriptor entities)
                                                                                 throws ResolverException
```
    Process an EntitiesDescriptor received from a non-entityID-based fetch.
    
    Parameters:
    
    entities - the metadata to process
    
    Returns:
    
    the resolved descriptor(s)
    
    Throws:
    
    ResolverException - if there is a fatal error attempting to resolve the metadata
  - processNonEntityIDFetchedEntityDescriptor
```
@Nullable
protected List<EntityDescriptor> processNonEntityIDFetchedEntityDescriptor(@Nonnull
                                                                                     EntityDescriptor entity)
                                                                              throws ResolverException
```
    Process an EntityDescriptor received from a non-entityID-based fetch.
    
    Parameters:
    
    entity - the metadata to process
    
    Returns:
    
    the resolved descriptor(s)
    
    Throws:
    
    ResolverException - if there is a fatal error attempting to resolve the metadata
  - fetchFromOriginSource
```
@Nullable
protected abstract org.opensaml.core.xml.XMLObject fetchFromOriginSource(@Nonnull
                                                                                   CriteriaSet criteria)
                                                                            throws IOException
```
    Fetch the metadata from the origin source.
    
    Parameters:
    
    criteria - the input criteria set
    
    Returns:
    
    the resolved metadata root XMLObject, or null if metadata could not be fetched
    
    Throws:
    
    IOException - if there is a fatal error fetching metadata from the origin source
  - lookupEntityID
```
@Nonnull
 @NonnullElements
protected List<EntityDescriptor> lookupEntityID(@Nonnull
                                                                           String entityID)
                                                                    throws ResolverException
```
    Get list of descriptors matching an entityID.
    
    Overrides:
    
    lookupEntityID in class AbstractMetadataResolver
    
    Parameters:
    
    entityID - entityID to lookup
    
    Returns:
    
    a list of descriptors
    
    Throws:
    
    ResolverException - if an error occurs
  - processNewMetadata
```
@Nonnull
protected void processNewMetadata(@Nonnull
                                           org.opensaml.core.xml.XMLObject root,
                                           @Nonnull
                                           String expectedEntityID)
                                    throws FilterException
```
    Process the specified new metadata document, including metadata filtering, and store the processed metadata in the backing store.
    Equivalent to processNewMetadata(XMLObject, String, boolean) called with false.
    
    Parameters:
    
    root - the root of the new metadata document being processed
    
    expectedEntityID - the expected entityID of the resolved metadata
    
    Throws:
    
    FilterException - if there is a problem filtering the metadata
  - processNewMetadata
```
@Nonnull
protected void processNewMetadata(@Nonnull
                                           org.opensaml.core.xml.XMLObject root,
                                           @Nonnull
                                           String expectedEntityID,
                                           boolean fromPersistentCache)
                                    throws FilterException,
                                           ResolverException
```
    Process the specified new metadata document, including metadata filtering, and store the processed metadata in the backing store.
    In order to be processed successfully, the metadata (after filtering) must be an instance of EntityDescriptor and its entityID value must match the value supplied as the required expectedEntityID argument.
    
    Parameters:
    
    root - the root of the new metadata document being processed
    
    expectedEntityID - the expected entityID of the resolved metadata
    
    fromPersistentCache - whether the entity data was loaded from the persistent cache
    
    Throws:
    
    FilterException - if there is a problem filtering the metadata
    
    ResolverException - if there is a problem processing the metadata
  - prepareForFiltering
```
@Nonnull
protected org.opensaml.core.xml.XMLObject prepareForFiltering(@Nonnull
                                                                       org.opensaml.core.xml.XMLObject input)
```
    Prepare the object for filtering: If persistent caching is enabled, return a clone of the object in case the configured filter mutates the object.
    
    Parameters:
    
    input - the XMLObject on which to operate
    
    Returns:
    
    the XMLObject instance to be filtered
  - 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.
    
    Overrides:
    
    preProcessEntityDescriptor in class AbstractMetadataResolver
    
    Parameters:
    
    entityDescriptor - the target entity descriptor to process
    
    backingStore - the backing store instance to update
  - logMetadataExpiration
```
private void logMetadataExpiration(@Nonnull
                                   EntityDescriptor descriptor,
                                   @Nonnull
                                   org.joda.time.DateTime now,
                                   @Nonnull
                                   org.joda.time.DateTime nextRefresh)
```
    Check metadata for expiration or pending expiration and log appropriately.
    
    Parameters:
    
    descriptor - the entity descriptor being processes
    
    now - the current date/time
    
    nextRefresh - the next refresh trigger time for the entity descriptor
  - computeExpirationTime
```
@Nonnull
protected org.joda.time.DateTime computeExpirationTime(@Nonnull
                                                                EntityDescriptor entityDescriptor,
                                                                @Nonnull
                                                                org.joda.time.DateTime now)
```
    Compute the effective expiration time for the specified metadata.
    
    Parameters:
    
    entityDescriptor - the EntityDescriptor instance to evaluate
    
    now - the current date time instant
    
    Returns:
    
    the effective expiration time for the metadata
  - computeRefreshTriggerTime
```
@Nonnull
protected org.joda.time.DateTime computeRefreshTriggerTime(@Nullable
                                                                    org.joda.time.DateTime expirationTime,
                                                                    @Nonnull
                                                                    org.joda.time.DateTime nowDateTime)
```
    Compute the refresh trigger time.
    
    Parameters:
    
    expirationTime - the time at which the metadata effectively expires
    
    nowDateTime - the current date time instant
    
    Returns:
    
    the time after which refresh attempt(s) should be made
  - shouldAttemptRefresh
```
protected boolean shouldAttemptRefresh(@Nonnull
                                       AbstractDynamicMetadataResolver.EntityManagementData mgmtData)
```
    Determine whether should attempt to refresh the metadata, based on stored refresh trigger time.
    
    Parameters:
    
    mgmtData - the entity'd management data
    
    Returns:
    
    true if should attempt refresh, false otherwise
  - createNewBackingStore
```
@Nonnull
protected AbstractDynamicMetadataResolver.DynamicEntityBackingStore 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 AbstractMetadataResolver.setBackingStore(EntityBackingStore) to make it the effective instance in use.
    
    Overrides:
    
    createNewBackingStore in class AbstractMetadataResolver
    
    Returns:
    
    the new backing store instance
  - getBackingStore
```
@NonnullAfterInit
protected AbstractDynamicMetadataResolver.DynamicEntityBackingStore getBackingStore()
```
    Get the EntityDescriptor backing store currently in use by the metadata resolver.
    
    Overrides:
    
    getBackingStore in class AbstractMetadataResolver
    
    Returns:
    
    the current effective entity backing store
  - initMetadataResolver
```
protected void initMetadataResolver()
                             throws ComponentInitializationException
```
    Subclasses should override this method to perform any initialization logic necessary. Default implementation is a no-op.
    
    Overrides:
    
    initMetadataResolver in class AbstractMetadataResolver
    
    Throws:
    
    ComponentInitializationException - thrown if there is a problem initializing the provider
  - initializeMetricsInstrumentation
```
private void initializeMetricsInstrumentation()
```
    Initialize the Metrics-based instrumentation.
  - initializeFromPersistentCache
```
protected void initializeFromPersistentCache()
```
    Initialize the resolver with data from the persistent cache manager, if enabled.
  - processPersistentCacheEntry
```
protected void processPersistentCacheEntry(@Nonnull
                                           String currentKey,
                                           @Nonnull
                                           EntityDescriptor descriptor)
```
    Process an entry loaded from the persistent cache.
    
    Parameters:
    
    currentKey - the current persistent cache key
    
    descriptor - the entity descriptor to process
  - removeByEntityID
```
protected void removeByEntityID(String entityID,
                                AbstractMetadataResolver.EntityBackingStore backingStore)
```
    Remove from the backing store all metadata for the entity with the given entity ID.
    
    Overrides:
    
    removeByEntityID in class AbstractMetadataResolver
    
    Parameters:
    
    entityID - the entity ID of the metadata to remove
    
    backingStore - the backing store instance to update
  - doDestroy
```
protected void doDestroy()
```
    Overrides:
    
    doDestroy in class AbstractMetadataResolver
  - 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.
    
    Overrides:
    
    indexEntityDescriptor in class AbstractMetadataResolver
    
    Parameters:
    
    entityDescriptor - the target entity descriptor to process
    
    backingStore - the backing store instance to update

Class AbstractDynamicMetadataResolver

Nested Class Summary

Nested classes/interfaces inherited from class org.opensaml.saml.metadata.resolver.impl.AbstractMetadataResolver

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.opensaml.saml.metadata.resolver.impl.AbstractMetadataResolver

Methods inherited from class net.shibboleth.utilities.java.support.component.AbstractIdentifiableInitializableComponent

Methods inherited from class net.shibboleth.utilities.java.support.component.AbstractIdentifiedInitializableComponent

Methods inherited from class net.shibboleth.utilities.java.support.component.AbstractInitializableComponent

Methods inherited from class java.lang.Object

Methods inherited from interface org.opensaml.saml.metadata.resolver.MetadataResolver

Methods inherited from interface net.shibboleth.utilities.java.support.resolver.Resolver

Methods inherited from interface net.shibboleth.utilities.java.support.component.IdentifiedComponent

Field Detail

METRIC_TIMER_FETCH_FROM_ORIGIN_SOURCE

METRIC_TIMER_RESOLVE

METRIC_RATIOGAUGE_FETCH_TO_RESOLVE

METRIC_GAUGE_NUM_LIVE_ENTITYIDS

METRIC_GAUGE_PERSISTENT_CACHE_INIT

log

metricsBaseName

timerResolve

timerFetchFromOriginSource

ratioGaugeFetchToResolve

gaugeNumLiveEntityIDs

gaugePersistentCacheInit

taskTimer

createdOwnTaskTimer

minCacheDuration

maxCacheDuration

negativeLookupCacheDuration

refreshDelayFactor

maxIdleEntityData

removeIdleEntityData

expirationWarningThreshold

cleanupTaskInterval

cleanupTask

persistentCacheManager

persistentCacheKeyGenerator

initializeFromPersistentCacheInBackground

backgroundInitializationFromCacheDelay

initializationFromCachePredicate

persistentCacheInitMetrics

indexes

initializing

Constructor Detail

AbstractDynamicMetadataResolver

Method Detail

isInitializeFromPersistentCacheInBackground

setInitializeFromPersistentCacheInBackground

getBackgroundInitializationFromCacheDelay

setBackgroundInitializationFromCacheDelay

getPersistentCacheManager

setPersistentCacheManager

isPersistentCachingEnabled

getPersistentCacheKeyGenerator

setPersistentCacheKeyGenerator

getInitializationFromCachePredicate

setInitializationFromCachePredicate

getMinCacheDuration

setMinCacheDuration

getMaxCacheDuration

setMaxCacheDuration

getNegativeLookupCacheDuration

setNegativeLookupCacheDuration

getRefreshDelayFactor

setRefreshDelayFactor

isRemoveIdleEntityData

setRemoveIdleEntityData

getMaxIdleEntityData

setMaxIdleEntityData

getExpirationWarningThreshold

setExpirationWarningThreshold

getCleanupTaskInterval

setCleanupTaskInterval

getMetricsBaseName

setMetricsBaseName

getIndexes

setIndexes