public override void ExecuteCmdlet()
{
VirtualMachine pendingVirtualMachine = null;
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? jobId = Guid.Empty;
var newVirtualMachine = new VirtualMachine()
{
Name = Name,
VMTemplateId = Template.ID,
LocalAdminUserName = VMCredential.UserName,
LocalAdminPassword = ExtractSecureString(VMCredential.Password),
};
pendingVirtualMachine = virtualMachineOperations.Create(newVirtualMachine, out jobId);
if (!jobId.HasValue)
{
throw new WAPackOperationException(Resources.CreateFailedErrorMessage);
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(jobId.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
var createdVM = virtualMachineOperations.Read(pendingVirtualMachine.ID);
WriteObject(createdVM);
}
protected override void ExecuteCommand()
{
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? jobId = null;
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RemoveVMConfirmationMessage, VM.Name),
string.Format(Resources.RemoveVMMessage),
VM.Name,
() =>
{
virtualMachineOperations.Delete(VM.ID, out jobId);
if (!jobId.HasValue)
{
throw new WAPackOperationException(String.Format(Resources.OperationFailedErrorMessage, Resources.Delete, VM.ID));
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(jobId.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
if (PassThru)
{
WriteObject(jobInfo.jobStatus != JobStatusEnum.Failed);
}
});
}
/// <summary>
/// Deletes the specified file from its compute node.
/// </summary>
/// <param name="recursive">If the file-path parameter represents a directory instead of a file, you can set the optional
/// recursive parameter to true to delete the directory and all of the files and subdirectories in it. If recursive is false
/// then the directory must be empty or deletion will fail..</param>
/// <param name="parameters">Specifies which node file to delete.</param>
public void DeleteNodeFile(bool?recursive, NodeFileOperationParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
switch (parameters.NodeFileType)
{
case PSNodeFileType.Task:
{
JobOperations jobOperations = parameters.Context.BatchOMClient.JobOperations;
jobOperations.DeleteNodeFile(parameters.JobId, parameters.TaskId, parameters.NodeFileName, recursive: recursive, additionalBehaviors: parameters.AdditionalBehaviors);
break;
}
case PSNodeFileType.ComputeNode:
{
PoolOperations poolOperations = parameters.Context.BatchOMClient.PoolOperations;
poolOperations.DeleteNodeFile(parameters.PoolId, parameters.ComputeNodeId, parameters.NodeFileName, recursive: recursive, additionalBehaviors: parameters.AdditionalBehaviors);
break;
}
case PSNodeFileType.PSNodeFileInstance:
{
parameters.NodeFile.omObject.Delete(recursive: recursive, additionalBehaviors: parameters.AdditionalBehaviors);
break;
}
default:
{
throw new ArgumentException(Resources.NoNodeFile);
}
}
}
/// <summary>
/// Lists the subtasks matching the specified filter options.
/// </summary>
/// <param name="options">The options to use when querying for subtasks.</param>
/// <returns>The subtasks matching the specified filter options.</returns>
public IEnumerable <PSSubtaskInformation> ListSubtasks(ListSubtaskOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
string taskId = options.Task == null ? options.TaskId : options.Task.Id;
string verboseLogString = string.Format(Resources.GetSubtaskNoFilter, taskId);
WriteVerbose(verboseLogString);
IPagedEnumerable <SubtaskInformation> subtasks = null;
if (options.Task != null)
{
subtasks = options.Task.omObject.ListSubtasks(additionalBehaviors: options.AdditionalBehaviors);
}
else
{
JobOperations jobOperations = options.Context.BatchOMClient.JobOperations;
subtasks = jobOperations.ListSubtasks(options.JobId, options.TaskId, additionalBehaviors: options.AdditionalBehaviors);
}
Func <SubtaskInformation, PSSubtaskInformation> mappingFunction = s => { return(new PSSubtaskInformation(s)); };
return(PSPagedEnumerable <PSSubtaskInformation, SubtaskInformation> .CreateWithMaxCount(
subtasks, mappingFunction, options.MaxCount, () => WriteVerbose(string.Format(Resources.MaxCount, options.MaxCount))));
}
/// <summary>
/// Lists the job prep and release status matching the specified filter options.
/// </summary>
/// <param name="options">The Batch account context.</param>
public IEnumerable <PSJobPreparationAndReleaseTaskExecutionInformation> ListJobPreparationAndReleaseStatus(ListJobPreparationAndReleaseStatusOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
string jobId = options.JobId ?? options.Job.Id;
if (jobId == null)
{
throw new ArgumentNullException(nameof(jobId));
}
WriteVerbose(string.Format(Resources.GetJobPreparationAndReleaseStatus, jobId));
JobOperations jobOperations = options.Context.BatchOMClient.JobOperations;
ODATADetailLevel getDetailLevel = new ODATADetailLevel(filterClause: options.Filter, selectClause: options.Select, expandClause: options.Expand);
IPagedEnumerable <JobPreparationAndReleaseTaskExecutionInformation> jobPrepAndReleaseDetails =
jobOperations.ListJobPreparationAndReleaseTaskStatus(jobId, getDetailLevel, additionalBehaviors: options.AdditionalBehaviors);
Func <JobPreparationAndReleaseTaskExecutionInformation, PSJobPreparationAndReleaseTaskExecutionInformation> mappingFunction =
j => new PSJobPreparationAndReleaseTaskExecutionInformation(j);
return(PSPagedEnumerable <PSJobPreparationAndReleaseTaskExecutionInformation, JobPreparationAndReleaseTaskExecutionInformation> .CreateWithMaxCount(
jobPrepAndReleaseDetails, mappingFunction, options.MaxCount, () => WriteVerbose(string.Format(Resources.MaxCount, options.MaxCount))));
}
public override void ExecuteCmdlet()
{
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid?jobId = Guid.Empty;
var vmToUpdate = virtualMachineOperations.Read(VM.ID);
this.SetSizeProfile(vmToUpdate);
var updatedVirtualMachine = virtualMachineOperations.Update(vmToUpdate, out jobId);
if (!jobId.HasValue)
{
throw new WAPackOperationException(String.Format(Resources.OperationFailedErrorMessage, Resources.Update, VM.ID));
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(jobId.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
if (PassThru)
{
updatedVirtualMachine = virtualMachineOperations.Read(updatedVirtualMachine.ID);
WriteObject(updatedVirtualMachine);
}
}
public override void ExecuteCmdlet()
{
VirtualMachine pendingVirtualMachine = null;
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? jobId = Guid.Empty;
var newVirtualMachine = new VirtualMachine()
{
Name = Name,
VMTemplateId = Template.ID,
UserName = VMCredential.UserName,
Password = ExtractSecureString(VMCredential.Password),
};
pendingVirtualMachine = virtualMachineOperations.Create(newVirtualMachine, out jobId);
if (!jobId.HasValue)
{
throw new WAPackOperationException(Resources.CreateFailedErrorMessage);
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(jobId.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
var createdVM = virtualMachineOperations.Read(pendingVirtualMachine.ID);
WriteObject(createdVM);
}
public override void ExecuteCmdlet()
{
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? jobId = Guid.Empty;
var vmToUpdate = virtualMachineOperations.Read(VM.ID);
this.SetSizeProfile(vmToUpdate);
var updatedVirtualMachine = virtualMachineOperations.Update(vmToUpdate, out jobId);
if (!jobId.HasValue)
{
throw new WAPackOperationException(String.Format(Resources.OperationFailedErrorMessage, Resources.Update, VM.ID));
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(jobId.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
if (PassThru)
{
updatedVirtualMachine = virtualMachineOperations.Read(updatedVirtualMachine.ID);
WriteObject(updatedVirtualMachine);
}
}
public override void ExecuteCmdlet()
{
VirtualMachine newVirtualMachine = null;
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? jobId = Guid.Empty;
var virtualNetworkAdaptersWithVNet = this.CustomizeVnaInput();
if (this.ParameterSetName == WAPackCmdletParameterSets.CreateWindowsVMFromTemplate)
{
newVirtualMachine = new VirtualMachine()
{
Name = Name,
VMTemplateId = Template.ID,
LocalAdminUserName = VMCredential.UserName,
LocalAdminPassword = ExtractSecureString(VMCredential.Password),
NewVirtualNetworkAdapterInput = virtualNetworkAdaptersWithVNet,
ProductKey = ProductKey,
};
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.CreateLinuxVMFromTemplate)
{
newVirtualMachine = new VirtualMachine()
{
Name = Name,
VMTemplateId = Template.ID,
LocalAdminUserName = VMCredential.UserName,
LocalAdminPassword = ExtractSecureString(VMCredential.Password),
NewVirtualNetworkAdapterInput = virtualNetworkAdaptersWithVNet,
LinuxAdministratorSSHKeyString = AdministratorSSHKey
};
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.CreateVMFromOSDisks)
{
newVirtualMachine = new VirtualMachine()
{
Name = Name,
HardwareProfileId = VMSizeProfile.ID,
VirtualHardDiskId = OSDisk.ID,
NewVirtualNetworkAdapterInput = virtualNetworkAdaptersWithVNet
};
}
var createdVirtualMachine = virtualMachineOperations.Create(newVirtualMachine, out jobId);
if (!jobId.HasValue)
{
throw new WAPackOperationException(Resources.CreateFailedErrorMessage);
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(jobId.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
createdVirtualMachine = virtualMachineOperations.Read(createdVirtualMachine.ID);
WriteObject(createdVirtualMachine);
}
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);
}
public override void ExecuteCmdlet()
{
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid?jobId = null;
ConfirmAction(
Force.IsPresent,
string.Format(Resources.RemoveVMConfirmationMessage, VM.Name),
string.Format(Resources.RemoveVMMessage),
VM.Name,
() =>
{
virtualMachineOperations.Delete(VM.ID, out jobId);
if (!jobId.HasValue)
{
throw new WAPackOperationException(String.Format(Resources.OperationFailedErrorMessage, Resources.Delete, VM.ID));
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(jobId.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
if (PassThru)
{
WriteObject(jobInfo.jobStatus != JobStatusEnum.Failed);
}
});
}
/// <summary>
/// Creates a new task.
/// </summary>
/// <param name="parameters">The parameters to use when creating the task.</param>
public void CreateTask(NewTaskParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
CloudTask task = new CloudTask(parameters.TaskId, parameters.CommandLine);
task.DisplayName = parameters.DisplayName;
task.RunElevated = parameters.RunElevated;
if (parameters.EnvironmentSettings != null)
{
task.EnvironmentSettings = new List <EnvironmentSetting>();
foreach (DictionaryEntry d in parameters.EnvironmentSettings)
{
EnvironmentSetting setting = new EnvironmentSetting(d.Key.ToString(), d.Value.ToString());
task.EnvironmentSettings.Add(setting);
}
}
if (parameters.ResourceFiles != null)
{
task.ResourceFiles = new List <ResourceFile>();
foreach (DictionaryEntry d in parameters.ResourceFiles)
{
ResourceFile file = new ResourceFile(d.Value.ToString(), d.Key.ToString());
task.ResourceFiles.Add(file);
}
}
if (parameters.AffinityInformation != null)
{
task.AffinityInformation = parameters.AffinityInformation.omObject;
}
if (parameters.Constraints != null)
{
task.Constraints = parameters.Constraints.omObject;
}
if (parameters.MultiInstanceSettings != null)
{
Utils.Utils.MultiInstanceSettingsSyncCollections(parameters.MultiInstanceSettings);
task.MultiInstanceSettings = parameters.MultiInstanceSettings.omObject;
}
WriteVerbose(string.Format(Resources.CreatingTask, parameters.TaskId));
if (parameters.Job != null)
{
parameters.Job.omObject.AddTask(task, parameters.AdditionalBehaviors);
}
else
{
JobOperations jobOperations = parameters.Context.BatchOMClient.JobOperations;
jobOperations.AddTask(parameters.JobId, task, parameters.AdditionalBehaviors);
}
}
internal AsyncListNodeFilesByTaskEnumerator(JobOperations jobOperations, string jobId, string taskId, bool?recursive, BehaviorManager behaviorMgr, DetailLevel detailLevel)
: base(behaviorMgr, detailLevel)
{
_jobOperations = jobOperations;
_jobId = jobId;
_taskId = taskId;
_recursive = recursive;
}
internal JobInfo WaitForJobCompletion(Guid?job)
{
JobInfo jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(job.Value);
if (jobInfo.jobStatus != JobStatusEnum.CompletedSuccessfully)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
return(jobInfo);
}
internal AsyncListTasksEnumerator(
JobOperations jobOperations,
string jobId,
BehaviorManager behaviorMgr,
DetailLevel detailLevel)
: base(behaviorMgr, detailLevel)
{
_jobOperations = jobOperations;
_jobId = jobId;
}
internal TrackedCloudTask(
string jobId,
JobOperations jobOperations,
CloudTask cloudTask)
{
this.Task = cloudTask;
this.JobId = jobId;
this.JobOperations = jobOperations; // matt-c: do we really need one of these in every instance? Even when they were wiMgrs couldnt something outside keep a reference?
this.RetryCount = 0;
}
/// <summary>
/// Gets lifetime summary statistics for all of the jobs in the specified account.
/// </summary>
/// <param name="context">The account to use.</param>
/// <param name="additionalBehaviors">Additional client behaviors to perform.</param>
public PSJobStatistics GetAllJobsLifetimeStatistics(BatchAccountContext context, IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
WriteVerbose(Resources.GetAllJobsLifetimeStatistics);
JobOperations jobOperations = context.BatchOMClient.JobOperations;
JobStatistics jobStatistics = jobOperations.GetAllJobsLifetimeStatistics(additionalBehaviors);
PSJobStatistics psJobStatistics = new PSJobStatistics(jobStatistics);
return(psJobStatistics);
}
internal AsyncListJobPrepReleaseTaskStatusEnumerator(
JobOperations parentJobOperations,
string jobId,
BehaviorManager behaviorMgr,
DetailLevel detailLevel)
{
_parentJobOperations = parentJobOperations;
_jobId = jobId;
_behaviorMgr = behaviorMgr;
_detailLevel = detailLevel;
}
internal AsyncListTasksEnumerator(
JobOperations jobOperations,
string jobId,
BehaviorManager behaviorMgr,
DetailLevel detailLevel)
{
this._jobOperations = jobOperations;
this._jobId = jobId;
this._behaviorMgr = behaviorMgr;
this._detailLevel = detailLevel;
}
internal TaskFile(
JobOperations jobOperations,
string jobId,
string taskId,
Models.NodeFile boundToThis,
IEnumerable <BatchClientBehavior> inheritTheseBehaviors) : base(boundToThis, inheritTheseBehaviors)
{
_jobOperations = jobOperations;
_jobId = jobId;
_taskId = taskId;
}
/// <summary>
/// Deletes the specified job.
/// </summary>
/// <param name="context">The account to use.</param>
/// <param name="jobId">The id of the job to delete.</param>
/// <param name="additionBehaviors">Additional client behaviors to perform.</param>
public void DeleteJob(BatchAccountContext context, string jobId, IEnumerable <BatchClientBehavior> additionBehaviors = null)
{
if (string.IsNullOrWhiteSpace(jobId))
{
throw new ArgumentNullException("jobId");
}
JobOperations jobOperations = context.BatchOMClient.JobOperations;
jobOperations.DeleteJob(jobId, additionBehaviors);
}
/// <summary>
/// Lists the jobs matching the specified filter options.
/// </summary>
/// <param name="options">The options to use when querying for jobs.</param>
/// <returns>The jobs matching the specified filter options.</returns>
public IEnumerable <PSCloudJob> ListJobs(ListJobOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
// Get the single job matching the specified id
if (!string.IsNullOrEmpty(options.JobId))
{
WriteVerbose(string.Format(Resources.GetJobById, options.JobId));
JobOperations jobOperations = options.Context.BatchOMClient.JobOperations;
ODATADetailLevel getDetailLevel = new ODATADetailLevel(selectClause: options.Select, expandClause: options.Expand);
CloudJob job = jobOperations.GetJob(options.JobId, detailLevel: getDetailLevel, additionalBehaviors: options.AdditionalBehaviors);
PSCloudJob psJob = new PSCloudJob(job);
return(new PSCloudJob[] { psJob });
}
// List jobs using the specified filter
else
{
string jobScheduleId = options.JobSchedule == null ? options.JobScheduleId : options.JobSchedule.Id;
bool filterByJobSchedule = !string.IsNullOrEmpty(jobScheduleId);
ODATADetailLevel listDetailLevel = new ODATADetailLevel(selectClause: options.Select, expandClause: options.Expand);
string verboseLogString = null;
if (!string.IsNullOrEmpty(options.Filter))
{
verboseLogString = filterByJobSchedule ? Resources.GetJobByOData : string.Format(Resources.GetJobByODataAndJobSChedule, jobScheduleId);
listDetailLevel.FilterClause = options.Filter;
}
else
{
verboseLogString = filterByJobSchedule ? Resources.GetJobNoFilter : string.Format(Resources.GetJobByJobScheduleNoFilter, jobScheduleId);
}
WriteVerbose(verboseLogString);
IPagedEnumerable <CloudJob> jobs = null;
if (filterByJobSchedule)
{
JobScheduleOperations jobScheduleOperations = options.Context.BatchOMClient.JobScheduleOperations;
jobs = jobScheduleOperations.ListJobs(jobScheduleId, listDetailLevel, options.AdditionalBehaviors);
}
else
{
JobOperations jobOperations = options.Context.BatchOMClient.JobOperations;
jobs = jobOperations.ListJobs(listDetailLevel, options.AdditionalBehaviors);
}
Func <CloudJob, PSCloudJob> mappingFunction = j => { return(new PSCloudJob(j)); };
return(PSPagedEnumerable <PSCloudJob, CloudJob> .CreateWithMaxCount(
jobs, mappingFunction, options.MaxCount, () => WriteVerbose(string.Format(Resources.MaxCount, options.MaxCount))));
}
}
internal AsyncListSubtasksEnumerator(
JobOperations parentJobOperations,
string jobId,
string taskId,
BehaviorManager behaviorMgr,
DetailLevel detailLevel)
{
_parentJobOperations = parentJobOperations;
_jobId = jobId;
_taskId = taskId;
_behaviorMgr = behaviorMgr;
_detailLevel = detailLevel;
}
/// <summary>
/// Enables the specified job.
/// </summary>
/// <param name="context">The account to use.</param>
/// <param name="jobId">The id of the job to enable.</param>
/// <param name="additionBehaviors">Additional client behaviors to perform.</param>
public void EnableJob(BatchAccountContext context, string jobId, IEnumerable <BatchClientBehavior> additionBehaviors = null)
{
if (string.IsNullOrWhiteSpace(jobId))
{
throw new ArgumentNullException("jobId");
}
WriteVerbose(string.Format(Resources.EnableJob, jobId));
JobOperations jobOperations = context.BatchOMClient.JobOperations;
jobOperations.EnableJob(jobId, additionBehaviors);
}
protected void ExecuteVMOperation(VMOperationsEnum operation)
{
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? job = null;
VirtualMachine virtualMachine = null;
switch (operation)
{
case VMOperationsEnum.Start:
virtualMachine = virtualMachineOperations.Start(VM.ID, out job);
break;
case VMOperationsEnum.Stop:
virtualMachine = virtualMachineOperations.Stop(VM.ID, out job);
break;
case VMOperationsEnum.Restart:
virtualMachine = virtualMachineOperations.Restart(VM.ID, out job);
break;
case VMOperationsEnum.Shutdown:
virtualMachine = virtualMachineOperations.Shutdown(VM.ID, out job);
break;
case VMOperationsEnum.Suspend:
virtualMachine = virtualMachineOperations.Suspend(VM.ID, out job);
break;
case VMOperationsEnum.Resume:
virtualMachine = virtualMachineOperations.Resume(VM.ID, out job);
break;
}
if (!job.HasValue)
{
throw new WAPackOperationException(String.Format(Resources.OperationFailedErrorMessage, operation, VM.ID));
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(job.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
if (PassThru)
{
var updatedVMObject = virtualMachineOperations.Read(virtualMachine.ID);
WriteObject(updatedVMObject);
}
}
protected void ExecuteVMOperation(VMOperationsEnum operation)
{
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? job = null;
VirtualMachine virtualMachine = null;
switch (operation)
{
case VMOperationsEnum.Start:
virtualMachine = virtualMachineOperations.Start(VM.ID, out job);
break;
case VMOperationsEnum.Stop:
virtualMachine = virtualMachineOperations.Stop(VM.ID, out job);
break;
case VMOperationsEnum.Restart:
virtualMachine = virtualMachineOperations.Restart(VM.ID, out job);
break;
case VMOperationsEnum.Shutdown:
virtualMachine = virtualMachineOperations.Shutdown(VM.ID, out job);
break;
case VMOperationsEnum.Suspend:
virtualMachine = virtualMachineOperations.Suspend(VM.ID, out job);
break;
case VMOperationsEnum.Resume:
virtualMachine = virtualMachineOperations.Resume(VM.ID, out job);
break;
}
if (!job.HasValue)
{
throw new WAPackOperationException(String.Format(Resources.OperationFailedErrorMessage, operation, VM.ID));
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(job.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
if (PassThru)
{
var updatedVMObject = virtualMachineOperations.Read(virtualMachine.ID);
WriteObject(updatedVMObject);
}
}
public void WaitOnJobCompletesImmediately()
{
Guid jobId = Guid.NewGuid();
MockRequestChannel mockChannel = MockRequestChannel.Create();
mockChannel.AddReturnObject(new Job {Name = "TestJob", ID = jobId, IsCompleted = true});
var jobOperations = new JobOperations(new WebClientFactory(
new Subscription(),
mockChannel));
DateTime start = DateTime.Now;
jobOperations.WaitOnJob(jobId);
Assert.True((DateTime.Now - start).TotalMilliseconds < 500);
}
public void ShouldReturnJobNotFoundOnNonexistantJob()
{
Guid jobId = Guid.NewGuid();
MockRequestChannel mockChannel = MockRequestChannel.Create();
var jobOperations = new JobOperations(new WebClientFactory(
new Subscription(),
mockChannel));
var result = jobOperations.WaitOnJob(jobId);
Assert.Equal(JobStatusEnum.JobNotFound, result.jobStatus);
}
/// <summary>
/// Lists the tasks matching the specified filter options.
/// </summary>
/// <param name="options">The options to use when querying for tasks.</param>
/// <returns>The tasks matching the specified filter options.</returns>
public IEnumerable <PSCloudTask> ListTasks(ListTaskOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
// Get the single task matching the specified id
if (!string.IsNullOrEmpty(options.TaskId))
{
WriteVerbose(string.Format(Resources.GetTaskById, options.TaskId, options.JobId));
JobOperations jobOperations = options.Context.BatchOMClient.JobOperations;
ODATADetailLevel getDetailLevel = new ODATADetailLevel(selectClause: options.Select, expandClause: options.Expand);
CloudTask task = jobOperations.GetTask(options.JobId, options.TaskId, detailLevel: getDetailLevel, additionalBehaviors: options.AdditionalBehaviors);
PSCloudTask psTask = new PSCloudTask(task);
return(new PSCloudTask[] { psTask });
}
// List tasks using the specified filter
else
{
string jobId = options.Job == null ? options.JobId : options.Job.Id;
string verboseLogString = null;
ODATADetailLevel listDetailLevel = new ODATADetailLevel(selectClause: options.Select, expandClause: options.Expand);
if (!string.IsNullOrEmpty(options.Filter))
{
verboseLogString = string.Format(Resources.GetTaskByOData, jobId);
listDetailLevel.FilterClause = options.Filter;
}
else
{
verboseLogString = string.Format(Resources.GetTaskNoFilter, jobId);
}
WriteVerbose(verboseLogString);
IPagedEnumerable <CloudTask> tasks = null;
if (options.Job != null)
{
tasks = options.Job.omObject.ListTasks(listDetailLevel, options.AdditionalBehaviors);
}
else
{
JobOperations jobOperations = options.Context.BatchOMClient.JobOperations;
tasks = jobOperations.ListTasks(options.JobId, listDetailLevel, options.AdditionalBehaviors);
}
Func <CloudTask, PSCloudTask> mappingFunction = t => { return(new PSCloudTask(t)); };
return(PSPagedEnumerable <PSCloudTask, CloudTask> .CreateWithMaxCount(
tasks, mappingFunction, options.MaxCount, () => WriteVerbose(string.Format(Resources.MaxCount, options.MaxCount))));
}
}
internal AsyncListNodeFilesByTaskEnumerator(
JobOperations jobOperations,
string jobId,
string taskId,
bool?recursive,
BehaviorManager behaviorMgr,
DetailLevel detailLevel)
{
this._jobOperations = jobOperations;
this._jobId = jobId;
this._taskId = taskId;
this._recursive = recursive;
this._behaviorMgr = behaviorMgr;
this._detailLevel = detailLevel;
}
/// <summary>
/// Terminates the specified job.
/// </summary>
/// <param name="parameters">Specifies the job to terminate as well as the terminate reason.</param>
public void TerminateJob(TerminateJobParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
string jobId = parameters.Job == null ? parameters.JobId : parameters.Job.Id;
WriteVerbose(string.Format(Resources.TerminateJob, jobId));
JobOperations jobOperations = parameters.Context.BatchOMClient.JobOperations;
jobOperations.TerminateJob(jobId, parameters.TerminateReason, parameters.AdditionalBehaviors);
}
/// <summary>
/// Deletes the specified task.
/// </summary>
/// <param name="parameters">The parameters indicating which task to delete.</param>
public void DeleteTask(TaskOperationParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (parameters.Task != null)
{
parameters.Task.omObject.Delete(parameters.AdditionalBehaviors);
}
else
{
JobOperations jobOperations = parameters.Context.BatchOMClient.JobOperations;
jobOperations.DeleteTask(parameters.JobId, parameters.TaskId, parameters.AdditionalBehaviors);
}
}
/// <summary>
/// Initializes client properties.
/// </summary>
private void Initialize()
{
Application = new ApplicationOperations(this);
Pool = new PoolOperations(this);
Account = new AccountOperations(this);
Job = new JobOperations(this);
Certificate = new CertificateOperations(this);
File = new FileOperations(this);
JobSchedule = new JobScheduleOperations(this);
Task = new TaskOperations(this);
ComputeNode = new ComputeNodeOperations(this);
ComputeNodeExtension = new ComputeNodeExtensionOperations(this);
BaseUri = "{batchUrl}";
ApiVersion = "2021-06-01.14.0";
AcceptLanguage = "en-US";
LongRunningOperationRetryTimeout = 30;
GenerateClientRequestId = true;
SerializationSettings = new JsonSerializerSettings
{
Formatting = Newtonsoft.Json.Formatting.Indented,
DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter()
}
};
DeserializationSettings = new JsonSerializerSettings
{
DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat,
DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize,
ContractResolver = new ReadOnlyJsonContractResolver(),
Converters = new List <JsonConverter>
{
new Iso8601TimeSpanConverter()
}
};
CustomInitialize();
DeserializationSettings.Converters.Add(new CloudErrorJsonConverter());
}
public void WaitOnJobCompletesImmediately()
{
Guid jobId = Guid.NewGuid();
MockRequestChannel mockChannel = MockRequestChannel.Create();
mockChannel.AddReturnObject(new Job {
Name = "TestJob", ID = jobId, IsCompleted = true
});
var jobOperations = new JobOperations(new WebClientFactory(
new Subscription(),
mockChannel));
DateTime start = DateTime.Now;
jobOperations.WaitOnJob(jobId);
Assert.True((DateTime.Now - start).TotalMilliseconds < 500);
}
/// <summary>
/// Creates the AddTasks workflow manager with the specified arguments.
/// </summary>
/// <param name="jobOperations"></param>
/// <param name="jobId"></param>
/// <param name="parallelOptions">The parallel options associated with this operation. If this is null, the default is used.</param>
/// <param name="fileStagingArtifacts">File staging artifacts associated with this operation. If the customer does not set this, it is unviewable by them.</param>
/// <param name="bhMgr">The behavior manager.</param>
internal AddTasksWorkflowManager(
JobOperations jobOperations,
string jobId,
BatchClientParallelOptions parallelOptions,
ConcurrentBag <ConcurrentDictionary <Type, IFileStagingArtifact> > fileStagingArtifacts,
BehaviorManager bhMgr)
{
//
// Setup some defaults for the parameters if they were null
//
if (parallelOptions == null)
{
parallelOptions = new BatchClientParallelOptions();
}
//
// Set up the data structures associated with this workflow
//
this._jobOperations = jobOperations;
this._jobId = jobId;
this._remainingTasksToAdd = new ConcurrentQueue <TrackedCloudTask>();
this._addTaskResultHandlerCollection = new List <Func <AddTaskResult, CancellationToken, AddTaskResultStatus> >();
this._parallelOptions = parallelOptions;
this._pendingAsyncOperations = new List <Task>();
this._customerVisibleFileStagingArtifacts = fileStagingArtifacts ?? new ConcurrentBag <ConcurrentDictionary <Type, IFileStagingArtifact> >();
this._behaviorManager = bhMgr;
this._maxTasks = Constants.MaxTasksInSingleAddTaskCollectionRequest;
this._hasRun = HasNotRun; //Has not run by default
//Read the behavior manager and populate the collection
List <AddTaskCollectionResultHandler> behaviorList = this._behaviorManager.GetBehaviors <AddTaskCollectionResultHandler>();
foreach (AddTaskCollectionResultHandler handler in behaviorList)
{
this._addTaskResultHandlerCollection.Add(handler.ResultHandler);
}
//Validation that there is a handler for AddTaskResult
if (this._addTaskResultHandlerCollection.Count == 0)
{
throw new BatchClientException(
string.Format(CultureInfo.InvariantCulture, BatchErrorMessages.GeneralBehaviorMissing, typeof(AddTaskCollectionResultHandler)));
}
}
public void WaitOnJobTimeoutJobNotFinished()
{
Guid jobId = Guid.NewGuid();
MockRequestChannel mockChannel = MockRequestChannel.Create();
mockChannel.AddReturnObject(new Job { Name = "TestJob", ID = jobId, IsCompleted = false, Status = "Running" });
mockChannel.AddReturnObject(new Job { Name = "TestJob", ID = jobId, IsCompleted = false, Status = "Running" });
mockChannel.AddReturnObject(new Job { Name = "TestJob", ID = jobId, IsCompleted = false, Status = "Running" });
mockChannel.AddReturnObject(new Job { Name = "TestJob", ID = jobId, IsCompleted = false, Status = "Running" });
mockChannel.AddReturnObject(new Job { Name = "TestJob", ID = jobId, IsCompleted = false, Status = "Running" });
mockChannel.AddReturnObject(new Job { Name = "TestJob", ID = jobId, IsCompleted = false, Status = "Running" });
mockChannel.AddReturnObject(new Job { Name = "TestJob", ID = jobId, IsCompleted = false, Status = "Running" });
var jobOperations = new JobOperations(new WebClientFactory(
new Subscription(),
mockChannel));
DateTime start = DateTime.Now;
var result = jobOperations.WaitOnJob(jobId, 6000);
var diff = (DateTime.Now - start).TotalMilliseconds;
Assert.True(diff > 6000);
Assert.Equal(JobStatusEnum.OperationTimedOut, result.jobStatus);
}
public void ShouldReturnJobNotFoundOnNonexistantJob()
{
Guid jobId = Guid.NewGuid();
MockRequestChannel mockChannel = MockRequestChannel.Create();
var jobOperations = new JobOperations(new WebClientFactory(
new Subscription(),
mockChannel));
var result = jobOperations.WaitOnJob(jobId);
Assert.Equal(JobStatusEnum.JobNotFound, result.jobStatus);
}
/// <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;
}
internal JobInfo WaitForJobCompletion(Guid? job)
{
JobInfo jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(job.Value);
if (jobInfo.jobStatus != JobStatusEnum.CompletedSuccessfully)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
return jobInfo;
}
public override void ExecuteCmdlet()
{
VirtualMachine newVirtualMachine = null;
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? jobId = Guid.Empty;
var virtualNetworkAdaptersWithVNet = this.CustomizeVnaInput();
if (this.ParameterSetName == WAPackCmdletParameterSets.CreateWindowsVMFromTemplate)
{
newVirtualMachine = new VirtualMachine()
{
Name = Name,
VMTemplateId = Template.ID,
LocalAdminUserName = VMCredential.UserName,
LocalAdminPassword = ExtractSecureString(VMCredential.Password),
NewVirtualNetworkAdapterInput = virtualNetworkAdaptersWithVNet,
ProductKey = ProductKey,
};
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.CreateLinuxVMFromTemplate)
{
newVirtualMachine = new VirtualMachine()
{
Name = Name,
VMTemplateId = Template.ID,
LocalAdminUserName = VMCredential.UserName,
LocalAdminPassword = ExtractSecureString(VMCredential.Password),
NewVirtualNetworkAdapterInput = virtualNetworkAdaptersWithVNet,
LinuxAdministratorSSHKeyString = AdministratorSSHKey
};
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.CreateVMFromOSDisks)
{
newVirtualMachine = new VirtualMachine()
{
Name = Name,
HardwareProfileId = VMSizeProfile.ID,
VirtualHardDiskId = OSDisk.ID,
NewVirtualNetworkAdapterInput = virtualNetworkAdaptersWithVNet
};
}
var createdVirtualMachine = virtualMachineOperations.Create(newVirtualMachine, out jobId);
if (!jobId.HasValue)
{
throw new WAPackOperationException(Resources.CreateFailedErrorMessage);
}
var jobInfo = new JobOperations(this.WebClientFactory).WaitOnJob(jobId.Value);
if (jobInfo.jobStatus == JobStatusEnum.Failed)
{
this.WriteErrorDetails(new Exception(jobInfo.errorMessage));
}
createdVirtualMachine = virtualMachineOperations.Read(createdVirtualMachine.ID);
WriteObject(createdVirtualMachine);
}
