| Modifier and Type | Class and Description |
|---|---|
class |
ComputeTaskInternalFuture<R>
This class provide implementation for task future.
|
| Modifier and Type | Method and Description |
|---|---|
<R> IgniteInternalFuture<R> |
IgniteComputeHandler.affinityCallAsync(@NotNull Collection<String> cacheNames,
int partId,
IgniteCallable<R> job)
Affinity call implementation.
|
<R> IgniteInternalFuture<R> |
IgniteComputeHandler.affinityCallAsync(@NotNull Collection<String> cacheNames,
Object affKey,
IgniteCallable<R> job)
Affinity call implementation.
|
<R> IgniteInternalFuture<R> |
IgniteComputeHandler.affinityCallAsync(String cacheName,
Object affKey,
IgniteCallable<R> job)
Affinity call implementation.
|
IgniteInternalFuture<?> |
IgniteComputeHandler.affinityRunAsync(@NotNull Collection<String> cacheNames,
int partId,
IgniteRunnable job)
Affinity run implementation.
|
IgniteInternalFuture<?> |
IgniteComputeHandler.affinityRunAsync(@NotNull Collection<String> cacheNames,
Object affKey,
IgniteRunnable job)
Affinity run implementation.
|
IgniteInternalFuture<?> |
IgniteComputeHandler.affinityRunAsync(String cacheName,
Object affKey,
IgniteRunnable job)
Affinity run implementation.
|
<T,R> IgniteInternalFuture<Collection<R>> |
IgniteComputeHandler.applyAsync(IgniteClosure<T,R> job,
@Nullable Collection<? extends T> args)
Apply implementation.
|
<R,T> IgniteInternalFuture<R> |
IgniteComputeHandler.applyAsync(IgniteClosure<T,R> job,
T arg)
Apply implementation.
|
<R1,R2,T> IgniteInternalFuture<R2> |
IgniteComputeHandler.applyAsync(IgniteClosure<T,R1> job,
Collection<? extends T> args,
IgniteReducer<R1,R2> rdc)
Apply with reducer implementation.
|
<R> IgniteInternalFuture<Collection<R>> |
IgniteComputeHandler.broadcastAsync(IgniteCallable<R> job)
Broadcast implementation.
|
<R,T> IgniteInternalFuture<Collection<R>> |
IgniteComputeHandler.broadcastAsync(IgniteClosure<T,R> job,
T arg)
Broadcast implementation.
|
IgniteInternalFuture<?> |
IgniteComputeHandler.broadcastAsync(IgniteRunnable job)
Broadcast implementation.
|
<R> IgniteInternalFuture<Collection<R>> |
IgniteComputeHandler.callAsync(Collection<? extends IgniteCallable<R>> jobs)
Call implementation.
|
<R1,R2> IgniteInternalFuture<R2> |
IgniteComputeHandler.callAsync(Collection<? extends IgniteCallable<R1>> jobs,
IgniteReducer<R1,R2> rdc)
Call with reducer implementation.
|
<R> IgniteInternalFuture<R> |
IgniteComputeHandler.callAsync(IgniteCallable<R> job)
Call implementation.
|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)
Make a chained future that is completed when
doneCb is executed. |
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb,
Executor exec)
Make a chained future that is completed when
doneCb is executed. |
IgniteInternalFuture<Boolean> |
IgniteKernal.destroyCacheAsync(String cacheName,
boolean sql,
boolean checkThreadTx) |
IgniteInternalFuture<?> |
IgniteKernal.destroyCachesAsync(Collection<String> cacheNames,
boolean checkThreadTx) |
static IgniteInternalFuture<String> |
IgniteDiagnosticMessage.dumpCommunicationInfo(GridKernalContext ctx,
UUID nodeId) |
<T,R> IgniteInternalFuture<R> |
IgniteComputeHandler.executeAsync(Class<? extends ComputeTask<T,R>> taskCls,
T arg)
Execute implementation.
|
<T,R> IgniteInternalFuture<R> |
IgniteComputeHandler.executeAsync(String taskName,
T arg)
Execute implementation.
|
IgniteInternalFuture<?> |
IgniteKernal.getOrCreateCacheAsync(String cacheName,
String templateName,
CacheConfigurationOverride cfgOverride,
boolean checkThreadTx) |
@Nullable IgniteInternalFuture<?> |
GridComponent.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
IgniteInternalFuture<?> |
GridPluginComponent.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
IgniteInternalFuture<?> |
IgniteComputeHandler.runAsync(Collection<? extends IgniteRunnable> jobs)
Run implementation.
|
IgniteInternalFuture<?> |
IgniteComputeHandler.runAsync(IgniteRunnable job)
Run implementation.
|
IgniteInternalFuture |
IgniteKernal.sendIoTest(ClusterNode node,
byte[] payload,
boolean procFromNioThread) |
IgniteInternalFuture |
IgniteKernal.sendIoTest(List<ClusterNode> nodes,
byte[] payload,
boolean procFromNioThread) |
| Modifier and Type | Method and Description |
|---|---|
protected <R> IgniteFuture<R> |
IgniteComputeImpl.createFuture(IgniteInternalFuture<R> fut) |
protected <R> IgniteFuture<R> |
AsyncSupportAdapter.createFuture(IgniteInternalFuture<R> fut) |
<R> R |
AsyncSupportAdapter.saveOrGet(IgniteInternalFuture<R> fut) |
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)
Make a chained future that is completed when
doneCb is executed. |
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)
Make a chained future that is completed when
doneCb is executed. |
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb,
Executor exec)
Make a chained future that is completed when
doneCb is executed. |
<T> IgniteInternalFuture<T> |
IgniteInternalFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb,
Executor exec)
Make a chained future that is completed when
doneCb is executed. |
void |
IgniteInternalFuture.listen(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Registers listener closure to be asynchronously notified whenever future completes.
|
| Modifier and Type | Method and Description |
|---|---|
@Nullable IgniteInternalFuture<?> |
IndexProcessor.rebuildIndexesForCache(GridCacheContext<?,?> cctx,
boolean force,
IndexRebuildCancelToken cancelTok)
Start rebuild of indexes for specified cache.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<DurableBackgroundTaskResult> |
DurableBackgroundCleanupIndexTreeTask.executeAsync(GridKernalContext ctx)
Deprecated.
Asynchronous task execution.
|
IgniteInternalFuture<DurableBackgroundTaskResult<Long>> |
DurableBackgroundCleanupIndexTreeTaskV2.executeAsync(GridKernalContext ctx)
Asynchronous task execution.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
ClusterTopologyCheckedException.retryReadyFuture() |
| Modifier and Type | Method and Description |
|---|---|
void |
ClusterTopologyCheckedException.retryReadyFuture(IgniteInternalFuture<?> readyFut) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridManagerAdapter.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridIoManager.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
IgniteInternalFuture<List<IgniteIoTestMessage>> |
GridIoManager.sendIoTest(ClusterNode node,
byte[] payload,
boolean procFromNioThread) |
IgniteInternalFuture |
GridIoManager.sendIoTest(List<ClusterNode> nodes,
byte[] payload,
boolean procFromNioThread) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridDeploymentManager.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Long> |
GridDiscoveryManager.topologyFuture(long awaitVer)
Gets future that will be completed when current topology version becomes greater or equal to argument passed.
|
@Nullable IgniteInternalFuture<Boolean> |
DiscoveryLocalJoinData.transitionWaitFuture() |
| Constructor and Description |
|---|
DiscoveryLocalJoinData(DiscoveryEvent evt,
DiscoCache discoCache,
@Nullable IgniteInternalFuture<Boolean> transitionWaitFut,
boolean active) |
| Modifier and Type | Class and Description |
|---|---|
protected static class |
GridEncryptionManager.KeyChangeFuture
Key change future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<T2<Collection<byte[]>,byte[]>> |
GridEncryptionManager.generateKeys(int keyCnt) |
IgniteInternalFuture<?> |
GridEncryptionManager.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
IgniteInternalFuture<Void> |
GridEncryptionManager.reencryptionFuture(int grpId) |
IgniteInternalFuture<Void> |
CacheGroupPageScanner.schedule(int grpId)
Schedule scanning partitions.
|
IgniteInternalFuture<Void> |
CacheGroupPageScanner.statusFuture(int grpId) |
| Modifier and Type | Method and Description |
|---|---|
<T extends Event> |
GridEventStorageManager.remoteEventsAsync(IgnitePredicate<T> p,
Collection<? extends ClusterNode> nodes,
long timeout) |
<T extends Event> |
GridEventStorageManager.waitForEvent(@Nullable IgnitePredicate<T> p,
int... types) |
| Modifier and Type | Method and Description |
|---|---|
@Nullable IgniteInternalFuture<?> |
IndexesRebuildTask.rebuild(GridCacheContext<?,?> cctx,
boolean force,
IndexRebuildCancelToken cancelTok)
Start to rebuild.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridProcessorAdapter.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<org.apache.ignite.internal.processors.affinity.GridAffinityProcessor.AffinityInfo> |
GridAffinityProcessor.affinityCacheFuture(String cacheName,
@Nullable AffinityTopologyVersion topVer) |
@Nullable IgniteInternalFuture<AffinityTopologyVersion> |
GridAffinityAssignmentCache.readyFuture(AffinityTopologyVersion topVer)
Gets future that will be completed after topology with version
topVer is calculated. |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
IgniteAuthenticationProcessor.onReconnected(boolean active)
Client reconnected callback.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
GridCacheAtomicFuture<R>
Update future for atomic cache.
|
interface |
GridCacheFuture<R>
This interface should be implemented by all distributed futures.
|
interface |
GridCacheVersionedFuture<T>
Distributed future aware of lock version.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CacheObjectsReleaseFuture<T,R> |
class |
GridCacheCompoundFuture<T,R> |
class |
GridCacheCompoundIdentityFuture<T> |
class |
GridCacheFutureAdapter<R> |
class |
GridCacheMultiTxFuture<K,V>
Future which waits for completion of one or more transactions.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
CachesRegistry.addUnregistered(Collection<DynamicCacheDescriptor> descs)
Adds cache and caches groups that is not registered yet to registry.
|
IgniteInternalFuture<AffinityTopologyVersion> |
GridCacheAffinityManager.affinityReadyFuture(AffinityTopologyVersion topVer)
Gets affinity ready future, a future that will be completed after affinity with given
topology version is calculated.
|
@NotNull IgniteInternalFuture<AffinityTopologyVersion> |
GridCachePartitionExchangeManager.affinityReadyFuture(AffinityTopologyVersion ver) |
IgniteInternalFuture<AffinityTopologyVersion> |
GridCacheAffinityManager.affinityReadyFuture(long topVer)
Gets affinity ready future, a future that will be completed after affinity with given
topology version is calculated.
|
@Nullable IgniteInternalFuture<AffinityTopologyVersion> |
GridCacheAffinityManager.affinityReadyFuturex(AffinityTopologyVersion topVer)
Gets affinity ready future that will be completed after affinity with given topology version is calculated.
|
protected <T> IgniteInternalFuture<T> |
GridCacheAdapter.asyncOp(GridNearTxLocal tx,
GridCacheAdapter.AsyncOp<T> op,
CacheOperationContext opCtx,
boolean retry) |
protected <T> @Nullable IgniteInternalFuture<T> |
GridCacheAdapter.asyncOpAcquire(boolean retry)
Tries to acquire asynchronous operations permit, if limited.
|
@Nullable IgniteInternalFuture<?> |
GridCacheMvccManager.atomicFuture(long futId)
Gets future by given future ID.
|
IgniteInternalFuture<Boolean> |
WalStateManager.changeWalMode(Collection<String> cacheNames,
boolean enabled)
Change WAL mode.
|
IgniteInternalFuture<?> |
GridCacheAdapter.clearAllAsync(Set<? extends K> keys) |
IgniteInternalFuture<?> |
GridCacheProxyImpl.clearAllAsync(Set<? extends K> keys) |
IgniteInternalFuture<?> |
IgniteInternalCache.clearAllAsync(Set<? extends K> keys) |
IgniteInternalFuture<?> |
GridCacheAdapter.clearAsync() |
IgniteInternalFuture<?> |
GridCacheProxyImpl.clearAsync() |
IgniteInternalFuture<?> |
IgniteInternalCache.clearAsync() |
IgniteInternalFuture<?> |
GridCacheAdapter.clearAsync(K key) |
IgniteInternalFuture<?> |
GridCacheProxyImpl.clearAsync(K key) |
IgniteInternalFuture<?> |
IgniteInternalCache.clearAsync(K key) |
IgniteInternalFuture<IgniteInternalTx> |
GridCacheSharedContext.commitTxAsync(GridNearTxLocal tx) |
IgniteInternalFuture<Void> |
GridCacheAtomicFuture.completeFuture(AffinityTopologyVersion topVer)
Gets future that will be completed when it is safe when update is finished on the given version of topology.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.containsKeyAsync(K key) |
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.containsKeyAsync(K key) |
IgniteInternalFuture<Boolean> |
IgniteInternalCache.containsKeyAsync(K key) |
IgniteInternalFuture<Boolean> |
GridCacheAdapter.containsKeysAsync(Collection<? extends K> keys) |
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.containsKeysAsync(Collection<? extends K> keys) |
IgniteInternalFuture<Boolean> |
IgniteInternalCache.containsKeysAsync(Collection<? extends K> keys) |
IgniteInternalFuture<?> |
GridCacheProcessor.createFromTemplate(String cacheName)
Dynamically starts cache using template configuration.
|
IgniteInternalFuture<Void> |
GridCachePartitionExchangeManager.deferStopCachesOnClientReconnect(Collection<GridCacheAdapter> caches) |
@NotNull IgniteInternalFuture<?> |
GridCacheProcessor.dynamicChangeCaches(List<DynamicCacheChangeRequest> reqs)
Starts cache stop request as cache change batch.
|
IgniteInternalFuture<Boolean> |
GridCacheProcessor.dynamicDestroyCache(String cacheName,
boolean sql,
boolean checkThreadTx,
boolean restart,
IgniteUuid restartId) |
IgniteInternalFuture<?> |
GridCacheProcessor.dynamicDestroyCaches(Collection<String> cacheNames,
boolean checkThreadTx) |
IgniteInternalFuture<?> |
GridCacheProcessor.dynamicDestroyCaches(Collection<String> cacheNames,
boolean checkThreadTx,
boolean destroy) |
IgniteInternalFuture<Boolean> |
GridCacheProcessor.dynamicStartCache(@Nullable CacheConfiguration ccfg,
String cacheName,
@Nullable NearCacheConfiguration nearCfg,
boolean failIfExists,
boolean failIfNotStarted,
boolean checkThreadTx)
Dynamically starts cache.
|
IgniteInternalFuture<Boolean> |
GridCacheProcessor.dynamicStartCache(@Nullable CacheConfiguration ccfg,
String cacheName,
@Nullable NearCacheConfiguration nearCfg,
CacheType cacheType,
boolean sql,
boolean failIfExists,
boolean failIfNotStarted,
boolean checkThreadTx)
Dynamically starts cache.
|
IgniteInternalFuture<Boolean> |
GridCacheProcessor.dynamicStartCaches(Collection<CacheConfiguration> ccfgList,
boolean failIfExists,
boolean checkThreadTx,
boolean disabledAfterStart)
Dynamically starts multiple caches.
|
IgniteInternalFuture<Boolean> |
GridCacheProcessor.dynamicStartCachesByStoredConf(Collection<StoredCacheData> storedCacheDataList,
boolean failIfExists,
boolean checkThreadTx,
boolean disabledAfterStart,
IgniteUuid restartId)
Dynamically starts multiple caches.
|
IgniteInternalFuture<Boolean> |
GridCacheProcessor.dynamicStartSqlCache(CacheConfiguration ccfg)
Dynamically starts cache as a result of SQL
CREATE TABLE command. |
IgniteInternalFuture<?> |
GridCacheProcessor.finalizePartitionsCounters()
Finalizes partitions update counters.
|
IgniteInternalFuture<?> |
GridCacheMvccManager.finishAtomicUpdates(AffinityTopologyVersion topVer) |
IgniteInternalFuture<?> |
GridCacheMvccManager.finishDataStreamerUpdates(AffinityTopologyVersion topVer) |
IgniteInternalFuture<?> |
GridCacheMvccManager.finishExplicitLocks(AffinityTopologyVersion topVer)
Creates a future that will wait for all explicit locks acquired on given topology
version to be released.
|
IgniteInternalFuture<?> |
GridCacheMvccManager.finishKeys(Collection<KeyCacheObject> keys,
int cacheId,
AffinityTopologyVersion topVer) |
IgniteInternalFuture<?> |
GridCacheMvccManager.finishLocks(AffinityTopologyVersion topVer) |
IgniteInternalFuture<?> |
GridCacheMvccManager.finishRemoteTxs(AffinityTopologyVersion topVer)
Creates a future that will wait for finishing all remote transactions (primary -> backup)
with topology version less or equal to
topVer. |
IgniteInternalFuture<Boolean> |
GridCachePreloaderAdapter.forceRebalance()
Force Rebalance process.
|
IgniteInternalFuture<Boolean> |
GridCachePreloader.forceRebalance()
Force Rebalance process.
|
IgniteInternalFuture<Boolean> |
GridCachePartitionExchangeManager.forceRebalance(GridDhtPartitionExchangeId exchId) |
IgniteInternalFuture<GridCacheReturn> |
GridCacheReturnCompletableWrapper.fut()
Allows wait for properly initialized value.
|
IgniteInternalFuture |
GridCacheAdapter.FutureHolder.future()
Gets future.
|
IgniteInternalFuture<Map<K,V>> |
GridCacheAdapter.getAllAsync(@Nullable Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Map<K,V>> |
GridCacheProxyImpl.getAllAsync(@Nullable Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Map<K,V>> |
IgniteInternalCache.getAllAsync(@Nullable Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
protected IgniteInternalFuture<Map<K,V>> |
GridCacheAdapter.getAllAsync(@Nullable Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean skipVals,
boolean needVer) |
IgniteInternalFuture<Map<K,V>> |
GridCacheAdapter.getAllAsync(@Nullable Collection<? extends K> keys,
@Nullable ReaderArguments readerArgs,
boolean readThrough,
boolean checkTx,
String taskName,
boolean deserializeBinary,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean forcePrimary,
@Nullable IgniteCacheExpiryPolicy expiry,
boolean skipVals,
boolean needVer) |
protected <K1,V1> IgniteInternalFuture<Map<K1,V1>> |
GridCacheAdapter.getAllAsync0(@Nullable Collection<KeyCacheObject> keys,
@Nullable ReaderArguments readerArgs,
boolean readThrough,
boolean checkTx,
String taskName,
boolean deserializeBinary,
@Nullable IgniteCacheExpiryPolicy expiry,
boolean skipVals,
boolean keepCacheObjects,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean needVer,
@Nullable String txLbl,
MvccSnapshot mvccSnapshot) |
IgniteInternalFuture<Map<K,V>> |
GridCacheAdapter.getAllOutTxAsync(Set<? extends K> keys)
Gets values from cache.
|
@Nullable IgniteInternalFuture<Map<K,V>> |
GridCacheProxyImpl.getAllOutTxAsync(Set<? extends K> keys)
Gets values from cache.
|
IgniteInternalFuture<Map<K,V>> |
IgniteInternalCache.getAllOutTxAsync(Set<? extends K> keys)
Gets values from cache.
|
IgniteInternalFuture<V> |
GridCacheAdapter.getAndPutAsync(K key,
V val)
Asynchronously stores given key-value pair in cache.
|
IgniteInternalFuture<V> |
GridCacheProxyImpl.getAndPutAsync(K key,
V val)
Asynchronously stores given key-value pair in cache.
|
IgniteInternalFuture<V> |
IgniteInternalCache.getAndPutAsync(K key,
V val)
Asynchronously stores given key-value pair in cache.
|
protected IgniteInternalFuture<V> |
GridCacheAdapter.getAndPutAsync(K key,
V val,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<V> |
GridCacheAdapter.getAndPutAsync0(K key,
V val,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<V> |
GridCacheAdapter.getAndPutIfAbsentAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
|
IgniteInternalFuture<V> |
GridCacheProxyImpl.getAndPutIfAbsentAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
|
IgniteInternalFuture<V> |
IgniteInternalCache.getAndPutIfAbsentAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
|
IgniteInternalFuture<V> |
GridCacheAdapter.getAndRemoveAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<V> |
GridCacheProxyImpl.getAndRemoveAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<V> |
IgniteInternalCache.getAndRemoveAsync(K key)
Asynchronously removes given key mapping from cache.
|
protected IgniteInternalFuture<V> |
GridCacheAdapter.getAndRemoveAsync0(K key) |
IgniteInternalFuture<V> |
GridCacheAdapter.getAndReplaceAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
|
IgniteInternalFuture<V> |
GridCacheProxyImpl.getAndReplaceAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
|
IgniteInternalFuture<V> |
IgniteInternalCache.getAndReplaceAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if there is a previous mapping for it.
|
IgniteInternalFuture<V> |
GridCacheAdapter.getAsync(K key)
Asynchronously retrieves value mapped to the specified key from cache.
|
IgniteInternalFuture<V> |
GridCacheProxyImpl.getAsync(K key)
Asynchronously retrieves value mapped to the specified key from cache.
|
IgniteInternalFuture<V> |
IgniteInternalCache.getAsync(K key)
Asynchronously retrieves value mapped to the specified key from cache.
|
protected IgniteInternalFuture<V> |
GridCacheAdapter.getAsync(K key,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean skipVals,
boolean needVer) |
IgniteInternalFuture<Collection<CacheEntry<K,V>>> |
GridCacheAdapter.getEntriesAsync(@Nullable Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Collection<CacheEntry<K,V>>> |
GridCacheProxyImpl.getEntriesAsync(@Nullable Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<Collection<CacheEntry<K,V>>> |
IgniteInternalCache.getEntriesAsync(@Nullable Collection<? extends K> keys)
Asynchronously retrieves values mapped to the specified keys from cache.
|
IgniteInternalFuture<CacheEntry<K,V>> |
GridCacheAdapter.getEntryAsync(K key)
Asynchronously retrieves value mapped to the specified key from cache.
|
IgniteInternalFuture<CacheEntry<K,V>> |
GridCacheProxyImpl.getEntryAsync(K key)
Asynchronously retrieves value mapped to the specified key from cache.
|
IgniteInternalFuture<CacheEntry<K,V>> |
IgniteInternalCache.getEntryAsync(K key)
Asynchronously retrieves value mapped to the specified key from cache.
|
IgniteInternalFuture<V> |
GridCacheAdapter.getForcePrimaryAsync(K key)
Asynchronously gets value from cache.
|
IgniteInternalFuture<V> |
GridCacheProxyImpl.getForcePrimaryAsync(K key)
Asynchronously gets value from cache.
|
IgniteInternalFuture<V> |
IgniteInternalCache.getForcePrimaryAsync(K key)
Asynchronously gets value from cache.
|
IgniteInternalFuture<?> |
GridCacheProcessor.getOrCreateFromTemplate(String cacheName,
boolean checkThreadTx)
Dynamically starts cache using template configuration.
|
IgniteInternalFuture<?> |
GridCacheProcessor.getOrCreateFromTemplate(String cacheName,
String templateName,
CacheConfigurationOverride cfgOverride,
boolean checkThreadTx)
Dynamically starts cache using template configuration.
|
IgniteInternalFuture<?> |
CachesRegistry.init(Map<Integer,CacheGroupDescriptor> groupDescriptors,
Map<String,DynamicCacheDescriptor> cacheDescriptors)
Removes currently registered cache groups and caches.
|
IgniteInternalFuture<Map<Integer,Map<Integer,List<UUID>>>> |
CacheAffinitySharedManager.initAffinityOnNodeLeft(GridDhtPartitionsExchangeFuture fut) |
IgniteInternalFuture<?> |
CacheAffinitySharedManager.initCachesOnLocalJoin(Map<Integer,CacheGroupDescriptor> grpDescs,
Map<String,DynamicCacheDescriptor> cacheDescs)
Must be called from exchange thread.
|
IgniteInternalFuture<?> |
CacheAffinitySharedManager.initCoordinatorCaches(GridDhtPartitionsExchangeFuture fut,
boolean newAff) |
IgniteInternalFuture<?> |
CacheAffinitySharedManager.initStartedCaches(boolean crd,
GridDhtPartitionsExchangeFuture fut,
Collection<DynamicCacheDescriptor> descs)
Initialized affinity for cache received from node joining on this exchange.
|
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridCacheAdapter.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridCacheProxyImpl.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
IgniteInternalCache.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridCacheAdapter.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridCacheProxyImpl.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
IgniteInternalCache.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
GridCacheAdapter.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
GridCacheProxyImpl.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
IgniteInternalCache.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
IgniteInternalFuture<?> |
GridCacheAdapter.loadAll(Set<? extends K> keys,
boolean replaceExisting) |
IgniteInternalFuture<?> |
IgniteInternalCache.localLoadCacheAsync(@Nullable IgniteBiPredicate<K,V> p,
Object... args)
Asynchronously delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to reload state from the underlying persistent storage. |
IgniteInternalFuture<?> |
GridCacheAdapter.localLoadCacheAsync(IgniteBiPredicate<K,V> p,
Object[] args)
Asynchronously delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to reload state from the underlying persistent storage. |
IgniteInternalFuture<?> |
GridCacheProxyImpl.localLoadCacheAsync(IgniteBiPredicate<K,V> p,
@Nullable Object[] args)
Asynchronously delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to reload state from the underlying persistent storage. |
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.lockAllAsync(@Nullable Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
IgniteInternalFuture<Boolean> |
IgniteInternalCache.lockAllAsync(@Nullable Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.lockAsync(K key,
long timeout)
Asynchronously acquires lock on a cached object with given
key only if the passed in filter (if any) passes.
|
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.lockAsync(K key,
long timeout)
Asynchronously acquires lock on a cached object with given
key only if the passed in filter (if any) passes.
|
IgniteInternalFuture<Boolean> |
IgniteInternalCache.lockAsync(K key,
long timeout)
Asynchronously acquires lock on a cached object with given
key only if the passed in filter (if any) passes.
|
IgniteInternalFuture<?> |
GridCacheSharedContext.nextAffinityReadyFuture(AffinityTopologyVersion curVer)
Gets ready future for the next affinity topology version (used in cases when a node leaves grid).
|
IgniteInternalFuture<?> |
CacheAffinitySharedManager.onCacheChangeRequest(GridDhtPartitionsExchangeFuture fut,
boolean crd,
ExchangeActions exchActions)
Called on exchange initiated for cache start/stop request.
|
IgniteInternalFuture<?> |
GridCacheProcessor.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
IgniteInternalFuture<T> |
GridCacheAdapter.AsyncOp.op(GridNearTxLocal tx) |
abstract IgniteInternalFuture<T> |
GridCacheAdapter.AsyncOp.op(GridNearTxLocal tx,
AffinityTopologyVersion readyTopVer) |
IgniteInternalFuture<?> |
GridCacheSharedContext.partitionRecoveryFuture(AffinityTopologyVersion topVer,
ClusterNode node)
Captures all prepared operations that we need to wait before we able to perform PME-free switch.
|
IgniteInternalFuture<?> |
GridCacheSharedContext.partitionReleaseFuture(AffinityTopologyVersion topVer)
Captures all ongoing operations that we need to wait before we can proceed to the next topology version.
|
IgniteInternalFuture<?> |
GridCacheAdapter.preloadPartitionAsync(int part)
Preload cache partition.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.preloadPartitionAsync(int part)
Preload cache partition.
|
IgniteInternalFuture<?> |
IgniteInternalCache.preloadPartitionAsync(int part)
Preload cache partition.
|
IgniteInternalFuture<?> |
GridCacheAdapter.putAllAsync(Map<? extends K,? extends V> m)
Asynchronously stores given key-value pairs in cache.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.putAllAsync(@Nullable Map<? extends K,? extends V> m)
Asynchronously stores given key-value pairs in cache.
|
IgniteInternalFuture<?> |
IgniteInternalCache.putAllAsync(@Nullable Map<? extends K,? extends V> m)
Asynchronously stores given key-value pairs in cache.
|
protected IgniteInternalFuture<?> |
GridCacheAdapter.putAllAsync0(Map<? extends K,? extends V> m) |
IgniteInternalFuture<?> |
GridCacheAdapter.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data asynchronously.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data asynchronously.
|
IgniteInternalFuture<?> |
IgniteInternalCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data asynchronously.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.putAsync(K key,
V val)
Stores given key-value pair in cache.
|
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.putAsync(K key,
V val)
Stores given key-value pair in cache.
|
IgniteInternalFuture<Boolean> |
IgniteInternalCache.putAsync(K key,
V val)
Stores given key-value pair in cache.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.putAsync(K key,
V val,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<Boolean> |
GridCacheAdapter.putAsync0(K key,
V val,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<Boolean> |
GridCacheAdapter.putIfAbsentAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
|
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.putIfAbsentAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
|
IgniteInternalFuture<Boolean> |
IgniteInternalCache.putIfAbsentAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if cache had no previous mapping for it.
|
IgniteInternalFuture<?> |
GridCacheAdapter.rebalance()
Forces this cache node to re-balance its partitions.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.rebalance()
Forces this cache node to re-balance its partitions.
|
IgniteInternalFuture<?> |
IgniteInternalCache.rebalance()
Forces this cache node to re-balance its partitions.
|
IgniteInternalFuture<Boolean> |
GridCachePreloaderAdapter.rebalanceFuture() |
IgniteInternalFuture<Boolean> |
GridCachePreloader.rebalanceFuture() |
IgniteInternalFuture<?> |
GridCachePartitionExchangeManager.reconnectExchangeFuture() |
IgniteInternalFuture<Object> |
GridCacheExplicitLockSpan.releaseFuture()
Gets span release future.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.removeAllAsync() |
IgniteInternalFuture<?> |
IgniteInternalCache.removeAllAsync() |
IgniteInternalFuture<?> |
GridCacheAdapter.removeAllAsync(@Nullable Collection<? extends K> keys)
Asynchronously removes given key mappings from cache for entries.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.removeAllAsync(@Nullable Collection<? extends K> keys)
Asynchronously removes given key mappings from cache for entries.
|
IgniteInternalFuture<?> |
IgniteInternalCache.removeAllAsync(@Nullable Collection<? extends K> keys)
Asynchronously removes given key mappings from cache for entries.
|
protected IgniteInternalFuture<Object> |
GridCacheAdapter.removeAllAsync0(Collection<? extends K> keys) |
IgniteInternalFuture<?> |
GridCacheAdapter.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<?> |
GridCacheProxyImpl.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<?> |
IgniteInternalCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.removeAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.removeAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<Boolean> |
IgniteInternalCache.removeAsync(K key)
Asynchronously removes given key mapping from cache.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.removeAsync(K key,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<Boolean> |
GridCacheAdapter.removeAsync(K key,
V val)
Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
|
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.removeAsync(K key,
V val)
Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
|
IgniteInternalFuture<Boolean> |
IgniteInternalCache.removeAsync(K key,
V val)
Asynchronously removes given key mapping from cache if one exists and value is equal to the passed in value.
|
protected IgniteInternalFuture<Boolean> |
GridCacheAdapter.removeAsync0(K key,
@Nullable CacheEntryPredicate filter) |
@Nullable IgniteInternalFuture<?> |
GridCacheMvccManager.removeAtomicFuture(long futId) |
IgniteInternalFuture<Map<K,V>> |
GridCacheAdapter.repairableGetAllAsync(@Nullable Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean skipVals,
boolean needVer) |
IgniteInternalFuture<V> |
GridCacheAdapter.repairableGetAsync(K key,
boolean deserializeBinary,
boolean needVer,
ReadRepairStrategy readRepairStrategy) |
IgniteInternalFuture<Boolean> |
GridCacheAdapter.replaceAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
|
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.replaceAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
|
IgniteInternalFuture<Boolean> |
IgniteInternalCache.replaceAsync(K key,
V val)
Asynchronously stores given key-value pair in cache only if only if there is a previous mapping for it.
|
IgniteInternalFuture<Boolean> |
GridCacheAdapter.replaceAsync(K key,
V oldVal,
V newVal)
Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the
'oldVal' passed in. |
IgniteInternalFuture<Boolean> |
GridCacheProxyImpl.replaceAsync(K key,
V oldVal,
V newVal)
Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the
'oldVal' passed in. |
IgniteInternalFuture<Boolean> |
IgniteInternalCache.replaceAsync(K key,
V oldVal,
V newVal)
Asynchronously stores given key-value pair in cache only if only if the previous value is equal to the
'oldVal' passed in. |
IgniteInternalFuture<?> |
GridCacheProcessor.resetCacheState(Collection<String> cacheNames)
Resets cache state after the cache has been moved to recovery state.
|
IgniteInternalFuture |
GridCacheSharedContext.rollbackTxAsync(GridNearTxLocal tx) |
IgniteInternalFuture<Integer> |
GridCacheAdapter.sizeAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Integer> |
GridCacheProxyImpl.sizeAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Integer> |
IgniteInternalCache.sizeAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
GridCacheAdapter.sizeLongAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
GridCacheProxyImpl.sizeLongAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
IgniteInternalCache.sizeLongAsync(CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
GridCacheAdapter.sizeLongAsync(int part,
CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
GridCacheProxyImpl.sizeLongAsync(int partition,
CachePeekMode[] peekModes) |
IgniteInternalFuture<Long> |
IgniteInternalCache.sizeLongAsync(int partition,
CachePeekMode[] peekModes) |
IgniteInternalFuture<?> |
GridCacheProcessor.startCachesOnLocalJoin(AffinityTopologyVersion exchTopVer,
LocalJoinCachesContext locJoinCtx) |
IgniteInternalFuture<Object> |
GridCachePreloaderAdapter.startFuture() |
IgniteInternalFuture<Object> |
GridCachePreloader.startFuture() |
IgniteInternalFuture<?> |
GridCachePreloaderAdapter.syncFuture() |
IgniteInternalFuture<?> |
GridCachePreloader.syncFuture() |
abstract IgniteInternalFuture<Boolean> |
GridCacheAdapter.txLockAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
boolean invalidate,
long createTtl,
long accessTtl) |
IgniteInternalFuture<?> |
CachesRegistry.update(ExchangeActions exchActions)
Adds caches and cache groups to start from
exchActions. |
@Nullable IgniteInternalFuture<GridCacheUpdateTxResult> |
GridCacheUpdateTxResult.updateFuture() |
| Modifier and Type | Method and Description |
|---|---|
static IgniteInClosure<IgniteInternalFuture<?>> |
GridCacheUtils.errorLogger(IgniteLogger log,
Class<? extends Exception>... excl) |
AtomicReference<IgniteInternalFuture<Boolean>> |
GridCacheContext.lastRemoveAllJobFut()
Returns future that assigned to last performing
GridDistributedCacheAdapter.GlobalRemoveAllJob. |
| Modifier and Type | Method and Description |
|---|---|
void |
GridCacheAdapter.UpdateTimeStatClosure.apply(IgniteInternalFuture<T> fut)
Closure body.
|
protected <R> IgniteFuture<R> |
IgniteCacheProxyImpl.createFuture(IgniteInternalFuture<R> fut) |
void |
GridCacheAdapter.FutureHolder.future(@Nullable IgniteInternalFuture fut)
Sets future.
|
protected void |
GridCacheAdapter.saveFuture(GridCacheAdapter.FutureHolder holder,
IgniteInternalFuture<?> fut,
boolean asyncOp,
boolean retry)
Saves future in thread local holder and adds listener
that will clear holder when future is finished.
|
| Constructor and Description |
|---|
IgniteCacheFutureImpl(IgniteInternalFuture<V> fut,
Executor defaultExecutor)
Constructor.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
CacheObjectBinaryProcessorImpl.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GridCacheTxRecoveryFuture
Future verifying that all remote transactions related to transaction were prepared or committed.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<IgniteInternalTx> |
GridDistributedTxRemoteAdapter.commitAsync()
Asynchronously commits this transaction by initiating
two-phase-commit process. |
IgniteInternalFuture<Boolean> |
GridDistributedCacheAdapter.lockAllAsync(Collection<? extends K> keys,
long timeout)
All or nothing synchronous lock for passed in keys.
|
protected abstract IgniteInternalFuture<Boolean> |
GridDistributedCacheAdapter.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
@Nullable IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
@Nullable TransactionIsolation isolation,
long createTtl,
long accessTtl) |
IgniteInternalFuture<?> |
GridDistributedCacheAdapter.removeAllAsync() |
IgniteInternalFuture<IgniteInternalTx> |
GridDistributedTxRemoteAdapter.rollbackAsync()
Asynchronously rollback this transaction.
|
IgniteInternalFuture<?> |
GridDistributedTxRemoteAdapter.salvageTx() |
IgniteInternalFuture<Boolean> |
GridDistributedCacheAdapter.txLockAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
boolean isInvalidate,
long createTtl,
long accessTtl) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
DhtLockFuture<T>
Marker interface.
|
interface |
GridDhtFuture<T>
Keys to retry.
|
interface |
GridDhtTopologyFuture
Future that implements a barrier after which dht topology is safe to use.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CacheDistributedGetFutureAdapter<K,V> |
protected class |
CacheDistributedGetFutureAdapter.AbstractMiniFuture
Mini-future for get operations.
|
class |
GridDhtAssignmentFetchFuture
Future that fetches affinity assignment from remote cache nodes.
|
class |
GridDhtEmbeddedFuture<A,B>
Embedded DHT future.
|
class |
GridDhtFinishedFuture<T>
Finished DHT future.
|
class |
GridDhtGetFuture<K,V> |
class |
GridDhtGetSingleFuture<K,V> |
class |
GridDhtLockFuture
Cache lock future.
|
class |
GridDhtTopologyFutureAdapter |
class |
GridDhtTxAbstractEnlistFuture<T>
Abstract future processing transaction enlisting and locking.
|
class |
GridDhtTxEnlistFuture
Future processing transaction enlisting and locking of entries produces by cache API operations.
|
class |
GridDhtTxFinishFuture<K,V> |
class |
GridDhtTxPrepareFuture |
class |
GridDhtTxQueryAbstractEnlistFuture
Abstract future processing transaction enlisting and locking of entries produced with DML and SELECT FOR UPDATE
queries.
|
class |
GridDhtTxQueryEnlistFuture
Cache query lock future.
|
class |
GridDhtTxQueryResultsEnlistFuture
Future processing transaction enlisting and locking of entries
produces by complex DML queries with reduce step.
|
class |
GridPartitionedGetFuture<K,V>
Colocated get future.
|
class |
GridPartitionedSingleGetFuture |
| Modifier and Type | Field and Description |
|---|---|
protected IgniteInternalFuture<?> |
GridDhtTxLocalAdapter.lockFut
Enlist or lock future what is currently in progress.
|
static IgniteInternalFuture<Boolean> |
GridDhtTxLocalAdapter.ROLLBACK_FUT
Asynchronous rollback marker for lock futures.
|
| Modifier and Type | Method and Description |
|---|---|
@Nullable IgniteInternalFuture<Boolean> |
GridDhtTxLocalAdapter.addEntry(long msgId,
IgniteTxEntry e) |
protected abstract @Nullable IgniteInternalFuture<Boolean> |
GridDhtTxLocalAdapter.addReader(long msgId,
GridDhtCacheEntry cached,
IgniteTxEntry entry,
AffinityTopologyVersion topVer)
Adds reader to cached entry.
|
protected @Nullable IgniteInternalFuture<Boolean> |
GridDhtTxLocal.addReader(long msgId,
GridDhtCacheEntry cached,
IgniteTxEntry entry,
AffinityTopologyVersion topVer)
Adds reader to cached entry.
|
@Nullable IgniteInternalFuture<Boolean> |
GridDhtCacheEntry.addReader(UUID nodeId,
long msgId,
AffinityTopologyVersion topVer) |
protected IgniteInternalFuture<GridNearTxPrepareResponse> |
GridDhtTxLocalAdapter.chainOnePhasePrepare(GridDhtTxPrepareFuture prepFut) |
IgniteInternalFuture<IgniteInternalTx> |
GridDhtTxLocal.commitAsync()
Asynchronously commits this transaction by initiating
two-phase-commit process. |
IgniteInternalFuture<IgniteInternalTx> |
GridDhtTxLocal.commitDhtLocalAsync() |
@Nullable IgniteInternalFuture<?> |
GridDhtTxLocal.currentPrepareFuture() |
IgniteInternalFuture<Map<K,V>> |
GridDhtCacheAdapter.getAllAsync(@Nullable Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean skipVals,
boolean needVer) |
IgniteInternalFuture<Boolean> |
GridDhtTransactionalCacheAdapter.lockAllAsync(@Nullable Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx txx,
boolean isInvalidate,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
long createTtl,
long accessTtl) |
IgniteInternalFuture<GridNearLockResponse> |
GridDhtTransactionalCacheAdapter.lockAllAsync(GridCacheContext<?,?> cacheCtx,
ClusterNode nearNode,
GridNearLockRequest req,
@Nullable CacheEntryPredicate[] filter0) |
IgniteInternalFuture<?> |
GridDhtTxLocalAdapter.lockFuture() |
IgniteInternalFuture<GridNearTxPrepareResponse> |
GridDhtTxLocal.prepareAsync(GridNearTxPrepareRequest req)
Prepares next batch of entries in dht transaction.
|
IgniteInternalFuture<IgniteInternalTx> |
GridDhtTxLocal.rollbackAsync()
Asynchronously rollback this transaction.
|
IgniteInternalFuture<IgniteInternalTx> |
GridDhtTxLocal.rollbackDhtLocalAsync() |
IgniteInternalFuture<?> |
GridDhtTxLocal.salvageTx() |
@Nullable IgniteInternalFuture<?> |
GridDhtTxLocalAdapter.tryRollbackAsync()
Prepare async rollback.
|
| Modifier and Type | Method and Description |
|---|---|
void |
NearTxResultHandler.apply(IgniteInternalFuture<GridCacheReturn> fut0)
Closure body.
|
void |
NearTxQueryEnlistResultHandler.apply(IgniteInternalFuture<Long> fut0)
Closure body.
|
void |
GridDhtTxLocalAdapter.clearLockFuture(@Nullable IgniteInternalFuture cond)
Clears lock future.
|
static <T> T |
NearTxResultHandler.createResponse(IgniteInternalFuture<?> future)
Response factory method.
|
static <T extends GridNearTxQueryEnlistResponse> |
NearTxQueryEnlistResultHandler.createResponse(IgniteInternalFuture<?> future) |
protected boolean |
GridPartitionedGetFuture.isMini(IgniteInternalFuture<?> f) |
protected abstract boolean |
CacheDistributedGetFutureAdapter.isMini(IgniteInternalFuture<?> f) |
boolean |
GridDhtTxLocalAdapter.updateLockFuture(IgniteInternalFuture<?> oldFut,
IgniteInternalFuture<?> newFut)
Atomically updates lock future.
|
boolean |
GridDhtTxLocalAdapter.updateLockFuture(IgniteInternalFuture<?> oldFut,
IgniteInternalFuture<?> newFut)
Atomically updates lock future.
|
| Constructor and Description |
|---|
GridDhtEmbeddedFuture(IgniteBiClosure<B,Exception,A> c,
IgniteInternalFuture<B> embedded) |
GridDhtEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c) |
| Constructor and Description |
|---|
GridDhtEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c) |
| Modifier and Type | Class and Description |
|---|---|
class |
GridDhtAtomicAbstractUpdateFuture
DHT atomic cache backup update future.
|
class |
GridNearAtomicAbstractUpdateFuture
Base for near atomic update futures.
|
class |
GridNearAtomicSingleUpdateFuture
DHT atomic cache near update future.
|
class |
GridNearAtomicUpdateFuture
DHT atomic cache near update future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Void> |
GridNearAtomicAbstractUpdateFuture.completeFuture(AffinityTopologyVersion topVer)
Gets future that will be completed when it is safe when update is finished on the given version of topology.
|
IgniteInternalFuture<Void> |
GridDhtAtomicAbstractUpdateFuture.completeFuture(AffinityTopologyVersion topVer)
Gets future that will be completed when it is safe when update is finished on the given version of topology.
|
IgniteInternalFuture<Map<K,V>> |
GridDhtAtomicCache.getAllAsync(@Nullable Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean skipVals,
boolean needVer) |
IgniteInternalFuture<V> |
GridDhtAtomicCache.getAndPutAsync0(K key,
V val,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<V> |
GridDhtAtomicCache.getAndRemoveAsync0(K key) |
protected IgniteInternalFuture<V> |
GridDhtAtomicCache.getAsync(K key,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean skipVals,
boolean needVer) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridDhtAtomicCache.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridDhtAtomicCache.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
GridDhtAtomicCache.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
protected IgniteInternalFuture<Boolean> |
GridDhtAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
@Nullable IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
@Nullable TransactionIsolation isolation,
long createTtl,
long accessTtl) |
IgniteInternalFuture<?> |
GridDhtAtomicCache.putAllAsync0(Map<? extends K,? extends V> m) |
IgniteInternalFuture<?> |
GridDhtAtomicCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> conflictMap)
Store DR data asynchronously.
|
IgniteInternalFuture<Boolean> |
GridDhtAtomicCache.putAsync0(K key,
V val,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<Object> |
GridDhtAtomicCache.removeAllAsync0(Collection<? extends K> keys) |
IgniteInternalFuture<?> |
GridDhtAtomicCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> conflictMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<Boolean> |
GridDhtAtomicCache.removeAsync0(K key,
@Nullable CacheEntryPredicate filter) |
| Modifier and Type | Class and Description |
|---|---|
class |
GridDhtColocatedLockFuture
Colocated cache lock future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Map<K,V>> |
GridDhtColocatedCache.getAllAsync(@Nullable Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean skipVals,
boolean needVer) |
protected IgniteInternalFuture<V> |
GridDhtColocatedCache.getAsync(K key,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean skipVals,
boolean needVer) |
IgniteInternalFuture<Map<K,V>> |
GridDhtColocatedCache.loadAsync(@Nullable Collection<KeyCacheObject> keys,
boolean readThrough,
boolean forcePrimary,
AffinityTopologyVersion topVer,
String taskName,
boolean deserializeBinary,
boolean recovery,
@Nullable IgniteCacheExpiryPolicy expiryPlc,
boolean skipVals,
boolean needVer,
boolean keepCacheObj,
@Nullable String txLbl,
@Nullable MvccSnapshot mvccSnapshot) |
IgniteInternalFuture<Object> |
GridDhtColocatedCache.loadAsync(KeyCacheObject key,
boolean readThrough,
boolean forcePrimary,
AffinityTopologyVersion topVer,
String taskName,
boolean deserializeBinary,
@Nullable IgniteCacheExpiryPolicy expiryPlc,
boolean skipVals,
boolean needVer,
boolean keepCacheObj,
boolean recovery,
@Nullable MvccSnapshot mvccSnapshot,
@Nullable String txLbl) |
IgniteInternalFuture<Boolean> |
GridDhtColocatedCache.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
@Nullable IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
@Nullable TransactionIsolation isolation,
long createTtl,
long accessTtl)
This is an entry point to pessimistic locking within transaction.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GridDhtForceKeysFuture<K,V>
Force keys request future.
|
static class |
GridDhtPartitionDemander.RebalanceFuture
The future is created for each topology version if some partitions should present by affinity and completed when
all partitions are transferred.
|
class |
GridDhtPartitionsExchangeFuture
Future for exchanging partition maps.
|
class |
InitNewCoordinatorFuture |
class |
StopCachesOnClientReconnectExchangeTask |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Boolean> |
GridDhtPreloader.forceRebalance()
Force Rebalance process.
|
IgniteInternalFuture<Boolean> |
GridDhtPreloader.rebalanceFuture() |
IgniteInternalFuture<Object> |
GridDhtPreloader.startFuture() |
IgniteInternalFuture<?> |
GridDhtPreloader.syncFuture() |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridDhtLocalPartition.clearAsync()
Initiates a partition clearing attempt.
|
IgniteInternalFuture<?> |
PartitionsEvictManager.evictPartitionAsync(CacheGroupContext grp,
GridDhtLocalPartition part,
GridFutureAdapter<?> finishFut)
Adds partition to eviction queue and starts eviction process if permit
available.
|
IgniteInternalFuture<?> |
GridDhtLocalPartition.rent()
Initiates partition eviction process and returns an eviction future.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
NearTxFinishFuture |
| Modifier and Type | Class and Description |
|---|---|
class |
GridNearGetFuture<K,V> |
class |
GridNearLockFuture
Cache lock future.
|
class |
GridNearOptimisticSerializableTxPrepareFuture |
class |
GridNearOptimisticTxPrepareFuture |
class |
GridNearOptimisticTxPrepareFutureAdapter |
protected static class |
GridNearOptimisticTxPrepareFutureAdapter.KeyLockFuture
Keys lock future.
|
class |
GridNearPessimisticTxPrepareFuture |
class |
GridNearTxAbstractEnlistFuture<T> |
class |
GridNearTxEnlistFuture
A future tracking requests for remote nodes transaction enlisting and locking produces by cache API operations.
|
class |
GridNearTxFastFinishFuture |
class |
GridNearTxFinishAndAckFuture |
class |
GridNearTxFinishFuture<K,V> |
class |
GridNearTxPrepareFutureAdapter
Common code for tx prepare in optimistic and pessimistic modes.
|
class |
GridNearTxQueryAbstractEnlistFuture |
class |
GridNearTxQueryEnlistFuture
Cache lock future.
|
class |
GridNearTxQueryResultsEnlistFuture
A future tracking requests for remote nodes transaction enlisting and locking
of entries produced with complex DML queries requiring reduce step.
|
| Modifier and Type | Method and Description |
|---|---|
protected IgniteInternalFuture<Boolean> |
GridNearTxLocal.addReader(long msgId,
GridDhtCacheEntry cached,
IgniteTxEntry entry,
AffinityTopologyVersion topVer)
Adds reader to cached entry.
|
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.commitAsync()
Asynchronously commits this transaction by initiating
two-phase-commit process. |
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.commitAsyncLocal()
Commits local part of colocated transaction.
|
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.commitNearTxLocalAsync() |
@Nullable IgniteInternalFuture<?> |
GridNearTxLocal.currentPrepareFuture() |
protected IgniteInternalFuture<Map<K,V>> |
GridNearAtomicCache.getAllAsync(@Nullable Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean skipVals,
boolean needVer) |
IgniteInternalFuture<Map<K,V>> |
GridNearTransactionalCache.getAllAsync(@Nullable Collection<? extends K> keys,
boolean forcePrimary,
boolean skipTx,
String taskName,
boolean deserializeBinary,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean skipVals,
boolean needVer) |
<K,V> IgniteInternalFuture<Map<K,V>> |
GridNearTxLocal.getAllAsync(GridCacheContext cacheCtx,
@Nullable AffinityTopologyVersion entryTopVer,
Collection<KeyCacheObject> keys,
boolean deserializeBinary,
boolean skipVals,
boolean keepCacheObjects,
boolean skipStore,
boolean recovery,
ReadRepairStrategy readRepairStrategy,
boolean needVer) |
IgniteInternalFuture<V> |
GridNearAtomicCache.getAndPutAsync0(K key,
V val,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<V> |
GridNearAtomicCache.getAndRemoveAsync(K key)
Asynchronously removes given key mapping from cache.
|
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridNearAtomicCache.invokeAllAsync(Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,T>> map,
Object... args) |
<T> IgniteInternalFuture<Map<K,javax.cache.processor.EntryProcessorResult<T>>> |
GridNearAtomicCache.invokeAllAsync(Set<? extends K> keys,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
<K,V> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.invokeAsync(GridCacheContext cacheCtx,
@Nullable AffinityTopologyVersion entryTopVer,
K key,
javax.cache.processor.EntryProcessor<K,V,Object> entryProcessor,
Object... invokeArgs) |
<K,V,T> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.invokeAsync(GridCacheContext cacheCtx,
@Nullable AffinityTopologyVersion entryTopVer,
@Nullable Map<? extends K,? extends javax.cache.processor.EntryProcessor<K,V,Object>> map,
Object... invokeArgs) |
<T> IgniteInternalFuture<javax.cache.processor.EntryProcessorResult<T>> |
GridNearAtomicCache.invokeAsync(K key,
javax.cache.processor.EntryProcessor<K,V,T> entryProcessor,
Object... args) |
IgniteInternalFuture<Map<K,V>> |
GridNearCacheAdapter.loadAsync(@Nullable IgniteInternalTx tx,
@Nullable Collection<KeyCacheObject> keys,
boolean forcePrimary,
String taskName,
boolean deserializeBinary,
boolean recovery,
@Nullable javax.cache.expiry.ExpiryPolicy expiryPlc,
boolean skipVal,
boolean skipStore,
boolean needVer) |
IgniteInternalFuture<?> |
GridNearCacheAdapter.localLoadCacheAsync(IgniteBiPredicate<K,V> p,
Object[] args)
Asynchronously delegates to
CacheStore.loadCache(IgniteBiInClosure, Object...) method
to reload state from the underlying persistent storage. |
protected IgniteInternalFuture<Boolean> |
GridNearAtomicCache.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
@Nullable IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
@Nullable TransactionIsolation isolation,
long createTtl,
long accessTtl) |
protected IgniteInternalFuture<Boolean> |
GridNearTransactionalCache.lockAllAsync(Collection<KeyCacheObject> keys,
long timeout,
IgniteTxLocalEx tx,
boolean isInvalidate,
boolean isRead,
boolean retval,
TransactionIsolation isolation,
long createTtl,
long accessTtl) |
<K> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.lockAllAsync(GridCacheContext cacheCtx,
Collection<? extends K> keys,
boolean retval,
boolean read,
long createTtl,
long accessTtl,
boolean skipStore,
boolean keepBinary) |
IgniteInternalFuture<GridNearTxPrepareResponse> |
GridNearTxLocal.prepareAsyncLocal(GridNearTxPrepareRequest req)
Prepares next batch of entries in dht transaction.
|
IgniteInternalFuture<?> |
GridNearTxLocal.prepareNearTxLocal() |
<K,V> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.putAllAsync(GridCacheContext cacheCtx,
@Nullable AffinityTopologyVersion entryTopVer,
Map<? extends K,? extends V> map,
boolean retval) |
IgniteInternalFuture<?> |
GridNearAtomicCache.putAllAsync(Map<? extends K,? extends V> m)
Asynchronously stores given key-value pairs in cache.
|
IgniteInternalFuture<?> |
GridNearAtomicCache.putAllConflictAsync(Map<KeyCacheObject,GridCacheDrInfo> drMap)
Store DR data asynchronously.
|
IgniteInternalFuture<?> |
GridNearTxLocal.putAllDrAsync(GridCacheContext cacheCtx,
Map<KeyCacheObject,GridCacheDrInfo> drMap) |
<K,V> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.putAsync(GridCacheContext cacheCtx,
@Nullable AffinityTopologyVersion entryTopVer,
K key,
V val,
boolean retval,
CacheEntryPredicate filter) |
IgniteInternalFuture<Boolean> |
GridNearAtomicCache.putAsync0(K key,
V val,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<?> |
GridNearAtomicCache.removeAllAsync() |
IgniteInternalFuture<?> |
GridNearAtomicCache.removeAllAsync(Collection<? extends K> keys)
Asynchronously removes given key mappings from cache for entries.
|
<K,V> IgniteInternalFuture<GridCacheReturn> |
GridNearTxLocal.removeAllAsync(GridCacheContext cacheCtx,
@Nullable AffinityTopologyVersion entryTopVer,
Collection<? extends K> keys,
boolean retval,
CacheEntryPredicate filter,
boolean singleRmv) |
IgniteInternalFuture<?> |
GridNearAtomicCache.removeAllConflictAsync(Map<KeyCacheObject,GridCacheVersion> drMap)
Removes DR data asynchronously.
|
IgniteInternalFuture<?> |
GridNearTxLocal.removeAllDrAsync(GridCacheContext cacheCtx,
Map<KeyCacheObject,GridCacheVersion> drMap) |
IgniteInternalFuture<Boolean> |
GridNearAtomicCache.removeAsync(K key,
@Nullable CacheEntryPredicate filter) |
IgniteInternalFuture<MvccSnapshot> |
GridNearTxLocal.requestSnapshot()
Requests version on coordinator.
|
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.rollbackAsync()
Asynchronously rollback this transaction.
|
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.rollbackAsyncLocal()
Rolls back local part of colocated transaction.
|
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.rollbackNearTxLocalAsync() |
IgniteInternalFuture<IgniteInternalTx> |
GridNearTxLocal.rollbackNearTxLocalAsync(boolean clearThreadMap,
boolean onTimeout) |
IgniteInternalFuture<?> |
GridNearTxLocal.salvageTx() |
IgniteInternalFuture<Long> |
GridNearTxLocal.updateAsync(GridCacheContext cacheCtx,
int[] cacheIds,
int[] parts,
String schema,
String qry,
Object[] params,
int flags,
int pageSize,
long timeout) |
IgniteInternalFuture<Long> |
GridNearTxLocal.updateAsync(GridCacheContext cacheCtx,
UpdateSourceIterator<?> it,
int pageSize,
long timeout,
boolean sequential) |
| Modifier and Type | Method and Description |
|---|---|
protected boolean |
GridNearGetFuture.isMini(IgniteInternalFuture<?> f) |
| Modifier and Type | Class and Description |
|---|---|
class |
GridCompoundReadRepairFuture
Compound future that represents the result of the external fixes for some keys.
|
class |
GridNearReadRepairAbstractFuture |
class |
GridNearReadRepairCheckOnlyFuture
Checks data consistency.
|
class |
GridNearReadRepairFuture
Checks data consistency.
|
| Modifier and Type | Method and Description |
|---|---|
<K,V> IgniteInternalFuture<Map<K,V>> |
GridNearReadRepairCheckOnlyFuture.multi()
Returns a future represents entries map.
|
<K,V> IgniteInternalFuture<V> |
GridNearReadRepairCheckOnlyFuture.single()
Returns a future represents 1 entry's value.
|
| Modifier and Type | Method and Description |
|---|---|
void |
GridCompoundReadRepairFuture.add(IgniteInternalFuture<Void> fut) |
void |
GridCompoundReadRepairFuture.apply(IgniteInternalFuture<Void> fut)
Closure body.
|
protected void |
GridNearReadRepairAbstractFuture.onResult(IgniteInternalFuture<Map<KeyCacheObject,EntryGetResult>> finished)
Collects results of each 'get' future and prepares an overall result of the operation.
|
| Modifier and Type | Class and Description |
|---|---|
class |
MvccFuture<T> |
class |
MvccSnapshotFuture |
class |
VacuumTask
Task for cleaning sing partition.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Void> |
MvccProcessorImpl.ackTxCommit(MvccSnapshot updateVer) |
IgniteInternalFuture<Void> |
MvccProcessor.ackTxCommit(MvccSnapshot updateVer) |
IgniteInternalFuture<MvccSnapshot> |
MvccProcessorImpl.requestReadSnapshotAsync()
Requests snapshot on Mvcc coordinator.
|
IgniteInternalFuture<MvccSnapshot> |
MvccProcessor.requestReadSnapshotAsync()
Requests snapshot on Mvcc coordinator.
|
IgniteInternalFuture<MvccSnapshot> |
MvccQueryTracker.requestSnapshot()
Requests version on coordinator.
|
IgniteInternalFuture<MvccSnapshot> |
MvccQueryTrackerImpl.requestSnapshot()
Requests version on coordinator.
|
IgniteInternalFuture<MvccSnapshot> |
StaticMvccQueryTracker.requestSnapshot()
Requests version on coordinator.
|
IgniteInternalFuture<MvccSnapshot> |
MvccProcessorImpl.requestWriteSnapshotAsync()
Requests snapshot on Mvcc coordinator.
|
IgniteInternalFuture<MvccSnapshot> |
MvccProcessor.requestWriteSnapshotAsync()
Requests snapshot on Mvcc coordinator.
|
IgniteInternalFuture<Void> |
MvccProcessorImpl.waitForLock(GridCacheContext cctx,
MvccVersion waiterVer,
MvccVersion blockerVer)
Stands in the lock wait queue for the current lock holder.
|
IgniteInternalFuture<Void> |
MvccProcessor.waitForLock(GridCacheContext cctx,
MvccVersion waiterVer,
MvccVersion blockerVer)
Stands in the lock wait queue for the current lock holder.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Void> |
GridCacheDatabaseSharedManager.enableCheckpoints(boolean enable)
For test use only.
|
@Nullable IgniteInternalFuture |
IgniteCacheDatabaseSharedManager.wakeupForCheckpoint(String reason) |
@Nullable IgniteInternalFuture |
GridCacheDatabaseSharedManager.wakeupForCheckpoint(String reason) |
| Modifier and Type | Method and Description |
|---|---|
<R> @Nullable CheckpointProgress |
IgniteCacheDatabaseSharedManager.forceNewCheckpoint(String reason,
IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Schedule a new checkpoint.
|
<R> CheckpointProgress |
GridCacheDatabaseSharedManager.forceNewCheckpoint(String reason,
IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Schedule a new checkpoint.
|
<R> void |
IgniteCacheDatabaseSharedManager.waitForCheckpoint(String reason,
IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Waits until current state is checkpointed and execution listeners after finish.
|
<R> void |
GridCacheDatabaseSharedManager.waitForCheckpoint(String reason,
IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Waits until current state is checkpointed and execution listeners after finish.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Void> |
CheckpointManager.enableCheckpoints(boolean enable)
For test use only.
|
IgniteInternalFuture<Void> |
Checkpointer.enableCheckpoints(boolean enable)
Deprecated.
Should be rewritten to public API.
|
IgniteInternalFuture<Void> |
LightweightCheckpointManager.enableCheckpoints(boolean enable)
For test use only.
|
IgniteInternalFuture<?> |
CheckpointContextImpl.finishedStateFut() |
IgniteInternalFuture<?> |
CheckpointListener.Context.finishedStateFut() |
IgniteInternalFuture |
Checkpointer.wakeupForSnapshotCreation(SnapshotOperation snapshotOperation) |
| Modifier and Type | Method and Description |
|---|---|
<R> CheckpointProgress |
CheckpointManager.forceCheckpoint(String reason,
IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Start the new checkpoint immediately.
|
<R> CheckpointProgress |
LightweightCheckpointManager.forceCheckpoint(String reason,
IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Start the new checkpoint immediately.
|
<R> CheckpointProgress |
Checkpointer.scheduleCheckpoint(long delayFromNow,
String reason,
IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Change the information for a scheduled checkpoint if it was scheduled further than
delayFromNow, or do
nothing otherwise. |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
CachePartitionDefragmentationManager.completionFuture() |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Void> |
FileDownloader.finishFuture() |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<DurableBackgroundTaskResult<R>> |
DurableBackgroundTask.executeAsync(GridKernalContext ctx)
Asynchronous task execution.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Void> |
PageMemoryEx.clearAsync(LoadedPagesMap.KeyPredicate pred,
boolean cleanDirty)
Asynchronously clears pages satisfying the given predicate.
|
IgniteInternalFuture<Void> |
PageMemoryImpl.clearAsync(LoadedPagesMap.KeyPredicate pred,
boolean cleanDirty)
Asynchronously clears pages satisfying the given predicate.
|
| Modifier and Type | Method and Description |
|---|---|
GridMultiCollectionWrapper<FullPageId> |
PageMemoryEx.beginCheckpoint(IgniteInternalFuture allowToReplace)
Gets a collection of dirty page IDs since the last checkpoint.
|
GridMultiCollectionWrapper<FullPageId> |
PageMemoryImpl.beginCheckpoint(IgniteInternalFuture allowToReplace)
Gets a collection of dirty page IDs since the last checkpoint.
|
| Modifier and Type | Class and Description |
|---|---|
static class |
IgniteSnapshotManager.ClusterSnapshotFuture |
class |
SnapshotFinishedFutureTask |
class |
SnapshotResponseRemoteFutureTask |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<SnapshotPartitionsVerifyTaskResult> |
IgniteSnapshotManager.checkSnapshot(String name,
@Nullable String snpPath)
Checks snapshot.
|
IgniteInternalFuture<SnapshotPartitionsVerifyTaskResult> |
IgniteSnapshotManager.checkSnapshot(String name,
@Nullable String snpPath,
@Nullable Collection<String> grps,
boolean includeCustomHandlers,
int incIdx,
boolean check)
The check snapshot procedure performs compute operation over the whole cluster to verify the snapshot
entirety and partitions consistency.
|
IgniteInternalFuture<SnapshotPartitionsVerifyTaskResult> |
IgniteSnapshotManager.checkSnapshot(String name,
@Nullable String snpPath,
int incIdx)
Checks snapshot and its increments.
|
IgniteInternalFuture<Void> |
IgniteSnapshotManager.requestRemoteSnapshotFiles(UUID rmtNodeId,
UUID reqId,
String snpName,
@Nullable String rmtSnpPath,
Map<Integer,Set<Integer>> parts,
BooleanSupplier stopChecker,
BiConsumer<File,Throwable> partHnd) |
@Nullable IgniteInternalFuture |
IgniteCacheSnapshotManager.startLocalSnapshotOperation(UUID initiatorNodeId,
T snapshotOperation,
AffinityTopologyVersion topVer)
Deprecated.
|
@Nullable IgniteInternalFuture |
IgniteCacheSnapshotManager.tryStartLocalSnapshotOperation(@Nullable DiscoveryEvent discoveryEvt,
AffinityTopologyVersion topVer)
Deprecated.
Try to start local snapshot operation if it's required by discovery event.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
CacheQueryFuture<T>
Cache query future returned by query execution.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GridCacheDistributedFieldsQueryFuture
Distributed fields query future.
|
class |
GridCacheDistributedQueryFuture<K,V,R>
Distributed query future.
|
class |
GridCacheLocalFieldsQueryFuture
Local fields query future.
|
class |
GridCacheLocalQueryFuture<K,V,R>
Local query future.
|
class |
GridCacheQueryErrorFuture<T>
Error future.
|
class |
GridCacheQueryFutureAdapter<K,V,R>
Query future adapter.
|
static class |
GridCacheQueryManager.QueryResult<K,V> |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<List<GridQueryFieldMetadata>> |
GridCacheLocalFieldsQueryFuture.metadata() |
IgniteInternalFuture<List<GridQueryFieldMetadata>> |
GridCacheQueryMetadataAware.metadata() |
IgniteInternalFuture<List<GridQueryFieldMetadata>> |
GridCacheDistributedFieldsQueryFuture.metadata() |
IgniteInternalFuture<Collection<GridCacheSqlMetadata>> |
GridCacheQueryManager.sqlMetadataAsync()
Gets SQL metadata asynchronously.
|
| Modifier and Type | Field and Description |
|---|---|
protected IgniteInternalFuture<Void> |
CacheContinuousQueryHandler.initFut
Initialization future.
|
protected IgniteInternalFuture<Void> |
CacheContinuousQueryHandler.p2pUnmarshalFut
P2P unmarshalling future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostLockClosure1.apply(Boolean locked,
@Nullable Exception e)
Closure body.
|
IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostLockClosure2.apply(Boolean locked,
@Nullable Exception e)
Closure body.
|
IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostMissClosure.apply(T t,
Exception e)
Closure body.
|
IgniteInternalFuture<IgniteInternalTx> |
IgniteInternalTx.commitAsync()
Asynchronously commits this transaction by initiating
two-phase-commit process. |
IgniteInternalFuture<Boolean> |
IgniteTxManager.commitIfPrepared(IgniteInternalTx tx,
Set<UUID> failedNodeIds)
Commits transaction in case when node started transaction failed, but all related
transactions were prepared (invalidates transaction if it is not fully prepared).
|
@Nullable IgniteInternalFuture<?> |
IgniteTxAdapter.currentPrepareFuture() |
@Nullable IgniteInternalFuture<?> |
IgniteInternalTx.currentPrepareFuture() |
IgniteInternalFuture<TxDeadlock> |
IgniteTxManager.detectDeadlock(IgniteInternalTx tx,
Set<IgniteTxKey> keys)
Performs deadlock detection for given keys.
|
@Nullable IgniteInternalFuture<IgniteInternalTx> |
IgniteTxHandler.finish(UUID nodeId,
@Nullable GridNearTxLocal locTx,
GridNearTxFinishRequest req) |
IgniteInternalFuture<?> |
IgniteTxManager.finishAllTxs(IgniteInternalFuture<?> finishLocalTxsFuture,
AffinityTopologyVersion topVer)
Creates a future that will wait for finishing all tx updates on backups after all local transactions are finished.
|
IgniteInternalFuture<IgniteInternalTx> |
IgniteTxHandler.finishColocatedLocal(boolean commit,
GridNearTxLocal tx) |
IgniteInternalFuture<IgniteInternalTx> |
IgniteTxAdapter.finishFuture() |
IgniteInternalFuture<IgniteInternalTx> |
IgniteInternalTx.finishFuture() |
IgniteInternalFuture<Boolean> |
IgniteTxManager.finishLocalTxs(AffinityTopologyVersion topVer)
Creates a future that will wait for all ongoing transactions that maybe affected by topology update
to be finished.
|
protected abstract IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostLockClosure2.postLock()
Post lock callback.
|
protected abstract IgniteInternalFuture<T> |
IgniteTxLocalAdapter.PostMissClosure.postMiss(T t)
Post lock callback.
|
IgniteInternalFuture<GridNearTxPrepareResponse> |
IgniteTxHandler.prepareColocatedTx(GridNearTxLocal locTx,
GridNearTxPrepareRequest req)
Prepares local colocated tx.
|
IgniteInternalFuture<GridNearTxPrepareResponse> |
IgniteTxHandler.prepareNearTxLocal(GridNearTxLocal originTx,
GridNearTxPrepareRequest req) |
IgniteInternalFuture<Boolean> |
IgniteTxManager.recoverLocalTxs(AffinityTopologyVersion topVer,
ClusterNode node)
Creates a future that will wait for all transactions with failed primary recovery.
|
IgniteInternalFuture<?> |
IgniteTxManager.remoteTxFinishFuture(GridCacheVersion nearVer) |
IgniteInternalFuture<IgniteInternalTx> |
IgniteInternalTx.rollbackAsync()
Asynchronously rollback this transaction.
|
IgniteInternalFuture |
IgniteTxAdapter.rollbackFuture() |
@Nullable IgniteInternalFuture<?> |
IgniteInternalTx.salvageTx() |
IgniteInternalFuture<Boolean> |
IgniteTxManager.txCommitted(GridCacheVersion xidVer) |
@Nullable IgniteInternalFuture<Boolean> |
IgniteTxManager.txsPreparedOrCommitted(GridCacheVersion nearVer,
int txNum)
Checks if transactions with given near version ID was prepared or committed.
|
| Modifier and Type | Method and Description |
|---|---|
Collection<IgniteInternalFuture<?>> |
IgniteTxManager.deadlockDetectionFutures() |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
IgniteTxManager.finishAllTxs(IgniteInternalFuture<?> finishLocalTxsFuture,
AffinityTopologyVersion topVer)
Creates a future that will wait for finishing all tx updates on backups after all local transactions are finished.
|
void |
IgniteTxAdapter.rollbackFuture(IgniteInternalFuture fut) |
| Modifier and Type | Method and Description |
|---|---|
<T,R> IgniteInternalFuture<Collection<R>> |
GridClosureProcessor.broadcast(IgniteClosure<T,R> job,
T arg,
TaskExecutionOptions opts) |
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callAsync(GridClosureCallMode mode,
Callable<R> job,
TaskExecutionOptions opts) |
<R> IgniteInternalFuture<Collection<R>> |
GridClosureProcessor.callAsync(GridClosureCallMode mode,
Collection<? extends Callable<R>> jobs,
TaskExecutionOptions opts) |
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callLocal(@Nullable Callable<R> c,
byte plc) |
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callLocalSafe(Callable<R> c)
Executes closure on system pool.
|
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callLocalSafe(Callable<R> c,
boolean sys)
Executes closure on system pool.
|
<R> IgniteInternalFuture<R> |
GridClosureProcessor.callLocalSafe(Callable<R> c,
byte plc)
Companion to
GridClosureProcessor.callLocal(Callable, boolean) but in case of rejected execution re-runs
the closure in the current thread (blocking). |
IgniteInternalFuture<?> |
GridClosureProcessor.runLocal(@Nullable Runnable c,
byte plc) |
IgniteInternalFuture<?> |
GridClosureProcessor.runLocalSafe(Runnable c)
Executes closure on system pool.
|
IgniteInternalFuture<?> |
GridClosureProcessor.runLocalSafe(Runnable c,
boolean sys)
In case of rejected execution re-runs the closure in the current thread (blocking).
|
IgniteInternalFuture<?> |
GridClosureProcessor.runLocalSafe(Runnable c,
byte plc)
In case of rejected execution re-runs the closure in the current thread (blocking).
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridClusterStateProcessor.changeGlobalState(ClusterState state,
boolean forceDeactivation,
Collection<? extends BaselineNode> baselineNodes,
boolean forceChangeBaselineTopology) |
IgniteInternalFuture<?> |
IGridClusterStateProcessor.changeGlobalState(ClusterState state,
boolean forceDeactivation,
Collection<? extends BaselineNode> baselineNodes,
boolean forceChangeBaselineTopology) |
IgniteInternalFuture<?> |
GridClusterStateProcessor.changeGlobalState(ClusterState state,
boolean forceDeactivation,
Collection<? extends BaselineNode> baselineNodes,
boolean forceChangeBaselineTopology,
boolean isAutoAdjust) |
@Nullable IgniteInternalFuture<Boolean> |
GridClusterStateProcessor.onLocalJoin(DiscoCache discoCache) |
@Nullable IgniteInternalFuture<Boolean> |
IGridClusterStateProcessor.onLocalJoin(DiscoCache discoCache) |
IgniteInternalFuture<?> |
ClusterProcessor.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
IgniteInternalFuture<String> |
ClusterProcessor.requestDiagnosticInfo(UUID nodeId,
IgniteClosure<GridKernalContext,IgniteDiagnosticInfo> c,
String baseMsg)
Sends diagnostic message closure to remote node.
|
protected IgniteInternalFuture<?> |
GridClusterStateProcessor.wrapStateChangeFuture(IgniteInternalFuture fut,
ChangeGlobalStateMessage msg) |
| Modifier and Type | Method and Description |
|---|---|
void |
GridClusterStateProcessor.onExchangeFinishedOnCoordinator(IgniteInternalFuture exchangeFuture,
boolean hasMovingPartitions) |
void |
IGridClusterStateProcessor.onExchangeFinishedOnCoordinator(IgniteInternalFuture exchangeFuture,
boolean hasMovingPartitions) |
protected IgniteInternalFuture<?> |
GridClusterStateProcessor.wrapStateChangeFuture(IgniteInternalFuture fut,
ChangeGlobalStateMessage msg) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<UUID> |
GridContinuousProcessor.startRoutine(GridContinuousHandler hnd,
boolean locOnly,
int bufSize,
long interval,
boolean autoUnsubscribe,
@Nullable IgnitePredicate<ClusterNode> prjPred) |
IgniteInternalFuture<?> |
GridContinuousProcessor.stopRoutine(UUID routineId) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
DataStreamerImpl.internalFuture() |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
DataStructuresProcessor.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
<R> IgniteInternalFuture<R> |
DurableBackgroundTasksProcessor.executeAsync(DurableBackgroundTask<R> task,
boolean save)
Asynchronous execution of a durable background task.
|
<R> IgniteInternalFuture<R> |
DurableBackgroundTasksProcessor.executeAsync(DurableBackgroundTask<R> t,
CacheConfiguration cacheCfg)
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
DistributedMetaStorageImpl.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
void |
DmsDataWriterWorker.suspend(IgniteInternalFuture<?> compFut) |
void |
DistributedMetaStorageImpl.suspend(IgniteInternalFuture<?> compFut) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
PlatformProcessorImpl.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
protected PlatformListenable |
PlatformAbstractTarget.readAndListenFuture(BinaryRawReader reader,
IgniteInternalFuture fut)
Reads future information and listens.
|
| Modifier and Type | Class and Description |
|---|---|
protected class |
PlatformCompute.ComputeConvertingFuture
Wraps ComputeTaskFuture as IgniteInternalFuture.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture |
PlatformCompute.ComputeConvertingFuture.chain(IgniteClosure doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
IgniteInternalFuture |
PlatformCompute.ComputeConvertingFuture.chain(IgniteClosure doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
IgniteInternalFuture |
PlatformCompute.ComputeConvertingFuture.chainCompose(IgniteClosure doneCb)
Make a chained future that is completed when
doneCb is executed. |
IgniteInternalFuture |
PlatformCompute.ComputeConvertingFuture.chainCompose(IgniteClosure doneCb,
@Nullable Executor exec)
Make a chained future that is completed when
doneCb is executed. |
| Modifier and Type | Method and Description |
|---|---|
static PlatformListenable |
PlatformFutureUtils.getListenable(IgniteInternalFuture fut)
Gets the listenable.
|
static <T> T |
PlatformFutureUtils.getResult(IgniteInternalFuture<T> fut)
Awaits and returns the result of the specified future.
|
static PlatformListenable |
PlatformFutureUtils.listen(PlatformContext ctx,
IgniteInternalFuture fut,
long futPtr,
int typ,
PlatformFutureUtils.Writer writer,
PlatformTarget target)
Listen future.
|
static PlatformListenable |
PlatformFutureUtils.listen(PlatformContext ctx,
IgniteInternalFuture fut,
long futPtr,
int typ,
PlatformTarget target)
Listen future.
|
static PlatformListenable |
PlatformFutureUtils.listen(PlatformContext ctx,
IgniteInternalFuture fut,
long futPtr,
PlatformFutureUtils.Writer writer,
PlatformTarget target)
Listen future.
|
| Modifier and Type | Class and Description |
|---|---|
class |
QueryRunningFuture
Query running future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
GridQueryProcessor.dynamicAddQueryEntity(String cacheName,
String schemaName,
QueryEntity entity,
Integer qryParallelism,
boolean sqlEscape)
Enable dynamically indexing of existing cache.
|
IgniteInternalFuture<?> |
GridQueryProcessor.dynamicColumnAdd(String cacheName,
String schemaName,
String tblName,
List<QueryField> cols,
boolean ifTblExists,
boolean ifNotExists)
Entry point for add column procedure.
|
IgniteInternalFuture<?> |
GridQueryProcessor.dynamicColumnRemove(String cacheName,
String schemaName,
String tblName,
List<String> cols,
boolean ifTblExists,
boolean ifExists)
Entry point for drop column procedure.
|
IgniteInternalFuture<?> |
GridQueryProcessor.dynamicIndexCreate(String cacheName,
String schemaName,
String tblName,
QueryIndex idx,
boolean ifNotExists,
int parallel)
Entry point for index procedure.
|
IgniteInternalFuture<?> |
GridQueryProcessor.dynamicIndexDrop(String cacheName,
String schemaName,
String idxName,
boolean ifExists)
Entry point for index drop procedure
|
@Nullable IgniteInternalFuture<?> |
GridQueryProcessor.indexRebuildFuture(int cacheId) |
IgniteInternalFuture<?> |
GridQueryProcessor.rebuildIndexesFromHash(GridCacheContext cctx,
boolean force)
Rebuilds indexes for provided caches from corresponding hash indexes.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SchemaIndexCacheCompoundFuture
Compound index rebuilding feature.
|
class |
SchemaIndexCacheFuture
Extending
GridFutureAdapter to rebuild indices. |
class |
SchemaOperationClientFuture
Schema operation client future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture |
SchemaOperationWorker.future() |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Boolean> |
IgniteStatisticsConfigurationManager.dropStatisticsAsync(List<StatisticsTarget> targets,
boolean validate)
Drop local statistic for specified database objects on the cluster.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridRestProtocolHandler.handleAsync(GridRestRequest req) |
protected IgniteInternalFuture<GridRestResponse> |
GridRestProcessor.handleAsync0(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridRestCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
AuthenticationCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
NodeStateBeforeStartCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridCacheCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridChangeClusterStateCommandHandler.handleAsync(GridRestRequest restReq) |
IgniteInternalFuture<GridRestResponse> |
GridBaselineCommandHandler.handleAsync(GridRestRequest req) |
IgniteInternalFuture<GridRestResponse> |
GridClusterNameCommandHandler.handleAsync(GridRestRequest restReq) |
IgniteInternalFuture<GridRestResponse> |
GridChangeStateCommandHandler.handleAsync(GridRestRequest restRest) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
DataStructuresCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridLogCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
MemoryMetricsCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridProbeCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
QueryCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRedisMessage> |
GridRedisRestCommandHandler.handleAsync(GridNioSession ses,
GridRedisMessage msg) |
IgniteInternalFuture<GridRedisMessage> |
GridRedisCommandHandler.handleAsync(GridNioSession ses,
GridRedisMessage msg) |
IgniteInternalFuture<GridRedisMessage> |
GridRedisConnectionCommandHandler.handleAsync(GridNioSession ses,
GridRedisMessage msg) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridTaskCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridTopologyCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
UserActionCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<GridRestResponse> |
GridVersionCommandHandler.handleAsync(GridRestRequest req) |
| Modifier and Type | Method and Description |
|---|---|
@Nullable IgniteInternalFuture<?> |
IgniteSecurityProcessor.onReconnected(boolean clusterRestarted)
Client reconnected callback.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GridServiceDeploymentCompoundFuture<T extends Serializable>
Service deployment compound future.
|
class |
GridServiceDeploymentFuture<T extends Serializable>
Service deployment future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<?> |
IgniteServiceProcessor.cancel(String name) |
IgniteInternalFuture<?> |
IgniteServiceProcessor.cancelAll() |
IgniteInternalFuture<?> |
IgniteServiceProcessor.cancelAll(@NotNull Collection<String> servicesNames) |
IgniteInternalFuture<?> |
IgniteServiceProcessor.deployAll(ClusterGroup prj,
Collection<ServiceConfiguration> cfgs) |
IgniteInternalFuture<?> |
IgniteServiceProcessor.deployClusterSingleton(ClusterGroup prj,
String name,
Service srvc) |
IgniteInternalFuture<?> |
IgniteServiceProcessor.deployKeyAffinitySingleton(String name,
Service srvc,
String cacheName,
Object affKey) |
IgniteInternalFuture<?> |
IgniteServiceProcessor.deployMultiple(ClusterGroup prj,
String name,
Service srvc,
int totalCnt,
int maxPerNodeCnt) |
IgniteInternalFuture<?> |
IgniteServiceProcessor.deployNodeSingleton(ClusterGroup prj,
String name,
Service srvc) |
IgniteInternalFuture<?> |
IgniteServiceProcessor.onReconnected(boolean active)
Client reconnected callback.
|
| Modifier and Type | Method and Description |
|---|---|
protected boolean |
GridServiceDeploymentCompoundFuture.processFailure(Throwable err,
IgniteInternalFuture<Object> fut)
Processes error thrown by some of the inner futures.
|
| Modifier and Type | Method and Description |
|---|---|
void |
GridTimeoutProcessor.waitAsync(IgniteInternalFuture<?> fut,
long timeout,
IgniteBiInClosure<IgniteCheckedException,Boolean> clo)
Wait for a future (listen with timeout).
|
| Modifier and Type | Method and Description |
|---|---|
static <T,R> Collector<? super IgniteInternalFuture,? super GridCompoundFuture<T,R>,GridCompoundFuture<T,R>> |
IgniteCollectors.toCompoundFuture()
Collector of
IgniteInternalFuture inheritors stream to GridCompoundFuture. |
| Modifier and Type | Method and Description |
|---|---|
static void |
IgniteUtils.asyncLogError(IgniteInternalFuture<?> f,
IgniteLogger log)
Adds listener to asynchronously log errors.
|
| Constructor and Description |
|---|
DistributedProcess(GridKernalContext ctx,
DistributedProcess.DistributedProcessType type,
Function<I,IgniteInternalFuture<R>> exec,
CI3<UUID,Map<UUID,R>,Map<UUID,Throwable>> finish) |
DistributedProcess(GridKernalContext ctx,
DistributedProcess.DistributedProcessType type,
Function<I,IgniteInternalFuture<R>> exec,
CI3<UUID,Map<UUID,R>,Map<UUID,Throwable>> finish,
BiFunction<UUID,I,? extends InitMessage<I>> initMsgFactory) |
| Modifier and Type | Class and Description |
|---|---|
class |
CountDownFuture |
class |
GridCompoundFuture<T,R>
Future composed of multiple inner futures.
|
class |
GridCompoundIdentityFuture<T>
Compound future with reducer which accepts and produces results of the same type.
|
class |
GridEmbeddedFuture<A,B>
Future which waits for embedded future to complete and then asynchronously executes
provided closure with embedded future result.
|
class |
GridFinishedFuture<T>
Future that is completed at creation time.
|
class |
GridFutureAdapter<R>
Future adapter.
|
| Modifier and Type | Field and Description |
|---|---|
protected IgniteInternalFuture<V> |
IgniteFutureImpl.fut |
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chain(IgniteClosure<? super IgniteInternalFuture<T>,R> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T1> IgniteInternalFuture<T1> |
GridFinishedFuture.chain(IgniteClosure<? super IgniteInternalFuture<T>,T1> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)
Make a chained future that is completed when
doneCb is executed. |
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb,
@Nullable Executor exec)
Make a chained future that is completed when
doneCb is executed. |
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb)
Make a chained future that is completed when
doneCb is executed. |
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb,
@Nullable Executor exec)
Make a chained future that is completed when
doneCb is executed. |
protected <T> IgniteInternalFuture<T> |
IgniteFutureImpl.chainInternal(IgniteClosure<? super IgniteFuture<V>,T> doneCb,
@Nullable Executor exec) |
protected IgniteInternalFuture<T> |
GridCompoundFuture.future(int idx)
Returns future at the specified position in this list.
|
IgniteInternalFuture<V> |
IgniteFutureImpl.internalFuture() |
| Modifier and Type | Method and Description |
|---|---|
Collection<IgniteInternalFuture<T>> |
GridCompoundFuture.futures()
Gets collection of futures.
|
| Modifier and Type | Method and Description |
|---|---|
GridCompoundFuture<T,R> |
GridCompoundFuture.add(IgniteInternalFuture<T> fut)
Adds a future to this compound future.
|
void |
GridCompoundFuture.apply(IgniteInternalFuture<T> fut)
Closure body.
|
protected boolean |
GridCompoundFuture.processFailure(Throwable err,
IgniteInternalFuture<T> fut)
Processes error thrown by some of the inner futures.
|
| Modifier and Type | Method and Description |
|---|---|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chain(IgniteClosure<? super IgniteInternalFuture<R>,T> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chain(IgniteClosure<? super IgniteInternalFuture<T>,R> doneCb)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T1> IgniteInternalFuture<T1> |
GridFinishedFuture.chain(IgniteClosure<? super IgniteInternalFuture<T>,T1> doneCb,
Executor exec)
Make a chained future to convert result of this future (when complete) into a new format.
|
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)
Make a chained future that is completed when
doneCb is executed. |
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb)
Make a chained future that is completed when
doneCb is executed. |
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb,
@Nullable Executor exec)
Make a chained future that is completed when
doneCb is executed. |
<T> IgniteInternalFuture<T> |
GridFutureAdapter.chainCompose(IgniteClosure<? super IgniteInternalFuture<R>,IgniteInternalFuture<T>> doneCb,
@Nullable Executor exec)
Make a chained future that is completed when
doneCb is executed. |
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb)
Make a chained future that is completed when
doneCb is executed. |
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb)
Make a chained future that is completed when
doneCb is executed. |
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb,
@Nullable Executor exec)
Make a chained future that is completed when
doneCb is executed. |
<R> IgniteInternalFuture<R> |
GridFinishedFuture.chainCompose(IgniteClosure<? super IgniteInternalFuture<T>,IgniteInternalFuture<R>> doneCb,
@Nullable Executor exec)
Make a chained future that is completed when
doneCb is executed. |
void |
GridFutureAdapter.listen(IgniteInClosure<? super IgniteInternalFuture<R>> lsnr)
Registers listener closure to be asynchronously notified whenever future completes.
|
void |
GridFinishedFuture.listen(IgniteInClosure<? super IgniteInternalFuture<T>> lsnr)
Registers listener closure to be asynchronously notified whenever future completes.
|
| Constructor and Description |
|---|
GridEmbeddedFuture(IgniteBiClosure<B,Exception,A> c,
IgniteInternalFuture<B> embedded) |
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c)
Embeds futures.
|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c1,
IgniteBiClosure<A,Exception,A> c2)
Embeds futures.
|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteOutClosure<IgniteInternalFuture<A>> c) |
IgniteFutureImpl(IgniteInternalFuture<V> fut) |
IgniteFutureImpl(IgniteInternalFuture<V> fut,
@Nullable Executor defaultExecutor) |
| Constructor and Description |
|---|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c)
Embeds futures.
|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteBiClosure<B,Exception,IgniteInternalFuture<A>> c1,
IgniteBiClosure<A,Exception,A> c2)
Embeds futures.
|
GridEmbeddedFuture(IgniteInternalFuture<B> embedded,
IgniteOutClosure<IgniteInternalFuture<A>> c) |
| Modifier and Type | Interface and Description |
|---|---|
interface |
GridNioFuture<R>
NIO future.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GridNioEmbeddedFuture<R>
Future that delegates to some other future.
|
class |
GridNioFinishedFuture<R>
Future that represents already completed result.
|
class |
GridNioFutureImpl<R>
Default future implementation.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<String> |
GridNioServer.dumpNodeStats(String msg,
IgnitePredicate<GridNioSession> p) |
IgniteInternalFuture<String> |
GridNioServer.dumpStats() |
IgniteInternalFuture<String> |
GridNioServer.dumpStats(String msg,
IgnitePredicate<GridNioSession> p) |
| Modifier and Type | Class and Description |
|---|---|
class |
GridWorkerFuture<T>
Future for locally executed closure that defines cancellation logic.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<String> |
TcpCommunicationSpi.dumpNodeStatistics(UUID nodeId) |
IgniteInternalFuture<Channel> |
TcpCommunicationSpi.openChannel(ClusterNode remote,
Message initMsg) |
| Modifier and Type | Class and Description |
|---|---|
class |
ConnectFuture
Connect future which uses as a marker of type connection releted with TCP.
|
class |
ConnectionRequestFuture
Marker future implementation, just like
ConnectFuture, but meaning that we're waiting for the inverse
connection. |
class |
TcpCommunicationConnectionCheckFuture
Tcp Communication Connection Check Future.
|
| Modifier and Type | Method and Description |
|---|---|
IgniteInternalFuture<Channel> |
GridNioServerWrapper.openChannel(ClusterNode remote,
Message initMsg)
Deprecated.
|
| Modifier and Type | Class and Description |
|---|---|
class |
FutureTask<T> |
Follow @ApacheIgnite
Ignite Database and Caching Platform : ver. 2.15.0 Release Date : April 25 2023