org.apache.ignite

## Interface IgniteEvents

All Superinterfaces:
  IgniteAsyncSupport

All Known Implementing Classes:
  IgniteEventsImpl

    public interface IgniteEvents
    extends IgniteAsyncSupport

Provides functionality for local and remote event notifications on nodes defined by `clusterGroup()`. There are `2` ways to subscribe to event listening, `local` and `remote`.

Instance of `IgniteEvents` is obtained from `Ignite` as follows:

     Ignite ignite = Ignition.ignite();

     IgniteEvents evts = ignite.events();

You can also obtain an instance of the events facade over a specific cluster group:

     // Cluster group over remote nodes (excluding the local node).
     ClusterGroup remoteNodes = ignite.cluster().forRemotes();

     // Events instance spanning all remote cluster nodes.
     IgniteEvents evts = ignite.events(remoteNodes);

Local subscription, defined by `localListen(IgnitePredicate, int...)` method, will add a listener for specified events on local node only. This listener will be notified whenever any of subscribed events happen on local node regardless of whether local node belongs to underlying cluster group or not.

Remote subscription, defined by `remoteListen(IgniteBiPredicate, IgnitePredicate, int...)`, will add an event listener for specified events on all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well). All cluster group nodes will then be notified of the subscribed events. If the events pass the remote event filter, the events will be sent to local node for local listener notification.

Note that by default, all events in Ignite are disabled for performance reasons. You must only enable events that you need within your logic. You can enable/disable events either by calling `enableLocal(int...)` or `disableLocal(int...)` methods, or from XML configuration. For example, you can enable all cache events as follows:

     <property name="includeEventTypes">
         <util:constant static-field="org.apache.ignite.events.IgniteEventType.EVTS_CACHE"/>
     </property>

### Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
`ClusterGroup` `clusterGroup()` Gets cluster group to which this `IgniteEvents` instance belongs.
`void` `disableLocal(int... types)` Disables provided events.
`int[]` `enabledEvents()` Gets types of enabled events.
`void` `enableLocal(int... types)` Enables provided events.
`boolean` `isEnabled(int type)` Check if event is enabled.
`void` `localListen(IgnitePredicate<? extends Event> lsnr, int... types)` Adds an event listener for local events.
`<T extends Event> Collection<T>` `localQuery(IgnitePredicate<T> p, int... types)` Queries local node for events using passed-in predicate filter for event selection.
`void` `recordLocal(Event evt)` Records customer user generated event.
`<T extends Event> UUID` `remoteListen(IgniteBiPredicate<UUID,T> locLsnr, IgnitePredicate<T> rmtFilter, int... types)` Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> UUID` `remoteListen(int bufSize, long interval, boolean autoUnsubscribe, IgniteBiPredicate<UUID,T> locLsnr, IgnitePredicate<T> rmtFilter, int... types)` Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> IgniteFuture<UUID>` `remoteListenAsync(IgniteBiPredicate<UUID,T> locLsnr, IgnitePredicate<T> rmtFilter, int... types)` Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> IgniteFuture<UUID>` `remoteListenAsync(int bufSize, long interval, boolean autoUnsubscribe, IgniteBiPredicate<UUID,T> locLsnr, IgnitePredicate<T> rmtFilter, int... types)` Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well).
`<T extends Event> List<T>` `remoteQuery(IgnitePredicate<T> p, long timeout, int... types)` Queries nodes in this cluster group for events using passed in predicate filter for event selection.
`<T extends Event> IgniteFuture<List<T>>` `remoteQueryAsync(IgnitePredicate<T> p, long timeout, int... types)` Asynchronously queries nodes in this cluster group for events using passed in predicate filter for event selection.
`boolean` `stopLocalListen(IgnitePredicate<? extends Event> lsnr, int... types)` Removes local event listener.
`void` `stopRemoteListen(UUID opId)` Stops listening to remote events.
`IgniteFuture<Void>` `stopRemoteListenAsync(UUID opId)` Asynchronously stops listening to remote events.
`<T extends Event> T` `waitForLocal(IgnitePredicate<T> filter, int... types)` Waits for the specified events.
`<T extends Event> IgniteFuture<T>` `waitForLocalAsync(IgnitePredicate<T> filter, int... types)` Create future to wait for the specified events.
`IgniteEvents` `withAsync()` Deprecated.

### Methods inherited from interface org.apache.ignite.lang.IgniteAsyncSupport

`future, isAsync`

### Method Detail

#### clusterGroup

    ClusterGroup clusterGroup()

Gets cluster group to which this `IgniteEvents` instance belongs.

Returns:
  Cluster group to which this `IgniteEvents` instance belongs.

#### remoteQuery

    @IgniteAsyncSupported
    <T extends Event> List<T> remoteQuery(IgnitePredicate<T> p,
                                                                long timeout,
                                                                @Nullable
                                                                int... types)
                                                         throws IgniteException

Queries nodes in this cluster group for events using passed in predicate filter for event selection.

Parameters:
  `p` - Predicate filter used to query events on remote nodes.
  `timeout` - Maximum time to wait for result, `0` to wait forever.
  `types` - Event types to be queried.
Returns:
  Collection of grid events returned from specified nodes.
Throws:
  `IgniteException` - If query failed.

#### remoteQueryAsync

    <T extends Event> IgniteFuture<List<T>> remoteQueryAsync(IgnitePredicate<T> p,
                                                             long timeout,
                                                             @Nullable
                                                             int... types)
                                                      throws IgniteException

Asynchronously queries nodes in this cluster group for events using passed in predicate filter for event selection.

Parameters:
  `p` - Predicate filter used to query events on remote nodes.
  `timeout` - Maximum time to wait for result, `0` to wait forever.
  `types` - Event types to be queried.
Returns:
  a Future representing pending completion of the query. The completed future contains collection of grid events returned from specified nodes.
Throws:
  `IgniteException` - If query failed.

#### remoteListen

    @IgniteAsyncSupported
    <T extends Event> UUID remoteListen(@Nullable
                                                              IgniteBiPredicate<UUID,T> locLsnr,
                                                              @Nullable
                                                              IgnitePredicate<T> rmtFilter,
                                                              @Nullable
                                                              int... types)
                                                       throws IgniteException

Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well). This means that all events occurring on any node within this cluster group that pass remote filter will be sent to local node for local listener notifications.

The listener can be unsubscribed automatically if local node stops, if `locLsnr` callback returns `false` or if `stopRemoteListen(UUID)` or `stopRemoteListenAsync(UUID)` are called.

Type Parameters:
  `T` - Type of the event.
Parameters:
  `locLsnr` - Listener callback that is called on local node. If `null`, this events will be handled on remote nodes by passed in `rmtFilter`.
  `rmtFilter` - Filter callback that is called on remote node. Only events that pass the remote filter will be sent to local node. If `null`, all events of specified types will be sent to local node. This remote filter can be used to pre-handle events remotely, before they are passed in to local callback. It will be auto-unsubsribed on the node where event occurred in case if it returns `false`.
  `types` - Types of events to listen for. If not provided, all events that pass the provided remote filter will be sent to local node.
Returns:
  `Operation ID` that can be passed to `stopRemoteListen(UUID)` or `stopRemoteListenAsync(UUID)` methods to stop listening.
Throws:
  `IgniteException` - If failed to add listener.

#### remoteListenAsync

    <T extends Event> IgniteFuture<UUID> remoteListenAsync(@Nullable
                                                           IgniteBiPredicate<UUID,T> locLsnr,
                                                           @Nullable
                                                           IgnitePredicate<T> rmtFilter,
                                                           @Nullable
                                                           int... types)
                                                    throws IgniteException

Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well). This means that all events occurring on any node within this cluster group that pass remote filter will be sent to local node for local listener notifications.

The listener can be unsubscribed automatically if local node stops, if `locLsnr` callback returns `false` or if `stopRemoteListen(UUID)` or `stopRemoteListenAsync(UUID)` are called.

Type Parameters:
  `T` - Type of the event.
Parameters:
  `locLsnr` - Listener callback that is called on local node. If `null`, this events will be handled on remote nodes by passed in `rmtFilter`.
  `rmtFilter` - Filter callback that is called on remote node. Only events that pass the remote filter will be sent to local node. If `null`, all events of specified types will be sent to local node. This remote filter can be used to pre-handle events remotely, before they are passed in to local callback. It will be auto-unsubsribed on the node where event occurred in case if it returns `false`.
  `types` - Types of events to listen for. If not provided, all events that pass the provided remote filter will be sent to local node.
Returns:
  a Future representing pending completion of the operation. The completed future contains `Operation ID` that can be passed to `stopRemoteListen(UUID)` or `stopRemoteListenAsync(UUID)` methods to stop listening.
Throws:
  `IgniteException` - If failed to add listener.

#### remoteListen

    @IgniteAsyncSupported
    <T extends Event> UUID remoteListen(int bufSize,
                                                              long interval,
                                                              boolean autoUnsubscribe,
                                                              @Nullable
                                                              IgniteBiPredicate<UUID,T> locLsnr,
                                                              @Nullable
                                                              IgnitePredicate<T> rmtFilter,
                                                              @Nullable
                                                              int... types)
                                                       throws IgniteException

Adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well). This means that all events occurring on any node within this cluster group that pass remote filter will be sent to local node for local listener notification.

Supports asynchronous execution (see `IgniteAsyncSupport`).

Type Parameters:
  `T` - Type of the event.
Parameters:
  `bufSize` - Remote events buffer size. Events from remote nodes won't be sent until buffer is full or time interval is exceeded.
  `interval` - Maximum time interval after which events from remote node will be sent. Events from remote nodes won't be sent until buffer is full or time interval is exceeded.
  `autoUnsubscribe` - Flag indicating that event listeners on remote nodes should be automatically unregistered if master node (node that initiated event listening) leaves topology. If this flag is `false`, listeners will be unregistered only when `stopRemoteListen(UUID)` method is called, or the `'callback (locLsnr)'` passed in returns `false`.
  `locLsnr` - Callback that is called on local node. If this predicate returns `true`, the implementation will continue listening to events. Otherwise, events listening will be stopped and listeners will be unregistered on all nodes in the cluster group. If `null`, this events will be handled on remote nodes by passed in `rmtFilter` until local node stops (if `'autoUnsubscribe'` is `true`) or until `stopRemoteListen(UUID)` is called.
  `rmtFilter` - Filter callback that is called on remote node. Only events that pass the remote filter will be sent to local node. If `null`, all events of specified types will be sent to local node. This remote filter can be used to pre-handle events remotely, before they are passed in to local callback. It will be auto-unsubsribed on the node where event occurred in case if it returns `false`.
  `types` - Types of events to listen for. If not provided, all events that pass the provided remote filter will be sent to local node.
Returns:
  `Operation ID` that can be passed to `stopRemoteListen(UUID)` or `stopRemoteListen(UUID)` methods to stop listening.
Throws:
  `IgniteException` - If failed to add listener.
See Also:
  `stopRemoteListen(UUID)`, `stopRemoteListenAsync(UUID)`

#### remoteListenAsync

    <T extends Event> IgniteFuture<UUID> remoteListenAsync(int bufSize,
                                                           long interval,
                                                           boolean autoUnsubscribe,
                                                           @Nullable
                                                           IgniteBiPredicate<UUID,T> locLsnr,
                                                           @Nullable
                                                           IgnitePredicate<T> rmtFilter,
                                                           @Nullable
                                                           int... types)
                                                    throws IgniteException

Asynchronously adds event listener for specified events to all nodes in the cluster group (possibly including local node if it belongs to the cluster group as well). This means that all events occurring on any node within this cluster group that pass remote filter will be sent to local node for local listener notification.

Type Parameters:
  `T` - Type of the event.
Parameters:
  `bufSize` - Remote events buffer size. Events from remote nodes won't be sent until buffer is full or time interval is exceeded.
  `interval` - Maximum time interval after which events from remote node will be sent. Events from remote nodes won't be sent until buffer is full or time interval is exceeded.
  `autoUnsubscribe` - Flag indicating that event listeners on remote nodes should be automatically unregistered if master node (node that initiated event listening) leaves topology. If this flag is `false`, listeners will be unregistered only when `stopRemoteListen(UUID)` method is called, or the `'callback (locLsnr)'` passed in returns `false`.
  `locLsnr` - Callback that is called on local node. If this predicate returns `true`, the implementation will continue listening to events. Otherwise, events listening will be stopped and listeners will be unregistered on all nodes in the cluster group. If `null`, this events will be handled on remote nodes by passed in `rmtFilter` until local node stops (if `'autoUnsubscribe'` is `true`) or until `stopRemoteListen(UUID)` is called.
  `rmtFilter` - Filter callback that is called on remote node. Only events that pass the remote filter will be sent to local node. If `null`, all events of specified types will be sent to local node. This remote filter can be used to pre-handle events remotely, before they are passed in to local callback. It will be auto-unsubsribed on the node where event occurred in case if it returns `false`.
  `types` - Types of events to listen for. If not provided, all events that pass the provided remote filter will be sent to local node.
Returns:
  a Future representing pending completion of the operation. The completed future contains `Operation ID` that can be passed to `stopRemoteListen(UUID)` or `stopRemoteListen(UUID)` methods to stop listening.
Throws:
  `IgniteException` - If failed to add listener.
See Also:
  `stopRemoteListen(UUID)`, `stopRemoteListenAsync(UUID)`

#### stopRemoteListen

    @IgniteAsyncSupported
    void stopRemoteListen(UUID opId)
                                         throws IgniteException

Stops listening to remote events. This will unregister all listeners identified with provided operation ID on all nodes defined by `clusterGroup()`.

Supports asynchronous execution (see `IgniteAsyncSupport`).

Parameters:
  `opId` - Operation ID that was returned from `remoteListen(IgniteBiPredicate, IgnitePredicate, int...)` method.
Throws:
  `IgniteException` - If failed to stop listeners.
See Also:
  `remoteListen(IgniteBiPredicate, IgnitePredicate, int...)`, `remoteListenAsync(int, long, boolean, IgniteBiPredicate, IgnitePredicate, int...)`

#### stopRemoteListenAsync

    IgniteFuture<Void> stopRemoteListenAsync(UUID opId)
                                      throws IgniteException

Asynchronously stops listening to remote events. This will unregister all listeners identified with provided operation ID on all nodes defined by `clusterGroup()`.

Parameters:
  `opId` - Operation ID that was returned from `remoteListen(IgniteBiPredicate, IgnitePredicate, int...)` method.
Returns:
  a Future representing pending completion of the operation.
Throws:
  `IgniteException` - If failed to stop listeners.
See Also:
  `remoteListen(IgniteBiPredicate, IgnitePredicate, int...)`, `remoteListenAsync(int, long, boolean, IgniteBiPredicate, IgnitePredicate, int...)`

#### waitForLocal

    @IgniteAsyncSupported
    <T extends Event> T waitForLocal(@Nullable
                                                           IgnitePredicate<T> filter,
                                                           @Nullable
                                                           int... types)
                                                    throws IgniteException

Waits for the specified events.

Supports asynchronous execution (see `IgniteAsyncSupport`).

Parameters:
  `filter` - Optional filtering predicate. Only if predicates evaluates to `true` will the event end the wait.
  `types` - Types of the events to wait for. If not provided, all events will be passed to the filter.
Returns:
  Grid event.
Throws:
  `IgniteException` - If wait was interrupted.

#### waitForLocalAsync

    <T extends Event> IgniteFuture<T> waitForLocalAsync(@Nullable
                                                        IgnitePredicate<T> filter,
                                                        @Nullable
                                                        int... types)
                                                 throws IgniteException

Create future to wait for the specified events.

Parameters:
  `filter` - Optional filtering predicate. Only if predicates evaluates to `true` will the event end the wait.
  `types` - Types of the events to wait for. If not provided, all events will be passed to the filter.
Returns:
  a Future representing pending completion of the operation. The completed future contains grid event.
Throws:
  `IgniteException` - If wait was interrupted.

#### localQuery

    <T extends Event> Collection<T> localQuery(IgnitePredicate<T> p,
                                               @Nullable
                                               int... types)

Queries local node for events using passed-in predicate filter for event selection.

Parameters:
  `p` - Predicate to filter events. All predicates must be satisfied for the event to be returned.
  `types` - Event types to be queried.
Returns:
  Collection of grid events found on local node.

#### recordLocal

    void recordLocal(Event evt)

Records customer user generated event. All registered local listeners will be notified.

NOTE: all types in range from 1 to 1000 are reserved for internal Ignite events and should not be used by user-defined events. Attempt to record internal event with this method will cause `IllegalArgumentException` to be thrown.

Parameters:
  `evt` - Locally generated event.
Throws:
  `IllegalArgumentException` - If event type is within Ignite reserved range between `1` and `1000`.

#### localListen

    void localListen(IgnitePredicate<? extends Event> lsnr,
                     int... types)

Adds an event listener for local events. Note that listener will be added regardless of whether local node is in this cluster group or not.

Parameters:
  `lsnr` - Predicate that is called on each received event. If predicate returns `false`, it will be unregistered and will stop receiving events.
  `types` - Event types for which this listener will be notified.
Throws:
  `IllegalArgumentException` - Thrown in case when passed in array of event types is empty.

#### stopLocalListen

    boolean stopLocalListen(IgnitePredicate<? extends Event> lsnr,
                            @Nullable
                            int... types)

Removes local event listener.

Parameters:
  `lsnr` - Local event listener to remove.
  `types` - Types of events for which to remove listener. If not specified, then listener will be removed for all types it was registered for.
Returns:
  `true` if listener was removed, `false` otherwise.

#### enableLocal

    void enableLocal(int... types)

Enables provided events. Allows to start recording events that were disabled before. Note that specified events will be enabled regardless of whether local node is in this cluster group or not.

Parameters:
  `types` - Events to enable.

#### disableLocal

    void disableLocal(int... types)

Disables provided events. Allows to stop recording events that were enabled before. Note that specified events will be disabled regardless of whether local node is in this cluster group or not.

Parameters:
  `types` - Events to disable.

#### enabledEvents

    int[] enabledEvents()

Gets types of enabled events.

Returns:
  Types of enabled events.

#### isEnabled

    boolean isEnabled(int type)

Check if event is enabled.

Parameters:
  `type` - Event type.
Returns:
  `True` if event of passed in type is enabled.

#### withAsync

    @Deprecated
    IgniteEvents withAsync()

Deprecated.
Gets instance of this component with asynchronous mode enabled.

Specified by:
  `withAsync` in interface `IgniteAsyncSupport`
Returns:
  Instance of this component with asynchronous mode enabled.

2018 Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Fabric | : ver. 2.4.0
Release Date | : March 5 2018