public void Bug2338301_CheckStreamPositionAfterFileRead()
{
Action test = () =>
{
using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result)
{
JobOperations jobOperations = batchCli.JobOperations;
{
string jobId = "Bug2338301Job-" + TestUtilities.GetMyName();
try
{
const string taskId = "hiWorld";
//
// Create the job
//
CloudJob unboundJob = jobOperations.CreateJob(jobId, new PoolInformation()
{
PoolId = this.poolFixture.PoolId
});
unboundJob.Commit();
CloudJob boundJob = jobOperations.GetJob(jobId);
CloudTask myTask = new CloudTask(taskId, "cmd /c echo hello world");
boundJob.AddTask(myTask);
this.testOutputHelper.WriteLine("Initial job commit()");
//
// Wait for task to go to completion
//
Utilities utilities = batchCli.Utilities;
TaskStateMonitor taskStateMonitor = utilities.CreateTaskStateMonitor();
taskStateMonitor.WaitAll(
boundJob.ListTasks(),
Microsoft.Azure.Batch.Common.TaskState.Completed,
TimeSpan.FromMinutes(3));
CloudTask boundTask = boundJob.GetTask(taskId);
//Get the task file
const string fileToGet = "stdout.txt";
NodeFile file = boundTask.GetNodeFile(fileToGet);
//Download the file data
string result = file.ReadAsString();
Assert.True(result.Length > 0);
}
finally
{
jobOperations.DeleteJob(jobId);
}
}
}
};
SynchronizationContextHelper.RunTest(test, TestTimeout);
}
/// <summary>
/// Create a job associated with the specific pool, giving it the specified ID
/// </summary>
private static CloudJob CreateBoundJob(JobOperations jobOps, string poolId, string jobId)
{
// get an empty unbound Job
var unboundJob = jobOps.CreateJob();
unboundJob.Id = jobId;
unboundJob.PoolInformation = new PoolInformation()
{
PoolId = poolId
};
// Commit Job to create it in the service
unboundJob.Commit();
// Get a new version of the object with all its properties filled in
CloudJob boundJob = jobOps.GetJob(jobId);
return(boundJob);
}
/// <summary>
/// Performs a simple AddTask test, adding the specified task count using the specified parallelOptions and resultHandlerFunc
/// </summary>
/// <returns></returns>
private async System.Threading.Tasks.Task AddTasksSimpleTestAsync(
BatchClient batchCli,
string testName,
int taskCount,
BatchClientParallelOptions parallelOptions,
Func <AddTaskResult, CancellationToken, AddTaskResultStatus> resultHandlerFunc,
StagingStorageAccount storageCredentials,
IEnumerable <string> localFilesToStage,
ConcurrentBag <ConcurrentDictionary <Type, IFileStagingArtifact> > fileStagingArtifacts = null,
TimeSpan?timeout = null,
bool useJobOperations = true)
{
JobOperations jobOperations = batchCli.JobOperations;
string jobId = "Bulk-" + TestUtilities.GetMyName() + "-" + testName + "-" + useJobOperations;
try
{
CloudJob unboundJob = jobOperations.CreateJob();
this.testOutputHelper.WriteLine("Initial job commit for job: {0}", jobId);
unboundJob.PoolInformation = new PoolInformation()
{
PoolId = "DummyPool"
};
unboundJob.Id = jobId;
await unboundJob.CommitAsync().ConfigureAwait(false);
CloudJob boundJob = await jobOperations.GetJobAsync(jobId).ConfigureAwait(false);
//
// Add a simple set of tasks
//
IEnumerable <string> taskNames = GenerateTaskIds(taskCount);
List <CloudTask> tasksToAdd = new List <CloudTask>();
List <CloudTask> tasksToValidateWith = new List <CloudTask>();
IList <IFileStagingProvider> lastFilesToStageList = null;
foreach (string taskName in taskNames)
{
CloudTask myTask = new CloudTask(taskName, "cmd /c echo hello world");
CloudTask duplicateReadableTask = new CloudTask(taskName, "cmd /c echo hello world");
if (localFilesToStage != null && storageCredentials != null)
{
myTask.FilesToStage = new List <IFileStagingProvider>();
lastFilesToStageList = myTask.FilesToStage;
duplicateReadableTask.FilesToStage = new List <IFileStagingProvider>();
foreach (string fileToStage in localFilesToStage)
{
duplicateReadableTask.FilesToStage.Add(new FileToStage(fileToStage, storageCredentials));
myTask.FilesToStage.Add(new FileToStage(fileToStage, storageCredentials));
}
}
tasksToAdd.Add(myTask);
tasksToValidateWith.Add(duplicateReadableTask);
}
List <BatchClientBehavior> behaviors = new List <BatchClientBehavior>();
if (resultHandlerFunc != null)
{
behaviors.Add(new AddTaskCollectionResultHandler(resultHandlerFunc));
}
//Add the tasks
Stopwatch stopwatch = new Stopwatch();
this.testOutputHelper.WriteLine("Starting task add");
stopwatch.Start();
if (useJobOperations)
{
await jobOperations.AddTaskAsync(
jobId,
tasksToAdd,
parallelOptions : parallelOptions,
fileStagingArtifacts : fileStagingArtifacts,
timeout : timeout,
additionalBehaviors : behaviors).ConfigureAwait(continueOnCapturedContext: false);
}
else
{
await boundJob.AddTaskAsync(
tasksToAdd,
parallelOptions : parallelOptions,
fileStagingArtifacts : fileStagingArtifacts,
timeout : timeout,
additionalBehaviors : behaviors).ConfigureAwait(continueOnCapturedContext: false);
}
stopwatch.Stop();
this.testOutputHelper.WriteLine("Task add finished, took: {0}", stopwatch.Elapsed);
if (lastFilesToStageList != null)
{
Assert.Throws <InvalidOperationException>(() => lastFilesToStageList.Add(new FileToStage("test", null)));
}
//Ensure the task lists match
List <CloudTask> tasksFromService = await jobOperations.ListTasks(jobId).ToListAsync().ConfigureAwait(false);
EnsureTasksListsMatch(tasksToValidateWith, tasksFromService);
}
catch (Exception e)
{
this.testOutputHelper.WriteLine("Exception: {0}", e.ToString());
throw;
}
finally
{
TestUtilities.DeleteJobIfExistsAsync(batchCli, jobId).Wait();
}
}
public void TestGetNodeFileByTask()
{
Action test = () =>
{
using (BatchClient batchCli = TestUtilities.OpenBatchClientAsync(TestUtilities.GetCredentialsFromEnvironment()).Result)
{
JobOperations jobOperations = batchCli.JobOperations;
string jobId = Constants.DefaultConveniencePrefix + TestUtilities.GetMyName() + "-" + nameof(TestGetNodeFileByTask);
try
{
//
// Create the job
//
CloudJob job = jobOperations.CreateJob(jobId, new PoolInformation());
job.PoolInformation = new PoolInformation()
{
PoolId = this.poolFixture.PoolId
};
this.testOutputHelper.WriteLine("Initial job schedule commit()");
job.Commit();
//
// Wait for the job
//
this.testOutputHelper.WriteLine("Waiting for job");
CloudJob boundJob = jobOperations.GetJob(jobId);
//
// Add task to the job
//
const string taskId = "T1";
const string taskMessage = "This is a test";
this.testOutputHelper.WriteLine("Adding task: {0}", taskId);
CloudTask task = new CloudTask(taskId, string.Format("cmd /c echo {0}", taskMessage));
boundJob.AddTask(task);
//
// Wait for the task to complete
//
this.testOutputHelper.WriteLine("Waiting for the task to complete");
Utilities utilities = batchCli.Utilities;
TaskStateMonitor taskStateMonitor = utilities.CreateTaskStateMonitor();
//Wait for the task state to be running
taskStateMonitor.WaitAll(
jobOperations.ListTasks(jobId),
TaskState.Completed,
TimeSpan.FromSeconds(30));
//Download the data
this.testOutputHelper.WriteLine("Downloading the stdout for the file");
NodeFile file = jobOperations.GetNodeFile(jobId, taskId, Constants.StandardOutFileName);
string data = file.ReadAsString();
this.testOutputHelper.WriteLine("Data: {0}", data);
Assert.Contains(taskMessage, data);
// Download the data again using the JobOperations read file content helper
data = batchCli.JobOperations.CopyNodeFileContentToString(jobId, taskId, Constants.StandardOutFileName);
this.testOutputHelper.WriteLine("Data: {0}", data);
Assert.Contains(taskMessage, data);
}
finally
{
jobOperations.DeleteJob(jobId);
}
}
};
SynchronizationContextHelper.RunTest(test, TestTimeout);
}
/// <summary>
/// Creates a new job.
/// </summary>
/// <param name="parameters">The parameters to use when creating the job.</param>
public void CreateJob(NewJobParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
JobOperations jobOperations = parameters.Context.BatchOMClient.JobOperations;
CloudJob job = jobOperations.CreateJob();
job.Id = parameters.JobId;
job.DisplayName = parameters.DisplayName;
job.Priority = parameters.Priority;
if (parameters.CommonEnvironmentSettings != null)
{
List <EnvironmentSetting> envSettings = new List <EnvironmentSetting>();
foreach (DictionaryEntry d in parameters.CommonEnvironmentSettings)
{
EnvironmentSetting envSetting = new EnvironmentSetting(d.Key.ToString(), d.Value.ToString());
envSettings.Add(envSetting);
}
job.CommonEnvironmentSettings = envSettings;
}
if (parameters.Constraints != null)
{
job.Constraints = parameters.Constraints.omObject;
}
if (parameters.JobManagerTask != null)
{
Utils.Utils.JobManagerTaskSyncCollections(parameters.JobManagerTask);
job.JobManagerTask = parameters.JobManagerTask.omObject;
}
if (parameters.JobPreparationTask != null)
{
Utils.Utils.JobPreparationTaskSyncCollections(parameters.JobPreparationTask);
job.JobPreparationTask = parameters.JobPreparationTask.omObject;
}
if (parameters.JobReleaseTask != null)
{
Utils.Utils.JobReleaseTaskSyncCollections(parameters.JobReleaseTask);
job.JobReleaseTask = parameters.JobReleaseTask.omObject;
}
if (parameters.Metadata != null)
{
job.Metadata = new List <MetadataItem>();
foreach (DictionaryEntry d in parameters.Metadata)
{
MetadataItem metadata = new MetadataItem(d.Key.ToString(), d.Value.ToString());
job.Metadata.Add(metadata);
}
}
if (parameters.PoolInformation != null)
{
Utils.Utils.PoolInformationSyncCollections(parameters.PoolInformation);
job.PoolInformation = parameters.PoolInformation.omObject;
}
WriteVerbose(string.Format(Resources.CreatingJob, parameters.JobId));
job.Commit(parameters.AdditionalBehaviors);
}
/// <summary>
/// Create a job associated with the specific pool, giving it the specified ID
/// </summary>
private static CloudJob CreateBoundJob(JobOperations jobOps, string poolId, string jobId)
{
// get an empty unbound Job
var unboundJob = jobOps.CreateJob();
unboundJob.Id = jobId;
unboundJob.PoolInformation = new PoolInformation() { PoolId = poolId };
// Commit Job to create it in the service
unboundJob.Commit();
// Get a new version of the object with all its properties filled in
CloudJob boundJob = jobOps.GetJob(jobId);
return boundJob;
}
