Package org.forgerock.openig.tools.authentication.chf

Class AsyncRefreshableSupplier<V,E extends Exception>

java.lang.Object

org.forgerock.openig.tools.authentication.chf.AsyncRefreshableSupplier<V,E>

Type Parameters:

V - input type of the function parameter

E - supported exception type of the function parameter

public final class AsyncRefreshableSupplier<V,E extends Exception>
extends Object

This utility class supports a lock-downgrading strategy to make sure that 2 concurrent calls to compute the "cached" value will result in a single computation. It supports concurrent refreshment.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static final class	AsyncRefreshableSupplier.Ticket<V,E extends Exception>	A holder for the currently active promise of this supplier.

Constructor Summary

Constructors

Constructor	Description
AsyncRefreshableSupplier(AsyncFunction<Context,V,E> compute)	Creates a provider ensuring "only-once" invocation of the given compute function.

Method Summary

Modifier and Type	Method	Description
AsyncRefreshableSupplier.Ticket<V,E>	get(Context context)	Computes (or re-computes) the value in a thread-safe manner, making sure that only 1 thread will compute the value, the other being blocked, waiting for the result to be computed.
AsyncRefreshableSupplier.Ticket<V,E>	getWithoutRefresh()	Computes the value in a thread-safe manner, making sure that only 1 thread will compute the value, the other being blocked, waiting for the result to be computed.
void	invalidate(AsyncRefreshableSupplier.Ticket<V,E> heldTicket)	Flag the value carried by heldTicket as being invalid, to force a recomputation on the next get(Context).
AsyncRefreshableSupplier.Ticket<V,E>	refresh(Context context, AsyncRefreshableSupplier.Ticket<V,E> heldTicket)	Returns a refreshed AsyncRefreshableSupplier.Ticket, in a thread-safe manner.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

AsyncRefreshableSupplier

public AsyncRefreshableSupplier(AsyncFunction<Context,V,E> compute)

Creates a provider ensuring "only-once" invocation of the given compute function.

Parameters:

compute - computation function

Method Details

get

public AsyncRefreshableSupplier.Ticket<V,E> get(Context context)

Computes (or re-computes) the value in a thread-safe manner, making sure that only 1 thread will compute the value, the other being blocked, waiting for the result to be computed.

Parameters:

context - Service context

Returns:

a ticket of the computed promise

refresh

public AsyncRefreshableSupplier.Ticket<V,E> refresh(Context context,
 AsyncRefreshableSupplier.Ticket<V,E> heldTicket)

Returns a refreshed AsyncRefreshableSupplier.Ticket, in a thread-safe manner.

heldTicket is the AsyncRefreshableSupplier.Ticket the caller was previously given by get(Context) and has since been flagged as invalid when used. If the AsyncRefreshableSupplier.Ticket has already been replaced then the caller gets that replacement back instead of triggering another computation, so one rejected AsyncRefreshableSupplier.Ticket leads to one recomputation however many callers report it. This matters when computing a new ticket invalidates the previous one — for example, an AM agent limited to a single session, where a recomputation would revoke the value a concurrent caller is currently using.

Parameters:

context - Service context

heldTicket - the AsyncRefreshableSupplier.Ticket the caller currently holds

Returns:

a refreshed AsyncRefreshableSupplier.Ticket

getWithoutRefresh

public AsyncRefreshableSupplier.Ticket<V,E> getWithoutRefresh()

Computes the value in a thread-safe manner, making sure that only 1 thread will compute the value, the other being blocked, waiting for the result to be computed. If the value needs to be refreshed, a AsyncRefreshableSupplier.Ticket containing a null result Promise is returned.

Returns:

a ticket containing the current valid promise, or a null result promise if the value is not valid

invalidate

public void invalidate(AsyncRefreshableSupplier.Ticket<V,E> heldTicket)

Flag the value carried by heldTicket as being invalid, to force a recomputation on the next get(Context).

If that AsyncRefreshableSupplier.Ticket has already been replaced then the report is ignored, leaving the replacement in place. This matters when computing a new value invalidates the previous one — an unconditional invalidation would discard a value another caller is currently using, and every discarded value costs a recomputation.

Parameters:

heldTicket - the AsyncRefreshableSupplier.Ticket the caller found unusable