Class TasksImpl
- java.lang.Object
-
- com.microsoft.azure.batch.protocol.implementation.TasksImpl
-
-
Constructor Summary
Constructors Constructor Description TasksImpl(retrofit2.Retrofit retrofit, BatchServiceClientImpl client)
Initializes an instance of TasksImpl.
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description void
add(String jobId, TaskAddParameter task)
Adds a Task to the specified Job.void
add(String jobId, TaskAddParameter task, TaskAddOptions taskAddOptions)
Adds a Task to the specified Job.rx.Observable<Void>
addAsync(String jobId, TaskAddParameter task)
Adds a Task to the specified Job.rx.Observable<Void>
addAsync(String jobId, TaskAddParameter task, TaskAddOptions taskAddOptions)
Adds a Task to the specified Job.com.microsoft.rest.ServiceFuture<Void>
addAsync(String jobId, TaskAddParameter task, TaskAddOptions taskAddOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Adds a Task to the specified Job.com.microsoft.rest.ServiceFuture<Void>
addAsync(String jobId, TaskAddParameter task, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Adds a Task to the specified Job.TaskAddCollectionResult
addCollection(String jobId, List<TaskAddParameter> value)
Adds a collection of Tasks to the specified Job.TaskAddCollectionResult
addCollection(String jobId, List<TaskAddParameter> value, TaskAddCollectionOptions taskAddCollectionOptions)
Adds a collection of Tasks to the specified Job.rx.Observable<TaskAddCollectionResult>
addCollectionAsync(String jobId, List<TaskAddParameter> value)
Adds a collection of Tasks to the specified Job.rx.Observable<TaskAddCollectionResult>
addCollectionAsync(String jobId, List<TaskAddParameter> value, TaskAddCollectionOptions taskAddCollectionOptions)
Adds a collection of Tasks to the specified Job.com.microsoft.rest.ServiceFuture<TaskAddCollectionResult>
addCollectionAsync(String jobId, List<TaskAddParameter> value, TaskAddCollectionOptions taskAddCollectionOptions, com.microsoft.rest.ServiceCallback<TaskAddCollectionResult> serviceCallback)
Adds a collection of Tasks to the specified Job.com.microsoft.rest.ServiceFuture<TaskAddCollectionResult>
addCollectionAsync(String jobId, List<TaskAddParameter> value, com.microsoft.rest.ServiceCallback<TaskAddCollectionResult> serviceCallback)
Adds a collection of Tasks to the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<TaskAddCollectionResult,TaskAddCollectionHeaders>>
addCollectionWithServiceResponseAsync(String jobId, List<TaskAddParameter> value)
Adds a collection of Tasks to the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<TaskAddCollectionResult,TaskAddCollectionHeaders>>
addCollectionWithServiceResponseAsync(String jobId, List<TaskAddParameter> value, TaskAddCollectionOptions taskAddCollectionOptions)
Adds a collection of Tasks to the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskAddHeaders>>
addWithServiceResponseAsync(String jobId, TaskAddParameter task)
Adds a Task to the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskAddHeaders>>
addWithServiceResponseAsync(String jobId, TaskAddParameter task, TaskAddOptions taskAddOptions)
Adds a Task to the specified Job.void
delete(String jobId, String taskId)
Deletes a Task from the specified Job.void
delete(String jobId, String taskId, TaskDeleteOptions taskDeleteOptions)
Deletes a Task from the specified Job.rx.Observable<Void>
deleteAsync(String jobId, String taskId)
Deletes a Task from the specified Job.rx.Observable<Void>
deleteAsync(String jobId, String taskId, TaskDeleteOptions taskDeleteOptions)
Deletes a Task from the specified Job.com.microsoft.rest.ServiceFuture<Void>
deleteAsync(String jobId, String taskId, TaskDeleteOptions taskDeleteOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Deletes a Task from the specified Job.com.microsoft.rest.ServiceFuture<Void>
deleteAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Deletes a Task from the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskDeleteHeaders>>
deleteWithServiceResponseAsync(String jobId, String taskId)
Deletes a Task from the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskDeleteHeaders>>
deleteWithServiceResponseAsync(String jobId, String taskId, TaskDeleteOptions taskDeleteOptions)
Deletes a Task from the specified Job.CloudTask
get(String jobId, String taskId)
Gets information about the specified Task.CloudTask
get(String jobId, String taskId, TaskGetOptions taskGetOptions)
Gets information about the specified Task.rx.Observable<CloudTask>
getAsync(String jobId, String taskId)
Gets information about the specified Task.rx.Observable<CloudTask>
getAsync(String jobId, String taskId, TaskGetOptions taskGetOptions)
Gets information about the specified Task.com.microsoft.rest.ServiceFuture<CloudTask>
getAsync(String jobId, String taskId, TaskGetOptions taskGetOptions, com.microsoft.rest.ServiceCallback<CloudTask> serviceCallback)
Gets information about the specified Task.com.microsoft.rest.ServiceFuture<CloudTask>
getAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<CloudTask> serviceCallback)
Gets information about the specified Task.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<CloudTask,TaskGetHeaders>>
getWithServiceResponseAsync(String jobId, String taskId)
Gets information about the specified Task.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<CloudTask,TaskGetHeaders>>
getWithServiceResponseAsync(String jobId, String taskId, TaskGetOptions taskGetOptions)
Gets information about the specified Task.com.microsoft.azure.PagedList<CloudTask>
list(String jobId)
Lists all of the Tasks that are associated with the specified Job.com.microsoft.azure.PagedList<CloudTask>
list(String jobId, TaskListOptions taskListOptions)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.azure.Page<CloudTask>>
listAsync(String jobId)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.azure.Page<CloudTask>>
listAsync(String jobId, TaskListOptions taskListOptions)
Lists all of the Tasks that are associated with the specified Job.com.microsoft.rest.ServiceFuture<List<CloudTask>>
listAsync(String jobId, TaskListOptions taskListOptions, com.microsoft.azure.ListOperationCallback<CloudTask> serviceCallback)
Lists all of the Tasks that are associated with the specified Job.com.microsoft.rest.ServiceFuture<List<CloudTask>>
listAsync(String jobId, com.microsoft.azure.ListOperationCallback<CloudTask> serviceCallback)
Lists all of the Tasks that are associated with the specified Job.com.microsoft.azure.PagedList<CloudTask>
listNext(String nextPageLink)
Lists all of the Tasks that are associated with the specified Job.com.microsoft.azure.PagedList<CloudTask>
listNext(String nextPageLink, TaskListNextOptions taskListNextOptions)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.azure.Page<CloudTask>>
listNextAsync(String nextPageLink)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.azure.Page<CloudTask>>
listNextAsync(String nextPageLink, TaskListNextOptions taskListNextOptions)
Lists all of the Tasks that are associated with the specified Job.com.microsoft.rest.ServiceFuture<List<CloudTask>>
listNextAsync(String nextPageLink, TaskListNextOptions taskListNextOptions, com.microsoft.rest.ServiceFuture<List<CloudTask>> serviceFuture, com.microsoft.azure.ListOperationCallback<CloudTask> serviceCallback)
Lists all of the Tasks that are associated with the specified Job.com.microsoft.rest.ServiceFuture<List<CloudTask>>
listNextAsync(String nextPageLink, com.microsoft.rest.ServiceFuture<List<CloudTask>> serviceFuture, com.microsoft.azure.ListOperationCallback<CloudTask> serviceCallback)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>>
listNextSinglePageAsync(String nextPageLink)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>>
listNextSinglePageAsync(String nextPageLink, TaskListNextOptions taskListNextOptions)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>>
listNextWithServiceResponseAsync(String nextPageLink)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>>
listNextWithServiceResponseAsync(String nextPageLink, TaskListNextOptions taskListNextOptions)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>>
listSinglePageAsync(String jobId)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>>
listSinglePageAsync(String jobId, TaskListOptions taskListOptions)
Lists all of the Tasks that are associated with the specified Job.CloudTaskListSubtasksResult
listSubtasks(String jobId, String taskId)
Lists all of the subtasks that are associated with the specified multi-instance Task.CloudTaskListSubtasksResult
listSubtasks(String jobId, String taskId, TaskListSubtasksOptions taskListSubtasksOptions)
Lists all of the subtasks that are associated with the specified multi-instance Task.rx.Observable<CloudTaskListSubtasksResult>
listSubtasksAsync(String jobId, String taskId)
Lists all of the subtasks that are associated with the specified multi-instance Task.rx.Observable<CloudTaskListSubtasksResult>
listSubtasksAsync(String jobId, String taskId, TaskListSubtasksOptions taskListSubtasksOptions)
Lists all of the subtasks that are associated with the specified multi-instance Task.com.microsoft.rest.ServiceFuture<CloudTaskListSubtasksResult>
listSubtasksAsync(String jobId, String taskId, TaskListSubtasksOptions taskListSubtasksOptions, com.microsoft.rest.ServiceCallback<CloudTaskListSubtasksResult> serviceCallback)
Lists all of the subtasks that are associated with the specified multi-instance Task.com.microsoft.rest.ServiceFuture<CloudTaskListSubtasksResult>
listSubtasksAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<CloudTaskListSubtasksResult> serviceCallback)
Lists all of the subtasks that are associated with the specified multi-instance Task.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<CloudTaskListSubtasksResult,TaskListSubtasksHeaders>>
listSubtasksWithServiceResponseAsync(String jobId, String taskId)
Lists all of the subtasks that are associated with the specified multi-instance Task.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<CloudTaskListSubtasksResult,TaskListSubtasksHeaders>>
listSubtasksWithServiceResponseAsync(String jobId, String taskId, TaskListSubtasksOptions taskListSubtasksOptions)
Lists all of the subtasks that are associated with the specified multi-instance Task.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>>
listWithServiceResponseAsync(String jobId)
Lists all of the Tasks that are associated with the specified Job.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>>
listWithServiceResponseAsync(String jobId, TaskListOptions taskListOptions)
Lists all of the Tasks that are associated with the specified Job.void
reactivate(String jobId, String taskId)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted.void
reactivate(String jobId, String taskId, TaskReactivateOptions taskReactivateOptions)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted.rx.Observable<Void>
reactivateAsync(String jobId, String taskId)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted.rx.Observable<Void>
reactivateAsync(String jobId, String taskId, TaskReactivateOptions taskReactivateOptions)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted.com.microsoft.rest.ServiceFuture<Void>
reactivateAsync(String jobId, String taskId, TaskReactivateOptions taskReactivateOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted.com.microsoft.rest.ServiceFuture<Void>
reactivateAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskReactivateHeaders>>
reactivateWithServiceResponseAsync(String jobId, String taskId)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskReactivateHeaders>>
reactivateWithServiceResponseAsync(String jobId, String taskId, TaskReactivateOptions taskReactivateOptions)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted.void
terminate(String jobId, String taskId)
Terminates the specified Task.void
terminate(String jobId, String taskId, TaskTerminateOptions taskTerminateOptions)
Terminates the specified Task.rx.Observable<Void>
terminateAsync(String jobId, String taskId)
Terminates the specified Task.rx.Observable<Void>
terminateAsync(String jobId, String taskId, TaskTerminateOptions taskTerminateOptions)
Terminates the specified Task.com.microsoft.rest.ServiceFuture<Void>
terminateAsync(String jobId, String taskId, TaskTerminateOptions taskTerminateOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Terminates the specified Task.com.microsoft.rest.ServiceFuture<Void>
terminateAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Terminates the specified Task.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskTerminateHeaders>>
terminateWithServiceResponseAsync(String jobId, String taskId)
Terminates the specified Task.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskTerminateHeaders>>
terminateWithServiceResponseAsync(String jobId, String taskId, TaskTerminateOptions taskTerminateOptions)
Terminates the specified Task.void
update(String jobId, String taskId)
Updates the properties of the specified Task.void
update(String jobId, String taskId, TaskConstraints constraints, TaskUpdateOptions taskUpdateOptions)
Updates the properties of the specified Task.rx.Observable<Void>
updateAsync(String jobId, String taskId)
Updates the properties of the specified Task.rx.Observable<Void>
updateAsync(String jobId, String taskId, TaskConstraints constraints, TaskUpdateOptions taskUpdateOptions)
Updates the properties of the specified Task.com.microsoft.rest.ServiceFuture<Void>
updateAsync(String jobId, String taskId, TaskConstraints constraints, TaskUpdateOptions taskUpdateOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Updates the properties of the specified Task.com.microsoft.rest.ServiceFuture<Void>
updateAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Updates the properties of the specified Task.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskUpdateHeaders>>
updateWithServiceResponseAsync(String jobId, String taskId)
Updates the properties of the specified Task.rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskUpdateHeaders>>
updateWithServiceResponseAsync(String jobId, String taskId, TaskConstraints constraints, TaskUpdateOptions taskUpdateOptions)
Updates the properties of the specified Task.
-
-
-
Constructor Detail
-
TasksImpl
public TasksImpl(retrofit2.Retrofit retrofit, BatchServiceClientImpl client)
Initializes an instance of TasksImpl.- Parameters:
retrofit
- the Retrofit instance built from a Retrofit Builder.client
- the instance of the service client containing this operation class.
-
-
Method Detail
-
add
public void add(String jobId, TaskAddParameter task)
Adds a Task to the specified Job. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
add
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task is to be added.task
- The Task to be added.- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
addAsync
public com.microsoft.rest.ServiceFuture<Void> addAsync(String jobId, TaskAddParameter task, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Adds a Task to the specified Job. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task is to be added.task
- The Task to be added.serviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addAsync
public rx.Observable<Void> addAsync(String jobId, TaskAddParameter task)
Adds a Task to the specified Job. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task is to be added.task
- The Task to be added.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskAddHeaders>> addWithServiceResponseAsync(String jobId, TaskAddParameter task)
Adds a Task to the specified Job. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task is to be added.task
- The Task to be added.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
add
public void add(String jobId, TaskAddParameter task, TaskAddOptions taskAddOptions)
Adds a Task to the specified Job. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
add
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task is to be added.task
- The Task to be added.taskAddOptions
- Additional parameters for the operation- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
addAsync
public com.microsoft.rest.ServiceFuture<Void> addAsync(String jobId, TaskAddParameter task, TaskAddOptions taskAddOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Adds a Task to the specified Job. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task is to be added.task
- The Task to be added.taskAddOptions
- Additional parameters for the operationserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addAsync
public rx.Observable<Void> addAsync(String jobId, TaskAddParameter task, TaskAddOptions taskAddOptions)
Adds a Task to the specified Job. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task is to be added.task
- The Task to be added.taskAddOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskAddHeaders>> addWithServiceResponseAsync(String jobId, TaskAddParameter task, TaskAddOptions taskAddOptions)
Adds a Task to the specified Job. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task is to be added.task
- The Task to be added.taskAddOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
list
public com.microsoft.azure.PagedList<CloudTask> list(String jobId)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
list
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.- Returns:
- the PagedList<CloudTask> object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
listAsync
public com.microsoft.rest.ServiceFuture<List<CloudTask>> listAsync(String jobId, com.microsoft.azure.ListOperationCallback<CloudTask> serviceCallback)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.serviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listAsync
public rx.Observable<com.microsoft.azure.Page<CloudTask>> listAsync(String jobId)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.- Returns:
- the observable to the PagedList<CloudTask> object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>> listWithServiceResponseAsync(String jobId)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.- Returns:
- the observable to the PagedList<CloudTask> object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listSinglePageAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>> listSinglePageAsync(String jobId)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Parameters:
jobId
- The ID of the Job.- Returns:
- the PagedList<CloudTask> object wrapped in
ServiceResponseWithHeaders
if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
list
public com.microsoft.azure.PagedList<CloudTask> list(String jobId, TaskListOptions taskListOptions)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
list
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskListOptions
- Additional parameters for the operation- Returns:
- the PagedList<CloudTask> object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
listAsync
public com.microsoft.rest.ServiceFuture<List<CloudTask>> listAsync(String jobId, TaskListOptions taskListOptions, com.microsoft.azure.ListOperationCallback<CloudTask> serviceCallback)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskListOptions
- Additional parameters for the operationserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listAsync
public rx.Observable<com.microsoft.azure.Page<CloudTask>> listAsync(String jobId, TaskListOptions taskListOptions)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskListOptions
- Additional parameters for the operation- Returns:
- the observable to the PagedList<CloudTask> object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>> listWithServiceResponseAsync(String jobId, TaskListOptions taskListOptions)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskListOptions
- Additional parameters for the operation- Returns:
- the observable to the PagedList<CloudTask> object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listSinglePageAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>> listSinglePageAsync(String jobId, TaskListOptions taskListOptions)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks. ServiceResponseWithHeaders, TaskListHeaders> * @param jobId The ID of the Job. ServiceResponseWithHeaders , TaskListHeaders> * @param taskListOptions Additional parameters for the operation - Returns:
- the PagedList<CloudTask> object wrapped in
ServiceResponseWithHeaders
if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addCollection
public TaskAddCollectionResult addCollection(String jobId, List<TaskAddParameter> value)
Adds a collection of Tasks to the specified Job. Note that each Task must have a unique ID. The Batch service may not return the results for each Task in the same order the Tasks were submitted in this request. If the server times out or the connection is closed during the request, the request may have been partially or fully processed, or not at all. In such cases, the user should re-issue the request. Note that it is up to the user to correctly handle failures when re-issuing a request. For example, you should use the same Task IDs during a retry so that if the prior operation succeeded, the retry will not create extra Tasks unexpectedly. If the response contains any Tasks which failed to add, a client can retry the request. In a retry, it is most efficient to resubmit only Tasks that failed to add, and to omit Tasks that were successfully added on the first attempt. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addCollection
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task collection is to be added.value
- The collection of Tasks to add. The maximum count of Tasks is 100. The total serialized size of this collection must be less than 1MB. If it is greater than 1MB (for example if each Task has 100's of resource files or environment variables), the request will fail with code 'RequestBodyTooLarge' and should be retried again with fewer Tasks.- Returns:
- the TaskAddCollectionResult object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
addCollectionAsync
public com.microsoft.rest.ServiceFuture<TaskAddCollectionResult> addCollectionAsync(String jobId, List<TaskAddParameter> value, com.microsoft.rest.ServiceCallback<TaskAddCollectionResult> serviceCallback)
Adds a collection of Tasks to the specified Job. Note that each Task must have a unique ID. The Batch service may not return the results for each Task in the same order the Tasks were submitted in this request. If the server times out or the connection is closed during the request, the request may have been partially or fully processed, or not at all. In such cases, the user should re-issue the request. Note that it is up to the user to correctly handle failures when re-issuing a request. For example, you should use the same Task IDs during a retry so that if the prior operation succeeded, the retry will not create extra Tasks unexpectedly. If the response contains any Tasks which failed to add, a client can retry the request. In a retry, it is most efficient to resubmit only Tasks that failed to add, and to omit Tasks that were successfully added on the first attempt. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addCollectionAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task collection is to be added.value
- The collection of Tasks to add. The maximum count of Tasks is 100. The total serialized size of this collection must be less than 1MB. If it is greater than 1MB (for example if each Task has 100's of resource files or environment variables), the request will fail with code 'RequestBodyTooLarge' and should be retried again with fewer Tasks.serviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addCollectionAsync
public rx.Observable<TaskAddCollectionResult> addCollectionAsync(String jobId, List<TaskAddParameter> value)
Adds a collection of Tasks to the specified Job. Note that each Task must have a unique ID. The Batch service may not return the results for each Task in the same order the Tasks were submitted in this request. If the server times out or the connection is closed during the request, the request may have been partially or fully processed, or not at all. In such cases, the user should re-issue the request. Note that it is up to the user to correctly handle failures when re-issuing a request. For example, you should use the same Task IDs during a retry so that if the prior operation succeeded, the retry will not create extra Tasks unexpectedly. If the response contains any Tasks which failed to add, a client can retry the request. In a retry, it is most efficient to resubmit only Tasks that failed to add, and to omit Tasks that were successfully added on the first attempt. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addCollectionAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task collection is to be added.value
- The collection of Tasks to add. The maximum count of Tasks is 100. The total serialized size of this collection must be less than 1MB. If it is greater than 1MB (for example if each Task has 100's of resource files or environment variables), the request will fail with code 'RequestBodyTooLarge' and should be retried again with fewer Tasks.- Returns:
- the observable to the TaskAddCollectionResult object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addCollectionWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<TaskAddCollectionResult,TaskAddCollectionHeaders>> addCollectionWithServiceResponseAsync(String jobId, List<TaskAddParameter> value)
Adds a collection of Tasks to the specified Job. Note that each Task must have a unique ID. The Batch service may not return the results for each Task in the same order the Tasks were submitted in this request. If the server times out or the connection is closed during the request, the request may have been partially or fully processed, or not at all. In such cases, the user should re-issue the request. Note that it is up to the user to correctly handle failures when re-issuing a request. For example, you should use the same Task IDs during a retry so that if the prior operation succeeded, the retry will not create extra Tasks unexpectedly. If the response contains any Tasks which failed to add, a client can retry the request. In a retry, it is most efficient to resubmit only Tasks that failed to add, and to omit Tasks that were successfully added on the first attempt. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addCollectionWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task collection is to be added.value
- The collection of Tasks to add. The maximum count of Tasks is 100. The total serialized size of this collection must be less than 1MB. If it is greater than 1MB (for example if each Task has 100's of resource files or environment variables), the request will fail with code 'RequestBodyTooLarge' and should be retried again with fewer Tasks.- Returns:
- the observable to the TaskAddCollectionResult object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addCollection
public TaskAddCollectionResult addCollection(String jobId, List<TaskAddParameter> value, TaskAddCollectionOptions taskAddCollectionOptions)
Adds a collection of Tasks to the specified Job. Note that each Task must have a unique ID. The Batch service may not return the results for each Task in the same order the Tasks were submitted in this request. If the server times out or the connection is closed during the request, the request may have been partially or fully processed, or not at all. In such cases, the user should re-issue the request. Note that it is up to the user to correctly handle failures when re-issuing a request. For example, you should use the same Task IDs during a retry so that if the prior operation succeeded, the retry will not create extra Tasks unexpectedly. If the response contains any Tasks which failed to add, a client can retry the request. In a retry, it is most efficient to resubmit only Tasks that failed to add, and to omit Tasks that were successfully added on the first attempt. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addCollection
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task collection is to be added.value
- The collection of Tasks to add. The maximum count of Tasks is 100. The total serialized size of this collection must be less than 1MB. If it is greater than 1MB (for example if each Task has 100's of resource files or environment variables), the request will fail with code 'RequestBodyTooLarge' and should be retried again with fewer Tasks.taskAddCollectionOptions
- Additional parameters for the operation- Returns:
- the TaskAddCollectionResult object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
addCollectionAsync
public com.microsoft.rest.ServiceFuture<TaskAddCollectionResult> addCollectionAsync(String jobId, List<TaskAddParameter> value, TaskAddCollectionOptions taskAddCollectionOptions, com.microsoft.rest.ServiceCallback<TaskAddCollectionResult> serviceCallback)
Adds a collection of Tasks to the specified Job. Note that each Task must have a unique ID. The Batch service may not return the results for each Task in the same order the Tasks were submitted in this request. If the server times out or the connection is closed during the request, the request may have been partially or fully processed, or not at all. In such cases, the user should re-issue the request. Note that it is up to the user to correctly handle failures when re-issuing a request. For example, you should use the same Task IDs during a retry so that if the prior operation succeeded, the retry will not create extra Tasks unexpectedly. If the response contains any Tasks which failed to add, a client can retry the request. In a retry, it is most efficient to resubmit only Tasks that failed to add, and to omit Tasks that were successfully added on the first attempt. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addCollectionAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task collection is to be added.value
- The collection of Tasks to add. The maximum count of Tasks is 100. The total serialized size of this collection must be less than 1MB. If it is greater than 1MB (for example if each Task has 100's of resource files or environment variables), the request will fail with code 'RequestBodyTooLarge' and should be retried again with fewer Tasks.taskAddCollectionOptions
- Additional parameters for the operationserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addCollectionAsync
public rx.Observable<TaskAddCollectionResult> addCollectionAsync(String jobId, List<TaskAddParameter> value, TaskAddCollectionOptions taskAddCollectionOptions)
Adds a collection of Tasks to the specified Job. Note that each Task must have a unique ID. The Batch service may not return the results for each Task in the same order the Tasks were submitted in this request. If the server times out or the connection is closed during the request, the request may have been partially or fully processed, or not at all. In such cases, the user should re-issue the request. Note that it is up to the user to correctly handle failures when re-issuing a request. For example, you should use the same Task IDs during a retry so that if the prior operation succeeded, the retry will not create extra Tasks unexpectedly. If the response contains any Tasks which failed to add, a client can retry the request. In a retry, it is most efficient to resubmit only Tasks that failed to add, and to omit Tasks that were successfully added on the first attempt. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addCollectionAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task collection is to be added.value
- The collection of Tasks to add. The maximum count of Tasks is 100. The total serialized size of this collection must be less than 1MB. If it is greater than 1MB (for example if each Task has 100's of resource files or environment variables), the request will fail with code 'RequestBodyTooLarge' and should be retried again with fewer Tasks.taskAddCollectionOptions
- Additional parameters for the operation- Returns:
- the observable to the TaskAddCollectionResult object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
addCollectionWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<TaskAddCollectionResult,TaskAddCollectionHeaders>> addCollectionWithServiceResponseAsync(String jobId, List<TaskAddParameter> value, TaskAddCollectionOptions taskAddCollectionOptions)
Adds a collection of Tasks to the specified Job. Note that each Task must have a unique ID. The Batch service may not return the results for each Task in the same order the Tasks were submitted in this request. If the server times out or the connection is closed during the request, the request may have been partially or fully processed, or not at all. In such cases, the user should re-issue the request. Note that it is up to the user to correctly handle failures when re-issuing a request. For example, you should use the same Task IDs during a retry so that if the prior operation succeeded, the retry will not create extra Tasks unexpectedly. If the response contains any Tasks which failed to add, a client can retry the request. In a retry, it is most efficient to resubmit only Tasks that failed to add, and to omit Tasks that were successfully added on the first attempt. The maximum lifetime of a Task from addition to completion is 180 days. If a Task has not completed within 180 days of being added it will be terminated by the Batch service and left in whatever state it was in at that time.- Specified by:
addCollectionWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job to which the Task collection is to be added.value
- The collection of Tasks to add. The maximum count of Tasks is 100. The total serialized size of this collection must be less than 1MB. If it is greater than 1MB (for example if each Task has 100's of resource files or environment variables), the request will fail with code 'RequestBodyTooLarge' and should be retried again with fewer Tasks.taskAddCollectionOptions
- Additional parameters for the operation- Returns:
- the observable to the TaskAddCollectionResult object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
delete
public void delete(String jobId, String taskId)
Deletes a Task from the specified Job. When a Task is deleted, all of the files in its directory on the Compute Node where it ran are also deleted (regardless of the retention time). For multi-instance Tasks, the delete Task operation applies synchronously to the primary task; subtasks and their files are then deleted asynchronously in the background.- Specified by:
delete
in interfaceTasks
- Parameters:
jobId
- The ID of the Job from which to delete the Task.taskId
- The ID of the Task to delete.- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
deleteAsync
public com.microsoft.rest.ServiceFuture<Void> deleteAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Deletes a Task from the specified Job. When a Task is deleted, all of the files in its directory on the Compute Node where it ran are also deleted (regardless of the retention time). For multi-instance Tasks, the delete Task operation applies synchronously to the primary task; subtasks and their files are then deleted asynchronously in the background.- Specified by:
deleteAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job from which to delete the Task.taskId
- The ID of the Task to delete.serviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
deleteAsync
public rx.Observable<Void> deleteAsync(String jobId, String taskId)
Deletes a Task from the specified Job. When a Task is deleted, all of the files in its directory on the Compute Node where it ran are also deleted (regardless of the retention time). For multi-instance Tasks, the delete Task operation applies synchronously to the primary task; subtasks and their files are then deleted asynchronously in the background.- Specified by:
deleteAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job from which to delete the Task.taskId
- The ID of the Task to delete.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
deleteWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskDeleteHeaders>> deleteWithServiceResponseAsync(String jobId, String taskId)
Deletes a Task from the specified Job. When a Task is deleted, all of the files in its directory on the Compute Node where it ran are also deleted (regardless of the retention time). For multi-instance Tasks, the delete Task operation applies synchronously to the primary task; subtasks and their files are then deleted asynchronously in the background.- Specified by:
deleteWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job from which to delete the Task.taskId
- The ID of the Task to delete.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
delete
public void delete(String jobId, String taskId, TaskDeleteOptions taskDeleteOptions)
Deletes a Task from the specified Job. When a Task is deleted, all of the files in its directory on the Compute Node where it ran are also deleted (regardless of the retention time). For multi-instance Tasks, the delete Task operation applies synchronously to the primary task; subtasks and their files are then deleted asynchronously in the background.- Specified by:
delete
in interfaceTasks
- Parameters:
jobId
- The ID of the Job from which to delete the Task.taskId
- The ID of the Task to delete.taskDeleteOptions
- Additional parameters for the operation- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
deleteAsync
public com.microsoft.rest.ServiceFuture<Void> deleteAsync(String jobId, String taskId, TaskDeleteOptions taskDeleteOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Deletes a Task from the specified Job. When a Task is deleted, all of the files in its directory on the Compute Node where it ran are also deleted (regardless of the retention time). For multi-instance Tasks, the delete Task operation applies synchronously to the primary task; subtasks and their files are then deleted asynchronously in the background.- Specified by:
deleteAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job from which to delete the Task.taskId
- The ID of the Task to delete.taskDeleteOptions
- Additional parameters for the operationserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
deleteAsync
public rx.Observable<Void> deleteAsync(String jobId, String taskId, TaskDeleteOptions taskDeleteOptions)
Deletes a Task from the specified Job. When a Task is deleted, all of the files in its directory on the Compute Node where it ran are also deleted (regardless of the retention time). For multi-instance Tasks, the delete Task operation applies synchronously to the primary task; subtasks and their files are then deleted asynchronously in the background.- Specified by:
deleteAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job from which to delete the Task.taskId
- The ID of the Task to delete.taskDeleteOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
deleteWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskDeleteHeaders>> deleteWithServiceResponseAsync(String jobId, String taskId, TaskDeleteOptions taskDeleteOptions)
Deletes a Task from the specified Job. When a Task is deleted, all of the files in its directory on the Compute Node where it ran are also deleted (regardless of the retention time). For multi-instance Tasks, the delete Task operation applies synchronously to the primary task; subtasks and their files are then deleted asynchronously in the background.- Specified by:
deleteWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job from which to delete the Task.taskId
- The ID of the Task to delete.taskDeleteOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
get
public CloudTask get(String jobId, String taskId)
Gets information about the specified Task. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
get
in interfaceTasks
- Parameters:
jobId
- The ID of the Job that contains the Task.taskId
- The ID of the Task to get information about.- Returns:
- the CloudTask object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
getAsync
public com.microsoft.rest.ServiceFuture<CloudTask> getAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<CloudTask> serviceCallback)
Gets information about the specified Task. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
getAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job that contains the Task.taskId
- The ID of the Task to get information about.serviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
getAsync
public rx.Observable<CloudTask> getAsync(String jobId, String taskId)
Gets information about the specified Task. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
getAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job that contains the Task.taskId
- The ID of the Task to get information about.- Returns:
- the observable to the CloudTask object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
getWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<CloudTask,TaskGetHeaders>> getWithServiceResponseAsync(String jobId, String taskId)
Gets information about the specified Task. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
getWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job that contains the Task.taskId
- The ID of the Task to get information about.- Returns:
- the observable to the CloudTask object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
get
public CloudTask get(String jobId, String taskId, TaskGetOptions taskGetOptions)
Gets information about the specified Task. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
get
in interfaceTasks
- Parameters:
jobId
- The ID of the Job that contains the Task.taskId
- The ID of the Task to get information about.taskGetOptions
- Additional parameters for the operation- Returns:
- the CloudTask object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
getAsync
public com.microsoft.rest.ServiceFuture<CloudTask> getAsync(String jobId, String taskId, TaskGetOptions taskGetOptions, com.microsoft.rest.ServiceCallback<CloudTask> serviceCallback)
Gets information about the specified Task. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
getAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job that contains the Task.taskId
- The ID of the Task to get information about.taskGetOptions
- Additional parameters for the operationserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
getAsync
public rx.Observable<CloudTask> getAsync(String jobId, String taskId, TaskGetOptions taskGetOptions)
Gets information about the specified Task. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
getAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job that contains the Task.taskId
- The ID of the Task to get information about.taskGetOptions
- Additional parameters for the operation- Returns:
- the observable to the CloudTask object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
getWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<CloudTask,TaskGetHeaders>> getWithServiceResponseAsync(String jobId, String taskId, TaskGetOptions taskGetOptions)
Gets information about the specified Task. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
getWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job that contains the Task.taskId
- The ID of the Task to get information about.taskGetOptions
- Additional parameters for the operation- Returns:
- the observable to the CloudTask object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
update
public void update(String jobId, String taskId)
Updates the properties of the specified Task.- Specified by:
update
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to update.- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
updateAsync
public com.microsoft.rest.ServiceFuture<Void> updateAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Updates the properties of the specified Task.- Specified by:
updateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to update.serviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
updateAsync
public rx.Observable<Void> updateAsync(String jobId, String taskId)
Updates the properties of the specified Task.- Specified by:
updateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to update.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
updateWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskUpdateHeaders>> updateWithServiceResponseAsync(String jobId, String taskId)
Updates the properties of the specified Task.- Specified by:
updateWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to update.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
update
public void update(String jobId, String taskId, TaskConstraints constraints, TaskUpdateOptions taskUpdateOptions)
Updates the properties of the specified Task.- Specified by:
update
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to update.constraints
- Constraints that apply to this Task. If omitted, the Task is given the default constraints. For multi-instance Tasks, updating the retention time applies only to the primary Task and not subtasks.taskUpdateOptions
- Additional parameters for the operation- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
updateAsync
public com.microsoft.rest.ServiceFuture<Void> updateAsync(String jobId, String taskId, TaskConstraints constraints, TaskUpdateOptions taskUpdateOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Updates the properties of the specified Task.- Specified by:
updateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to update.constraints
- Constraints that apply to this Task. If omitted, the Task is given the default constraints. For multi-instance Tasks, updating the retention time applies only to the primary Task and not subtasks.taskUpdateOptions
- Additional parameters for the operationserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
updateAsync
public rx.Observable<Void> updateAsync(String jobId, String taskId, TaskConstraints constraints, TaskUpdateOptions taskUpdateOptions)
Updates the properties of the specified Task.- Specified by:
updateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to update.constraints
- Constraints that apply to this Task. If omitted, the Task is given the default constraints. For multi-instance Tasks, updating the retention time applies only to the primary Task and not subtasks.taskUpdateOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
updateWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskUpdateHeaders>> updateWithServiceResponseAsync(String jobId, String taskId, TaskConstraints constraints, TaskUpdateOptions taskUpdateOptions)
Updates the properties of the specified Task.- Specified by:
updateWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to update.constraints
- Constraints that apply to this Task. If omitted, the Task is given the default constraints. For multi-instance Tasks, updating the retention time applies only to the primary Task and not subtasks.taskUpdateOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listSubtasks
public CloudTaskListSubtasksResult listSubtasks(String jobId, String taskId)
Lists all of the subtasks that are associated with the specified multi-instance Task. If the Task is not a multi-instance Task then this returns an empty collection.- Specified by:
listSubtasks
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskId
- The ID of the Task.- Returns:
- the CloudTaskListSubtasksResult object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
listSubtasksAsync
public com.microsoft.rest.ServiceFuture<CloudTaskListSubtasksResult> listSubtasksAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<CloudTaskListSubtasksResult> serviceCallback)
Lists all of the subtasks that are associated with the specified multi-instance Task. If the Task is not a multi-instance Task then this returns an empty collection.- Specified by:
listSubtasksAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskId
- The ID of the Task.serviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listSubtasksAsync
public rx.Observable<CloudTaskListSubtasksResult> listSubtasksAsync(String jobId, String taskId)
Lists all of the subtasks that are associated with the specified multi-instance Task. If the Task is not a multi-instance Task then this returns an empty collection.- Specified by:
listSubtasksAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskId
- The ID of the Task.- Returns:
- the observable to the CloudTaskListSubtasksResult object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listSubtasksWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<CloudTaskListSubtasksResult,TaskListSubtasksHeaders>> listSubtasksWithServiceResponseAsync(String jobId, String taskId)
Lists all of the subtasks that are associated with the specified multi-instance Task. If the Task is not a multi-instance Task then this returns an empty collection.- Specified by:
listSubtasksWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskId
- The ID of the Task.- Returns:
- the observable to the CloudTaskListSubtasksResult object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listSubtasks
public CloudTaskListSubtasksResult listSubtasks(String jobId, String taskId, TaskListSubtasksOptions taskListSubtasksOptions)
Lists all of the subtasks that are associated with the specified multi-instance Task. If the Task is not a multi-instance Task then this returns an empty collection.- Specified by:
listSubtasks
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskId
- The ID of the Task.taskListSubtasksOptions
- Additional parameters for the operation- Returns:
- the CloudTaskListSubtasksResult object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
listSubtasksAsync
public com.microsoft.rest.ServiceFuture<CloudTaskListSubtasksResult> listSubtasksAsync(String jobId, String taskId, TaskListSubtasksOptions taskListSubtasksOptions, com.microsoft.rest.ServiceCallback<CloudTaskListSubtasksResult> serviceCallback)
Lists all of the subtasks that are associated with the specified multi-instance Task. If the Task is not a multi-instance Task then this returns an empty collection.- Specified by:
listSubtasksAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskId
- The ID of the Task.taskListSubtasksOptions
- Additional parameters for the operationserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listSubtasksAsync
public rx.Observable<CloudTaskListSubtasksResult> listSubtasksAsync(String jobId, String taskId, TaskListSubtasksOptions taskListSubtasksOptions)
Lists all of the subtasks that are associated with the specified multi-instance Task. If the Task is not a multi-instance Task then this returns an empty collection.- Specified by:
listSubtasksAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskId
- The ID of the Task.taskListSubtasksOptions
- Additional parameters for the operation- Returns:
- the observable to the CloudTaskListSubtasksResult object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listSubtasksWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<CloudTaskListSubtasksResult,TaskListSubtasksHeaders>> listSubtasksWithServiceResponseAsync(String jobId, String taskId, TaskListSubtasksOptions taskListSubtasksOptions)
Lists all of the subtasks that are associated with the specified multi-instance Task. If the Task is not a multi-instance Task then this returns an empty collection.- Specified by:
listSubtasksWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job.taskId
- The ID of the Task.taskListSubtasksOptions
- Additional parameters for the operation- Returns:
- the observable to the CloudTaskListSubtasksResult object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
terminate
public void terminate(String jobId, String taskId)
Terminates the specified Task. When the Task has been terminated, it moves to the completed state. For multi-instance Tasks, the terminate Task operation applies synchronously to the primary task; subtasks are then terminated asynchronously in the background.- Specified by:
terminate
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to terminate.- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
terminateAsync
public com.microsoft.rest.ServiceFuture<Void> terminateAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Terminates the specified Task. When the Task has been terminated, it moves to the completed state. For multi-instance Tasks, the terminate Task operation applies synchronously to the primary task; subtasks are then terminated asynchronously in the background.- Specified by:
terminateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to terminate.serviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
terminateAsync
public rx.Observable<Void> terminateAsync(String jobId, String taskId)
Terminates the specified Task. When the Task has been terminated, it moves to the completed state. For multi-instance Tasks, the terminate Task operation applies synchronously to the primary task; subtasks are then terminated asynchronously in the background.- Specified by:
terminateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to terminate.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
terminateWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskTerminateHeaders>> terminateWithServiceResponseAsync(String jobId, String taskId)
Terminates the specified Task. When the Task has been terminated, it moves to the completed state. For multi-instance Tasks, the terminate Task operation applies synchronously to the primary task; subtasks are then terminated asynchronously in the background.- Specified by:
terminateWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to terminate.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
terminate
public void terminate(String jobId, String taskId, TaskTerminateOptions taskTerminateOptions)
Terminates the specified Task. When the Task has been terminated, it moves to the completed state. For multi-instance Tasks, the terminate Task operation applies synchronously to the primary task; subtasks are then terminated asynchronously in the background.- Specified by:
terminate
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to terminate.taskTerminateOptions
- Additional parameters for the operation- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
terminateAsync
public com.microsoft.rest.ServiceFuture<Void> terminateAsync(String jobId, String taskId, TaskTerminateOptions taskTerminateOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Terminates the specified Task. When the Task has been terminated, it moves to the completed state. For multi-instance Tasks, the terminate Task operation applies synchronously to the primary task; subtasks are then terminated asynchronously in the background.- Specified by:
terminateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to terminate.taskTerminateOptions
- Additional parameters for the operationserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
terminateAsync
public rx.Observable<Void> terminateAsync(String jobId, String taskId, TaskTerminateOptions taskTerminateOptions)
Terminates the specified Task. When the Task has been terminated, it moves to the completed state. For multi-instance Tasks, the terminate Task operation applies synchronously to the primary task; subtasks are then terminated asynchronously in the background.- Specified by:
terminateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to terminate.taskTerminateOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
terminateWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskTerminateHeaders>> terminateWithServiceResponseAsync(String jobId, String taskId, TaskTerminateOptions taskTerminateOptions)
Terminates the specified Task. When the Task has been terminated, it moves to the completed state. For multi-instance Tasks, the terminate Task operation applies synchronously to the primary task; subtasks are then terminated asynchronously in the background.- Specified by:
terminateWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to terminate.taskTerminateOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
reactivate
public void reactivate(String jobId, String taskId)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted. Reactivation makes a Task eligible to be retried again up to its maximum retry count. The Task's state is changed to active. As the Task is no longer in the completed state, any previous exit code or failure information is no longer available after reactivation. Each time a Task is reactivated, its retry count is reset to 0. Reactivation will fail for Tasks that are not completed or that previously completed successfully (with an exit code of 0). Additionally, it will fail if the Job has completed (or is terminating or deleting).- Specified by:
reactivate
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to reactivate.- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
reactivateAsync
public com.microsoft.rest.ServiceFuture<Void> reactivateAsync(String jobId, String taskId, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted. Reactivation makes a Task eligible to be retried again up to its maximum retry count. The Task's state is changed to active. As the Task is no longer in the completed state, any previous exit code or failure information is no longer available after reactivation. Each time a Task is reactivated, its retry count is reset to 0. Reactivation will fail for Tasks that are not completed or that previously completed successfully (with an exit code of 0). Additionally, it will fail if the Job has completed (or is terminating or deleting).- Specified by:
reactivateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to reactivate.serviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
reactivateAsync
public rx.Observable<Void> reactivateAsync(String jobId, String taskId)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted. Reactivation makes a Task eligible to be retried again up to its maximum retry count. The Task's state is changed to active. As the Task is no longer in the completed state, any previous exit code or failure information is no longer available after reactivation. Each time a Task is reactivated, its retry count is reset to 0. Reactivation will fail for Tasks that are not completed or that previously completed successfully (with an exit code of 0). Additionally, it will fail if the Job has completed (or is terminating or deleting).- Specified by:
reactivateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to reactivate.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
reactivateWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskReactivateHeaders>> reactivateWithServiceResponseAsync(String jobId, String taskId)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted. Reactivation makes a Task eligible to be retried again up to its maximum retry count. The Task's state is changed to active. As the Task is no longer in the completed state, any previous exit code or failure information is no longer available after reactivation. Each time a Task is reactivated, its retry count is reset to 0. Reactivation will fail for Tasks that are not completed or that previously completed successfully (with an exit code of 0). Additionally, it will fail if the Job has completed (or is terminating or deleting).- Specified by:
reactivateWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to reactivate.- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
reactivate
public void reactivate(String jobId, String taskId, TaskReactivateOptions taskReactivateOptions)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted. Reactivation makes a Task eligible to be retried again up to its maximum retry count. The Task's state is changed to active. As the Task is no longer in the completed state, any previous exit code or failure information is no longer available after reactivation. Each time a Task is reactivated, its retry count is reset to 0. Reactivation will fail for Tasks that are not completed or that previously completed successfully (with an exit code of 0). Additionally, it will fail if the Job has completed (or is terminating or deleting).- Specified by:
reactivate
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to reactivate.taskReactivateOptions
- Additional parameters for the operation- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
reactivateAsync
public com.microsoft.rest.ServiceFuture<Void> reactivateAsync(String jobId, String taskId, TaskReactivateOptions taskReactivateOptions, com.microsoft.rest.ServiceCallback<Void> serviceCallback)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted. Reactivation makes a Task eligible to be retried again up to its maximum retry count. The Task's state is changed to active. As the Task is no longer in the completed state, any previous exit code or failure information is no longer available after reactivation. Each time a Task is reactivated, its retry count is reset to 0. Reactivation will fail for Tasks that are not completed or that previously completed successfully (with an exit code of 0). Additionally, it will fail if the Job has completed (or is terminating or deleting).- Specified by:
reactivateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to reactivate.taskReactivateOptions
- Additional parameters for the operationserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
reactivateAsync
public rx.Observable<Void> reactivateAsync(String jobId, String taskId, TaskReactivateOptions taskReactivateOptions)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted. Reactivation makes a Task eligible to be retried again up to its maximum retry count. The Task's state is changed to active. As the Task is no longer in the completed state, any previous exit code or failure information is no longer available after reactivation. Each time a Task is reactivated, its retry count is reset to 0. Reactivation will fail for Tasks that are not completed or that previously completed successfully (with an exit code of 0). Additionally, it will fail if the Job has completed (or is terminating or deleting).- Specified by:
reactivateAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to reactivate.taskReactivateOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
reactivateWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<Void,TaskReactivateHeaders>> reactivateWithServiceResponseAsync(String jobId, String taskId, TaskReactivateOptions taskReactivateOptions)
Reactivates a Task, allowing it to run again even if its retry count has been exhausted. Reactivation makes a Task eligible to be retried again up to its maximum retry count. The Task's state is changed to active. As the Task is no longer in the completed state, any previous exit code or failure information is no longer available after reactivation. Each time a Task is reactivated, its retry count is reset to 0. Reactivation will fail for Tasks that are not completed or that previously completed successfully (with an exit code of 0). Additionally, it will fail if the Job has completed (or is terminating or deleting).- Specified by:
reactivateWithServiceResponseAsync
in interfaceTasks
- Parameters:
jobId
- The ID of the Job containing the Task.taskId
- The ID of the Task to reactivate.taskReactivateOptions
- Additional parameters for the operation- Returns:
- the
ServiceResponseWithHeaders
object if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listNext
public com.microsoft.azure.PagedList<CloudTask> listNext(String nextPageLink)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listNext
in interfaceTasks
- Parameters:
nextPageLink
- The NextLink from the previous successful call to List operation.- Returns:
- the PagedList<CloudTask> object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
listNextAsync
public com.microsoft.rest.ServiceFuture<List<CloudTask>> listNextAsync(String nextPageLink, com.microsoft.rest.ServiceFuture<List<CloudTask>> serviceFuture, com.microsoft.azure.ListOperationCallback<CloudTask> serviceCallback)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listNextAsync
in interfaceTasks
- Parameters:
nextPageLink
- The NextLink from the previous successful call to List operation.serviceFuture
- the ServiceFuture object tracking the Retrofit callsserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listNextAsync
public rx.Observable<com.microsoft.azure.Page<CloudTask>> listNextAsync(String nextPageLink)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listNextAsync
in interfaceTasks
- Parameters:
nextPageLink
- The NextLink from the previous successful call to List operation.- Returns:
- the observable to the PagedList<CloudTask> object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listNextWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>> listNextWithServiceResponseAsync(String nextPageLink)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listNextWithServiceResponseAsync
in interfaceTasks
- Parameters:
nextPageLink
- The NextLink from the previous successful call to List operation.- Returns:
- the observable to the PagedList<CloudTask> object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listNextSinglePageAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>> listNextSinglePageAsync(String nextPageLink)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Parameters:
nextPageLink
- The NextLink from the previous successful call to List operation.- Returns:
- the PagedList<CloudTask> object wrapped in
ServiceResponseWithHeaders
if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listNext
public com.microsoft.azure.PagedList<CloudTask> listNext(String nextPageLink, TaskListNextOptions taskListNextOptions)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listNext
in interfaceTasks
- Parameters:
nextPageLink
- The NextLink from the previous successful call to List operation.taskListNextOptions
- Additional parameters for the operation- Returns:
- the PagedList<CloudTask> object if successful.
- Throws:
IllegalArgumentException
- thrown if parameters fail the validationBatchErrorException
- thrown if the request is rejected by serverRuntimeException
- all other wrapped checked exceptions if the request fails to be sent
-
listNextAsync
public com.microsoft.rest.ServiceFuture<List<CloudTask>> listNextAsync(String nextPageLink, TaskListNextOptions taskListNextOptions, com.microsoft.rest.ServiceFuture<List<CloudTask>> serviceFuture, com.microsoft.azure.ListOperationCallback<CloudTask> serviceCallback)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listNextAsync
in interfaceTasks
- Parameters:
nextPageLink
- The NextLink from the previous successful call to List operation.taskListNextOptions
- Additional parameters for the operationserviceFuture
- the ServiceFuture object tracking the Retrofit callsserviceCallback
- the async ServiceCallback to handle successful and failed responses.- Returns:
- the
ServiceFuture
object - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listNextAsync
public rx.Observable<com.microsoft.azure.Page<CloudTask>> listNextAsync(String nextPageLink, TaskListNextOptions taskListNextOptions)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listNextAsync
in interfaceTasks
- Parameters:
nextPageLink
- The NextLink from the previous successful call to List operation.taskListNextOptions
- Additional parameters for the operation- Returns:
- the observable to the PagedList<CloudTask> object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listNextWithServiceResponseAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>> listNextWithServiceResponseAsync(String nextPageLink, TaskListNextOptions taskListNextOptions)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks.- Specified by:
listNextWithServiceResponseAsync
in interfaceTasks
- Parameters:
nextPageLink
- The NextLink from the previous successful call to List operation.taskListNextOptions
- Additional parameters for the operation- Returns:
- the observable to the PagedList<CloudTask> object
- Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
listNextSinglePageAsync
public rx.Observable<com.microsoft.rest.ServiceResponseWithHeaders<com.microsoft.azure.Page<CloudTask>,TaskListHeaders>> listNextSinglePageAsync(String nextPageLink, TaskListNextOptions taskListNextOptions)
Lists all of the Tasks that are associated with the specified Job. For multi-instance Tasks, information such as affinityId, executionInfo and nodeInfo refer to the primary Task. Use the list subtasks API to retrieve information about subtasks. ServiceResponseWithHeaders, TaskListHeaders> * @param nextPageLink The NextLink from the previous successful call to List operation. ServiceResponseWithHeaders , TaskListHeaders> * @param taskListNextOptions Additional parameters for the operation - Returns:
- the PagedList<CloudTask> object wrapped in
ServiceResponseWithHeaders
if successful. - Throws:
IllegalArgumentException
- thrown if parameters fail the validation
-
-