io.fabric8.kubernetes.client.informers

Interface SharedIndexInformer<T>

All Superinterfaces:

AutoCloseable

public interface SharedIndexInformer<T>
extends AutoCloseable

SharedInxedInformer extends SharedInformer and provides indexer operability additionally.

Method Summary

Modifier and Type	Method and Description
SharedIndexInformer<T>	addEventHandler(ResourceEventHandler<? super T> handler) Add event handler.
SharedIndexInformer<T>	addEventHandlerWithResyncPeriod(ResourceEventHandler<? super T> handle, long resyncPeriod) Adds an event handler to the shared informer using the specified resync period.
SharedIndexInformer<T>	addIndexers(Map<String,Function<T,List<String>>> indexers) Add indexers
default void	close()
SharedIndexInformer<T>	exceptionHandler(ExceptionHandler handler) Sets the ExceptionHandler for this informer.
Class<T>	getApiTypeClass() Return the class this informer is watching
Indexer<T>	getIndexer() returns the internal indexer store.
Store<T>	getStore() Return the Store associated with this informer
default boolean	hasSynced() Return true if the informer has ever synced
SharedIndexInformer<T>	initialState(Stream<T> items) Sets the initial state of the informer store, which will be replaced by the initial list operation.
boolean	isRunning() Return true if the informer is running
boolean	isWatching() Return true if the informer is actively watching Will return false when isRunning() is true when the watch needs to be re-established.
SharedIndexInformer<T>	itemStore(ItemStore<T> itemStore)
String	lastSyncResourceVersion() The resource version observed when last synced with the underlying store.
SharedIndexInformer<T>	removeIndexer(String name) Remove the named index
default SharedIndexInformer<T>	removeNamespaceIndex() Remove the namesapce index
SharedIndexInformer<T>	run() Starts the shared informer, which will be stopped when stop() is called.
CompletionStage<Void>	start() A non-blocking alternative to run.
void	stop() Stops the shared informer.
CompletionStage<Void>	stopped() Return a CompletionStage that will allow notification of the informer stopping.

Method Detail

addIndexers

SharedIndexInformer<T> addIndexers(Map<String,Function<T,List<String>>> indexers)

Add indexers

Parameters:

indexers - indexers

removeNamespaceIndex

default SharedIndexInformer<T> removeNamespaceIndex()

Remove the namesapce index

Returns:

this

removeIndexer

SharedIndexInformer<T> removeIndexer(String name)

Remove the named index

Parameters:

name -

Returns:

this

getIndexer

Indexer<T> getIndexer()

returns the internal indexer store.

Returns:

the internal indexer store

addEventHandler

SharedIndexInformer<T> addEventHandler(ResourceEventHandler<? super T> handler)

Add event handler.

The handler methods will be called using the client's Executor

Parameters:

handler - event handler

addEventHandlerWithResyncPeriod

SharedIndexInformer<T> addEventHandlerWithResyncPeriod(ResourceEventHandler<? super T> handle,
                                                       long resyncPeriod)

Adds an event handler to the shared informer using the specified resync period. Events to a single handler are delivered sequentially, but there is no coordination between different handlers.

The handler methods will be called using the client's Executor

Parameters:

handle - the event handler

resyncPeriod - the specific resync period

run

SharedIndexInformer<T> run()

Starts the shared informer, which will be stopped when stop() is called.
Only one start attempt is made - subsequent calls will not re-start the informer.
If the informer is not already running, this is a blocking call

stop

void stop()

Stops the shared informer. The informer cannot be started again.

Once this call completes the informer will stop processing events, but the underlying watch closure may not yet be completed

close

default void close()

Specified by:

close in interface AutoCloseable

hasSynced

default boolean hasSynced()

Return true if the informer has ever synced

lastSyncResourceVersion

String lastSyncResourceVersion()

The resource version observed when last synced with the underlying store. The value returned is not synchronized with access to the underlying store and is not thread-safe.

Since the store processes events asynchronously this value should not be used as an indication of the last resourceVersion seen. Also after an informer is stopped any pending event processing may not happen.

Returns:

string value or null if never synced

isRunning

boolean isRunning()

Return true if the informer is running

See also stopped()

getApiTypeClass

Class<T> getApiTypeClass()

Return the class this informer is watching

isWatching

boolean isWatching()

Return true if the informer is actively watching
Will return false when isRunning() is true when the watch needs to be re-established.

getStore

Store<T> getStore()

Return the Store associated with this informer

Returns:

the store

initialState

SharedIndexInformer<T> initialState(Stream<T> items)

Sets the initial state of the informer store, which will be replaced by the initial list operation. This will emit relevant delete and update events, rather than just adds.
Can only be called before the informer is running

Parameters:

items -

itemStore

SharedIndexInformer<T> itemStore(ItemStore<T> itemStore)

start

CompletionStage<Void> start()

A non-blocking alternative to run. Starts the shared informer, which will normally be stopped when stop() is called.
The stage will be completed normally once the Informer starts watching successfully for the first time.

By default the informer will attempt only a single start attempt. Use exceptionHandler(ExceptionHandler) to modify this behavior.

exceptionHandler

SharedIndexInformer<T> exceptionHandler(ExceptionHandler handler)

Sets the ExceptionHandler for this informer. For example, exceptionHandler((b, t) -> true)), will keep retrying no matter what the exception is.

May only be called prior to the informer starting

Parameters:

handler -

stopped

CompletionStage<Void> stopped()

Return a CompletionStage that will allow notification of the informer stopping. This will be completed after event processing has stopped.

If stop() is called, the CompletionStage will complete normally.

If an exception occurs that terminates the informer, then it will be exceptionally completed with that exception - typically a WatcherException