public async Task Exists()
{
var vmName = Recording.GenerateAssetName("testvm");
var _virtualMachineCollection = await GetVirtualMachineCollectionAsync();
var _extendedLocation = new ExtendedLocation()
{
Name = CustomLocationId,
ExtendedLocationType = EXTENDED_LOCATION_TYPE
};
var _placementProfile = new PlacementProfile()
{
ResourcePoolId = _resourcePoolId
};
var virtualMachineBody = new VirtualMachineData(DefaultLocation);
virtualMachineBody.VCenterId = VcenterId;
virtualMachineBody.ExtendedLocation = _extendedLocation;
virtualMachineBody.PlacementProfile = _placementProfile;
virtualMachineBody.TemplateId = _vmTemplateId;
// create virtual machine
VirtualMachine vm1 = (await _virtualMachineCollection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, virtualMachineBody)).Value;
Assert.IsNotNull(vm1);
Assert.AreEqual(vm1.Id.Name, vmName);
// check for exists virtual machine
vm1 = await _virtualMachineCollection.GetIfExistsAsync(vmName);
Assert.AreEqual(vm1.Id.Name, vmName);
}
VirtualMachine IOperationSource <VirtualMachine> .CreateResult(Response response, CancellationToken cancellationToken)
{
using var document = JsonDocument.Parse(response.ContentStream);
var data = VirtualMachineData.DeserializeVirtualMachineData(document.RootElement);
return(new VirtualMachine(_armClient, data));
}
public async Task GetAll()
{
var vmName = Recording.GenerateAssetName("testvm");
var _virtualMachineCollection = await GetVirtualMachineCollectionAsync();
var _extendedLocation = new ExtendedLocation()
{
Name = CustomLocationId,
Type = EXTENDED_LOCATION_TYPE
};
var _placementProfile = new PlacementProfile()
{
ResourcePoolId = _resourcePoolId
};
var virtualMachineBody = new VirtualMachineData(DefaultLocation);
virtualMachineBody.VCenterId = VcenterId;
virtualMachineBody.ExtendedLocation = _extendedLocation;
virtualMachineBody.PlacementProfile = _placementProfile;
virtualMachineBody.TemplateId = _vmTemplateId;
// create virtual machine
VirtualMachine vm1 = (await _virtualMachineCollection.CreateOrUpdateAsync(true, vmName, virtualMachineBody)).Value;
Assert.IsNotNull(vm1);
Assert.AreEqual(vm1.Id.Name, vmName);
int count = 0;
await foreach (var vm in _virtualMachineCollection.GetAllAsync())
{
count++;
}
Assert.GreaterOrEqual(count, 1);
}
internal static VirtualMachinesList DeserializeVirtualMachinesList(JsonElement element)
{
Optional <string> nextLink = default;
IReadOnlyList <VirtualMachineData> value = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
if (property.NameEquals("value"))
{
List <VirtualMachineData> array = new List <VirtualMachineData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(VirtualMachineData.DeserializeVirtualMachineData(item));
}
value = array;
continue;
}
}
return(new VirtualMachinesList(nextLink.Value, value));
}
public async Task NewCode()
{
#endif
var armClient = new ArmClient(new DefaultAzureCredential());
var location = AzureLocation.WestUS;
// Create ResourceGroup
Subscription subscription = await armClient.GetDefaultSubscriptionAsync();
ArmOperation<ResourceGroup> rgOperation = await subscription.GetResourceGroups().CreateOrUpdateAsync(WaitUntil.Completed, "myResourceGroup", new ResourceGroupData(location));
ResourceGroup resourceGroup = rgOperation.Value;
// Create AvailabilitySet
var availabilitySetData = new AvailabilitySetData(location)
{
PlatformUpdateDomainCount = 5,
PlatformFaultDomainCount = 2,
Sku = new ComputeSku() { Name = "Aligned" }
};
ArmOperation<AvailabilitySet> asetOperation = await resourceGroup.GetAvailabilitySets().CreateOrUpdateAsync(WaitUntil.Completed, "myAvailabilitySet", availabilitySetData);
AvailabilitySet availabilitySet = asetOperation.Value;
// Create VNet
var vnetData = new VirtualNetworkData()
{
Location = location,
Subnets =
{
new SubnetData()
{
Name = "mySubnet",
AddressPrefix = "10.0.0.0/24",
}
},
};
vnetData.AddressPrefixes.Add("10.0.0.0/16");
ArmOperation<VirtualNetwork> vnetOperation = await resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(WaitUntil.Completed, "myVirtualNetwork", vnetData);
VirtualNetwork vnet = vnetOperation.Value;
// Create Network interface
var nicData = new NetworkInterfaceData()
{
Location = location,
IPConfigurations =
{
new NetworkInterfaceIPConfigurationData()
{
Name = "Primary",
Primary = true,
Subnet = new SubnetData() { Id = vnet.Data.Subnets.First().Id },
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
}
}
};
ArmOperation<NetworkInterface> nicOperation = await resourceGroup.GetNetworkInterfaces().CreateOrUpdateAsync(WaitUntil.Completed, "myNetworkInterface", nicData);
NetworkInterface nic = nicOperation.Value;
var vmData = new VirtualMachineData(location)
{
AvailabilitySet = new WritableSubResource() { Id = availabilitySet.Id },
NetworkProfile = new Compute.Models.NetworkProfile { NetworkInterfaces = { new NetworkInterfaceReference() { Id = nic.Id } } },
OSProfile = new OSProfile
{
ComputerName = "testVM",
AdminUsername = "******",
AdminPassword = "******",
LinuxConfiguration = new LinuxConfiguration { DisablePasswordAuthentication = false, ProvisionVmAgent = true }
},
StorageProfile = new StorageProfile()
{
ImageReference = new ImageReference()
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "18.04-LTS",
Version = "latest"
}
},
HardwareProfile = new HardwareProfile() { VmSize = VirtualMachineSizeTypes.StandardB1Ms },
};
ArmOperation<VirtualMachine> vmOperation = await resourceGroup.GetVirtualMachines().CreateOrUpdateAsync(WaitUntil.Completed, "myVirtualMachine", vmData);
VirtualMachine vm = vmOperation.Value;
#endregion
}
public async Task CreateVirtualMachine()
{
#region Snippet:Managing_VirtualMachines_CreateAVirtualMachine
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
SubscriptionResource subscription = await armClient.GetDefaultSubscriptionAsync();
// first we need to get the resource group
string rgName = "myRgName";
ResourceGroupResource resourceGroup = await subscription.GetResourceGroups().GetAsync(rgName);
// Now we get the virtual machine collection from the resource group
VirtualMachineCollection vmCollection = resourceGroup.GetVirtualMachines();
// Use the same location as the resource group
string vmName = "myVM";
var input = new VirtualMachineData(resourceGroup.Data.Location)
{
HardwareProfile = new HardwareProfile()
{
VmSize = VirtualMachineSizeTypes.StandardF2
},
OSProfile = new OSProfile()
{
AdminUsername = "******",
ComputerName = "myVM",
LinuxConfiguration = new LinuxConfiguration()
{
DisablePasswordAuthentication = true,
SshPublicKeys =
{
new SshPublicKeyInfo()
{
Path = $"/home/adminUser/.ssh/authorized_keys",
KeyData = "<value of the public ssh key>",
}
}
}
},
NetworkProfile = new NetworkProfile()
{
NetworkInterfaces =
{
new NetworkInterfaceReference()
{
Id = new ResourceIdentifier("/subscriptions/<subscriptionId>/resourceGroups/<rgName>/providers/Microsoft.Network/networkInterfaces/<nicName>"),
Primary = true,
}
}
},
StorageProfile = new StorageProfile()
{
OSDisk = new OSDisk(DiskCreateOptionTypes.FromImage)
{
OSType = OperatingSystemTypes.Linux,
Caching = CachingTypes.ReadWrite,
ManagedDisk = new ManagedDiskParameters()
{
StorageAccountType = StorageAccountTypes.StandardLRS
}
},
ImageReference = new ImageReference()
{
Publisher = "Canonical",
Offer = "UbuntuServer",
Sku = "16.04-LTS",
Version = "latest",
}
}
};
ArmOperation <VirtualMachineResource> lro = await vmCollection.CreateOrUpdateAsync(WaitUntil.Completed, vmName, input);
VirtualMachineResource vm = lro.Value;
#endregion Snippet:Managing_VirtualMachines_CreateAVirtualMachine
}
public static void AssertVirtualMachine(VirtualMachineData vm1, VirtualMachineData vm2)
{
AssertTrackedResource(vm1, vm2);
// adding these checks one by one is so tedious, is there anything we can do about this?
}
public async Task MigrationExample()
{
#region Snippet:Construct_Client
ArmClient armClient = new ArmClient(new DefaultAzureCredential());
#endregion
#region Snippet:Create_ResourceGroup
Subscription subscription = armClient.DefaultSubscription;
ResourceGroupContainer rgContainer = subscription.GetResourceGroups();
Location location = Location.WestUS2;
string rgName = "QuickStartRG";
ResourceGroupData rgData = new ResourceGroupData(location);
ResourceGroupCreateOrUpdateOperation rgCreateLro = await rgContainer.CreateOrUpdateAsync(rgName, rgData);
ResourceGroup resourceGroup = rgCreateLro.Value;
#endregion
#region Snippet:Create_AvailabilitySet
string vmName = "quickstartvm";
AvailabilitySetData aSetData = new AvailabilitySetData(location);
AvailabilitySetCreateOrUpdateOperation asetCreateLro = await resourceGroup.GetAvailabilitySets().CreateOrUpdateAsync(vmName + "_aSet", aSetData);
AvailabilitySet aset = asetCreateLro.Value;
string asetId = aset.Id;
#endregion
#region Snippet:Create_Vnet_and_Subnet
string vnetName = "MYVM" + "_vnet";
string subnetName = "mySubnet";
AddressSpace addressSpace = new AddressSpace();
addressSpace.AddressPrefixes.Add("10.0.0.0/16");
VirtualNetworkData vnetData = new VirtualNetworkData()
{
AddressSpace = addressSpace,
Subnets =
{
new SubnetData()
{
Name = subnetName,
AddressPrefix = "10.0.0.0/24"
}
}
};
VirtualNetworkCreateOrUpdateOperation vnetCreateLro = await resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(vnetName, vnetData);
VirtualNetwork vnet = vnetCreateLro.Value;
#endregion
#region Snippet:Create_NetworkSecurityGroup
string nsgName = vmName + "_nsg";
NetworkSecurityGroupData nsgData = new NetworkSecurityGroupData()
{
Location = location
};
NetworkSecurityGroupCreateOrUpdateOperation nsgCreateLro = await resourceGroup.GetNetworkSecurityGroups().CreateOrUpdateAsync(nsgName, nsgData);
NetworkSecurityGroup nsg = nsgCreateLro.Value;
#endregion
#region Snippet:Create_NetworkInterface
string nicName = vmName + "_nic";
NetworkInterfaceIPConfiguration nicIPConfig = new NetworkInterfaceIPConfiguration()
{
Name = "Primary",
Primary = true,
Subnet = new SubnetData()
{
Id = vnet.Data.Subnets.First().Id
},
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
};
NetworkInterfaceData nicData = new NetworkInterfaceData();
nicData.Location = location;
nicData.IpConfigurations.Add(nicIPConfig);
NetworkInterfaceCreateOrUpdateOperation nicCreateLro = await resourceGroup.GetNetworkInterfaces().CreateOrUpdateAsync(nicName, nicData);
NetworkInterface nic = nicCreateLro.Value;
#endregion
#region Snippet:Create_VirtualMachine
VirtualMachineData vmData = new VirtualMachineData(location);
vmData.OsProfile.AdminUsername = "******";
vmData.OsProfile.AdminPassword = "******";
vmData.OsProfile.ComputerName = "computer-name";
vmData.AvailabilitySet = new Compute.Models.SubResource();
vmData.AvailabilitySet.Id = aset.Id;
NetworkInterfaceReference nicReference = new NetworkInterfaceReference();
nicReference.Id = nic.Id;
vmData.NetworkProfile.NetworkInterfaces.Add(nicReference);
VirtualMachine vm = (await resourceGroup.GetVirtualMachines().CreateOrUpdateAsync(vmName, vmData)).Value;
Console.WriteLine("VM ID: " + vm.Id);
#endregion
}
private void RefreshGrid()
{
if (vm_GridView.InvokeRequired) //Make sure we're on the UI thread
{
vm_GridView.Invoke(new MethodInvoker(this.RefreshGrid));
}
else
{
lock (this)
{
try
{
// Store the current location so we can restore it
int currentLocation = vm_GridView.SelectedRows.Any() ? vm_GridView.SelectedRows[0].Index : 0;
vm_GridView.DataSource = null;
_machineData.Clear();
foreach (var item in VirtualMachine.SelectVirtualMachineSessionInfo())
{
VirtualMachineData data = new VirtualMachineData()
{
HoldId = GetProperty(item, "HoldId"),
Name = GetProperty(item, "Name"),
LastUpdated = GetProperty(item, "LastUpdated"),
Owner = GetProperty(item, "Owner"),
PlatformUsage = GetProperty(item, "PlatformUsage"),
PowerState = GetProperty(item, "PowerState"),
SessionId = GetProperty(item, "SessionId"),
SortOrder = GetProperty(item, "SortOrder"),
StartDate = GetProperty(item, "StartDate"),
Status = GetProperty(item, "Status"),
UsageState = GetProperty(item, "UsageState"),
Environment = GetProperty(item, "Environment")
};
_machineData.Add(data);
}
vm_GridView.DataSource = _machineData;
Task.Factory.StartNew(UpdateRowColor);
//Restore the current location
if (vm_GridView.Rows.Any())
{
if (vm_GridView.Rows.Count <= currentLocation)
{
currentLocation = vm_GridView.Rows.Count - 1;
}
vm_GridView.TableElement.ScrollToRow(currentLocation);
vm_GridView.Rows[currentLocation].IsCurrent = true;
}
}
catch //Intentionally left blank. We don't want any exceptions crashing the process.
{
}
}
}
}
// TODO: GENERATOR Update Builder after models are incorporated in generated models
internal VirtualMachineModelBuilder(VirtualMachineContainer containerOperations, VirtualMachineData vm) : base(containerOperations, vm)
{
// _model.Name = vmName;
//_model = new VirtualMachine(location);
}
public async Task MigrationExample()
{
#region Snippet:Construct_Client
ArmClient client = new ArmClient(new DefaultAzureCredential());
#endregion
#region Snippet:Create_ResourceGroup
Subscription subscription = await client.GetDefaultSubscriptionAsync();
ResourceGroupCollection resourceGroups = subscription.GetResourceGroups();
AzureLocation location = AzureLocation.WestUS2;
string resourceGroupName = "QuickStartRG";
ResourceGroupData resourceGroupData = new ResourceGroupData(location);
ArmOperation <ResourceGroup> resourceGroupOperation = await resourceGroups.CreateOrUpdateAsync(WaitUntil.Completed, resourceGroupName, resourceGroupData);
ResourceGroup resourceGroup = resourceGroupOperation.Value;
#endregion
#region Snippet:Create_AvailabilitySet
string virtualMachineName = "quickstartvm";
AvailabilitySetData availabilitySetData = new AvailabilitySetData(location);
AvailabilitySetCollection availabilitySets = resourceGroup.GetAvailabilitySets();
ArmOperation <AvailabilitySet> availabilitySetOperation = await availabilitySets.CreateOrUpdateAsync(WaitUntil.Completed, virtualMachineName + "_aSet", availabilitySetData);
AvailabilitySet availabilitySet = availabilitySetOperation.Value;
#endregion
#region Snippet:Create_Vnet_and_Subnet
string virtualNetworkName = "MYVM" + "_vnet";
string subnetName = "mySubnet";
VirtualNetworkData virtualNetworkData = new VirtualNetworkData()
{
Subnets =
{
new SubnetData()
{
Name = subnetName,
AddressPrefix = "10.0.0.0/24"
}
}
};
VirtualNetworkCollection virtualNetworks = resourceGroup.GetVirtualNetworks();
virtualNetworkData.AddressPrefixes.Add("10.0.0.0/16");
ArmOperation <VirtualNetwork> virtualNetworkOperation = await virtualNetworks.CreateOrUpdateAsync(WaitUntil.Completed, virtualNetworkName, virtualNetworkData);
VirtualNetwork virtualNetwork = virtualNetworkOperation.Value;
#endregion
#region Snippet:Create_NetworkSecurityGroup
string networkSecurityGroupName = virtualMachineName + "_nsg";
NetworkSecurityGroupData networkSecurityGroupData = new NetworkSecurityGroupData()
{
Location = location
};
NetworkSecurityGroupCollection networkSecurityGroups = resourceGroup.GetNetworkSecurityGroups();
ArmOperation <NetworkSecurityGroup> networkSecurityGroupOperation = await networkSecurityGroups.CreateOrUpdateAsync(WaitUntil.Completed, networkSecurityGroupName, networkSecurityGroupData);
NetworkSecurityGroup networkSecurityGroup = networkSecurityGroupOperation.Value;
#endregion
#region Snippet:Create_NetworkInterface
string networkInterfaceName = virtualMachineName + "_nic";
NetworkInterfaceIPConfigurationData networkInterfaceIPConfiguration = new NetworkInterfaceIPConfigurationData()
{
Name = "Primary",
Primary = true,
Subnet = new SubnetData()
{
Id = virtualNetwork.Data.Subnets.First().Id
},
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
};
NetworkInterfaceData nicData = new NetworkInterfaceData();
nicData.Location = location;
nicData.IPConfigurations.Add(networkInterfaceIPConfiguration);
NetworkInterfaceCollection networkInterfaces = resourceGroup.GetNetworkInterfaces();
ArmOperation <NetworkInterface> networkInterfaceOperation = await networkInterfaces.CreateOrUpdateAsync(WaitUntil.Completed, networkInterfaceName, nicData);
NetworkInterface networkInterface = networkInterfaceOperation.Value;
#endregion
#region Snippet:Create_VirtualMachine
VirtualMachineData virutalMachineData = new VirtualMachineData(location);
virutalMachineData.OSProfile.AdminUsername = "******";
virutalMachineData.OSProfile.AdminPassword = "******";
virutalMachineData.OSProfile.ComputerName = "computer-name";
virutalMachineData.AvailabilitySetId = availabilitySet.Id;
NetworkInterfaceReference nicReference = new NetworkInterfaceReference();
nicReference.Id = networkInterface.Id;
virutalMachineData.NetworkProfile.NetworkInterfaces.Add(nicReference);
VirtualMachineCollection virtualMachines = resourceGroup.GetVirtualMachines();
ArmOperation <VirtualMachine> virtualMachineOperation = await virtualMachines.CreateOrUpdateAsync(WaitUntil.Completed, virtualMachineName, virutalMachineData);
VirtualMachine virtualMachine = virtualMachineOperation.Value;
Console.WriteLine("VM ID: " + virtualMachine.Id);
#endregion
}
/// <summary>
/// Initializes a new instance of the <see cref="VirtualMachineModelBuilder"/> class.
/// </summary>
/// <param name="containerOperations"> The container to create the virtual machine in. </param>
/// <param name="vm"> The data model representing the virtual machine to create. </param>
public VirtualMachineModelBuilder(VirtualMachineContainer containerOperations, VirtualMachineData vm) : base(containerOperations, vm)
{
// TODO: GENERATOR Update Builder after models are incorporated in generated models
// _model.Name = vmName;
//_model = new VirtualMachine(location);
}
async Task <OneFuzzResultVoid> CreateVm(
string name,
string location,
string vmSku,
string image,
string password,
string sshPublicKey,
Nsg?nsg,
IDictionary <string, string>?tags
)
{
var resourceGroup = _context.Creds.GetBaseResourceGroup();
_logTracer.Info($"creating vm {resourceGroup}:{location}:{name}");
var nic = await _context.IpOperations.GetPublicNic(resourceGroup, name);
if (nic == null)
{
var result = await _context.IpOperations.CreatePublicNic(resourceGroup, name, location, nsg);
if (!result.IsOk)
{
return(result);
}
_logTracer.Info("waiting on nic creation");
return(OneFuzzResultVoid.Ok);
}
// when public nic is created, VNET must exist at that point
// this is logic of get_public_nic function
if (nsg != null)
{
var result = await _context.NsgOperations.AssociateNic(nsg, nic);
if (!result.IsOk)
{
return(result);
}
}
var vmParams = new VirtualMachineData(location)
{
OSProfile = new OSProfile {
ComputerName = "node",
AdminUsername = "******",
},
HardwareProfile = new HardwareProfile {
VmSize = vmSku,
},
StorageProfile = new StorageProfile {
ImageReference = GenerateImageReference(image),
},
NetworkProfile = new NetworkProfile(),
};
vmParams.NetworkProfile.NetworkInterfaces.Add(new NetworkInterfaceReference {
Id = nic.Id
});
var imageOs = await _context.ImageOperations.GetOs(location, image);
if (!imageOs.IsOk)
{
return(OneFuzzResultVoid.Error(imageOs.ErrorV));
}
switch (imageOs.OkV)
{
case Os.Windows: {
vmParams.OSProfile.AdminPassword = password;
break;
}
case Os.Linux: {
vmParams.OSProfile.LinuxConfiguration = new LinuxConfiguration {
DisablePasswordAuthentication = true,
};
vmParams.OSProfile.LinuxConfiguration.SshPublicKeys.Add(
new SshPublicKeyInfo {
Path = "/home/onefuzz/.ssh/authorized_keys",
KeyData = sshPublicKey
}
);
break;
}
default: throw new NotSupportedException($"No support for OS type: {imageOs.OkV}");
}
var onefuzzOwner = _context.ServiceConfiguration.OneFuzzOwner;
if (!string.IsNullOrEmpty(onefuzzOwner))
{
vmParams.Tags.Add("OWNER", onefuzzOwner);
}
else
{
tags?.ToList()
.ForEach(kvp => {
if (!vmParams.Tags.TryAdd(kvp.Key, kvp.Value))
{
_logTracer.Warning($"Failed to add tag {kvp.Key}:{kvp.Value} to vm {name}");
}
});
}
try {
await _context.Creds.GetResourceGroupResource().GetVirtualMachines().CreateOrUpdateAsync(
WaitUntil.Started,
name,
vmParams
);
} catch (RequestFailedException ex) {
if (ex.ErrorCode == "ResourceNotFound" && ex.Message.Contains("The request failed due to conflict with a concurrent request"))
{
// _logTracer.Debug($"create VM had conflicts with concurrent request, ignoring {ex.ToString()}");
return(OneFuzzResultVoid.Ok);
}
return(OneFuzzResultVoid.Error(
ErrorCode.VM_CREATE_FAILED,
ex.ToString()
));
}
return(OneFuzzResultVoid.Ok);
}
