[java-oidc-common] branch main updated: Add expiration time context for expiration time computation strategies
Phil Smart
philip.smart at jisc.ac.uk
Thu Nov 11 17:09:30 UTC 2021
This is an automated email from the git hooks/post-receive script.
philsmart pushed a commit to branch main
in repository java-oidc-common.
View the commit online:
http://git.shibboleth.net/view/?p=java-oidc-common.git;a=commit;h=0e844122a0b5f155f018193a59ebdbce7b8b0566
The following commit(s) were added to refs/heads/main by this push:
new 0e84412 Add expiration time context for expiration time computation strategies
0e84412 is described below
commit 0e844122a0b5f155f018193a59ebdbce7b8b0566
Author: Phil Smart <philip.smart at jisc.ac.uk>
AuthorDate: Thu Nov 11 17:09:15 2021 +0000
Add expiration time context for expiration time computation strategies
---
.../oidc/metadata/cache/ExpirationTimeContext.java | 87 ++++++++++++++++++++++
.../metadata/cache/impl/BatchMetadataCache.java | 4 +-
...OIDCProviderMetadataExpirationTimeStrategy.java | 26 ++-----
.../metadata/cache/impl/DynamicMetadataCache.java | 50 +++++++++++--
.../cache/impl/DynamicMetadataCacheBuilder.java | 3 +-
.../impl/DynamicMetadataCacheBuilderSpec.java | 7 +-
.../metadata/impl/DefaultDynamicBackingStore.java | 7 +-
.../impl/DynamicMetadataCacheBuilderTest.java | 4 +-
.../cache/impl/DynamicMetadataCacheTest.java | 24 +++---
.../impl/OIDCProviderMetadataResolverTest.java | 4 +-
10 files changed, 162 insertions(+), 54 deletions(-)
diff --git a/oidc-common-metadata-api/src/main/java/net/shibboleth/oidc/metadata/cache/ExpirationTimeContext.java b/oidc-common-metadata-api/src/main/java/net/shibboleth/oidc/metadata/cache/ExpirationTimeContext.java
new file mode 100644
index 0000000..98a392b
--- /dev/null
+++ b/oidc-common-metadata-api/src/main/java/net/shibboleth/oidc/metadata/cache/ExpirationTimeContext.java
@@ -0,0 +1,87 @@
+package net.shibboleth.oidc.metadata.cache;
+
+import java.time.Duration;
+import java.time.Instant;
+
+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.Immutable;
+
+import net.shibboleth.utilities.java.support.logic.Constraint;
+
+/**
+ * Context to hold information pertaining to the computation of a metadata's expiration time.
+ *
+ * @param <T> The metadata type.
+ */
+ at Immutable
+public class ExpirationTimeContext<T> {
+
+ /** The metadata to base the expiry time off.*/
+ @Nonnull private final T metadata;
+
+ /** Minimum cache duration. */
+ @Nonnull private final Duration minCacheDuration;
+
+ /** Maximum cache duration. */
+ @Nonnull private final Duration maxCacheDuration;
+
+ /** The now time to base computation off.*/
+ @Nonnull private final Instant now;
+
+ /**
+ * Constructor.
+ *
+ * @param metadataIn the metadata to base the expiry time off.
+ * @param minimumCacheDuration minimum cache duration.
+ * @param maximumCacheDuration maximum cache duration. *
+ * @param timeNow the now time to base computation off.
+ */
+ public ExpirationTimeContext(@Nonnull final T metadataIn,
+ @Nonnull final Duration minimumCacheDuration,
+ @Nonnull final Duration maximumCacheDuration,
+ @Nonnull final Instant timeNow) {
+ super();
+ metadata = Constraint.isNotNull(metadataIn, "Metadata to base expiry off can not be null");
+ minCacheDuration = Constraint.isNotNull(minimumCacheDuration,"Min cache duration can not be null");
+ maxCacheDuration = Constraint.isNotNull(maximumCacheDuration,"Max cache duration can not be null");
+ now = timeNow;
+ }
+
+ /**
+ * Get the metadata.
+ *
+ * @return Returns the metadata.
+ */
+ public final T getMetadata() {
+ return metadata;
+ }
+
+ /**
+ * Get the minimum cache duration.
+ *
+ * @return Returns the minCacheDuration.
+ */
+ public final Duration getMinCacheDuration() {
+ return minCacheDuration;
+ }
+
+ /**
+ *
+ * Get the maximum cache duration.
+ *
+ * @return Returns the maxCacheDuration.
+ */
+ public final Duration getMaxCacheDuration() {
+ return maxCacheDuration;
+ }
+
+ /**
+ * Get the time to use a 'now'.
+ *
+ * @return Returns now.
+ */
+ public final Instant getNow() {
+ return now;
+ }
+
+}
diff --git a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/BatchMetadataCache.java b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/BatchMetadataCache.java
index 688ce8e..ead7376 100644
--- a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/BatchMetadataCache.java
+++ b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/BatchMetadataCache.java
@@ -303,7 +303,7 @@ public class BatchMetadataCache<IdentifierType, MetadataType>
log.info("{} Metadata has not changed since last refresh", getLogPrefix());
}
// Compute metadata expiration from whatever is in the cache (updated or not) will
- // remain null if no cached original value.
+ // remain null if no cached original value.
metadataExpiration = sourceMetadataExpiryStrategy.apply(getBackingStore().getOriginalValue());
} catch (final Throwable t) {
log.error("{} Error loading or parsing metadata",getLogPrefix(), t);
@@ -354,7 +354,7 @@ public class BatchMetadataCache<IdentifierType, MetadataType>
* Computes the delay until the next refresh time based on the current metadata's expiration time and the refresh
* interval floor.
*
- * @param expectedExpiration the time when the metadata is expected to expire and need refreshing
+ * @param expectedExpiration the time when the metadata is expected to expire and needs refreshing
*
* @return delay until the next refresh time
*/
diff --git a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DefaultOIDCProviderMetadataExpirationTimeStrategy.java b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DefaultOIDCProviderMetadataExpirationTimeStrategy.java
index f797943..4182a84 100644
--- a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DefaultOIDCProviderMetadataExpirationTimeStrategy.java
+++ b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DefaultOIDCProviderMetadataExpirationTimeStrategy.java
@@ -17,38 +17,24 @@
package net.shibboleth.oidc.metadata.cache.impl;
-import java.time.Duration;
import java.time.Instant;
-import java.util.function.BiFunction;
+import java.util.function.Function;
import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import com.nimbusds.openid.connect.sdk.op.OIDCProviderMetadata;
-import net.shibboleth.utilities.java.support.logic.Constraint;
+import net.shibboleth.oidc.metadata.cache.ExpirationTimeContext;
/** Strategy for computing an expiry time for {@link OIDCProviderMetadata}.
- * Defaults to now plus the provided expiry time.*/
+ * Defaults to now plus the max cache duration.*/
public class DefaultOIDCProviderMetadataExpirationTimeStrategy
- implements BiFunction<OIDCProviderMetadata, Instant, Instant> {
+ implements Function<ExpirationTimeContext<OIDCProviderMetadata>, Instant> {
- /** How long after now should the metadata expire.*/
- @Nonnull private final Duration expiryDuration;
-
- /**
- *
- * Constructor.
- *
- * @param duration the expiry duration.
- */
- public DefaultOIDCProviderMetadataExpirationTimeStrategy(@Nonnull final Duration duration) {
- expiryDuration = Constraint.isNotNull(duration, "Expiry duration can not be null");
- }
@Override
- public Instant apply(@Nullable final OIDCProviderMetadata metadata, @Nullable final Instant now) {
- return now.plus(expiryDuration);
+ public Instant apply(@Nonnull final ExpirationTimeContext<OIDCProviderMetadata> context) {
+ return context.getNow().plus(context.getMaxCacheDuration());
}
}
diff --git a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCache.java b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCache.java
index e0deb36..fb87066 100644
--- a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCache.java
+++ b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCache.java
@@ -39,6 +39,7 @@ import org.slf4j.LoggerFactory;
import net.shibboleth.oidc.metadata.DynamicBackingStore;
import net.shibboleth.oidc.metadata.MetadataManagementData;
+import net.shibboleth.oidc.metadata.cache.ExpirationTimeContext;
import net.shibboleth.oidc.metadata.cache.MetadataCacheException;
import net.shibboleth.utilities.java.support.annotation.constraint.NonnullAfterInit;
import net.shibboleth.utilities.java.support.annotation.constraint.NonnullElements;
@@ -59,6 +60,8 @@ import net.shibboleth.utilities.java.support.resolver.CriteriaSet;
* <li>Synchronous 'read-through' metadata fetching for stale (past refresh point) metadata.</li>
* <li>A background task to remove expired and idle metadata.</li>
* </ul>
+ *
+ * <p>This class should only be instantiated through the {@link DynamicMetadataCacheBuilder}.</p>
*
* @param <IdentifierType> the metadata identifier type.
* @param <MetadataType> the metadata type.
@@ -85,11 +88,15 @@ public class DynamicMetadataCache<IdentifierType, MetadataType>
/** Minimum cache duration. */
@NonnullAfterInit private Duration minCacheDuration;
+ /** Maximum cache duration. */
+ //FIXME: is not being used here, should be for metadata expiry computation
+ @NonnullAfterInit private Duration maxCacheDuration;
+
/** The function to use to fetch/load metadata if either none exists, or the existing is stale.*/
@NonnullAfterInit private Function<CriteriaSet, MetadataType> fetchStrategy;
/** Strategy used to compute an expiration time from a metadata instance. */
- @NonnullAfterInit private BiFunction<MetadataType, Instant, Instant> metadataExpirationTimeStrategy;
+ @NonnullAfterInit private Function<ExpirationTimeContext<MetadataType>, Instant> metadataExpirationTimeStrategy;
/**
* Constructor.
@@ -119,8 +126,6 @@ public class DynamicMetadataCache<IdentifierType, MetadataType>
/**
* Set the minimum cache duration for metadata.
*
- * <p>Defaults to: 10 minutes.</p>
- *
* @param duration the minimum cache duration
*/
public void setMinCacheDuration(@Nonnull final Duration duration) {
@@ -133,6 +138,18 @@ public class DynamicMetadataCache<IdentifierType, MetadataType>
minCacheDuration = duration;
}
+ /**
+ * Set the maximum cache duration for metadata.
+ *
+ * @param duration the maximum cache duration
+ */
+ public void setMaxCacheDuration(@Nonnull final Duration duration) {
+ Constraint.isNotNull(duration, "Duration cannot be null");
+ Constraint.isFalse(duration.isNegative(), "Duration cannot be negative");
+
+ maxCacheDuration = duration;
+ }
+
/**
* Set the metadata fetching strategy.
*
@@ -213,7 +230,7 @@ public class DynamicMetadataCache<IdentifierType, MetadataType>
* @param strategy the strategy.
*/
public void setMetadataExpirationTimeStrategy(
- @Nonnull final BiFunction<MetadataType, Instant, Instant> strategy) {
+ @Nonnull final Function<ExpirationTimeContext<MetadataType>, Instant> strategy) {
ComponentSupport.ifInitializedThrowUnmodifiabledComponentException(this);
ComponentSupport.ifDestroyedThrowDestroyedComponentException(this);
@@ -225,7 +242,8 @@ public class DynamicMetadataCache<IdentifierType, MetadataType>
*
* @return the expiration time strategy.
*/
- @NonnullAfterInit protected BiFunction<MetadataType, Instant, Instant> getMetadataExpirationTimeStrategy() {
+ @NonnullAfterInit
+ protected Function<ExpirationTimeContext<MetadataType>, Instant> getMetadataExpirationTimeStrategy() {
return metadataExpirationTimeStrategy;
}
@@ -234,8 +252,8 @@ public class DynamicMetadataCache<IdentifierType, MetadataType>
protected void doInitialize() throws ComponentInitializationException {
super.doInitialize();
- if (minCacheDuration == null || maxIdleEntityData == null || cleanupTaskInterval == null ||
- initialCleanupTaskDelay == null) {
+ if (maxCacheDuration == null || minCacheDuration == null || maxIdleEntityData == null ||
+ cleanupTaskInterval == null || initialCleanupTaskDelay == null) {
throw new ComponentInitializationException("Dynamic metadata cache not property initialized");
}
if (metadataExpirationTimeStrategy == null) {
@@ -385,7 +403,8 @@ public class DynamicMetadataCache<IdentifierType, MetadataType>
mgmtData.setLastUpdateTime(now);
- mgmtData.setExpirationTime(getMetadataExpirationTimeStrategy().apply(filteredMetadata, now));
+ mgmtData.setExpirationTime(getMetadataExpirationTimeStrategy()
+ .apply(createExpirationTimeContext(filteredMetadata, now)));
log.debug("{} Computed metadata '{}' expiration time: {}", getLogPrefix(),
extractedIdentifier, mgmtData.getExpirationTime());
@@ -396,6 +415,21 @@ public class DynamicMetadataCache<IdentifierType, MetadataType>
log.info("{} Successfully loaded new Metadata with identifer '{}'", getLogPrefix(), extractedIdentifier);
}
+ /**
+ * Create an expiration time context from the given metadata, the min and max cache durations,
+ * and the instant representing 'now'.
+ *
+ * @param metadata the metadata.
+ * @param now the instant representing now.
+ *
+ * @return an expiration time context.
+ */
+ protected ExpirationTimeContext<MetadataType> createExpirationTimeContext(
+ @Nonnull final MetadataType metadata,
+ @Nonnull final Instant now){
+ return new ExpirationTimeContext<>(metadata, minCacheDuration, maxCacheDuration, now);
+ }
+
/**
* Compute the refresh trigger time.
*
diff --git a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilder.java b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilder.java
index 4c5e4de..3e5f060 100644
--- a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilder.java
+++ b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilder.java
@@ -62,8 +62,7 @@ public final class DynamicMetadataCacheBuilder {
new DefaultDynamicBackingStore<>(spec.getMaxCacheDuration()));
cache.setFetchStrategy(spec.getFetchStrategy());
cache.setMinCacheDuration(spec.getMinCacheDuration());
- // FIXME what did we do with this.
- //cache.setMaxCacheDuration(spec.getMaxCacheDuration());
+ cache.setMaxCacheDuration(spec.getMaxCacheDuration());
cache.setRefreshDelayFactor(spec.getRefreshDelayFactor());
cache.setMaxIdleEntityData(spec.getMaxIdleEntityData());
cache.setMetadataExpirationTimeStrategy(spec.getMetadataExpirationTimeStrategy());
diff --git a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilderSpec.java b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilderSpec.java
index 13b20d4..e6ac16b 100644
--- a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilderSpec.java
+++ b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilderSpec.java
@@ -26,6 +26,7 @@ import java.util.function.Function;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
+import net.shibboleth.oidc.metadata.cache.ExpirationTimeContext;
import net.shibboleth.utilities.java.support.logic.Constraint;
import net.shibboleth.utilities.java.support.resolver.CriteriaSet;
@@ -61,7 +62,7 @@ public class DynamicMetadataCacheBuilderSpec <IdentifierType, MetadataType>
@Nonnull private Duration initialCleanupTaskDelay;
/** Strategy used to compute an expiration time. */
- @Nullable private BiFunction<MetadataType, Instant, Instant> metadataExpirationTimeStrategy;
+ @Nullable private Function<ExpirationTimeContext<MetadataType>, Instant> metadataExpirationTimeStrategy;
/** Constructor. */
protected DynamicMetadataCacheBuilderSpec() {
@@ -148,7 +149,7 @@ public class DynamicMetadataCacheBuilderSpec <IdentifierType, MetadataType>
* @param strategy the strategy.
*/
public void setMetadataExpirationTimeStrategy(
- @Nonnull final BiFunction<MetadataType, Instant, Instant> strategy) {
+ @Nonnull final Function<ExpirationTimeContext<MetadataType>, Instant> strategy) {
metadataExpirationTimeStrategy = Constraint.isNotNull(strategy, "Strategy can not be null");
}
@@ -157,7 +158,7 @@ public class DynamicMetadataCacheBuilderSpec <IdentifierType, MetadataType>
*
* @return the strategy.
*/
- @Nullable protected BiFunction<MetadataType, Instant, Instant> getMetadataExpirationTimeStrategy() {
+ @Nullable protected Function<ExpirationTimeContext<MetadataType>, Instant> getMetadataExpirationTimeStrategy() {
return metadataExpirationTimeStrategy;
}
diff --git a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/impl/DefaultDynamicBackingStore.java b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/impl/DefaultDynamicBackingStore.java
index 773159b..fb029e9 100644
--- a/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/impl/DefaultDynamicBackingStore.java
+++ b/oidc-common-metadata-impl/src/main/java/net/shibboleth/oidc/metadata/impl/DefaultDynamicBackingStore.java
@@ -53,11 +53,11 @@ public class DefaultDynamicBackingStore<I,T> extends AbstractBackingStore<I,T> i
/**
* Constructor.
*
- * @param cacheDuration TODO should this be here?
+ * @param maximumCacheDuration the maximum duration the metadata is valid for in the cache.
*/
- public DefaultDynamicBackingStore(@Nonnull final Duration cacheDuration) {
+ public DefaultDynamicBackingStore(@Nonnull final Duration maximumCacheDuration) {
super();
- maxCacheDuration = Constraint.isNotNull(cacheDuration,"Max cache duration can not be null");
+ maxCacheDuration = Constraint.isNotNull(maximumCacheDuration,"Max cache duration can not be null");
mgmtDataMap = new ConcurrentHashMap<>();
}
@@ -70,6 +70,7 @@ public class DefaultDynamicBackingStore<I,T> extends AbstractBackingStore<I,T> i
final Instant now = Instant.now();
final MetadataManagementData<I> mgmt = new MetadataManagementData<>(id);
mgmt.setRefreshTriggerTime(now.plus(maxCacheDuration));
+ mgmt.setExpirationTime(now.plus(maxCacheDuration));
return mgmt;
});
diff --git a/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilderTest.java b/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilderTest.java
index 55ab491..f4545c5 100644
--- a/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilderTest.java
+++ b/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheBuilderTest.java
@@ -43,7 +43,7 @@ public class DynamicMetadataCacheBuilderTest {
DynamicMetadataCacheBuilderSpec<Issuer, OIDCProviderMetadata> spec = new DynamicMetadataCacheBuilderSpec<>();
spec.setIdentifierExtractionStrategy(m -> m.getIssuer());
- spec.setMetadataExpirationTimeStrategy((m, time) -> time.plus(Duration.ofMinutes(5)));
+ spec.setMetadataExpirationTimeStrategy(ctx -> ctx.getNow().plus(Duration.ofMinutes(5)));
spec.setCriteriaToIdentifierStrategy(crit -> {
final IssuerIDCriterion issuerId = crit.get(IssuerIDCriterion.class);
if (issuerId != null) {
@@ -63,7 +63,7 @@ public class DynamicMetadataCacheBuilderTest {
final Issuer iss = crit.get(IssuerIDCriterion.class).getIssuerID();
return new OIDCProviderMetadata(iss, List.of(SubjectType.PUBLIC),
new URI("http://example.oidc.op.org"));
- } catch (URISyntaxException e) {
+ } catch (final URISyntaxException e) {
return null;
}
});
diff --git a/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheTest.java b/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheTest.java
index 644954c..bf65fa2 100644
--- a/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheTest.java
+++ b/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/cache/impl/DynamicMetadataCacheTest.java
@@ -82,7 +82,7 @@ public class DynamicMetadataCacheTest {
cache = new DynamicMetadataCache<Issuer, OIDCProviderMetadata>
(new DefaultDynamicBackingStore<>(Duration.ofMinutes(5)),defaultFetchStrategy, scheduler);
cache.setIdentifierExtractionStrategy(m -> m.getIssuer());
- cache.setMetadataExpirationTimeStrategy((m, time) -> time.plus(Duration.ofMinutes(5)));
+ cache.setMetadataExpirationTimeStrategy(ctx -> ctx.getNow().plus(Duration.ofMinutes(5)));
cache.setCriteriaToIdentifierStrategy(crit -> {
final IssuerIDCriterion issuerId = crit.get(IssuerIDCriterion.class);
if (issuerId != null) {
@@ -96,7 +96,7 @@ public class DynamicMetadataCacheTest {
cache.setRemoveIdleEntityData(true);
cache.setRefreshDelayFactor(0.75f);
cache.setMinCacheDuration(Duration.ofMinutes(10));
- //cache.setMaxCacheDuration(Duration.ofMinutes(20));
+ cache.setMaxCacheDuration(Duration.ofMinutes(20));
cache.setMetadataFilterStrategy((metadata, context) -> metadata);
cache.setId("MockCache");
// Initialise when you need to use it, if creating a local version, do not init this one.
@@ -122,7 +122,7 @@ public class DynamicMetadataCacheTest {
// use a cache local to this method
cacheLocal.setIdentifierExtractionStrategy(m -> m.getIssuer());
- cacheLocal.setMetadataExpirationTimeStrategy((m, time) -> time.plus(Duration.ofMinutes(10)));
+ cacheLocal.setMetadataExpirationTimeStrategy(ctx -> ctx.getNow().plus(Duration.ofMinutes(10)));
cacheLocal.setCriteriaToIdentifierStrategy(crit -> crit.get(IssuerIDCriterion.class).getIssuerID());
//test a simple logging hook
cacheLocal.setMetadataBeforeRemovalHook((metadata, identifer) -> log.info("Before removal hook ran"));
@@ -135,7 +135,7 @@ public class DynamicMetadataCacheTest {
cacheLocal.setRemoveIdleEntityData(true);
cacheLocal.setRefreshDelayFactor(0.75f);
cacheLocal.setMinCacheDuration(Duration.ofMinutes(10));
- //cacheLocal.setMaxCacheDuration(Duration.ofMinutes(20));
+ cacheLocal.setMaxCacheDuration(Duration.ofMinutes(20));
cacheLocal.setMetadataFilterStrategy((metadata, context) -> metadata);
cacheLocal.setId("MockCache");
cacheLocal.initialize();
@@ -173,7 +173,7 @@ public class DynamicMetadataCacheTest {
public void testCacheNotInitialized() throws Exception {
// Create but do not initialise
- DynamicMetadataCache<Issuer, OIDCProviderMetadata> cacheLocal = new DynamicMetadataCache<>(
+ final DynamicMetadataCache<Issuer, OIDCProviderMetadata> cacheLocal = new DynamicMetadataCache<>(
new DefaultDynamicBackingStore<>(Duration.ofMinutes(5)));
final Issuer iss = new Issuer("https://example.oidc.op.org");
cacheLocal.get(new CriteriaSet(new IssuerIDCriterion(iss)));
@@ -184,15 +184,15 @@ public class DynamicMetadataCacheTest {
public void testBackgroundCleanup_Idle_Success() throws Exception {
// Give our own executor, so we do not need to wait.
- ManuallyTriggeredScheduledExecutorService scheduler = new ManuallyTriggeredScheduledExecutorService();
- DynamicMetadataCache<Issuer, OIDCProviderMetadata> cacheLocal =
+ final ManuallyTriggeredScheduledExecutorService scheduler = new ManuallyTriggeredScheduledExecutorService();
+ final DynamicMetadataCache<Issuer, OIDCProviderMetadata> cacheLocal =
new DynamicMetadataCache<Issuer, OIDCProviderMetadata>(
new DefaultDynamicBackingStore<>(Duration.ofMinutes(5)),
defaultFetchStrategy, scheduler);
// use a cache local to this method
cacheLocal.setIdentifierExtractionStrategy(m -> m.getIssuer());
- cacheLocal.setMetadataExpirationTimeStrategy((m, time) -> time.plus(Duration.ofMinutes(10)));
+ cacheLocal.setMetadataExpirationTimeStrategy(ctx -> ctx.getNow().plus(Duration.ofMinutes(10)));
cacheLocal.setCriteriaToIdentifierStrategy(crit -> crit.get(IssuerIDCriterion.class).getIssuerID());
// background task settings make no difference as it is manually scheduled.
@@ -205,7 +205,7 @@ public class DynamicMetadataCacheTest {
cacheLocal.setRemoveIdleEntityData(true);
cacheLocal.setRefreshDelayFactor(0.75f);
cacheLocal.setMinCacheDuration(Duration.ofMinutes(10));
- // cacheLocal.setMaxCacheDuration(Duration.ofMinutes(20));
+ cacheLocal.setMaxCacheDuration(Duration.ofMinutes(20));
cacheLocal.setMetadataFilterStrategy((metadata, context) -> metadata);
cacheLocal.setId("MockCache");
cacheLocal.initialize();
@@ -285,7 +285,7 @@ public class DynamicMetadataCacheTest {
@Test
public void testGetNotCached_WrongIdentifier_Fail() throws MetadataCacheException, ComponentInitializationException {
- ManuallyTriggeredScheduledExecutorService scheduler = new ManuallyTriggeredScheduledExecutorService();
+ final ManuallyTriggeredScheduledExecutorService scheduler = new ManuallyTriggeredScheduledExecutorService();
final DynamicMetadataCache<Issuer, OIDCProviderMetadata> localCache =
new DynamicMetadataCache<Issuer, OIDCProviderMetadata>(
new DefaultDynamicBackingStore<>(Duration.ofMinutes(5)),crit -> {
@@ -296,7 +296,7 @@ public class DynamicMetadataCacheTest {
return null;
}}, scheduler);
localCache.setIdentifierExtractionStrategy(m -> m.getIssuer());
- localCache.setMetadataExpirationTimeStrategy((m, time) -> time.plus(Duration.ofMinutes(5)));
+ localCache.setMetadataExpirationTimeStrategy(ctx -> ctx.getNow().plus(Duration.ofMinutes(5)));
localCache.setCriteriaToIdentifierStrategy(crit -> {
final IssuerIDCriterion issuerId = crit.get(IssuerIDCriterion.class);
if (issuerId != null) {
@@ -310,7 +310,7 @@ public class DynamicMetadataCacheTest {
localCache.setRemoveIdleEntityData(true);
localCache.setRefreshDelayFactor(0.75f);
localCache.setMinCacheDuration(Duration.ofMinutes(10));
- //localCache.setMaxCacheDuration(Duration.ofMinutes(20));
+ localCache.setMaxCacheDuration(Duration.ofMinutes(20));
localCache.setMetadataFilterStrategy((metadata, context) -> metadata);
localCache.setId("MockCache");
localCache.initialize();
diff --git a/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/impl/OIDCProviderMetadataResolverTest.java b/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/impl/OIDCProviderMetadataResolverTest.java
index d0b9fc5..05681d7 100644
--- a/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/impl/OIDCProviderMetadataResolverTest.java
+++ b/oidc-common-metadata-impl/src/test/java/net/shibboleth/oidc/metadata/impl/OIDCProviderMetadataResolverTest.java
@@ -242,7 +242,7 @@ public class OIDCProviderMetadataResolverTest {
dynCache = new TestableDynamicMetadataCache<Issuer, OIDCProviderMetadata>
(new DefaultDynamicBackingStore<>(Duration.ofMinutes(5)),fetchingStrategy, scheduler);
dynCache.setIdentifierExtractionStrategy(m -> m.getIssuer());
- dynCache.setMetadataExpirationTimeStrategy((m, time) -> time.plus(Duration.ofMinutes(5)));
+ dynCache.setMetadataExpirationTimeStrategy(ctx -> ctx.getNow().plus(Duration.ofMinutes(5)));
dynCache.setCriteriaToIdentifierStrategy(crit -> {
final IssuerIDCriterion issuerId = crit.get(IssuerIDCriterion.class);
if (issuerId != null) {
@@ -256,7 +256,7 @@ public class OIDCProviderMetadataResolverTest {
dynCache.setRemoveIdleEntityData(true);
dynCache.setRefreshDelayFactor(0.75f);
dynCache.setMinCacheDuration(Duration.ofMinutes(10));
- //cache.setMaxCacheDuration(Duration.ofMinutes(20));
+ dynCache.setMaxCacheDuration(Duration.ofMinutes(20));
dynCache.setMetadataFilterStrategy((metadata, context) -> metadata);
dynCache.setId("MockDynCache");
dynCache.initialize();
--
To stop receiving notification emails like this one, please contact
the administrator of this repository.
More information about the commits
mailing list