org.apache.ignite.internal

## Class GridTaskSessionImpl

- java.lang.Object
- - org.apache.ignite.internal.GridTaskSessionImpl

All Implemented Interfaces:
  ComputeTaskSession, GridTaskSessionInternal

    public class GridTaskSessionImpl
    extends Object
    implements GridTaskSessionInternal

Task session.

### Constructor Summary

Constructors
Constructor and Description

`GridTaskSessionImpl(UUID taskNodeId, String taskName, @Nullable GridDeployment dep, String taskClsName, IgniteUuid sesId, @Nullable Collection<UUID> top, @Nullable IgnitePredicate<ClusterNode> topPred, long startTime, long endTime, Collection<ComputeJobSibling> siblings, @Nullable Map<Object,Object> attrs, GridKernalContext ctx, boolean fullSup, boolean internal, UUID subjId, @Nullable String execName)`

### Method Summary

All Methods Instance Methods Concrete Methods
`boolean` `acquire()`
`void` `addAttributeListener(ComputeTaskSessionAttributeListener lsnr, boolean rewind)` Add listener for the session attributes.
`void` `addJobSiblings(Collection<ComputeJobSibling> siblings)`
`protected void` `checkFullSupport()`
`GridDeployment` `deployment()`
`@Nullable String` `executorName()`
`<K,V> V` `getAttribute(K key)` Gets an attribute set by `ComputeTaskSession.setAttribute(Object, Object)` or `ComputeTaskSession.setAttributes(Map)` method.
`Map<Object,Object>` `getAttributes()` Gets all attributes.
`String` `getCheckpointSpi()`
`ClassLoader` `getClassLoader()` Gets class loader responsible for loading all classes within task.
`long` `getEndTime()` Gets end of computation time for the task.
`String` `getFailoverSpi()`
`IgniteUuid` `getId()` Gets session ID of the task being executed.
`@Nullable IgniteUuid` `getJobId()`
`ComputeJobSibling` `getJobSibling(IgniteUuid jobId)` Gets job sibling for a given ID.
`Collection<ComputeJobSibling>` `getJobSiblings()` Gets a collection of all grid job siblings.
`String` `getLoadBalancingSpi()`
`long` `getSequenceNumber()`
`long` `getStartTime()` Gets start of computation time for the task.
`String` `getTaskClassName()` Returns task class name.
`String` `getTaskName()` Gets task name of the task this session belongs to.
`UUID` `getTaskNodeId()` Gets ID of the node on which task execution originated.
`Collection<UUID>` `getTopology()` Gets a collection of grid nodes IDs.
`@Nullable IgnitePredicate<ClusterNode>` `getTopologyPredicate()`
`String` `getUserVersion()`
`boolean` `isClosed()`
`boolean` `isFullSupport()`
`boolean` `isInternal()`
`boolean` `isTaskNode()`
`<T> T` `loadCheckpoint(String key)` Loads job's state previously saved via `ComputeTaskSession.saveCheckpoint(String, Object, ComputeTaskSessionScope, long)` method from an underlying storage for a given `key`.
`protected <T> T` `loadCheckpoint0(GridTaskSessionInternal ses, String key)`
`IgniteFuture<?>` `mapFuture()` Gets future that will be completed when task "`map`" step has completed (which means that `ComputeTask.map(List, Object)` method has finished).
`void` `onClosed()` Closes session.
`void` `onDone()` Finish task callback.
`void` `onMapped()` Task map callback.
`Collection<ComputeJobSibling>` `refreshJobSiblings()` Refreshes collection of job siblings.
`boolean` `release()`
`boolean` `removeAttributeListener(ComputeTaskSessionAttributeListener lsnr)` Removes given listener.
`boolean` `removeCheckpoint(String key)` Removes previously saved job's state for a given `key` from an underlying storage.
`protected boolean` `removeCheckpoint0(GridTaskSessionInternal ses, String key)`
`void` `saveCheckpoint(String key, Object state)` Saves intermediate state of a job or task to a storage.
`void` `saveCheckpoint(String key, Object state, ComputeTaskSessionScope scope, long timeout)` Saves intermediate state of a job to a storage.
`void` `saveCheckpoint(String key, Object state, ComputeTaskSessionScope scope, long timeout, boolean overwrite)` Saves intermediate state of a job or task to a storage.
`protected void` `saveCheckpoint0(GridTaskSessionInternal ses, String key, Object state, ComputeTaskSessionScope scope, long timeout, boolean overwrite)`
`GridTaskSessionInternal` `session()`
`void` `setAttribute(Object key, Object val)` Sets session attributed.
`void` `setAttributes(Map<?,?> attrs)` Sets task attributes.
`void` `setCheckpointSpi(String cpSpi)`
`void` `setClassLoader(ClassLoader clsLdr)`
`void` `setFailoverSpi(String failSpi)`
`void` `setInternal(Map<?,?> attrs)`
`void` `setJobSiblings(Collection<ComputeJobSibling> siblings)`
`void` `setLoadBalancingSpi(String loadSpi)`
`UUID` `subjectId()`
`String` `toString()`
`<K,V> V` `waitForAttribute(K key, long timeout)` Waits for the specified attribute to be set.
`boolean` `waitForAttribute(Object key, Object val, long timeout)` Waits for the specified attribute to be set or updated with given value.
`Map<?,?>` `waitForAttributes(Collection<?> keys, long timeout)` Waits for the specified attributes to be set.
`boolean` `waitForAttributes(Map<?,?> attrs, long timeout)` Waits for the specified attributes to be set or updated with given values.

### Methods inherited from class java.lang.Object

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

### Constructor Detail

#### GridTaskSessionImpl

    public GridTaskSessionImpl(UUID taskNodeId,
                               String taskName,
                               @Nullable
                               @Nullable GridDeployment dep,
                               String taskClsName,
                               IgniteUuid sesId,
                               @Nullable
                               @Nullable Collection<UUID> top,
                               @Nullable
                               @Nullable IgnitePredicate<ClusterNode> topPred,
                               long startTime,
                               long endTime,
                               Collection<ComputeJobSibling> siblings,
                               @Nullable
                               @Nullable Map<Object,Object> attrs,
                               GridKernalContext ctx,
                               boolean fullSup,
                               boolean internal,
                               UUID subjId,
                               @Nullable
                               @Nullable String execName)

Parameters:
  `taskNodeId` - Task node ID.
  `taskName` - Task name.
  `dep` - Deployment.
  `taskClsName` - Task class name.
  `sesId` - Task session ID.
  `top` - Topology.
  `topPred` - Topology predicate.
  `startTime` - Task execution start time.
  `endTime` - Task execution end time.
  `siblings` - Collection of siblings.
  `attrs` - Session attributes.
  `ctx` - Grid Kernal Context.
  `fullSup` - Session full support enabled flag.
  `internal` - Internal task flag.
  `subjId` - Subject ID.
  `execName` - Custom executor name.

### Method Detail

#### isFullSupport

    public boolean isFullSupport()

Specified by:
  `isFullSupport` in interface `GridTaskSessionInternal`
Returns:
  `True` if checkpoints and attributes are enabled.

#### subjectId

    public UUID subjectId()

Specified by:
  `subjectId` in interface `GridTaskSessionInternal`
Returns:
  Subject ID.

#### checkFullSupport

    protected void checkFullSupport()

#### acquire

    public boolean acquire()

Returns:
  `True` if session was acquired.

#### release

    public boolean release()

Returns:
  `True` if session cannot be acquired any more.

#### session

    public GridTaskSessionInternal session()

Specified by:
  `session` in interface `GridTaskSessionInternal`
Returns:
  Task session.

#### getJobId

    @Nullable
    public @Nullable IgniteUuid getJobId()

Specified by:
  `getJobId` in interface `GridTaskSessionInternal`
Returns:
  Job ID (possibly `null`).

#### onClosed

    public void onClosed()

Closes session.

Specified by:
  `onClosed` in interface `GridTaskSessionInternal`

#### isClosed

    public boolean isClosed()

Specified by:
  `isClosed` in interface `GridTaskSessionInternal`
Returns:
  Checks if session is closed.

#### getTaskNodeId

    public UUID getTaskNodeId()

Description copied from interface: `ComputeTaskSession`
Gets ID of the node on which task execution originated.

Specified by:
  `getTaskNodeId` in interface `ComputeTaskSession`
Returns:
  Task node ID.

#### getStartTime

    public long getStartTime()

Gets start of computation time for the task.

Specified by:
  `getStartTime` in interface `ComputeTaskSession`
Returns:
  Start of computation time for the task.

#### waitForAttribute

    public <K,V> V waitForAttribute(K key,
                                    long timeout)
                             throws InterruptedException

Waits for the specified attribute to be set. If this attribute is already in session this method will return immediately.

Specified by:
  `waitForAttribute` in interface `ComputeTaskSession`
Type Parameters:
  `K` - Attribute key type.
  `V` - Attribute value type.
Parameters:
  `key` - Attribute key to wait for.
  `timeout` - Timeout in milliseconds to wait for. `0` means indefinite wait.
Returns:
  Value of newly set attribute.
Throws:
  `InterruptedException` - Thrown if wait was interrupted.

#### waitForAttribute

    public boolean waitForAttribute(Object key,
                                    Object val,
                                    long timeout)
                             throws InterruptedException

Waits for the specified attribute to be set or updated with given value. Note that this method will block even if attribute is set for as long as its value is not equal to the specified.

Specified by:
  `waitForAttribute` in interface `ComputeTaskSession`
Parameters:
  `key` - Attribute key to wait for.
  `val` - Attribute value to wait for. Can be `null`.
  `timeout` - Timeout in milliseconds to wait for. `0` means indefinite wait.
Returns:
  Whether or not specified key/value pair has been set.
Throws:
  `InterruptedException` - Thrown if wait was interrupted.

#### waitForAttributes

    public Map<?,?> waitForAttributes(Collection<?> keys,
                                      long timeout)
                               throws InterruptedException

Waits for the specified attributes to be set. If these attributes are already in session this method will return immediately.

Specified by:
  `waitForAttributes` in interface `ComputeTaskSession`
Parameters:
  `keys` - Attribute keys to wait for.
  `timeout` - Timeout in milliseconds to wait for. `0` means indefinite wait.
Returns:
  Attribute values mapped by their keys.
Throws:
  `InterruptedException` - Thrown if wait was interrupted.

#### waitForAttributes

    public boolean waitForAttributes(Map<?,?> attrs,
                                     long timeout)
                              throws InterruptedException

Waits for the specified attributes to be set or updated with given values. Note that this method will block even if attributes are set for as long as their values are not equal to the specified.

Specified by:
  `waitForAttributes` in interface `ComputeTaskSession`
Parameters:
  `attrs` - Key/value pairs to wait for.
  `timeout` - Timeout in milliseconds to wait for. `0` means indefinite wait.
Returns:
  Whether or not key/value pair has been set.
Throws:
  `InterruptedException` - Thrown if wait was interrupted.

#### getTaskName

    public String getTaskName()

Gets task name of the task this session belongs to.

Specified by:
  `getTaskName` in interface `ComputeTaskSession`
Returns:
  Task name of the task this session belongs to.

#### getTaskClassName

    public String getTaskClassName()

Returns task class name.

Returns:
  Task class name.

#### getId

    public IgniteUuid getId()

Gets session ID of the task being executed.

Specified by:
  `getId` in interface `ComputeTaskSession`
Returns:
  Session ID of the task being executed.

#### getEndTime

    public long getEndTime()

Gets end of computation time for the task. No job within the task will be allowed to execute passed this time.

Specified by:
  `getEndTime` in interface `ComputeTaskSession`
Returns:
  End of computation time for the task.

#### getUserVersion

    public String getUserVersion()

Returns:
  Task version.

#### getClassLoader

    public ClassLoader getClassLoader()

Gets class loader responsible for loading all classes within task.

Note that for classes that were loaded remotely from other nodes methods `Class.getResource(String)` or `ClassLoader.getResource(String)` will always return `null`. Use `Class.getResourceAsStream(String)` or `ClassLoader.getResourceAsStream(String)` instead.

Specified by:
  `getClassLoader` in interface `ComputeTaskSession`
Returns:
  Class loader responsible for loading all classes within task.

#### setClassLoader

    public void setClassLoader(ClassLoader clsLdr)

Parameters:
  `clsLdr` - Class loader.

#### isTaskNode

    public boolean isTaskNode()

Specified by:
  `isTaskNode` in interface `GridTaskSessionInternal`
Returns:
  `True` if task node.

#### refreshJobSiblings

    public Collection<ComputeJobSibling> refreshJobSiblings()

Refreshes collection of job siblings. This method has no effect when invoked on originating node, as the list of siblings is always most recent. However, when using `continuous mapping` (see `ComputeTaskContinuousMapper`), list of siblings on remote node may not be fresh. In that case, this method will re-request list of siblings from originating node.

Specified by:
  `refreshJobSiblings` in interface `ComputeTaskSession`
Returns:
  Refreshed collection of job siblings.

#### getJobSiblings

    public Collection<ComputeJobSibling> getJobSiblings()

Gets a collection of all grid job siblings. Job siblings are grid jobs that are executing within the same task.

If task uses continuous mapper (i.e. it injected into task class) then job siblings will be requested from task node for each apply.

Specified by:
  `getJobSiblings` in interface `ComputeTaskSession`
Returns:
  Collection of grid job siblings executing within this task.

#### setJobSiblings

    public void setJobSiblings(Collection<ComputeJobSibling> siblings)

Parameters:
  `siblings` - Siblings.

#### addJobSiblings

    public void addJobSiblings(Collection<ComputeJobSibling> siblings)

Parameters:
  `siblings` - Siblings.

#### getJobSibling

    public ComputeJobSibling getJobSibling(IgniteUuid jobId)

Gets job sibling for a given ID.

If task uses continuous mapper (i.e. it injected into task class) then job sibling will be requested from task node for each apply.

Specified by:
  `getJobSibling` in interface `ComputeTaskSession`
Parameters:
  `jobId` - Job ID to get the sibling for.
Returns:
  Grid job sibling for a given ID.

#### setAttribute

    public void setAttribute(Object key,
                             Object val)

Sets session attributed. Note that task session is distributed and this attribute will be propagated to all other jobs within this task and task itself - i.e., to all accessors of this session. Other jobs then will be notified by `ComputeTaskSessionAttributeListener` callback than an attribute has changed.

This method is no-op if the session has finished.

Specified by:
  `setAttribute` in interface `ComputeTaskSession`
Parameters:
  `key` - Attribute key.
  `val` - Attribute value. Can be `null`.

#### getAttribute

    public <K,V> V getAttribute(K key)

Gets an attribute set by `ComputeTaskSession.setAttribute(Object, Object)` or `ComputeTaskSession.setAttributes(Map)` method. Note that this attribute could have been set by another job on another node.

This method is no-op if the session has finished.

Specified by:
  `getAttribute` in interface `ComputeTaskSession`
Type Parameters:
  `K` - Attribute key type.
  `V` - Attribute value type.
Parameters:
  `key` - Attribute key.
Returns:
  Gets task attribute for given name.

#### setAttributes

    public void setAttributes(Map<?,?> attrs)

Sets task attributes. This method exists so one distributed replication operation will take place for the whole group of attributes passed in. Use it for performance reasons, rather than `ComputeTaskSession.setAttribute(Object, Object)` method, whenever you need to set multiple attributes.

This method is no-op if the session has finished.

Specified by:
  `setAttributes` in interface `ComputeTaskSession`
Parameters:
  `attrs` - Attributes to set.

#### getAttributes

    public Map<Object,Object> getAttributes()

Gets all attributes.

Specified by:
  `getAttributes` in interface `ComputeTaskSession`
Returns:
  All session attributes.

#### setInternal

    public void setInternal(Map<?,?> attrs)

Parameters:
  `attrs` - Attributes to set.

#### addAttributeListener

    public void addAttributeListener(ComputeTaskSessionAttributeListener lsnr,
                                     boolean rewind)

Add listener for the session attributes.

Specified by:
  `addAttributeListener` in interface `ComputeTaskSession`
Parameters:
  `lsnr` - Listener to add.
  `rewind` - `true` value will result in calling given listener for all already received attributes, while `false` value will result only in new attribute notification. Settings `rewind` to `true` allows for a simple mechanism that prevents the loss of notifications for the attributes that were previously received or received while this method was executing.

#### removeAttributeListener

    public boolean removeAttributeListener(ComputeTaskSessionAttributeListener lsnr)

Removes given listener.

Specified by:
  `removeAttributeListener` in interface `ComputeTaskSession`
Parameters:
  `lsnr` - Listener to remove.
Returns:
  `true` if listener was removed, `false` otherwise.

#### saveCheckpoint

    public void saveCheckpoint(String key,
                               Object state)

Saves intermediate state of a job or task to a storage. The storage implementation is defined by `CheckpointSpi` implementation used.

Long running jobs may decide to store intermediate state to protect themselves from failures. This way whenever a job fails over to another node, it can load its previously saved state via `ComputeTaskSession.loadCheckpoint(String)` method and continue with execution.

This method defaults checkpoint scope to `ComputeTaskSessionScope.SESSION_SCOPE` and implementation will automatically remove the checkpoint at the end of the session. It is analogous to calling `saveCheckpoint(String, Serializable, GridCheckpointScope.SESSION_SCOPE, 0`.

Specified by:
  `saveCheckpoint` in interface `ComputeTaskSession`
Parameters:
  `key` - Key to be used to load this checkpoint in future.
  `state` - Intermediate job state to save.
See Also:
  `ComputeTaskSession.loadCheckpoint(String)`, `ComputeTaskSession.removeCheckpoint(String)`, `CheckpointSpi`

#### saveCheckpoint

    public void saveCheckpoint(String key,
                               Object state,
                               ComputeTaskSessionScope scope,
                               long timeout)

Saves intermediate state of a job to a storage. The storage implementation is defined by `CheckpointSpi` implementation used.

Long running jobs may decide to store intermediate state to protect themselves from failures. This way whenever a job fails over to another node, it can load its previously saved state via `ComputeTaskSession.loadCheckpoint(String)` method and continue with execution.

The life time of the checkpoint is determined by its timeout and scope. If `ComputeTaskSessionScope.GLOBAL_SCOPE` is used, the checkpoint will outlive its session, and can only be removed by calling `CheckpointSpi.removeCheckpoint(String)` from `Ignite` or another task or job.

Specified by:
  `saveCheckpoint` in interface `ComputeTaskSession`
Parameters:
  `key` - Key to be used to load this checkpoint in future.
  `state` - Intermediate job state to save.
  `scope` - Checkpoint scope. If equal to `ComputeTaskSessionScope.SESSION_SCOPE`, then state will automatically be removed at the end of task execution. Otherwise, if scope is `ComputeTaskSessionScope.GLOBAL_SCOPE` then state will outlive its session and can be removed by calling `ComputeTaskSession.removeCheckpoint(String)` from another task or whenever timeout expires.
  `timeout` - Maximum time this state should be kept by the underlying storage. Value `0` means that timeout will never expire.
See Also:
  `ComputeTaskSession.loadCheckpoint(String)`, `ComputeTaskSession.removeCheckpoint(String)`, `CheckpointSpi`

#### saveCheckpoint

    public void saveCheckpoint(String key,
                               Object state,
                               ComputeTaskSessionScope scope,
                               long timeout,
                               boolean overwrite)

Saves intermediate state of a job or task to a storage. The storage implementation is defined by `CheckpointSpi` implementation used.

Long running jobs may decide to store intermediate state to protect themselves from failures. This way whenever a job fails over to another node, it can load its previously saved state via `ComputeTaskSession.loadCheckpoint(String)` method and continue with execution.

The life time of the checkpoint is determined by its timeout and scope. If `ComputeTaskSessionScope.GLOBAL_SCOPE` is used, the checkpoint will outlive its session, and can only be removed by calling `CheckpointSpi.removeCheckpoint(String)` from `Ignite` or another task or job.

Specified by:
  `saveCheckpoint` in interface `ComputeTaskSession`
Parameters:
  `key` - Key to be used to load this checkpoint in future.
  `state` - Intermediate job state to save.
  `scope` - Checkpoint scope. If equal to `ComputeTaskSessionScope.SESSION_SCOPE`, then state will automatically be removed at the end of task execution. Otherwise, if scope is `ComputeTaskSessionScope.GLOBAL_SCOPE` then state will outlive its session and can be removed by calling `ComputeTaskSession.removeCheckpoint(String)` from another task or whenever timeout expires.
  `timeout` - Maximum time this state should be kept by the underlying storage. Value `0` means that timeout will never expire.
  `overwrite` - Whether or not overwrite checkpoint if it already exists.
See Also:
  `ComputeTaskSession.loadCheckpoint(String)`, `ComputeTaskSession.removeCheckpoint(String)`, `CheckpointSpi`

#### saveCheckpoint0

    protected void saveCheckpoint0(GridTaskSessionInternal ses,
                                   String key,
                                   Object state,
                                   ComputeTaskSessionScope scope,
                                   long timeout,
                                   boolean overwrite)
                            throws IgniteException

Parameters:
  `ses` - Session.
  `key` - Key.
  `state` - State.
  `scope` - Scope.
  `timeout` - Timeout.
  `overwrite` - Overwrite.
Throws:
  `IgniteException` - If failed.

#### loadCheckpoint

    public <T> T loadCheckpoint(String key)

Loads job's state previously saved via `ComputeTaskSession.saveCheckpoint(String, Object, ComputeTaskSessionScope, long)` method from an underlying storage for a given `key`. If state was not previously saved, then `null` will be returned. The storage implementation is defined by `CheckpointSpi` implementation used.

Long running jobs may decide to store intermediate state to protect themselves from failures. This way whenever a job starts, it can load its previously saved state and continue with execution.

Specified by:
  `loadCheckpoint` in interface `ComputeTaskSession`
Type Parameters:
  `T` - Type of the checkpoint state.
Parameters:
  `key` - Key for intermediate job state to load.
Returns:
  Previously saved state or `null` if no state was found for a given `key`.
See Also:
  `ComputeTaskSession.removeCheckpoint(String)`, `CheckpointSpi`

#### loadCheckpoint0

    protected <T> T loadCheckpoint0(GridTaskSessionInternal ses,
                                    String key)

Parameters:
  `ses` - Session.
  `key` - Key.
Returns:
  Checkpoint.
Throws:
  `IgniteException` - If failed.

#### removeCheckpoint

    public boolean removeCheckpoint(String key)

Removes previously saved job's state for a given `key` from an underlying storage. The storage implementation is defined by `CheckpointSpi` implementation used.

Long running jobs may decide to store intermediate state to protect themselves from failures. This way whenever a job starts, it can load its previously saved state and continue with execution.

Specified by:
  `removeCheckpoint` in interface `ComputeTaskSession`
Parameters:
  `key` - Key for intermediate job state to load.
Returns:
  `true` if job state was removed, `false` if state was not found.
See Also:
  `ComputeTaskSession.loadCheckpoint(String)`, `CheckpointSpi`

#### removeCheckpoint0

    protected boolean removeCheckpoint0(GridTaskSessionInternal ses,
                                        String key)
                                 throws IgniteException

Parameters:
  `ses` - Session.
  `key` - Key.
Returns:
  `True` if removed.
Throws:
  `IgniteException` - If failed.

#### getTopologyPredicate

    @Nullable
    public @Nullable IgnitePredicate<ClusterNode> getTopologyPredicate()

Returns:
  Topology predicate.

#### getTopology

    public Collection<UUID> getTopology()

Gets a collection of grid nodes IDs.

Specified by:
  `getTopology` in interface `ComputeTaskSession`
Returns:
  Collection of grid nodes IDs for the task's split.

#### getCheckpointSpi

    public String getCheckpointSpi()

Specified by:
  `getCheckpointSpi` in interface `GridTaskSessionInternal`
Returns:
  Checkpoint SPI name.

#### setCheckpointSpi

    public void setCheckpointSpi(String cpSpi)

Parameters:
  `cpSpi` - Checkpoint SPI name.

#### getFailoverSpi

    public String getFailoverSpi()

Returns:
  Failover SPI name.

#### setFailoverSpi

    public void setFailoverSpi(String failSpi)

Parameters:
  `failSpi` - Failover SPI name.

#### getLoadBalancingSpi

    public String getLoadBalancingSpi()

Returns:
  Load balancing SPI name.

#### setLoadBalancingSpi

    public void setLoadBalancingSpi(String loadSpi)

Parameters:
  `loadSpi` - Load balancing SPI name.

#### getSequenceNumber

    public long getSequenceNumber()

Returns:
  Task internal version.

#### deployment

    public GridDeployment deployment()

Returns:
  Deployment.

#### onMapped

    public void onMapped()

Task map callback.

#### onDone

    public void onDone()

Finish task callback.

#### mapFuture

    public IgniteFuture<?> mapFuture()

Gets future that will be completed when task "`map`" step has completed (which means that `ComputeTask.map(List, Object)` method has finished).

Specified by:
  `mapFuture` in interface `ComputeTaskSession`
Returns:
  Future that will be completed when task "`map`" step has completed.

#### isInternal

    public boolean isInternal()

Returns:
  `True` if task is internal.

#### executorName

    @Nullable
    public @Nullable String executorName()

Returns:
  Custom executor name.

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`

${current.year} Copyright © Apache Software Foundation

Follow @ApacheIgnite

Ignite Database and Caching Platform | : ver. 2.9.0
Release Date | : October 15 2020