/// <summary>
/// Refreshes the current <see cref="CloudTask"/>.
/// </summary>
/// <param name="detailLevel">The detail level for the refresh. If a detail level which omits the <see cref="Id"/> property is specified, refresh will fail.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
public async System.Threading.Tasks.Task RefreshAsync(
DetailLevel detailLevel = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// create the behavior managaer
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors, detailLevel);
System.Threading.Tasks.Task <AzureOperationResponse <Models.CloudTask, Models.TaskGetHeaders> > asyncTask =
this.parentBatchClient.ProtocolLayer.GetTask(
this.parentJobId,
this.Id,
bhMgr,
cancellationToken);
AzureOperationResponse <Models.CloudTask, Models.TaskGetHeaders> response = await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
// get task from response
Models.CloudTask newProtocolTask = response.Body;
// immediately available to all threads
this.propertyContainer = new PropertyContainer(newProtocolTask);
}
/// <summary>
/// Commits all pending changes to this <see cref="CloudJob" /> to the Azure Batch service.
/// </summary>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
/// <remarks>
/// <para>
/// Updates an existing <see cref="CloudJob"/> on the Batch service by replacing its properties with the properties of this <see cref="CloudJob"/> which have been changed.
/// Unchanged properties are ignored.
/// All changes since the last time this entity was retrieved from the Batch service (either via <see cref="Refresh"/>, <see cref="JobOperations.GetJob"/>,
/// or <see cref="JobOperations.ListJobs"/>) are applied.
/// Properties which are explicitly set to null will cause an exception because the Batch service does not support partial updates which set a property to null.
/// If you need to set a property to null, use <see cref="Commit"/>.
/// </para>
/// <para>This operation runs asynchronously.</para>
/// </remarks>
public async Task CommitChangesAsync(
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// first forbid actions during patch
this.propertyContainer.IsReadOnly = true;
// craft the behavior manager for this call
BehaviorManager behaveMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
Models.MetadataItem[] modelMetadata = this.propertyContainer.MetadataProperty.
GetTransportObjectIfChanged <MetadataItem, Models.MetadataItem>();
Models.JobConstraints modelJobConstraints = this.propertyContainer.ConstraintsProperty.
GetTransportObjectIfChanged <JobConstraints, Models.JobConstraints>();
Models.PoolInformation modelPoolInformation = this.propertyContainer.PoolInformationProperty.
GetTransportObjectIfChanged <PoolInformation, Models.PoolInformation>();
int?priority = this.propertyContainer.PriorityProperty.GetIfChangedOrNull();
Task asyncTask = this.parentBatchClient.ProtocolLayer.PatchJob(
this.Id,
priority,
UtilitiesInternal.MapNullableEnum <Common.OnAllTasksComplete, Models.OnAllTasksComplete>(this.OnAllTasksComplete),
modelPoolInformation,
modelJobConstraints,
modelMetadata,
behaveMgr,
cancellationToken);
await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
}
/// <summary>
/// Commits all pending changes to this <see cref="CloudJobSchedule" /> to the Azure Batch service.
/// </summary>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
/// <remarks>
/// <para>
/// Updates an existing <see cref="CloudJobSchedule"/> on the Batch service by replacing its properties with the properties of this <see cref="CloudJobSchedule"/> which have been changed.
/// Unchanged properties are ignored.
/// All changes since the last time this entity was retrieved from the Batch service (either via <see cref="Refresh"/>, <see cref="JobScheduleOperations.GetJobSchedule"/>,
/// or <see cref="JobScheduleOperations.ListJobSchedules"/>) are applied.
/// Properties which are explicitly set to null will cause an exception because the Batch service does not support partial updates which set a property to null.
/// If you need to set a property to null, use <see cref="Commit"/>.
/// </para>
/// <para>This operation runs asynchronously.</para>
/// </remarks>
public async System.Threading.Tasks.Task CommitChangesAsync(
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// after this no prop access is allowed
this.propertyContainer.IsReadOnly = true;
// craft the bahavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
Models.JobSpecification jobSpecification = this.propertyContainer.JobSpecificationProperty.GetTransportObjectIfChanged <JobSpecification, Models.JobSpecification>();
Models.Schedule schedule = this.propertyContainer.ScheduleProperty.GetTransportObjectIfChanged <Schedule, Models.Schedule>();
Models.MetadataItem[] metadata = this.propertyContainer.MetadataProperty.GetTransportObjectIfChanged <MetadataItem, Models.MetadataItem>();
System.Threading.Tasks.Task asyncJobScheduleUpdate =
this.parentBatchClient.ProtocolLayer.PatchJobSchedule(
this.Id,
jobSpecification,
metadata,
schedule,
bhMgr,
cancellationToken);
await asyncJobScheduleUpdate.ConfigureAwait(continueOnCapturedContext : false);
}
/// <summary>
/// Commits all pending changes to this <see cref="CloudTask" /> to the Azure Batch service.
/// </summary>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> object that represents the asynchronous operation.</returns>
/// <remarks>The commit operation runs asynchronously.</remarks>
public async System.Threading.Tasks.Task CommitAsync(IEnumerable <BatchClientBehavior> additionalBehaviors = null, CancellationToken cancellationToken = default(CancellationToken))
{
this.propertyContainer.IsReadOnly = true;
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
if (BindingState.Unbound == this.propertyContainer.BindingState)
{
//TODO: Implement task submission via .Commit here
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
}
else
{
Models.TaskConstraints protoTaskConstraints = UtilitiesInternal.CreateObjectWithNullCheck(this.Constraints, o => o.GetTransportObject());
System.Threading.Tasks.Task <AzureOperationHeaderResponse <Models.TaskUpdateHeaders> > asyncTaskUpdate =
this.parentBatchClient.ProtocolLayer.UpdateTask(
this.parentJobId,
this.Id,
protoTaskConstraints,
bhMgr,
cancellationToken);
await asyncTaskUpdate.ConfigureAwait(continueOnCapturedContext : false);
}
}
/// <summary>
/// Enumerates the subtasks of the multi-instance <see cref="CloudTask"/>.
/// </summary>
/// <param name="detailLevel">A <see cref="DetailLevel"/> used for filtering the list and for controlling which properties are retrieved from the service.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/> and <paramref name="detailLevel"/>.</param>
/// <returns>An <see cref="IPagedEnumerable{SubtaskInformation}"/> that can be used to enumerate files asynchronously or synchronously.</returns>
/// <remarks>This method returns immediately; the file data is retrieved from the Batch service only when the collection is enumerated.
/// Retrieval is non-atomic; file data is retrieved in pages during enumeration of the collection.</remarks>
public IPagedEnumerable <SubtaskInformation> ListSubtasks(DetailLevel detailLevel = null, IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
IPagedEnumerable <SubtaskInformation> enumerator = this.parentBatchClient.JobOperations.ListSubtasksImpl(this.parentJobId, this.Id, bhMgr, detailLevel);
return(enumerator);
}
/// <summary>
/// Enumerates the <see cref="CloudTask">tasks</see> of this <see cref="CloudJob"/>.
/// </summary>
/// <param name="detailLevel">A <see cref="DetailLevel"/> used for filtering the list and for controlling which properties are retrieved from the service.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/> and <paramref name="detailLevel"/>.</param>
/// <returns>An <see cref="IPagedEnumerable{CloudTask}"/> that can be used to enumerate tasks asynchronously or synchronously.</returns>
/// <remarks>This method returns immediately; the tasks are retrieved from the Batch service only when the collection is enumerated.
/// Retrieval is non-atomic; tasks are retrieved in pages during enumeration of the collection.</remarks>
public IPagedEnumerable <CloudTask> ListTasks(DetailLevel detailLevel = null, IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
// throw if if this object is unbound
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// craft the behavior manager for this call
BehaviorManager behaveMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
IPagedEnumerable <CloudTask> ienumAsync = this.parentBatchClient.JobOperations.ListTasksImpl(this.Id, behaveMgr, detailLevel);
return(ienumAsync);
}
/// <summary>
/// Adds a single task to this <see cref="CloudJob"/>. To add multiple tasks,
/// use <see cref="JobOperations.AddTask(string,IEnumerable{CloudTask},BatchClientParallelOptions,ConcurrentBag{ConcurrentDictionary{Type, IFileStagingArtifact}},TimeSpan?,IEnumerable{BatchClientBehavior})">JobOperations.AddTaskAsync</see>.
/// </summary>
/// <param name="taskToAdd">The <see cref="CloudTask"/> to add.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <returns>A collection of information about the file staging process (see <see cref="CloudTask.FilesToStage"/>).
/// For more information see <see cref="IFileStagingArtifact"/>.</returns>
/// <remarks>
/// <para>
/// Each call to this method incurs a request to the Batch service. Therefore, using this method to add
/// multiple tasks is less efficient than using a bulk add method, and can incur HTTP connection restrictions.
/// If you are performing many of these operations in parallel and are seeing client side timeouts (a <see cref="TaskCanceledException"/>), please see
/// http://msdn.microsoft.com/en-us/library/system.net.servicepointmanager.defaultconnectionlimit%28v=vs.110%29.aspx
/// or use
/// <see cref="JobOperations.AddTask(string,IEnumerable{CloudTask},BatchClientParallelOptions,ConcurrentBag{ConcurrentDictionary{Type, IFileStagingArtifact}},TimeSpan?,IEnumerable{Microsoft.Azure.Batch.BatchClientBehavior})"/>.
/// </para>
/// <para>This is a blocking operation. For a non-blocking equivalent, see <see cref="AddTaskAsync(CloudTask, ConcurrentDictionary{Type, IFileStagingArtifact}, IEnumerable{BatchClientBehavior}, CancellationToken)"/>.</para>
/// </remarks>
public ConcurrentDictionary <Type, IFileStagingArtifact> AddTask(CloudTask taskToAdd, IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
ConcurrentDictionary <Type, IFileStagingArtifact> allFileStagingArtifacts = new ConcurrentDictionary <Type, IFileStagingArtifact>();
Task asyncTask = AddTaskAsync(taskToAdd, allFileStagingArtifacts, additionalBehaviors);
asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
return(allFileStagingArtifacts);
}
/// <summary>
/// Deletes this <see cref="CloudJobSchedule" />.
/// </summary>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
/// <remarks>
/// <para>The delete operation requests that the job schedule be deleted. The request puts the schedule in the <see cref="Common.JobScheduleState.Deleting"/> state.
/// The Batch service will delete any existing jobs and tasks under the schedule, including any active job, and perform the actual job schedule deletion without any further client action.</para>
/// <para>The delete operation runs asynchronously.</para>
/// </remarks>
public async System.Threading.Tasks.Task DeleteAsync(IEnumerable <BatchClientBehavior> additionalBehaviors = null, CancellationToken cancellationToken = default(CancellationToken))
{
// throw if if this object is unbound
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
System.Threading.Tasks.Task asyncTask = this.parentBatchClient.ProtocolLayer.DeleteJobSchedule(this.Id, bhMgr, cancellationToken);
await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
}
/// <summary>
/// Deletes this <see cref="CloudJob" />.
/// </summary>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
/// <remarks>
/// <para>The delete operation requests that the job be deleted. The request puts the job in the <see cref="Common.JobState.Deleting"/> state.
/// The Batch service will stop any running tasks and perform the actual job deletion without any further client action.</para>
/// <para>The delete operation runs asynchronously.</para>
/// </remarks>
public System.Threading.Tasks.Task DeleteAsync(IEnumerable <BatchClientBehavior> additionalBehaviors = null, CancellationToken cancellationToken = default(CancellationToken))
{
// throw if if this object is unbound
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
// start call
System.Threading.Tasks.Task asyncTask = this.parentBatchClient.ProtocolLayer.DeleteJob(this.Id, bhMgr, cancellationToken);
return(asyncTask);
}
/// <summary>
/// Adds tasks to a job.
/// </summary>
/// <param name="tasksToAdd">The <see cref="CloudTask"/>s to add.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="parallelOptions">
/// Controls the number of simultaneous parallel AddTaskCollection requests issued to the Batch service. Each AddTaskCollection request contains at most
/// <see cref="Constants.MaxTasksInSingleAddTaskCollectionRequest"/> tasks in it.
/// Also controls the cancellation token for the operation.
/// If omitted, the default is used (see <see cref="BatchClientParallelOptions"/>.)
/// </param>
/// <param name="fileStagingArtifacts">An optional collection to receive information about the file staging process (see <see cref="CloudTask.FilesToStage"/>).
/// An entry is added to the <see cref="ConcurrentBag{T}"/> for each set of tasks grouped for submission to the Batch service.
/// Unlike single-task adds, you cannot use this parameter to customize the file staging process.
/// For more information about the format of each entry, see <see cref="IFileStagingArtifact"/>.</param>
/// <param name="timeout">The amount of time after which the operation times out.</param>
/// <remarks>
/// <para>This is a blocking operation; for a non-blocking equivalent, see <see cref="AddTaskAsync(IEnumerable{CloudTask}, BatchClientParallelOptions, ConcurrentBag{ConcurrentDictionary{Type, IFileStagingArtifact}}, TimeSpan?, IEnumerable{BatchClientBehavior})"/>.</para>
/// <para>This method is not atomic; that is, it is possible for the method to start adding tasks and
/// then fail. The collection of tasks to add is broken down into chunks of size at most <see cref="Constants.MaxTasksInSingleAddTaskCollectionRequest"/>,
/// and an AddTaskCollection request is issued for each chunk. Requests may be issued in parallel according to
/// the <paramref name="parallelOptions"/>.</para>
/// <para>Issuing a large number of simultaneous requests to the Batch service can incur HTTP connection restrictions.
/// If you are performing many of these operations in parallel (or have specified a large MaxDegreeOfParallelism in
/// the parallelOptions) and are seeing client side timeouts (a <see cref="TaskCanceledException"/>), please see
/// http://msdn.microsoft.com/en-us/library/system.net.servicepointmanager.defaultconnectionlimit%28v=vs.110%29.aspx .</para>
/// <para>The progress of the operation in the face of errors is determined by <see cref="AddTaskCollectionResultHandler"/> behavior.
/// You do not normally need to specify this behavior, as the Batch client uses a default which works in normal circumstances.
/// If you do want to customize this behavior, specify an AddTaskCollectionResultHandler in the <see cref="CustomBehaviors"/>
/// or <paramref name="additionalBehaviors"/> collections.</para>
/// </remarks>
/// <exception cref="ParallelOperationsException">Thrown if one or more requests to the Batch service fail.</exception>
public void AddTask(
IEnumerable <CloudTask> tasksToAdd,
BatchClientParallelOptions parallelOptions = null,
ConcurrentBag <ConcurrentDictionary <Type, IFileStagingArtifact> > fileStagingArtifacts = null,
TimeSpan?timeout = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
Task asyncTask = this.AddTaskAsync(tasksToAdd, parallelOptions, fileStagingArtifacts, timeout, additionalBehaviors);
asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors);
}
/// <summary>
/// Adds a single task to this <see cref="CloudJob"/>. To add multiple tasks,
/// use <see cref="JobOperations.AddTaskAsync(string,IEnumerable{CloudTask},BatchClientParallelOptions,ConcurrentBag{ConcurrentDictionary{Type, IFileStagingArtifact}},TimeSpan?,IEnumerable{BatchClientBehavior})">JobOperations.AddTaskAsync</see>.
/// </summary>
/// <param name="taskToAdd">The <see cref="CloudTask"/> to add.</param>
/// <param name="allFileStagingArtifacts">An optional collection to customize and receive information about the file staging process (see <see cref="CloudTask.FilesToStage"/>).
/// For more information see <see cref="IFileStagingArtifact"/>.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
/// <remarks>
/// <para>
/// Each call to this method incurs a request to the Batch service. Therefore, using this method to add
/// multiple tasks is less efficient than using a bulk add method, and can incur HTTP connection restrictions.
/// If you are performing many of these operations in parallel and are seeing client side timeouts (a <see cref="TaskCanceledException"/>), please see
/// http://msdn.microsoft.com/en-us/library/system.net.servicepointmanager.defaultconnectionlimit%28v=vs.110%29.aspx
/// or use
/// <see cref="JobOperations.AddTaskAsync(string,IEnumerable{CloudTask},BatchClientParallelOptions,ConcurrentBag{ConcurrentDictionary{Type, IFileStagingArtifact}},TimeSpan?,IEnumerable{Microsoft.Azure.Batch.BatchClientBehavior})"/>.
/// </para>
/// <para>The add task operation runs asynchronously.</para>
/// </remarks>
public async System.Threading.Tasks.Task AddTaskAsync(
CloudTask taskToAdd,
ConcurrentDictionary <Type, IFileStagingArtifact> allFileStagingArtifacts = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// craft the behavior manager for this call
BehaviorManager behaveMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
System.Threading.Tasks.Task asyncTask = this.parentBatchClient.JobOperations.AddTaskAsyncImpl(this.Id, taskToAdd, behaveMgr, cancellationToken, allFileStagingArtifacts);
await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
}
/// <summary>
/// Gets the specified <see cref="NodeFile"/> from the <see cref="CloudTask"/>'s directory on its compute node.
/// </summary>
/// <param name="filePath">The path of the file to retrieve.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="NodeFile"/> representing the specified file.</returns>
/// <remarks>The get file operation runs asynchronously.</remarks>
public System.Threading.Tasks.Task <NodeFile> GetNodeFileAsync(
string filePath,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
//create the behavior manager
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
//make the call
System.Threading.Tasks.Task <NodeFile> asyncTask = this.parentBatchClient.JobOperations.GetNodeFileAsyncImpl(this.parentJobId, this.Id, filePath, bhMgr, cancellationToken);
return(asyncTask);
}
/// <summary>
/// Reactivates this <see cref="CloudTask"/>, allowing it to run again even if its retry count has been exhausted.
/// </summary>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns>
/// <remarks>
/// <para>
/// Reactivation makes a task eligible to be retried again up to its maximum retry count.
/// </para>
/// <para>
/// This operation will fail for tasks that are not completed or that previously completed successfully (with an exit code of 0).
/// Additionally, this will fail if the job is in the <see cref="JobState.Completed"/> or <see cref="JobState.Terminating"/> or <see cref="JobState.Deleting"/> state.
/// </para>
/// <para>
/// The reactivate operation runs asynchronously.
/// </para>
/// </remarks>
public System.Threading.Tasks.Task ReactivateAsync(IEnumerable <BatchClientBehavior> additionalBehaviors = null, CancellationToken cancellationToken = default(CancellationToken))
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// create the behavior manager
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
System.Threading.Tasks.Task asyncTask = this.parentBatchClient.ProtocolLayer.ReactivateTask(
this.parentJobId,
this.Id,
bhMgr,
cancellationToken);
return(asyncTask);
}
/// <summary>
/// Adds tasks to a job.
/// </summary>
/// <param name="tasksToAdd">The <see cref="CloudTask"/>s to add.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="parallelOptions">
/// Controls the number of simultaneous parallel AddTaskCollection requests issued to the Batch service. Each AddTaskCollection request contains at most
/// <see cref="Constants.MaxTasksInSingleAddTaskCollectionRequest"/> tasks in it.
/// Also controls the cancellation token for the operation.
/// If omitted, the default is used (see <see cref="BatchClientParallelOptions"/>.)
/// </param>
/// <param name="fileStagingArtifacts">An optional collection to receive information about the file staging process (see <see cref="CloudTask.FilesToStage"/>).
/// An entry is added to the <see cref="ConcurrentBag{T}"/> for each set of tasks grouped for submission to the Batch service.
/// Unlike single-task adds, you cannot use this parameter to customize the file staging process.
/// For more information about the format of each entry, see <see cref="IFileStagingArtifact"/>.</param>
/// <param name="timeout">The amount of time after which the operation times out.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> object that represents the asynchronous operation.</returns>
/// <remarks>
/// <para>The add task operation runs asynchronously.</para>
/// <para>This method is not atomic; that is, it is possible for the method to start adding tasks and
/// then fail. The collection of tasks to add is broken down into chunks of size at most <see cref="Constants.MaxTasksInSingleAddTaskCollectionRequest"/>,
/// and an AddTaskCollection request is issued for each chunk. Requests may be issued in parallel according to
/// the <paramref name="parallelOptions"/>.</para>
/// <para>Issuing a large number of simultaneous requests to the Batch service can incur HTTP connection restrictions.
/// If you are performing many of these operations in parallel (or have specified a large MaxDegreeOfParallelism in
/// the parallelOptions) and are seeing client side timeouts (a <see cref="TaskCanceledException"/>), please see
/// http://msdn.microsoft.com/en-us/library/system.net.servicepointmanager.defaultconnectionlimit%28v=vs.110%29.aspx .</para>
/// <para>The progress of the operation in the face of errors is determined by <see cref="AddTaskCollectionResultHandler"/> behavior.
/// You do not normally need to specify this behavior, as the Batch client uses a default which works in normal circumstances.
/// If you do want to customize this behavior, specify an AddTaskCollectionResultHandler in the <see cref="CustomBehaviors"/>
/// or <paramref name="additionalBehaviors"/> collections.</para>
/// </remarks>
/// <exception cref="ParallelOperationsException">Thrown if one or more requests to the Batch service fail.</exception>
public async Task AddTaskAsync(
IEnumerable <CloudTask> tasksToAdd,
BatchClientParallelOptions parallelOptions = null,
ConcurrentBag <ConcurrentDictionary <Type, IFileStagingArtifact> > fileStagingArtifacts = null,
TimeSpan?timeout = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// craft the behavior manager for this call
BehaviorManager behaveMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
Task asyncTask = this.parentBatchClient.JobOperations.AddTaskAsyncImpl(this.Id, tasksToAdd, parallelOptions, fileStagingArtifacts, timeout, behaveMgr);
await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
}
/// <summary>
/// Terminates this <see cref="CloudJob"/>, marking it as completed.
/// </summary>
/// <param name="terminateReason">The text you want to appear as the job's <see cref="JobExecutionInformation.TerminateReason"/>.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="Task"/> object that represents the asynchronous operation.</returns>
/// <remarks>The terminate operation runs asynchronously.</remarks>
public Task TerminateAsync(
string terminateReason = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default)
{
// throw if if this object is unbound
UtilitiesInternal.ThrowOnUnbound(propertyContainer.BindingState);
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(CustomBehaviors, additionalBehaviors);
// start call
Task asyncTask = this.parentBatchClient.ProtocolLayer.TerminateJob(Id, terminateReason, bhMgr, cancellationToken);
return(asyncTask);
}
/// <summary>
/// Gets the specified <see cref="CloudTask"/>.
/// </summary>
/// <param name="taskId">The id of the task to get.</param>
/// <param name="detailLevel">A <see cref="DetailLevel"/> used for controlling which properties are retrieved from the service.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/> and <paramref name="detailLevel"/>.</param>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param>
/// <returns>A <see cref="CloudTask"/> containing information about the specified Azure Batch task.</returns>
/// <remarks>The get task operation runs asynchronously.</remarks>
public async System.Threading.Tasks.Task <CloudTask> GetTaskAsync(
string taskId,
DetailLevel detailLevel = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
// throw if if this object is unbound
UtilitiesInternal.ThrowOnUnbound(this.propertyContainer.BindingState);
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors, detailLevel);
Task <CloudTask> asyncTask = this.parentBatchClient.JobOperations.GetTaskAsyncImpl(this.Id, taskId, bhMgr, cancellationToken);
CloudTask theTask = await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
return(theTask);
}
