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); }