/// <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>
/// 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>
/// See <see cref="IFileStagingProvider.StageFilesAsync"/>.
/// </summary>
/// <param name="filesToStage">The instances of IFileStagingProvider to stage.</param>
/// <param name="fileStagingArtifact">IFileStagingProvider specific staging artifacts including error/progress.</param>
/// <returns>A <see cref="System.Threading.Tasks.Task"/> object that represents the asynchronous operation.</returns>
public async System.Threading.Tasks.Task StageFilesAsync(List <IFileStagingProvider> filesToStage, IFileStagingArtifact fileStagingArtifact)
{
System.Threading.Tasks.Task taskForStaticStaging = FileToStage.StageFilesInternalAsync(filesToStage, fileStagingArtifact);
await taskForStaticStaging.ConfigureAwait(continueOnCapturedContext : false);
return;
}
/// <summary>
/// Extension to fire and forget an asynchronous task
/// </summary>
/// <param name="task">The Task-returning async method being started</param>
/// <param name="continueOnCapturedContext">Optional boolean for ConfigureAwait</param>
/// <param name="onException">Optional delegate for exception handling</param>
#pragma warning disable RECS0165
public static async void SafeFireAndForget(this System.Threading.Tasks.Task task, bool continueOnCapturedContext = true, Action <Exception> onException = null)
#pragma warning restore RECS0165
{
try
{
await task.ConfigureAwait(continueOnCapturedContext);
}
catch (Exception ex) when(onException != null)
{
onException(ex);
}
}
/// <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>
/// Safely execute the Task without waiting for it to complete before moving to the next line of code; commonly known as "Fire And Forget". Inspired by John Thiriet's blog post, "Removing Async Void": https://johnthiriet.com/removing-async-void/.
/// </summary>
/// <param name="task">Task.</param>
/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
#pragma warning disable RECS0165 // Asynchronous methods should return a Task instead of void
public static async void SafeFireAndForget(this System.Threading.Tasks.Task task, bool continueOnCapturedContext = true, System.Action <System.Exception> onException = null)
#pragma warning restore RECS0165 // Asynchronous methods should return a Task instead of void
{
try
{
await task.ConfigureAwait(continueOnCapturedContext);
}
catch (System.Exception ex) when(onException != null)
{
onException(ex);
}
}
public static void BindFuture <T> (this System.Threading.Tasks.Task <T> task, Future <T> future)
{
if (task.IsCompleted)
{
future.SetResultFrom(task);
return;
}
task.ConfigureAwait(false).GetAwaiter().OnCompleted(() => {
future.SetResultFrom(task);
});
future.RegisterOnDispose(CancelScopeForTask, task);
}
// Allocate the async/await state machine only when needed for performance reason.
// More info about the state machine: https://blogs.msdn.microsoft.com/seteplia/2017/11/30/dissecting-the-async-methods-in-c/
static async Task ForgetAwaited(Task task)
{
try
{
// No need to resume on the original SynchronizationContext, so use ConfigureAwait(false)
await task.ConfigureAwait(false);
}
catch (Exception ex)
{
MessageBoxHelper.ShowError($"Asynchronous Task failed: {ex.Message}\nSee output pane or log file for more details.", Resources.TaskFailed);
s_log.Error("Asynchronous Task failed", ex);
}
}
/// <summary>
/// Starts a Task and lets it run in the background, while silently handles any exceptions.
/// </summary>
/// <remarks>
/// This is similar to the <c>task.FileAndForget(string)</c> method introduced in 16.0, but this doesn't record
/// telemetry on faults and it doesn't take a string parameter. This also works in all version of Visual Studio.
/// </remarks>
public static void FireAndForget(this System.Threading.Tasks.Task task)
{
ThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
try
{
await task.ConfigureAwait(false);
}
catch (Exception ex)
{
await ex.LogAsync();
}
});
}
static StackObject *ConfigureAwait_3(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 2);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Boolean @continueOnCapturedContext = ptr_of_this_method->Value == 1;
ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
System.Threading.Tasks.Task instance_of_this_method = (System.Threading.Tasks.Task) typeof(System.Threading.Tasks.Task).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.ConfigureAwait(@continueOnCapturedContext);
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
/// <summary>
/// Stages all files in the queue
/// </summary>
private async static System.Threading.Tasks.Task StageFilesAsync(List <IFileStagingProvider> filesToStage, SequentialFileStagingArtifact seqArtifacts)
{
foreach (IFileStagingProvider currentFile in filesToStage)
{
// for "retry" and/or "double calls" we ignore files that have already been staged
if (null == currentFile.StagedFiles)
{
FileToStage fts = currentFile as FileToStage;
if (null != fts)
{
System.Threading.Tasks.Task stageTask = StageOneFileAsync(fts, seqArtifacts);
await stageTask.ConfigureAwait(continueOnCapturedContext : false);
}
}
}
}
/// <summary>
/// Starts an asynchronous call to stage the given files.
/// </summary>
private static async System.Threading.Tasks.Task StageFilesInternalAsync(List <IFileStagingProvider> filesToStage, IFileStagingArtifact fileStagingArtifact)
{
if (null == filesToStage)
{
throw new ArgumentNullException("filesToStage");
}
if (null == fileStagingArtifact)
{
throw new ArgumentNullException("filesStagingArtifact");
}
SequentialFileStagingArtifact seqArtifact = fileStagingArtifact as SequentialFileStagingArtifact;
if (null == seqArtifact)
{
throw new ArgumentOutOfRangeException(ErrorMessages.FileStagingIncorrectArtifact);
}
// is there any work to do?
if (null == FindAtLeastOne(filesToStage))
{
return; // now work to do. none of the files belong to this provider
}
// is there any work to do
if ((null == filesToStage) || (filesToStage.Count <= 0))
{
return; // we are done
}
// create a Run task to create the blob containers if needed
System.Threading.Tasks.Task createContainerTask = System.Threading.Tasks.Task.Run(() => { CreateDefaultBlobContainerAndSASIfNeededReturn(filesToStage, seqArtifact); });
// wait for container to be created
await createContainerTask.ConfigureAwait(continueOnCapturedContext : false);
// begin staging the files
System.Threading.Tasks.Task stageTask = StageFilesAsync(filesToStage, seqArtifact);
// wait for files to be staged
await stageTask.ConfigureAwait(continueOnCapturedContext : false);
}
public override async System.Threading.Tasks.Task CopyToStreamAsync(
Stream stream,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(base.CustomBehaviors, additionalBehaviors);
System.Threading.Tasks.Task <AzureOperationResponse <Models.NodeFile, Models.FileGetFromComputeNodeHeaders> > asyncTask =
this._poolOperations.ParentBatchClient.ProtocolLayer.GetNodeFileByNode(
_poolId,
_computeNodeId,
base.Name,
stream,
bhMgr,
cancellationToken);
await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
}
public static void BindFuture(this tTask task, IFuture future)
{
if (task.IsCompleted && !task.IsFaulted)
{
future.Complete();
return;
}
task.ConfigureAwait(false).GetAwaiter().OnCompleted(() => {
// FIXME: ExceptionDispatchInfo?
if (task.IsFaulted)
{
future.Fail(task.Exception.InnerExceptions.Count == 1 ? task.Exception.InnerException : task.Exception);
}
else
{
future.Complete();
}
});
future.RegisterOnDispose(CancelScopeForTask, task);
}
/// <summary>
/// Commits 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>The commit operation runs asynchronously.</para>
/// </remarks>
public async System.Threading.Tasks.Task CommitAsync(
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
// after this no prop access is allowed
this.propertyContainer.IsReadOnly = true;
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
// fetch props with admin rights so we can make calls, etc.
if (BindingState.Unbound == this.propertyContainer.BindingState)
{
// take all property changes and create a job schedule
Models.JobScheduleAddParameter protoJobSchedule = this.GetTransportObject <Models.JobScheduleAddParameter>();
System.Threading.Tasks.Task <AzureOperationHeaderResponse <Models.JobScheduleAddHeaders> > asyncTask =
this.parentBatchClient.ProtocolLayer.AddJobSchedule(protoJobSchedule, bhMgr, cancellationToken);
await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
}
else
{
Models.JobSpecification jobSpecification = UtilitiesInternal.CreateObjectWithNullCheck(this.JobSpecification, o => o.GetTransportObject());
Models.Schedule schedule = UtilitiesInternal.CreateObjectWithNullCheck(this.Schedule, o => o.GetTransportObject());
Models.MetadataItem[] metadata = UtilitiesInternal.ConvertToProtocolArray(this.Metadata);
System.Threading.Tasks.Task <AzureOperationHeaderResponse <Models.JobScheduleUpdateHeaders> > asyncJobScheduleUpdate =
this.parentBatchClient.ProtocolLayer.UpdateJobSchedule(
this.Id,
jobSpecification,
metadata,
schedule,
bhMgr,
cancellationToken);
await asyncJobScheduleUpdate.ConfigureAwait(continueOnCapturedContext : false);
}
}
public override async System.Threading.Tasks.Task RefreshAsync(
DetailLevel detailLevel = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
// create the behavior managaer
BehaviorManager bhMgr = new BehaviorManager(base.CustomBehaviors, additionalBehaviors, detailLevel);
System.Threading.Tasks.Task <AzureOperationResponse <Models.NodeFile, Models.FileGetPropertiesFromComputeNodeHeaders> > asyncTask =
this._poolOperations.ParentBatchClient.ProtocolLayer.GetNodeFilePropertiesByNode(
_poolId,
_computeNodeId,
base.Path,
bhMgr,
cancellationToken);
AzureOperationResponse <Models.NodeFile, Models.FileGetPropertiesFromComputeNodeHeaders> response = await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
// immediately available to all threads
System.Threading.Interlocked.Exchange(ref base.fileItemBox, new FileItemBox(response.Body));
}
/// <summary>
/// Refreshes the current <see cref="CloudJobSchedule"/>.
/// </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"/> representing the asynchronous refresh operation.</returns>
public async System.Threading.Tasks.Task RefreshAsync(
DetailLevel detailLevel = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors, detailLevel);
// start call
System.Threading.Tasks.Task <AzureOperationResponse <Models.CloudJobSchedule, Models.JobScheduleGetHeaders> > asyncTask =
this.parentBatchClient.ProtocolLayer.GetJobSchedule(this.Id, bhMgr, cancellationToken);
AzureOperationResponse <Models.CloudJobSchedule, Models.JobScheduleGetHeaders> response = await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
// get job schedule from response
Models.CloudJobSchedule newProtocolJobSchedule = response.Body;
this.propertyContainer = new PropertyContainer(newProtocolJobSchedule);
}
/// <summary>
/// Gets the specified <see cref="CloudJobSchedule"/>.
/// </summary>
/// <param name="jobScheduleId">The id of the job schedule 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="CloudJobSchedule"/> containing information about the specified Azure Batch job schedule.</returns>
/// <remarks>The get job schedule operation runs asynchronously.</remarks>
public async System.Threading.Tasks.Task <CloudJobSchedule> GetJobScheduleAsync(
string jobScheduleId,
DetailLevel detailLevel = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
// set up behavior manager
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors, detailLevel);
using (System.Threading.Tasks.Task <AzureOperationResponse <Models.CloudJobSchedule, Models.JobScheduleGetHeaders> > asyncTask =
this.ParentBatchClient.ProtocolLayer.GetJobSchedule(jobScheduleId, bhMgr, cancellationToken))
{
AzureOperationResponse <Models.CloudJobSchedule, Models.JobScheduleGetHeaders> result = await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
// construct a new object bound to the protocol layer object
CloudJobSchedule newWI = new CloudJobSchedule(this.ParentBatchClient, result.Body, this.CustomBehaviors);
return(newWI);
}
}
public static void AssemblyCleanup()
{
System.Threading.Tasks.Task t = TraceBuffer.Flush();
t.ConfigureAwait(false).GetAwaiter().GetResult();
}
/// <summary>
/// Attempts to download the file.
/// </summary>
/// <param name="uri">The parsed <see cref="Uri"/> of the request.</param>
private void Download(Uri uri)
{
// The main reason to use HttpClient vs WebClient is because we can pass a message handler for unit tests to mock
using (var client = new HttpClient(HttpMessageHandler ?? new HttpClientHandler(), disposeHandler: true))
{
// Only get the response without downloading the file so we can determine if the file is already up-to-date
using (HttpResponseMessage response = client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, _cancellationTokenSource.Token)
.ConfigureAwait(continueOnCapturedContext: false)
.GetAwaiter()
.GetResult())
{
try
{
response.EnsureSuccessStatusCode();
}
catch (HttpRequestException e)
{
// HttpRequestException does not have the status code so its wrapped and thrown here so that later on we can determine
// if a retry is possible based on the status code
throw new CustomHttpRequestException(e.Message, e.InnerException, response.StatusCode);
}
if (!TryGetFileName(response, out string filename))
{
Log.LogErrorWithCodeFromResources("DownloadFile.ErrorUnknownFileName", SourceUrl, nameof(DestinationFileName));
return;
}
DirectoryInfo destinationDirectory = Directory.CreateDirectory(DestinationFolder.ItemSpec);
var destinationFile = new FileInfo(Path.Combine(destinationDirectory.FullName, filename));
// The file is considered up-to-date if its the same length. This could be inaccurate, we can consider alternatives in the future
if (ShouldSkip(response, destinationFile))
{
Log.LogMessageFromResources(MessageImportance.Normal, "DownloadFile.DidNotDownloadBecauseOfFileMatch", SourceUrl, destinationFile.FullName, nameof(SkipUnchangedFiles), "true");
DownloadedFile = new TaskItem(destinationFile.FullName);
return;
}
try
{
using (var target = new FileStream(destinationFile.FullName, FileMode.Create, FileAccess.Write, FileShare.None))
{
Log.LogMessageFromResources(MessageImportance.High, "DownloadFile.Downloading", SourceUrl, destinationFile.FullName, response.Content.Headers.ContentLength);
Task task = response.Content.CopyToAsync(target);
task.ConfigureAwait(continueOnCapturedContext: false);
task.Wait(_cancellationTokenSource.Token);
DownloadedFile = new TaskItem(destinationFile.FullName);
}
}
finally
{
if (DownloadedFile == null)
{
// Delete the file if anything goes wrong during download. This could be destructive but we don't want to leave
// partially downloaded files on disk either. Alternatively we could download to a temporary location and copy
// on success but we are concerned about the added I/O
destinationFile.Delete();
}
}
}
}
}
/// <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>
/// Refreshes the current <see cref="ComputeNode"/>.
/// </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="Task"/> representing the asynchronous refresh operation.</returns>
public async Task RefreshAsync(DetailLevel detailLevel = null, IEnumerable <BatchClientBehavior> additionalBehaviors = null, CancellationToken cancellationToken = default(CancellationToken))
{
// create the behavior manager
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors, detailLevel);
System.Threading.Tasks.Task <AzureOperationResponse <Models.ComputeNode, Models.ComputeNodeGetHeaders> > asyncTask =
this.parentBatchClient.ProtocolLayer.GetComputeNode(this.parentPoolId, this.Id, bhMgr, cancellationToken);
AzureOperationResponse <Models.ComputeNode, Models.ComputeNodeGetHeaders> response = await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
// get pool from response
Models.ComputeNode newProtocolComputeNode = response.Body;
this.propertyContainer = new PropertyContainer(newProtocolComputeNode);
}
private static async Task WriteMessageCore(ValueTask writeMessageTask)
{
await writeMessageTask.ConfigureAwait(false);
GrpcEventSource.Log.MessageSent();
}
/// <summary>
/// Stage a single file.
/// </summary>
private async static System.Threading.Tasks.Task StageOneFileAsync(FileToStage stageThisFile, SequentialFileStagingArtifact seqArtifacts)
{
StagingStorageAccount storecreds = stageThisFile.StagingStorageAccount;
string containerName = seqArtifacts.BlobContainerCreated;
// TODO: this flattens all files to the top of the compute node/task relative file directory. solve the hiearchy problem (virt dirs?)
string blobName = Path.GetFileName(stageThisFile.LocalFileToStage);
// Create the storage account with the connection string.
CloudStorageAccount storageAccount = new CloudStorageAccount(
new WindowsAzure.Storage.Auth.StorageCredentials(storecreds.StorageAccount, storecreds.StorageAccountKey),
blobEndpoint: storecreds.BlobUri,
queueEndpoint: null,
tableEndpoint: null,
fileEndpoint: null);
CloudBlobClient client = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = client.GetContainerReference(containerName);
ICloudBlob blob = container.GetBlockBlobReference(blobName);
bool doesBlobExist;
try
{
// fetch attributes so we can compare file lengths
System.Threading.Tasks.Task fetchTask = blob.FetchAttributesAsync();
await fetchTask.ConfigureAwait(continueOnCapturedContext : false);
doesBlobExist = true;
}
catch (StorageException scex)
{
// check to see if blob does not exist
if ((int)System.Net.HttpStatusCode.NotFound == scex.RequestInformation.HttpStatusCode)
{
doesBlobExist = false;
}
else
{
throw; // unknown exception, throw to caller
}
}
bool mustUploadBlob = true; // we do not re-upload blobs if they have already been uploaded
if (doesBlobExist) // if the blob exists, compare
{
FileInfo fi = new FileInfo(stageThisFile.LocalFileToStage);
// since we don't have a hash of the contents... we check length
if (blob.Properties.Length == fi.Length)
{
mustUploadBlob = false;
}
}
if (mustUploadBlob)
{
// upload the file
System.Threading.Tasks.Task uploadTask = blob.UploadFromFileAsync(stageThisFile.LocalFileToStage);
await uploadTask.ConfigureAwait(continueOnCapturedContext : false);
}
// get the SAS for the blob
string blobSAS = ConstructBlobSource(seqArtifacts.DefaultContainerSAS, blobName);
string nodeFileName = stageThisFile.NodeFileName;
// create a new ResourceFile and populate it. This file is now staged!
stageThisFile.StagedFiles = new ResourceFile[] { ResourceFile.FromUrl(blobSAS, nodeFileName) };
}
private void log(string level, string message)
{
//Try to get the threadId which is very useful when debugging
string threadId = null;
try
{
#if NETFX_CORE
threadId = Environment.CurrentManagedThreadId.ToString();
#else
threadId = System.Threading.Thread.CurrentThread.ManagedThreadId.ToString();
#endif
}
catch (Exception) { }
string logStringToWrite;
if (threadId != null)
logStringToWrite = DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " [" + threadId + " - " + level + "] - " + message;
else
logStringToWrite = DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " [" + level + "] - " + message;
#if !NETFX_CORE
if (_currentLogMode == LogMode.ConsoleAndLogFile || _currentLogMode == LogMode.ConsoleOnly)
Console.WriteLine(logStringToWrite);
#endif
if ((_currentLogMode == LogMode.ConsoleAndLogFile || _currentLogMode == LogMode.LogFileOnly) && LogFileLocationName != null)
{
try
{
lock (_locker)
{
#if NETFX_CORE
System.Threading.Tasks.Task writeTask = new System.Threading.Tasks.Task(async () =>
{
while (true)
{
try
{
Windows.Storage.StorageFolder folder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile file = await folder.CreateFileAsync(LogFileLocationName, Windows.Storage.CreationCollisionOption.OpenIfExists);
await Windows.Storage.FileIO.AppendTextAsync(file, logStringToWrite + "\n");
break;
}
catch (Exception) { }
}
});
writeTask.ConfigureAwait(false);
writeTask.Start();
writeTask.Wait();
#else
using (var sw = new System.IO.StreamWriter(LogFileLocationName, true))
sw.WriteLine(logStringToWrite);
#endif
}
}
catch (Exception) { }
}
}
private void log(string level, string message)
{
//Try to get the threadId which is very useful when debugging
string threadId = null;
try
{
#if NETFX_CORE
threadId = Environment.CurrentManagedThreadId.ToString();
#else
threadId = System.Threading.Thread.CurrentThread.ManagedThreadId.ToString();
#endif
}
catch (Exception) { }
string logStringToWrite;
if (threadId != null)
{
logStringToWrite = DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " [" + threadId + " - " + level + "] - " + message;
}
else
{
logStringToWrite = DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " [" + level + "] - " + message;
}
#if !NETFX_CORE
if (_currentLogMode == LogMode.ConsoleAndLogFile || _currentLogMode == LogMode.ConsoleOnly)
{
Console.WriteLine(logStringToWrite);
}
#endif
if ((_currentLogMode == LogMode.ConsoleAndLogFile || _currentLogMode == LogMode.LogFileOnly) && LogFileLocationName != null)
{
try
{
lock (_locker)
{
#if NETFX_CORE
System.Threading.Tasks.Task writeTask = new System.Threading.Tasks.Task(async() =>
{
while (true)
{
try
{
Windows.Storage.StorageFolder folder = Windows.Storage.ApplicationData.Current.LocalFolder;
Windows.Storage.StorageFile file = await folder.CreateFileAsync(LogFileLocationName, Windows.Storage.CreationCollisionOption.OpenIfExists);
await Windows.Storage.FileIO.AppendTextAsync(file, logStringToWrite + "\n");
break;
}
catch (Exception) { }
}
});
writeTask.ConfigureAwait(false);
writeTask.Start();
writeTask.Wait();
#else
using (var sw = new System.IO.StreamWriter(LogFileLocationName, true))
sw.WriteLine(logStringToWrite);
#endif
}
}
catch (Exception) { }
}
}
/// <summary>
/// Refreshes the current <see cref="CloudJob"/>.
/// </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="Task"/> representing the asynchronous refresh operation.</returns>
public async System.Threading.Tasks.Task RefreshAsync(
DetailLevel detailLevel = null,
IEnumerable <BatchClientBehavior> additionalBehaviors = null,
CancellationToken cancellationToken = default(CancellationToken))
{
// create the behavior managaer
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors, detailLevel);
// start operation
System.Threading.Tasks.Task <AzureOperationResponse <Models.CloudJob, Models.JobGetHeaders> > asyncTask =
this.parentBatchClient.ProtocolLayer.GetJob(this.Id, bhMgr, cancellationToken);
AzureOperationResponse <Models.CloudJob, Models.JobGetHeaders> response = await asyncTask.ConfigureAwait(continueOnCapturedContext : false);
// get job from response
Models.CloudJob newProtocolJob = response.Body;
PropertyContainer container = new PropertyContainer(newProtocolJob);
// immediately available to all threads
this.propertyContainer = container;
}
static async System.Threading.Tasks.Task <object> TaskCast <T>(System.Threading.Tasks.Task <T> task)
{
var t = await task.ConfigureAwait(false);
return((object)t);
}
