public async Task <bool> DeleteDisk(string resourceGroup, string name)
{
try {
_logTracer.Info($"deleting disks {resourceGroup} : {name}");
var disk = await _creds.GetResourceGroupResource().GetDiskAsync(name);
if (disk != null)
{
await disk.Value.DeleteAsync(WaitUntil.Started);
return(true);
}
} catch (Exception e) {
_logTracer.Error($"unable to delete disk: {name} {e.Message}");
_logTracer.Exception(e);
}
return(false);
}
public async Task <OneFuzzResultVoid> CreateVirtualNetwork(string resourceGroup, string name, string region, NetworkConfig networkConfig)
{
_logTracer.Info($"creating subnet - resource group:{resourceGroup} name:{name} region: {region}");
var virtualNetParam = new VirtualNetworkData {
Location = region,
};
virtualNetParam.AddressPrefixes.Add(networkConfig.AddressSpace);
virtualNetParam.Subnets.Add(new SubnetData {
Name = name,
AddressPrefix = networkConfig.Subnet
}
);
var onefuzzOwner = _context.ServiceConfiguration.OneFuzzOwner;
if (!string.IsNullOrEmpty(onefuzzOwner))
{
if (!virtualNetParam.Tags.TryAdd("OWNER", onefuzzOwner))
{
_logTracer.Warning($"Failed to add tag 'OWNER':{onefuzzOwner} to virtual network {resourceGroup}:{name}");
}
}
try {
await _creds.GetResourceGroupResource().GetVirtualNetworks().CreateOrUpdateAsync(
WaitUntil.Started,
name,
virtualNetParam
);
} catch (RequestFailedException ex) {
_logTracer.Error($"network creation failed: {name}:{region} {{error}}");
return(OneFuzzResultVoid.Error(
ErrorCode.UNABLE_TO_CREATE_NETWORK,
ex.ToString()
));
}
return(OneFuzzResultVoid.Ok);
}
public async Async.Task <NetworkInterfaceResource> GetPublicNic(string resourceGroup, string name)
{
_logTracer.Info($"getting nic: {resourceGroup} {name}");
return(await _creds.GetResourceGroupResource().GetNetworkInterfaceAsync(name));
}
public async Async.Task <VirtualMachineResource?> GetVm(string name)
{
return(await _creds.GetResourceGroupResource().GetVirtualMachineAsync(name));
}
public async Async.Task <OneFuzzResultVoid> CreateVmss(
string location,
Guid name,
string vmSku,
long vmCount,
string image,
string networkId,
bool?spotInstance,
bool ephemeralOsDisks,
IList <VirtualMachineScaleSetExtensionData>?extensions,
string password,
string sshPublicKey,
IDictionary <string, string> tags)
{
var vmss = await GetVmss(name);
if (vmss is not null)
{
return(OneFuzzResultVoid.Ok);
}
_log.Info($"creating VM name: {name}, vm_sku: {vmSku}, vm_count: {vmCount}, image: {image}, subnet: {networkId}, spot_instance: {spotInstance}");
var getOsResult = await _imageOps.GetOs(location, image);
if (!getOsResult.IsOk)
{
return(getOsResult.ErrorV);
}
var vmssData = new VirtualMachineScaleSetData(location)
{
DoNotRunExtensionsOnOverprovisionedVms = false,
Sku = new ComputeSku()
{
Name = vmSku
},
Overprovision = false,
SinglePlacementGroup = false,
UpgradePolicy = new UpgradePolicy()
{
Mode = UpgradeMode.Manual
},
Identity = new ManagedServiceIdentity(managedServiceIdentityType: ManagedServiceIdentityType.UserAssigned),
};
vmssData.Identity.UserAssignedIdentities.Add(_creds.GetScalesetIdentityResourcePath(), new UserAssignedIdentity());
vmssData.VirtualMachineProfile = new VirtualMachineScaleSetVmProfile()
{
Priority = VirtualMachinePriorityTypes.Regular
};
var imageRef = new ImageReference();
if (image.StartsWith('/'))
{
imageRef.Id = image;
}
else
{
var info = IImageOperations.GetImageInfo(image);
imageRef.Publisher = info.Publisher;
imageRef.Offer = info.Offer;
imageRef.Sku = info.Sku;
imageRef.Version = info.Version;
}
vmssData.VirtualMachineProfile.StorageProfile = new VirtualMachineScaleSetStorageProfile()
{
ImageReference = imageRef
};
vmssData.VirtualMachineProfile.OSProfile = new VirtualMachineScaleSetOSProfile()
{
ComputerNamePrefix = "node", AdminUsername = "******"
};
var networkConfiguration = new VirtualMachineScaleSetNetworkConfiguration("onefuzz-nic")
{
Primary = true
};
var ipConfig = new VirtualMachineScaleSetIPConfiguration("onefuzz-ip-config");
ipConfig.SubnetId = new ResourceIdentifier(networkId);
networkConfiguration.IPConfigurations.Add(ipConfig);
vmssData.VirtualMachineProfile.NetworkProfile = new VirtualMachineScaleSetNetworkProfile();
vmssData.VirtualMachineProfile.NetworkProfile.NetworkInterfaceConfigurations.Add(networkConfiguration);
if (extensions is not null)
{
vmssData.VirtualMachineProfile.ExtensionProfile = new VirtualMachineScaleSetExtensionProfile();
foreach (var e in extensions)
{
vmssData.VirtualMachineProfile.ExtensionProfile.Extensions.Add(e);
}
}
switch (getOsResult.OkV)
{
case Os.Windows:
vmssData.VirtualMachineProfile.OSProfile.AdminPassword = password;
break;
case Os.Linux:
vmssData.VirtualMachineProfile.OSProfile.LinuxConfiguration = new LinuxConfiguration();
vmssData.VirtualMachineProfile.OSProfile.LinuxConfiguration.DisablePasswordAuthentication = true;
var i = new SshPublicKeyInfo()
{
KeyData = sshPublicKey, Path = "/home/onefuzz/.ssh/authorized_keys"
};
vmssData.VirtualMachineProfile.OSProfile.LinuxConfiguration.SshPublicKeys.Add(i);
break;
default:
return(OneFuzzResultVoid.Error(ErrorCode.INVALID_CONFIGURATION, $"unhandled OS: {getOsResult.OkV} in image: {image}"));
}
if (ephemeralOsDisks)
{
vmssData.VirtualMachineProfile.StorageProfile.OSDisk = new VirtualMachineScaleSetOSDisk(DiskCreateOptionTypes.FromImage);
vmssData.VirtualMachineProfile.StorageProfile.OSDisk.DiffDiskSettings = new DiffDiskSettings();
vmssData.VirtualMachineProfile.StorageProfile.OSDisk.DiffDiskSettings.Option = DiffDiskOptions.Local;
vmssData.VirtualMachineProfile.StorageProfile.OSDisk.Caching = CachingTypes.ReadOnly;
}
if (spotInstance.HasValue && spotInstance.Value)
{
// Setting max price to -1 means it won't be evicted because of
// price.
//
// https://docs.microsoft.com/en-us/azure/
// virtual-machine-scale-sets/use-spot#resource-manager-templates
vmssData.VirtualMachineProfile.EvictionPolicy = VirtualMachineEvictionPolicyTypes.Deallocate;
vmssData.VirtualMachineProfile.Priority = VirtualMachinePriorityTypes.Spot;
vmssData.VirtualMachineProfile.BillingMaxPrice = 1.0;
}
foreach (var tag in tags)
{
vmssData.Tags.Add(tag);
}
if (_serviceConfig.OneFuzzOwner is not null)
{
vmssData.Tags.Add("OWNER", _serviceConfig.OneFuzzOwner);
}
try {
var rg = _creds.GetResourceGroupResource();
var createUpdate = await rg.GetVirtualMachineScaleSets().CreateOrUpdateAsync(WaitUntil.Started, name.ToString(), vmssData);
if (createUpdate.GetRawResponse().IsError)
{
var msg = $"Failed to create new scaleset due to {createUpdate.GetRawResponse().ReasonPhrase}";
_log.Error(msg);
return(OneFuzzResultVoid.Error(ErrorCode.VM_CREATE_FAILED, new[] { msg }));
}
else
{
return(OneFuzzResultVoid.Ok);
}
} catch (Exception ex) {
_log.Exception(ex);
return(OneFuzzResultVoid.Error(ErrorCode.VM_CREATE_FAILED, new[] { ex.Message }));
}
}
