public static IList <NetworkInterfaceData> GetNetworkInterfaces()
{
lock (_interfacesLock)
{
if (_interfaces != null)
{
return(_interfaces);
}
_interfaces = new List <NetworkInterfaceData>();
foreach (var iface in NetworkInterface.GetAllNetworkInterfaces().Where(x => x.OperationalStatus == OperationalStatus.Up))
{
var data = new NetworkInterfaceData()
{
Name = iface.Name,
Type = iface.NetworkInterfaceType,
PhysicalAddress = iface.GetPhysicalAddress(),
Addresses = new List <IPAddress>()
};
foreach (IPAddressInformation unicast in iface.GetIPProperties().UnicastAddresses)
{
if ((unicast.Address.AddressFamily == AddressFamily.InterNetwork || unicast.Address.AddressFamily == AddressFamily.InterNetworkV6) &&
!unicast.Address.IsIPv6LinkLocal && !unicast.Address.IsIPv6Multicast)
{
data.Addresses.Add(unicast.Address);
}
}
_interfaces.Add(data);
}
return(_interfaces);
}
}
public static IList<NetworkInterfaceData> GetNetworkInterfaces()
{
lock(_interfacesLock)
{
if (_interfaces != null)
return _interfaces;
_interfaces = new List<NetworkInterfaceData>();
foreach (var iface in NetworkInterface.GetAllNetworkInterfaces().Where(x => x.OperationalStatus == OperationalStatus.Up))
{
var data = new NetworkInterfaceData()
{
Name = iface.Name,
Type = iface.NetworkInterfaceType,
PhysicalAddress = iface.GetPhysicalAddress(),
Addresses = new List<IPAddress>()
};
foreach (IPAddressInformation unicast in iface.GetIPProperties().UnicastAddresses)
{
if ((unicast.Address.AddressFamily == AddressFamily.InterNetwork || unicast.Address.AddressFamily == AddressFamily.InterNetworkV6) &&
!unicast.Address.IsIPv6LinkLocal && !unicast.Address.IsIPv6Multicast)
data.Addresses.Add(unicast.Address);
}
_interfaces.Add(data);
}
return _interfaces;
}
}
NetworkInterface IOperationSource <NetworkInterface> .CreateResult(Response response, CancellationToken cancellationToken)
{
using var document = JsonDocument.Parse(response.ContentStream);
var data = NetworkInterfaceData.DeserializeNetworkInterfaceData(document.RootElement);
return(new NetworkInterface(_armClient, data));
}
internal static NetworkInterfaceListResult DeserializeNetworkInterfaceListResult(JsonElement element)
{
Optional <IReadOnlyList <NetworkInterfaceData> > value = default;
Optional <string> nextLink = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("value"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
List <NetworkInterfaceData> array = new List <NetworkInterfaceData>();
foreach (var item in property.Value.EnumerateArray())
{
array.Add(NetworkInterfaceData.DeserializeNetworkInterfaceData(item));
}
value = array;
continue;
}
if (property.NameEquals("nextLink"))
{
nextLink = property.Value.GetString();
continue;
}
}
return(new NetworkInterfaceListResult(Optional.ToList(value), nextLink.Value));
}
public override void Execute()
{
var rg = new Azure.ResourceManager.Resources.Models.ResourceGroup("East US");
var resourceGroupData = new ResourceGroupData(rg);
var nic = new Azure.ResourceManager.Network.Models.NetworkInterface();
var networkInterfaceData = new NetworkInterfaceData(nic);
var aset = new Azure.ResourceManager.Compute.Models.AvailabilitySet("East US");
var availabilitySet = new AvailabilitySetData(aset);
}
public void DomainName_Returns_Successfully_WithEmptyDomainName()
{
var networkInterface = new NetworkInterfaceData(string.Empty, new List <UnicastIPAddressInformation>());
// ACT
var actualDomainName = _realNetworkData.GetDomainName(networkInterface);
Assert.That(actualDomainName, Is.Not.Null);
Assert.That(actualDomainName, Is.EqualTo(string.Empty));
}
public async Task <NetworkInterface> CreateNetworkInterface(string name, string publicIpAddressId, string subnetId,
string location, string ipConfigName, NetworkInterfaceCollection networkInterfaceCollection)
{
var nicParameters = new NetworkInterfaceData()
{
Location = location,
Tags = { { "key", "value" } },
IpConfigurations =
{
new NetworkInterfaceIPConfigurationData()
{
Name = ipConfigName,
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
Subnet = new SubnetData()
{
Id = subnetId
}
}
}
};
if (!string.IsNullOrEmpty(publicIpAddressId))
{
nicParameters.IpConfigurations[0].PublicIPAddress = new PublicIPAddressData() /*Id = publicIpAddressId*/ }
{
;
}
// Test NIC apis
var operation = InstrumentOperation(await networkInterfaceCollection.CreateOrUpdateAsync(true, name, nicParameters));
await operation.WaitForCompletionAsync();
Response <NetworkInterface> getNicResponse = await networkInterfaceCollection.GetAsync(name);
Assert.AreEqual(getNicResponse.Value.Data.Name, name);
// because its a single CA nic, primaryOnCA is always true
Assert.True(getNicResponse.Value.Data.IpConfigurations[0].Primary);
Assert.AreEqual("Succeeded", getNicResponse.Value.Data.ProvisioningState.ToString());
return(getNicResponse);
}
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 VirtualNetworkUsageTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = TestEnvironment.Location;
var resourceGroup = await CreateResourceGroup(resourceGroupName);
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = Recording.GenerateAssetName("azsmnet");
var vnet = new VirtualNetworkData()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new SubnetData()
{
Name = subnetName, AddressPrefix = "10.0.1.0/24"
} }
};
// Put Vnet
var virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
var putVnetResponseOperation = await virtualNetworkCollection.CreateOrUpdateAsync(true, vnetName, vnet);
Response <VirtualNetwork> putVnetResponse = await putVnetResponseOperation.WaitForCompletionAsync();;
Assert.AreEqual("Succeeded", putVnetResponse.Value.Data.ProvisioningState.ToString());
Response <Subnet> getSubnetResponse = await putVnetResponse.Value.GetSubnets().GetAsync(subnetName);
// Get Vnet usage
var usage = await putVnetResponse.Value.GetUsageAsync().ToEnumerableAsync();
Assert.AreEqual(0.0, usage[0].CurrentValue);
// Create Nic
string nicName = Recording.GenerateAssetName("azsmnet");
string ipConfigName = Recording.GenerateAssetName("azsmnet");
var nicParameters = new NetworkInterfaceData()
{
Location = location,
Tags = { { "key", "value" } },
IpConfigurations =
{
new NetworkInterfaceIPConfigurationData()
{
Name = ipConfigName,
PrivateIPAllocationMethod = IPAllocationMethod.Static,
PrivateIPAddress = "10.0.1.9",
Subnet = new SubnetData()
{
Id = getSubnetResponse.Value.Id
}
}
}
};
var networkInterfaceCollection = resourceGroup.GetNetworkInterfaces();
var putNicResponseOperation = await networkInterfaceCollection.CreateOrUpdateAsync(true, nicName, nicParameters);
var nicResponse = await putNicResponseOperation.WaitForCompletionAsync();;
// Get Vnet usage again
usage = await putVnetResponse.Value.GetUsageAsync().ToEnumerableAsync();
Assert.AreEqual(1.0, usage[0].CurrentValue);
// Delete Vnet and Nic
await nicResponse.Value.DeleteAsync(true);
await putVnetResponse.Value.DeleteAsync(true);
}
public async Task VirtualNetworkCheckIpAddressAvailabilityTest()
{
string resourceGroupName = Recording.GenerateAssetName("csmrg");
string location = TestEnvironment.Location;
var resourceGroup = await CreateResourceGroup(resourceGroupName);
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = Recording.GenerateAssetName("azsmnet");
var vnet = new VirtualNetworkData()
{
Location = location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new SubnetData()
{
Name = subnetName, AddressPrefix = "10.0.1.0/24"
} }
};
// Put Vnet
var virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
var putVnetResponseOperation = await virtualNetworkCollection.CreateOrUpdateAsync(true, vnetName, vnet);
Response <VirtualNetwork> putVnetResponse = await putVnetResponseOperation.WaitForCompletionAsync();;
Assert.AreEqual("Succeeded", putVnetResponse.Value.Data.ProvisioningState.ToString());
Response <Subnet> getSubnetResponse = await putVnetResponse.Value.GetSubnets().GetAsync(subnetName);
// Create Nic
string nicName = Recording.GenerateAssetName("azsmnet");
string ipConfigName = Recording.GenerateAssetName("azsmnet");
var nicParameters = new NetworkInterfaceData()
{
Location = location,
Tags = { { "key", "value" } },
IpConfigurations =
{
new NetworkInterfaceIPConfigurationData()
{
Name = ipConfigName,
PrivateIPAllocationMethod = IPAllocationMethod.Static,
PrivateIPAddress = "10.0.1.9",
Subnet = new SubnetData()
{
Id = getSubnetResponse.Value.Id
}
}
}
};
var putNicResponseOperation = await resourceGroup.GetNetworkInterfaces().CreateOrUpdateAsync(true, nicName, nicParameters);
await putNicResponseOperation.WaitForCompletionAsync();;
// Check Ip Address availability API
Response <IPAddressAvailabilityResult> responseAvailable = await putVnetResponse.Value.CheckIPAddressAvailabilityAsync("10.0.1.10");
Assert.True(responseAvailable.Value.Available);
Assert.IsEmpty(responseAvailable.Value.AvailableIPAddresses);
Response <IPAddressAvailabilityResult> responseTaken = await putVnetResponse.Value.CheckIPAddressAvailabilityAsync("10.0.1.9");
Assert.False(responseTaken.Value.Available);
Assert.AreEqual(5, responseTaken.Value.AvailableIPAddresses.Count);
await putNicResponseOperation.Value.DeleteAsync(true);
await putVnetResponse.Value.DeleteAsync(true);
}
public async Task CreateOrUpdate()
{
VirtualNetworkCollection virtualNetworkCollection = resourceGroup.GetVirtualNetworks();
string vnetName = "myVnet";
// Use the same location as the resource group
VirtualNetworkData vnetInput = new VirtualNetworkData()
{
Location = resourceGroup.Data.Location,
AddressSpace = new AddressSpace()
{
AddressPrefixes = { "10.0.0.0/16", }
},
DhcpOptions = new DhcpOptions()
{
DnsServers = { "10.1.1.1", "10.1.2.4" }
},
Subnets = { new SubnetData()
{
Name = "mySubnet", AddressPrefix = "10.0.1.0/24"
} }
};
VirtualNetwork virtualNetwork = await virtualNetworkCollection.CreateOrUpdate(vnetName, vnetInput).WaitForCompletionAsync();
#region Snippet:Managing_Networks_CreateANetworkInterface
PublicIPAddressCollection publicIPAddressCollection = resourceGroup.GetPublicIPAddresses();
string publicIPAddressName = "myIPAddress";
PublicIPAddressData publicIPInput = new PublicIPAddressData()
{
Location = resourceGroup.Data.Location,
PublicIPAllocationMethod = IPAllocationMethod.Dynamic,
DnsSettings = new PublicIPAddressDnsSettings()
{
DomainNameLabel = "myDomain"
}
};
PublicIPAddress publicIPAddress = await publicIPAddressCollection.CreateOrUpdate(publicIPAddressName, publicIPInput).WaitForCompletionAsync();
NetworkInterfaceCollection networkInterfaceCollection = resourceGroup.GetNetworkInterfaces();
string networkInterfaceName = "myNetworkInterface";
NetworkInterfaceData networkInterfaceInput = new NetworkInterfaceData()
{
Location = resourceGroup.Data.Location,
IpConfigurations =
{
new NetworkInterfaceIPConfiguration()
{
Name = "ipConfig",
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
PublicIPAddress = new PublicIPAddressData()
{
Id = publicIPAddress.Id
},
Subnet = new SubnetData()
{
// use the virtual network just created
Id = virtualNetwork.Data.Subnets[0].Id
}
}
}
};
NetworkInterface networkInterface = await networkInterfaceCollection.CreateOrUpdate(networkInterfaceName, networkInterfaceInput).WaitForCompletionAsync();
#endregion
}
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
}
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
}
public async Task <OneFuzzResultVoid> CreatePublicNic(string resourceGroup, string name, string region, Nsg?nsg)
{
_logTracer.Info($"creating nic for {resourceGroup}:{name} in {region}");
var network = await Network.Create(region, _context);
var subnetId = await network.GetId();
if (subnetId is null)
{
await network.Create();
return(OneFuzzResultVoid.Ok);
}
if (nsg != null)
{
var subnet = await network.GetSubnet();
if (subnet != null && subnet.Data.NetworkSecurityGroup == null)
{
var vnet = await network.GetVnet();
var result = await _context.NsgOperations.AssociateSubnet(nsg.Name, vnet !, subnet);
if (!result.IsOk)
{
return(OneFuzzResultVoid.Error(result.ErrorV));
}
return(OneFuzzResultVoid.Ok);
}
}
var ip = await GetIp(resourceGroup, name);
if (ip == null)
{
await CreateIp(resourceGroup, name, region);
return(OneFuzzResultVoid.Ok);
}
var networkInterface = new NetworkInterfaceData {
Location = region,
};
networkInterface.IPConfigurations.Add(new NetworkInterfaceIPConfigurationData {
Name = "myIPConfig",
PublicIPAddress = ip?.Data,
Subnet = new SubnetData {
Id = subnetId
}
}
);
var onefuzzOwner = _context.ServiceConfiguration.OneFuzzOwner;
if (!string.IsNullOrEmpty(onefuzzOwner))
{
if (!networkInterface.Tags.TryAdd("OWNER", onefuzzOwner))
{
_logTracer.Warning($"Failed to add tag 'OWNER':{onefuzzOwner} to nic {resourceGroup}:{name}");
}
}
try {
await _context.Creds.GetResourceGroupResource().GetNetworkInterfaces().CreateOrUpdateAsync(
WaitUntil.Started,
name,
networkInterface
);
} catch (RequestFailedException ex) {
if (!ex.ToString().Contains("RetryableError"))
{
return(OneFuzzResultVoid.Error(
ErrorCode.VM_CREATE_FAILED,
$"unable to create nic: {ex}"
));
}
}
return(OneFuzzResultVoid.Ok);
}
