/// <summary> /// Monitors a <see cref="CloudTask"/> collection until each of its members has reached a desired state at least once. /// </summary> /// <remarks> /// <para> /// The state of each <see cref="CloudTask"/> instance is assumed to be authoritative at the time of the call. /// Instances that are already at the <paramref name="desiredState"/> are ignored. /// The <see cref="CloudTask"/> instances in the collection are treated as read-only. /// This means that when the call completes (timeout or not) the <see cref="CloudTask"/> instances should be refreshed before using. /// </para> /// <para> /// This method runs asynchronously. /// </para> /// </remarks> /// <param name="tasksToMonitor">The collection of tasks to monitor.</param> /// <param name="desiredState">The target state of the tasks. The method will exit when all tasks have reached this state at least once.</param> /// <param name="timeout">The maximum amount of time this call will wait before timing out.</param> /// <param name="controlParams">Controls various settings of the monitor, such as delay between each poll.</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 <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns> /// <exception cref="TimeoutException">Thrown if the <paramref name="timeout"/> has elapsed.</exception> public async Task WhenAll( IEnumerable <CloudTask> tasksToMonitor, Common.TaskState desiredState, TimeSpan timeout, ODATAMonitorControl controlParams = null, IEnumerable <BatchClientBehavior> additionalBehaviors = null) { using (CancellationTokenSource tokenSource = new CancellationTokenSource(timeout)) { try { await this.WhenAllImplAsync( tasksToMonitor, desiredState, tokenSource.Token, controlParams, additionalBehaviors).ConfigureAwait(continueOnCapturedContext: false); } catch (OperationCanceledException cancellationException) { if (cancellationException.CancellationToken == tokenSource.Token) { throw new TimeoutException( string.Format(CultureInfo.InvariantCulture, BatchErrorMessages.ODataMonitorTimedOut, timeout), cancellationException); } throw; } } }
internal TaskInformation(Models.TaskInformation protocolObject) { this.executionInformation = UtilitiesInternal.CreateObjectWithNullCheck(protocolObject.ExecutionInfo, o => new TaskExecutionInformation(o).Freeze()); this.jobId = protocolObject.JobId; this.subtaskId = protocolObject.SubtaskId; this.taskId = protocolObject.TaskId; this.taskState = UtilitiesInternal.MapEnum <Models.TaskState, Common.TaskState>(protocolObject.TaskState); this.taskUrl = protocolObject.TaskUrl; }
/// <summary> /// Monitors a <see cref="CloudTask"/> collection until each of its members has reached a desired state at least once. /// </summary> /// <remarks> /// <para> /// The state of each <see cref="CloudTask"/> instance is assumed to be authoritative at the time of the call. /// Instances that are already at the <paramref name="desiredState"/> are ignored. /// The <see cref="CloudTask"/> instances in the collection are treated as read-only. /// This means that when the call completes (timeout or not) the <see cref="CloudTask"/> instances should be refreshed before using. /// </para> /// <para> /// This is a blocking operation. For a non-blocking equivalent, see /// <see cref="WhenAll(System.Collections.Generic.IEnumerable{Microsoft.Azure.Batch.CloudTask},Microsoft.Azure.Batch.Common.TaskState,System.TimeSpan,Microsoft.Azure.Batch.ODATAMonitorControl,System.Collections.Generic.IEnumerable{Microsoft.Azure.Batch.BatchClientBehavior})"/>. /// </para> /// </remarks> /// <param name="tasksToMonitor">The collection of tasks to monitor.</param> /// <param name="desiredState">The target state of the tasks. The method will exit when all tasks have reached this state at least once.</param> /// <param name="timeout">The maximum amount of time this call will wait before timing out.</param> /// <param name="controlParams">Controls various settings of the monitor, such as delay between each poll.</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> /// <exception cref="TimeoutException">Thrown if the <paramref name="timeout"/> has elapsed.</exception> public void WaitAll( IEnumerable <CloudTask> tasksToMonitor, Common.TaskState desiredState, TimeSpan timeout, ODATAMonitorControl controlParams = null, IEnumerable <BatchClientBehavior> additionalBehaviors = null) { Task asyncTask = this.WhenAll(tasksToMonitor, desiredState, timeout, controlParams, additionalBehaviors); asyncTask.WaitAndUnaggregateException(this.CustomBehaviors, additionalBehaviors); }
/// <summary> /// Monitors a <see cref="CloudTask"/> collection until each of its members has reached a desired state at least once. /// </summary> /// <remarks> /// <para> /// The state of each <see cref="CloudTask"/> instance is assumed to be authoritative at the time of the call. /// Instances that are already at the <paramref name="desiredState"/> are ignored. /// The <see cref="CloudTask"/> instances in the collection are treated as read-only. /// This means that when the call completes (timeout or not) the <see cref="CloudTask"/> instances should be refreshed before using. /// </para> /// <para> /// This method runs asynchronously. /// </para> /// </remarks> /// <param name="tasksToMonitor">The collection of tasks to monitor.</param> /// <param name="desiredState">The target state of the tasks. The method will exit when all tasks have reached this state at least once.</param> /// <param name="cancellationToken">A <see cref="CancellationToken"/> for controlling the lifetime of the asynchronous operation.</param> /// <param name="controlParams">Controls various settings of the monitor, such as delay between each poll.</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 <see cref="System.Threading.Tasks.Task"/> that represents the asynchronous operation.</returns> /// <exception cref="OperationCanceledException">Thrown if the <paramref name="cancellationToken"/> was cancelled.</exception> public async Task WhenAll( IEnumerable <CloudTask> tasksToMonitor, Common.TaskState desiredState, CancellationToken cancellationToken, ODATAMonitorControl controlParams = null, IEnumerable <BatchClientBehavior> additionalBehaviors = null) { await this.WhenAllImplAsync( tasksToMonitor, desiredState, cancellationToken, controlParams, additionalBehaviors).ConfigureAwait(continueOnCapturedContext: false); }
private async Task WhenAllImplAsync( IEnumerable <CloudTask> tasksToMonitor, Common.TaskState desiredState, CancellationToken cancellationToken, ODATAMonitorControl controlParams, IEnumerable <BatchClientBehavior> additionalBehaviors) { if (null == tasksToMonitor) { throw new ArgumentNullException("tasksToMonitor"); } // we only need the id and state for this monitor. the filter clause will be updated by the monitor ODATADetailLevel odataSuperOptimalPredicates = new ODATADetailLevel() { SelectClause = "id,state" }; // for validation and list calls we need the parent name values string jobId = null; // set up behaviors BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors); // set up control params if needed if (null == controlParams) { controlParams = new ODATAMonitorControl(); // use defaults } tasksToMonitor = await UtilitiesInternal.EnumerateIfNeededAsync(tasksToMonitor, cancellationToken).ConfigureAwait(continueOnCapturedContext: false); // validation: job schedule id and jobId foreach (CloudTask curTask in tasksToMonitor) { // can only monitor bound objects if (curTask.BindingState != BindingState.Bound) { Exception ex = UtilitiesInternal.OperationForbiddenOnUnboundObjects; throw ex; } // set or validate job Id if (null == jobId) { jobId = curTask.ParentJobId; } else { // all instances must have same parent if (!jobId.Equals(curTask.ParentJobId, StringComparison.OrdinalIgnoreCase)) { Exception ex = UtilitiesInternal.MonitorRequiresConsistentHierarchyChain; throw ex; } } } // start call Task asyncTask = ODATAMonitor.WhenAllAsync( tasksToMonitor, x => { // return true if is desired state bool hasReachedDesiredState = x.State == desiredState; return(hasReachedDesiredState); }, x => { return(x.Id); }, // return the Id of the task () => _parentUtilities.ParentBatchClient.JobOperations.ListTasksImpl(jobId, bhMgr, odataSuperOptimalPredicates), // call this lambda to (re)fetch the list cancellationToken, odataSuperOptimalPredicates, controlParams); await asyncTask.ConfigureAwait(continueOnCapturedContext : false); }