org.microbean.kubernetes.controller

Class ResourceTrackingEventQueueConsumer<T extends HasMetadata>

java.lang.Object

org.microbean.kubernetes.controller.ResourceTrackingEventQueueConsumer<T>

Type Parameters:

T - a Kubernetes resource type

All Implemented Interfaces:

Consumer<EventQueue<? extends T>>

Direct Known Subclasses:

EventDistributor

public abstract class ResourceTrackingEventQueueConsumer<T extends HasMetadata>
extends Object
implements Consumer<EventQueue<? extends T>>

A Consumer of EventQueues that tracks the Kubernetes resources they contain before allowing subclasses to process their individual Events.

Typically you would supply an implementation of this class to a Controller.

Author:

Laird Nelson

See Also:

accept(AbstractEvent), Controller

Field Summary

Fields

Modifier and Type	Field and Description
protected Logger	logger A Logger for use by this ResourceTrackingEventQueueConsumer implementation.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	ResourceTrackingEventQueueConsumer(Map<Object,T> knownObjects) Creates a new ResourceTrackingEventQueueConsumer.

Method Summary

Modifier and Type	Method and Description
protected abstract void	accept(AbstractEvent<? extends T> event) Called to process a given AbstractEvent from the EventQueue supplied to the accept(EventQueue) method, with that EventQueue's monitor held.
void	accept(EventQueue<? extends T> eventQueue) Loops through all the AbstractEvents in the supplied EventQueue, keeping track of the HasMetadata it concerns along the way by synchronizing on and writing to the Map supplied at construction time.
protected Event<T>	createEvent(AbstractEvent.Type eventType, T priorResource, T resource) Creates and returns a new Event.
protected Logger	createLogger() Returns a Logger for use with this ResourceTrackingEventQueueConsumer.
protected SynchronizationEvent<T>	createSynchronizationEvent(AbstractEvent.Type eventType, T priorResource, T resource) Creates and returns a new SynchronizationEvent.

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.function.Consumer

andThen

Field Detail

logger

protected final Logger logger

A Logger for use by this ResourceTrackingEventQueueConsumer implementation.

This field is never null.

See Also:

createLogger()

Constructor Detail

ResourceTrackingEventQueueConsumer

protected ResourceTrackingEventQueueConsumer(Map<Object,T> knownObjects)

Creates a new ResourceTrackingEventQueueConsumer.

Parameters:

knownObjects - a mutable Map of HasMetadata objects indexed by their keys (often a pairing of namespace and name); may be null if deletion tracking is not needed; will have its contents changed by this ResourceTrackingEventQueueConsumer's accept(EventQueue) method; will be synchronized on by this ResourceTrackingEventQueueConsumer's accept(EventQueue) method

See Also:

accept(EventQueue)

Method Detail

createLogger

protected Logger createLogger()

Returns a Logger for use with this ResourceTrackingEventQueueConsumer.

This method never returns null.

Overrides of this method must not return null.

Returns:

a non-null Logger

accept

public final void accept(EventQueue<? extends T> eventQueue)

Loops through all the AbstractEvents in the supplied EventQueue, keeping track of the HasMetadata it concerns along the way by synchronizing on and writing to the Map supplied at construction time.

Individual AbstractEvents are forwarded on to the accept(AbstractEvent) method.

Implementation Notes

This loosely models the HandleDeltas function in tools/cache/shared_informer.go. The final distribution step is left unimplemented on purpose.

Specified by:

accept in interface Consumer<EventQueue<? extends T extends HasMetadata>>

Parameters:

eventQueue - the EventQueue to process; may be null in which case no action will be taken

See Also:

accept(AbstractEvent)

createEvent

protected Event<T> createEvent(AbstractEvent.Type eventType,
                               T priorResource,
                               T resource)

Creates and returns a new Event.

This method never returns null.

Overrides of this method must not return null.

Parameters:

eventType - the AbstractEvent.Type for the new Event; must not be null; when supplied by the accept(EventQueue) method's internals, will always be either AbstractEvent.Type.ADDITION or AbstractEvent.Type.MODIFICATION

priorResource - the prior state of the resource the new Event will represent; may be (and often is) null

resource - the latest state of the resource the new Event will represent; must not be null

Returns:

a new, non-null Event with each invocation

Throws:

NullPointerException - if eventType or resource is null

createSynchronizationEvent

protected SynchronizationEvent<T> createSynchronizationEvent(AbstractEvent.Type eventType,
                                                             T priorResource,
                                                             T resource)

Creates and returns a new SynchronizationEvent.

This method never returns null.

Overrides of this method must not return null.

Parameters:

eventType - the AbstractEvent.Type for the new SynchronizationEvent; must not be null; when supplied by the accept(EventQueue) method's internals, will always be AbstractEvent.Type.MODIFICATION

priorResource - the prior state of the resource the new SynchronizationEvent will represent; may be (and often is) null

resource - the latest state of the resource the new SynchronizationEvent will represent; must not be null

Returns:

a new, non-null SynchronizationEvent with each invocation

Throws:

NullPointerException - if eventType or resource is null

accept

protected abstract void accept(AbstractEvent<? extends T> event)

Called to process a given AbstractEvent from the EventQueue supplied to the accept(EventQueue) method, with that EventQueue's monitor held.

Implementations of this method should be relatively fast as this method dictates the speed of EventQueue processing.

Parameters:

event - the AbstractEvent encountered in the EventQueue; must not be null

Throws:

NullPointerException - if event is null

See Also:

accept(EventQueue)