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()
{
IEnumerable <Utilities.WAPackIaaS.DataContract.VirtualMachine> results = null;
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
if (this.ParameterSetName == WAPackCmdletParameterSets.Empty)
{
results = virtualMachineOperations.Read();
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.FromId)
{
Utilities.WAPackIaaS.DataContract.VirtualMachine vm = null;
vm = virtualMachineOperations.Read(ID);
results = new List <Utilities.WAPackIaaS.DataContract.VirtualMachine>()
{
vm
};
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.FromName)
{
results = virtualMachineOperations.Read(Name);
}
this.GenerateCmdletOutput(results);
}
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 = WaitForJobCompletion(jobId);
if (PassThru)
{
WriteObject(jobInfo.jobStatus != JobStatusEnum.Failed);
}
});
}
public override void Execute()
{
var createMultipleVms = new CreateMultipleVms(Context);
createMultipleVms.Execute();
var rg = new AzureResourceManagerClient().ResourceGroup(Context.SubscriptionId, Context.RgName).Get().Value;
//set tags on random vms
Random rand = new Random(Environment.TickCount);
foreach (var generic in rg.VirtualMachines().ListByName(Environment.UserName))
{
var vm = VirtualMachineOperations.FromGeneric(generic);
if (rand.NextDouble() > 0.5)
{
Console.WriteLine("adding tag to {0}", vm.Id.Name);
vm.StartAddTag("tagkey", "tagvalue");
}
}
var filteredList = rg.VirtualMachines().List().Where(vm =>
{
string value;
return(vm.Data.Tags.TryGetValue("tagkey", out value) && value == "tagvalue");
});
foreach (var vm in filteredList)
{
Console.WriteLine("--------Stopping VM {0}--------", vm.Id.Name);
vm.PowerOff();
Console.WriteLine("--------Starting VM {0}--------", vm.Id.Name);
vm.PowerOn();
}
}
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,
LocalAdminUserName = VMCredential.UserName,
LocalAdminPassword = ExtractSecureString(VMCredential.Password),
};
pendingVirtualMachine = virtualMachineOperations.Create(newVirtualMachine, out jobId);
if (!jobId.HasValue)
{
throw new WAPackOperationException(Resources.CreateFailedErrorMessage);
}
WaitForJobCompletion(jobId);
var createdVM = virtualMachineOperations.Read(pendingVirtualMachine.ID);
WriteObject(createdVM);
}
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 async override void Execute()
{
#region SETUP
ScenarioContext[] contexts = new ScenarioContext[] { new ScenarioContext(), new ScenarioContext("c9cbd920-c00c-427c-852b-8aaf38badaeb") };
ParallelOptions options = new ParallelOptions
{
MaxDegreeOfParallelism = 1
};
Parallel.ForEach(contexts, options, context =>
{
var createMultipleVms = new CreateMultipleVms(context);
createMultipleVms.Execute();
});
#endregion
var client = new AzureResourceManagerClient();
foreach (var sub in client.Subscriptions().List())
{
await foreach (var armResource in sub.ListVirtualMachinesByNameAsync("even"))
{
var vmOperations = VirtualMachineOperations.FromGeneric(armResource);
Console.WriteLine($"Stopping {vmOperations.Id.Subscription} {vmOperations.Id.ResourceGroup} {vmOperations.Id.Name}");
vmOperations.PowerOff();
Console.WriteLine($"Starting {vmOperations.Id.Subscription} {vmOperations.Id.ResourceGroup} {vmOperations.Id.Name}");
vmOperations.PowerOn();
}
}
}
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);
}
});
}
public void DeleteVM()
{
var sub = new Subscription();
var channel = new MockRequestChannel();
//Response to client getting /Clouds (client needs stampId, gets it from clouds)
var testCloud = new Cloud {
ID = Guid.NewGuid(), StampId = Guid.NewGuid()
};
channel.AddReturnObject(testCloud);
//Response to the DELETE
channel.AddReturnObject(null, new WebHeaderCollection {
"x-ms-request-id:" + Guid.NewGuid()
});
var vmOps = new VirtualMachineOperations(new WebClientFactory(sub, channel));
Guid toDelete = Guid.NewGuid();
Guid?jobOut;
vmOps.Delete(toDelete, out jobOut);
//Check the requests the client generated
Assert.Equal(channel.ClientRequests.Count, 2);
Assert.Equal(channel.ClientRequests[1].Item1.Method, HttpMethod.Delete.ToString());
}
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 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);
}
WaitForJobCompletion(jobId);
var createdVM = virtualMachineOperations.Read(pendingVirtualMachine.ID);
WriteObject(createdVM);
}
public void ShouldThrowGetByIdNoResult()
{
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
MockRequestChannel.Create()));
Assert.Throws <WAPackOperationException>(() => vmOperations.Read(Guid.NewGuid()));
}
public void ShouldReturnEmptyOnNoResult()
{
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
MockRequestChannel.Create()));
Assert.False(vmOperations.Read().Any());
}
public void ShouldThrowGetByIdNoResult()
{
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
MockRequestChannel.Create()));
vmOperations.Read(Guid.NewGuid());
}
public void ShouldReturnEmptyOnNoResult()
{
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
MockRequestChannel.Create()));
Assert.IsFalse(vmOperations.Read().Any());
}
public async Task DeleteVirtualMachineAsync_ValidParameters()
{
IUKFastECloudClient client = Substitute.For <IUKFastECloudClient>();
var ops = new VirtualMachineOperations <VirtualMachine>(client);
await ops.DeleteVirtualMachineAsync(123);
await client.Received().DeleteAsync("/ecloud/v1/vms/123");
}
public async Task PowerRestartVirtualMachineAsync_ExpectedResult()
{
IUKFastECloudClient client = Substitute.For <IUKFastECloudClient>();
var ops = new VirtualMachineOperations <VirtualMachine>(client);
await ops.PowerRestartVirtualMachineAsync(123);
await client.Received().PutAsync("/ecloud/v1/vms/123/power-restart");
}
public void ShouldReturnOneVM()
{
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
MockRequestChannel.Create()
.AddReturnObject(new VirtualMachine { Name = "vm1", ID = Guid.NewGuid() })));
Assert.AreEqual(1, vmOperations.Read().Count);
}
public void CreateVMFromTemplate()
{
var mockChannel = new MockRequestChannel();
var testCloud = new Cloud {
ID = Guid.NewGuid(), StampId = Guid.NewGuid()
};
mockChannel.AddReturnObject(testCloud);
var vmToCreate = new VirtualMachine {
VMTemplateId = Guid.NewGuid(), Name = "Test"
};
var vmToReturn = new VirtualMachine
{
ID = Guid.NewGuid(),
Name = vmToCreate.Name,
CloudId = testCloud.ID,
StampId = testCloud.StampId
};
mockChannel.AddReturnObject(vmToReturn, new WebHeaderCollection {
"x-ms-request-id:" + Guid.NewGuid()
});
var vmOps = new VirtualMachineOperations(new WebClientFactory(new Subscription(), mockChannel));
Guid?jobOut;
var resultVM = vmOps.Create(vmToCreate, out jobOut);
//Check the results that client returns
Assert.NotNull(resultVM);
Assert.True(resultVM is VirtualMachine);
Assert.Equal(resultVM.ID, vmToReturn.ID);
Assert.Equal(resultVM.Name, vmToReturn.Name);
Assert.Equal(resultVM.CloudId, vmToReturn.CloudId);
Assert.Equal(resultVM.StampId, vmToReturn.StampId);
//Check the requests that the client made
var requestList = mockChannel.ClientRequests;
Assert.Equal(requestList.Count, 2);
Assert.Equal(requestList[1].Item1.Method, HttpMethod.Post.ToString());
Assert.True(requestList[1].Item1.RequestUri.ToString().TrimEnd(new[] { '/' }).EndsWith("/VirtualMachines"));
var sentVM = mockChannel.DeserializeClientPayload <VirtualMachine>(requestList[1].Item2);
Assert.NotNull(sentVM);
Assert.True(sentVM.Count == 1);
Assert.Equal(sentVM[0].CloudId, testCloud.ID);
Assert.Equal(sentVM[0].StampId, testCloud.StampId);
Assert.Equal(sentVM[0].Name, vmToCreate.Name);
Assert.Equal(sentVM[0].VMTemplateId, vmToCreate.VMTemplateId);
}
public void ShouldReturnOneVM()
{
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
MockRequestChannel.Create()
.AddReturnObject(new VirtualMachine {
Name = "vm1", ID = Guid.NewGuid()
})));
Assert.Equal(1, vmOperations.Read().Count);
}
public void ShouldReturnOneVMGetById()
{
var expectedVmId = Guid.NewGuid();
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
MockRequestChannel.Create()
.AddReturnObject(new VirtualMachine { Name = "vm1", ID = expectedVmId })));
var vm = vmOperations.Read(expectedVmId);
Assert.AreEqual(expectedVmId, vm.ID);
}
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 ShouldReturnOneVMGetById()
{
var expectedVmId = Guid.NewGuid();
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
MockRequestChannel.Create()
.AddReturnObject(new VirtualMachine {
Name = "vm1", ID = expectedVmId
})));
var vm = vmOperations.Read(expectedVmId);
Assert.Equal(expectedVmId, vm.ID);
}
public void VmUpdateShouldThrowWhenNoObjectReturned()
{
var mockChannel = new MockRequestChannel();
var vmOps = new VirtualMachineOperations(new WebClientFactory(new Subscription(), mockChannel));
var vmToUpdate = new VirtualMachine {
VirtualHardDiskId = Guid.NewGuid(), Name = "Test"
};
Guid?jobOut;
Assert.Throws <WAPackOperationException>(() => vmOps.Update(vmToUpdate, out jobOut));
}
public async Task UpdateVirtualMachineAsync_ExpectedResult()
{
UpdateVirtualMachineRequest req = new UpdateVirtualMachineRequest()
{
Name = "testvm"
};
IUKFastECloudClient client = Substitute.For <IUKFastECloudClient>();
var ops = new VirtualMachineOperations <VirtualMachine>(client);
await ops.UpdateVirtualMachineAsync(123, req);
await client.Received().PatchAsync("/ecloud/v1/vms/123", req);
}
public async Task GetVirtualMachineAsync_ValidParameters_ExpectedResult()
{
IUKFastECloudClient client = Substitute.For <IUKFastECloudClient>();
client.GetAsync <VirtualMachine>("/ecloud/v1/vms/123").Returns(new VirtualMachine()
{
ID = 123
});
var ops = new VirtualMachineOperations <VirtualMachine>(client);
var vm = await ops.GetVirtualMachineAsync(123);
Assert.AreEqual(123, vm.ID);
}
public async Task CreateVirtualMachineTemplateAsync_ExpectedResult()
{
CreateVirtualMachineTemplateRequest req = new CreateVirtualMachineTemplateRequest()
{
TemplateName = "testtemplate"
};
IUKFastECloudClient client = Substitute.For <IUKFastECloudClient>();
var ops = new VirtualMachineOperations <VirtualMachine>(client);
await ops.CreateVirtualMachineTemplateAsync(123, req);
await client.Received().PostAsync("/ecloud/v1/vms/123/clone-to-template", req);
}
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 async void ShutdownAsync()
{
var client = new AzureResourceManagerClient();
await foreach (var subscription in client.Subscriptions().ListAsync())
{
await foreach (var armResource in subscription.ListVirtualMachinesByNameAsync("even"))
{
var vmOperations = VirtualMachineOperations.FromGeneric(armResource);
await vmOperations.PowerOffAsync();
await vmOperations.PowerOnAsync();
}
}
}
public override void Execute()
{
var createMultipleVms = new CreateMultipleVms(Context);
createMultipleVms.Execute();
var sub = new AzureResourceManagerClient().GetSubscriptionOperations(Context.SubscriptionId);
foreach (var armResource in sub.ListVirtualMachinesByName("-e"))
{
var vmOperations = VirtualMachineOperations.FromGeneric(armResource);
Console.WriteLine($"Stopping {armResource.Id.ResourceGroup} : {armResource.Id.Name}");
vmOperations.PowerOff();
Console.WriteLine($"Starting {armResource.Id.ResourceGroup} : {armResource.Id.Name}");
vmOperations.PowerOn();
}
}
protected void ExecuteVMOperation(VMOperationsEnum operation)
{
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid?job = null;
Utilities.WAPackIaaS.DataContract.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));
}
WaitForJobCompletion(job);
if (PassThru)
{
var updatedVMObject = virtualMachineOperations.Read(virtualMachine.ID);
WriteObject(updatedVMObject);
}
}
protected void ExecuteVMOperation(VMOperationsEnum operation)
{
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? job = null;
Utilities.WAPackIaaS.DataContract.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));
}
WaitForJobCompletion(job);
if (PassThru)
{
var updatedVMObject = virtualMachineOperations.Read(virtualMachine.ID);
WriteObject(updatedVMObject);
}
}
public async Task GetVirtualMachinesAsync_ExpectedResult()
{
IUKFastECloudClient client = Substitute.For <IUKFastECloudClient>();
client.GetAllAsync(Arg.Any <UKFastClient.GetPaginatedAsyncFunc <VirtualMachine> >(), null).Returns(Task.Run <IList <VirtualMachine> >(() =>
{
return(new List <VirtualMachine>()
{
new VirtualMachine(),
new VirtualMachine()
});
}));
var ops = new VirtualMachineOperations <VirtualMachine>(client);
var vms = await ops.GetVirtualMachinesAsync();
Assert.AreEqual(2, vms.Count);
}
public async Task CreateVirtualMachineAsync_ExpectedResult()
{
CreateVirtualMachineRequest req = new CreateVirtualMachineRequest()
{
Template = "testtemplate"
};
IUKFastECloudClient client = Substitute.For <IUKFastECloudClient>();
client.PostAsync <VirtualMachine>("/ecloud/v1/vms", req).Returns(new VirtualMachine()
{
ID = 123
});
var ops = new VirtualMachineOperations <VirtualMachine>(client);
var vmID = await ops.CreateVirtualMachineAsync(req);
Assert.AreEqual(123, vmID);
}
public async Task CloneVirtualMachineAsync_ExpectedResult()
{
CloneVirtualMachineRequest req = new CloneVirtualMachineRequest()
{
Name = "testvm"
};
IUKFastECloudClient client = Substitute.For <IUKFastECloudClient>();
client.PostAsync <VirtualMachine>("/ecloud/v1/vms/123/clone", req).Returns(new VirtualMachine()
{
ID = 123
});
var ops = new VirtualMachineOperations <VirtualMachine>(client);
int vmID = await ops.CloneVirtualMachineAsync(123, req);
Assert.AreEqual(123, vmID);
}
public void VmCreateShouldThrowWhenNoObjectReturned()
{
var mockChannel = new MockRequestChannel();
var testCloud = new Cloud {
ID = Guid.NewGuid(), StampId = Guid.NewGuid()
};
mockChannel.AddReturnObject(testCloud);
var vmOps = new VirtualMachineOperations(new WebClientFactory(new Subscription(), mockChannel));
var vmToCreate = new VirtualMachine {
VirtualHardDiskId = Guid.NewGuid(), Name = "Test"
};
Guid?jobOut;
vmOps.Create(vmToCreate, out jobOut);
}
public void VmCreateShouldThrowIfNoVhdAndNoTemplateSupplied()
{
var channel = new MockRequestChannel();
var testCloud = new Cloud {
ID = Guid.NewGuid(), StampId = Guid.NewGuid()
};
channel.AddReturnObject(testCloud);
var sub = new Subscription();
var vmOps = new VirtualMachineOperations(new WebClientFactory(sub, channel));
var vmToCreate = new VirtualMachine {
Name = "Test"
};
Guid?jobOut;
Assert.Throws <WAPackOperationException>(() => vmOps.Create(vmToCreate, out jobOut));
}
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));
}
WaitForJobCompletion(jobId);
if (PassThru)
{
updatedVirtualMachine = virtualMachineOperations.Read(updatedVirtualMachine.ID);
WriteObject(updatedVirtualMachine);
}
}
public override void ExecuteCmdlet()
{
IEnumerable<Utilities.WAPackIaaS.DataContract.VirtualMachine> results = null;
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
if (this.ParameterSetName == WAPackCmdletParameterSets.Empty)
{
results = virtualMachineOperations.Read();
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.FromId)
{
Utilities.WAPackIaaS.DataContract.VirtualMachine vm = null;
vm = virtualMachineOperations.Read(ID);
results = new List<Utilities.WAPackIaaS.DataContract.VirtualMachine>() { vm };
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.FromName)
{
results = virtualMachineOperations.Read(Name);
}
this.GenerateCmdletOutput(results);
}
protected override void ExecuteCommand()
{
IEnumerable<VirtualMachine> results = null;
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
if (this.ParameterSetName == WAPackCmdletParameterSets.Empty)
{
results = virtualMachineOperations.Read();
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.FromId)
{
VirtualMachine vm = null;
vm = virtualMachineOperations.Read(ID);
results = new List<VirtualMachine>() { vm };
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.FromName)
{
results = virtualMachineOperations.Read(Name);
}
this.GenerateCmdletOutput(results);
}
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));
}
WaitForJobCompletion(jobId);
if (PassThru)
{
updatedVirtualMachine = virtualMachineOperations.Read(updatedVirtualMachine.ID);
WriteObject(updatedVirtualMachine);
}
}
public void ShouldReturnMultipleVMsGetByName()
{
const string expectedVmName = "myVM";
var expectedVmIds = new[] { Guid.NewGuid(), Guid.NewGuid() };
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
new MockRequestChannel()
.AddReturnObject(new List <object>
{
new VirtualMachine {
Name = expectedVmName, ID = expectedVmIds[1]
},
new VirtualMachine {
Name = expectedVmName, ID = expectedVmIds[0]
}
})));
var vmList = vmOperations.Read(expectedVmName);
Assert.Equal(expectedVmIds.Length, vmList.Count);
Assert.True(vmList.All(vm => vm.Name == expectedVmName));
Assert.Equal(expectedVmIds.OrderBy(g => g), vmList.Select(v => v.ID).OrderBy(g => g).ToArray());
}
protected override void ExecuteCommand()
{
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,
UserName = VMCredential.UserName,
Password = ExtractSecureString(VMCredential.Password),
NewVirtualNetworkAdapterInput = virtualNetworkAdaptersWithVNet,
ProductKey = ProductKey,
};
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.CreateLinuxVMFromTemplate)
{
newVirtualMachine = new VirtualMachine()
{
Name = Name,
VMTemplateId = Template.ID,
UserName = VMCredential.UserName,
Password = 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 override void ExecuteCmdlet()
{
Utilities.WAPackIaaS.DataContract.VirtualMachine newVirtualMachine = null;
var virtualMachineOperations = new VirtualMachineOperations(this.WebClientFactory);
Guid? jobId = Guid.Empty;
var virtualNetworkAdaptersWithVNet = this.CustomizeVnaInput();
if (this.ParameterSetName == WAPackCmdletParameterSets.CreateWindowsVMFromTemplate)
{
newVirtualMachine = new Utilities.WAPackIaaS.DataContract.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 Utilities.WAPackIaaS.DataContract.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 Utilities.WAPackIaaS.DataContract.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);
}
WaitForJobCompletion(jobId);
createdVirtualMachine = virtualMachineOperations.Read(createdVirtualMachine.ID);
WriteObject(createdVirtualMachine);
}
public void CreateVMFromTemplate()
{
var mockChannel = new MockRequestChannel();
var testCloud = new Cloud { ID = Guid.NewGuid(), StampId = Guid.NewGuid() };
mockChannel.AddReturnObject(testCloud);
var vmToCreate = new VirtualMachine { VMTemplateId = Guid.NewGuid(), Name = "Test" };
var vmToReturn = new VirtualMachine
{
ID = Guid.NewGuid(),
Name = vmToCreate.Name,
CloudId = testCloud.ID,
StampId = testCloud.StampId
};
mockChannel.AddReturnObject(vmToReturn, new WebHeaderCollection { "x-ms-request-id:" + Guid.NewGuid() });
var vmOps = new VirtualMachineOperations(new WebClientFactory(new Subscription(), mockChannel));
Guid? jobOut;
var resultVM = vmOps.Create(vmToCreate, out jobOut);
//Check the results that client returns
Assert.IsNotNull(resultVM);
Assert.IsInstanceOfType(resultVM, typeof(VirtualMachine));
Assert.AreEqual(resultVM.ID, vmToReturn.ID);
Assert.AreEqual(resultVM.Name, vmToReturn.Name);
Assert.AreEqual(resultVM.CloudId, vmToReturn.CloudId);
Assert.AreEqual(resultVM.StampId, vmToReturn.StampId);
//Check the requests that the client made
var requestList = mockChannel.ClientRequests;
Assert.AreEqual(requestList.Count, 2);
Assert.AreEqual(requestList[1].Item1.Method, HttpMethod.Post.ToString());
Assert.IsTrue(requestList[1].Item1.RequestUri.ToString().TrimEnd(new[] { '/' }).EndsWith("/VirtualMachines"));
var sentVM = mockChannel.DeserializeClientPayload<VirtualMachine>(requestList[1].Item2);
Assert.IsNotNull(sentVM);
Assert.IsTrue(sentVM.Count == 1);
Assert.AreEqual(sentVM[0].CloudId, testCloud.ID);
Assert.AreEqual(sentVM[0].StampId, testCloud.StampId);
Assert.AreEqual(sentVM[0].Name, vmToCreate.Name);
Assert.AreEqual(sentVM[0].VMTemplateId, vmToCreate.VMTemplateId);
}
public void ShouldReturnMultipleVMsGetByName()
{
const string expectedVmName = "myVM";
var expectedVmIds = new[] { Guid.NewGuid(), Guid.NewGuid() };
var vmOperations = new VirtualMachineOperations(new WebClientFactory(
new Subscription(),
new MockRequestChannel()
.AddReturnObject(new List<object>
{new VirtualMachine { Name = expectedVmName, ID = expectedVmIds[1] },
new VirtualMachine { Name = expectedVmName, ID = expectedVmIds[0] }})));
var vmList = vmOperations.Read(expectedVmName);
Assert.AreEqual(expectedVmIds.Length, vmList.Count);
Assert.IsTrue(vmList.All(vm => vm.Name == expectedVmName));
CollectionAssert.AreEquivalent(expectedVmIds, vmList.Select(v => v.ID).ToArray());
}
public void VmCreateShouldThrowIfNoVhdAndNoTemplateSupplied()
{
var channel = new MockRequestChannel();
var testCloud = new Cloud { ID = Guid.NewGuid(), StampId = Guid.NewGuid() };
channel.AddReturnObject(testCloud);
var sub = new Subscription();
var vmOps = new VirtualMachineOperations(new WebClientFactory(sub, channel));
var vmToCreate = new VirtualMachine {Name = "Test"};
Guid? jobOut;
vmOps.Create(vmToCreate, out jobOut);
}
public void VmCreateShouldThrowWhenNoObjectReturned()
{
var mockChannel = new MockRequestChannel();
var testCloud = new Cloud { ID = Guid.NewGuid(), StampId = Guid.NewGuid() };
mockChannel.AddReturnObject(testCloud);
var vmOps = new VirtualMachineOperations(new WebClientFactory(new Subscription(), mockChannel));
var vmToCreate = new VirtualMachine { VirtualHardDiskId = Guid.NewGuid(), Name = "Test" };
Guid? jobOut;
vmOps.Create(vmToCreate, out jobOut);
}
private static VirtualMachine InitVirtualMachineOperation(MockRequestChannel mockChannel, out VirtualMachineOperations vmOperations)
{
//Cloud for return value of first request (client gets cloud to get stampId)
var testCloud = new Cloud {ID = Guid.NewGuid(), StampId = Guid.NewGuid()};
mockChannel.AddReturnObject(testCloud);
//VM for return value of second request (client updates VM with operation)
var testVM = new VirtualMachine {ID = Guid.NewGuid(), StampId = testCloud.StampId};
mockChannel.AddReturnObject(testVM, new WebHeaderCollection {"x-ms-request-id:" + Guid.NewGuid()});
var factory = new WebClientFactory(new Subscription(), mockChannel);
vmOperations = new VirtualMachineOperations(factory);
return testVM;
}
public void VmUpdateShouldThrowWhenNoObjectReturned()
{
var mockChannel = new MockRequestChannel();
var vmOps = new VirtualMachineOperations(new WebClientFactory(new Subscription(), mockChannel));
var vmToUpdate = new VirtualMachine { VirtualHardDiskId = Guid.NewGuid(), Name = "Test" };
Guid? jobOut;
vmOps.Update(vmToUpdate, out jobOut);
}
public void DeleteVM()
{
var sub = new Subscription();
var channel = new MockRequestChannel();
//Response to client getting /Clouds (client needs stampId, gets it from clouds)
var testCloud = new Cloud { ID = Guid.NewGuid(), StampId = Guid.NewGuid() };
channel.AddReturnObject(testCloud);
//Response to the DELETE
channel.AddReturnObject(null, new WebHeaderCollection {"x-ms-request-id:" + Guid.NewGuid()});
var vmOps = new VirtualMachineOperations(new WebClientFactory(sub, channel));
Guid toDelete = Guid.NewGuid();
Guid? jobOut;
vmOps.Delete(toDelete, out jobOut);
//Check the requests the client generated
Assert.AreEqual(channel.ClientRequests.Count, 2);
Assert.AreEqual(channel.ClientRequests[1].Item1.Method, HttpMethod.Delete.ToString());
}
