private void BuildVNetPeering() { //_primaryVirtualNetwork //_vnet var example_1VirtualNetworkPeering = new VirtualNetworkPeering("vnetPeerEUS_CUS", new VirtualNetworkPeeringArgs { ResourceGroupName = _ResourceGroup.Name, VirtualNetworkName = _vnet.Name, RemoteVirtualNetworkId = _primaryVirtualNetwork.Id, AllowForwardedTraffic = false, AllowGatewayTransit = false, UseRemoteGateways = false, AllowVirtualNetworkAccess = true }); var example_2VirtualNetworkPeering = new VirtualNetworkPeering("vnetPeerCUS_EUS", new VirtualNetworkPeeringArgs { ResourceGroupName = "rsgMarketPlace", VirtualNetworkName = _primaryVirtualNetwork.Name, RemoteVirtualNetworkId = _vnet.Id, AllowForwardedTraffic = false, AllowGatewayTransit = false, UseRemoteGateways = false, AllowVirtualNetworkAccess = true }); }
public async Task <Response <VirtualNetworkPeering> > GetAsync(string resourceGroupName, string virtualNetworkName, string virtualNetworkPeeringName, CancellationToken cancellationToken = default) { if (resourceGroupName == null) { throw new ArgumentNullException(nameof(resourceGroupName)); } if (virtualNetworkName == null) { throw new ArgumentNullException(nameof(virtualNetworkName)); } if (virtualNetworkPeeringName == null) { throw new ArgumentNullException(nameof(virtualNetworkPeeringName)); } using var message = CreateGetRequest(resourceGroupName, virtualNetworkName, virtualNetworkPeeringName); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); switch (message.Response.Status) { case 200: { VirtualNetworkPeering value = default; using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false); if (document.RootElement.ValueKind == JsonValueKind.Null) { value = null; } else { value = VirtualNetworkPeering.DeserializeVirtualNetworkPeering(document.RootElement); } return(Response.FromValue(value, message.Response)); }
private void RegionPeering(Output <string> resourceGroupName, VirtualNetwork inVNet, VirtualNetwork exVNet, int vnetRangePrefix) { var inVNetPeer = new VirtualNetworkPeering($"peer-vnet{vnetRangePrefix / 2 + 1}-in", new VirtualNetworkPeeringArgs { ResourceGroupName = resourceGroupName, VirtualNetworkName = inVNet.Name, RemoteVirtualNetworkId = exVNet.Id, AllowForwardedTraffic = true }); var exVNetPeer = new VirtualNetworkPeering($"peer-vnet{vnetRangePrefix / 2 + 1}-ex", new VirtualNetworkPeeringArgs { ResourceGroupName = resourceGroupName, VirtualNetworkName = exVNet.Name, RemoteVirtualNetworkId = inVNet.Id, AllowForwardedTraffic = true }); }
private void GlobalPeering(VirtualNetwork[] vnets) { for (int currVNetEx = 0; currVNetEx < vnets.Length; currVNetEx++) { for (int currVNetIn = 0; currVNetIn < vnets.Length; currVNetIn++) { if (vnets[currVNetEx] != vnets[currVNetIn]) { var vnetPeer = new VirtualNetworkPeering($"peer-vnet{currVNetEx + 1}-vnet{currVNetIn + 1}", new VirtualNetworkPeeringArgs { ResourceGroupName = vnets[currVNetEx].ResourceGroupName, VirtualNetworkName = vnets[currVNetEx].Name, RemoteVirtualNetworkId = vnets[currVNetIn].Id, AllowForwardedTraffic = true }); } } } }
/// <summary> /// Creates or updates a peering in the specified virtual network. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='virtualNetworkName'> /// The name of the virtual network. /// </param> /// <param name='virtualNetworkPeeringName'> /// The name of the peering. /// </param> /// <param name='virtualNetworkPeeringParameters'> /// Parameters supplied to the create or update virtual network peering /// operation. /// </param> public static VirtualNetworkPeering BeginCreateOrUpdate(this IVirtualNetworkPeeringsOperations operations, string resourceGroupName, string virtualNetworkName, string virtualNetworkPeeringName, VirtualNetworkPeering virtualNetworkPeeringParameters) { return(operations.BeginCreateOrUpdateAsync(resourceGroupName, virtualNetworkName, virtualNetworkPeeringName, virtualNetworkPeeringParameters).GetAwaiter().GetResult()); }
public async Task VirtualNetworkPeeringApiTest() { string resourceGroupName = Recording.GenerateAssetName("csmrg"); var location = "westus"; await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location)); string vnetName = Recording.GenerateAssetName("azsmnet"); string remoteVirtualNetworkName = Recording.GenerateAssetName("azsmnet"); string vnetPeeringName = Recording.GenerateAssetName("azsmnet"); string subnet1Name = Recording.GenerateAssetName("azsmnet"); string subnet2Name = Recording.GenerateAssetName("azsmnet"); VirtualNetwork vnet = new VirtualNetwork() { Location = location, AddressSpace = new AddressSpace() { AddressPrefixes = new List <string>() { "10.0.0.0/16", } }, DhcpOptions = new DhcpOptions() { DnsServers = new List <string>() { "10.1.1.1", "10.1.2.4" } }, Subnets = new List <Subnet>() { new Subnet() { Name = subnet1Name, AddressPrefix = "10.0.1.0/24", }, new Subnet() { Name = subnet2Name, AddressPrefix = "10.0.2.0/24", } } }; // Put Vnet VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnet); Response <VirtualNetwork> putVnetResponse = await WaitForCompletionAsync(putVnetResponseOperation); Assert.AreEqual("Succeeded", putVnetResponse.Value.ProvisioningState.ToString()); // Get Vnet Response <VirtualNetwork> getVnetResponse = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnetName); Assert.AreEqual(vnetName, getVnetResponse.Value.Name); Assert.NotNull(getVnetResponse.Value.ResourceGuid); Assert.AreEqual("Succeeded", getVnetResponse.Value.ProvisioningState.ToString()); // Get all Vnets AsyncPageable <VirtualNetwork> getAllVnetsAP = NetworkManagementClient.VirtualNetworks.ListAsync(resourceGroupName); await getAllVnetsAP.ToEnumerableAsync(); vnet.AddressSpace.AddressPrefixes[0] = "10.1.0.0/16"; vnet.Subnets[0].AddressPrefix = "10.1.1.0/24"; vnet.Subnets[1].AddressPrefix = "10.1.2.0/24"; VirtualNetworksCreateOrUpdateOperation remoteVirtualNetworkOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, remoteVirtualNetworkName, vnet); Response <VirtualNetwork> remoteVirtualNetwork = await WaitForCompletionAsync(remoteVirtualNetworkOperation); // Get Peerings in the vnet AsyncPageable <VirtualNetworkPeering> listPeeringAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnetName); List <VirtualNetworkPeering> listPeering = await listPeeringAP.ToEnumerableAsync(); Assert.IsEmpty(listPeering); VirtualNetworkPeering peering = new VirtualNetworkPeering { Name = vnetPeeringName, RemoteVirtualNetwork = new SubResource { Id = remoteVirtualNetwork.Value.Id }, AllowForwardedTraffic = true, AllowVirtualNetworkAccess = false }; // Put peering in the vnet VirtualNetworkPeeringsCreateOrUpdateOperation putPeeringOperation = await NetworkManagementClient.VirtualNetworkPeerings.StartCreateOrUpdateAsync(resourceGroupName, vnetName, vnetPeeringName, peering); Response <VirtualNetworkPeering> putPeering = await WaitForCompletionAsync(putPeeringOperation); Assert.NotNull(putPeering.Value.Etag); Assert.AreEqual(vnetPeeringName, putPeering.Value.Name); Assert.AreEqual(remoteVirtualNetwork.Value.Id, putPeering.Value.RemoteVirtualNetwork.Id); Assert.AreEqual(peering.AllowForwardedTraffic, putPeering.Value.AllowForwardedTraffic); Assert.AreEqual(peering.AllowVirtualNetworkAccess, putPeering.Value.AllowVirtualNetworkAccess); Assert.False(putPeering.Value.UseRemoteGateways); Assert.False(putPeering.Value.AllowGatewayTransit); Assert.AreEqual(VirtualNetworkPeeringState.Initiated, putPeering.Value.PeeringState); // get peering Response <VirtualNetworkPeering> getPeering = await NetworkManagementClient.VirtualNetworkPeerings.GetAsync(resourceGroupName, vnetName, vnetPeeringName); Assert.AreEqual(getPeering.Value.Etag, putPeering.Value.Etag); Assert.AreEqual(vnetPeeringName, getPeering.Value.Name); Assert.AreEqual(remoteVirtualNetwork.Value.Id, getPeering.Value.RemoteVirtualNetwork.Id); Assert.AreEqual(peering.AllowForwardedTraffic, getPeering.Value.AllowForwardedTraffic); Assert.AreEqual(peering.AllowVirtualNetworkAccess, getPeering.Value.AllowVirtualNetworkAccess); Assert.False(getPeering.Value.UseRemoteGateways); Assert.False(getPeering.Value.AllowGatewayTransit); Assert.AreEqual(VirtualNetworkPeeringState.Initiated, getPeering.Value.PeeringState); // list peering listPeeringAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnetName); listPeering = await listPeeringAP.ToEnumerableAsync(); Has.One.EqualTo(listPeering); Assert.AreEqual(listPeering.ElementAt(0).Etag, putPeering.Value.Etag); Assert.AreEqual(vnetPeeringName, listPeering.ElementAt(0).Name); Assert.AreEqual(remoteVirtualNetwork.Value.Id, listPeering.ElementAt(0).RemoteVirtualNetwork.Id); Assert.AreEqual(peering.AllowForwardedTraffic, listPeering.ElementAt(0).AllowForwardedTraffic); Assert.AreEqual(peering.AllowVirtualNetworkAccess, listPeering.ElementAt(0).AllowVirtualNetworkAccess); Assert.False(listPeering.ElementAt(0).UseRemoteGateways); Assert.False(listPeering.ElementAt(0).AllowGatewayTransit); Assert.AreEqual(VirtualNetworkPeeringState.Initiated, listPeering.ElementAt(0).PeeringState); // delete peering await NetworkManagementClient.VirtualNetworkPeerings.StartDeleteAsync(resourceGroupName, vnetName, vnetPeeringName); listPeeringAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnetName); listPeering = await listPeeringAP.ToEnumerableAsync(); Assert.IsEmpty(listPeering); // Delete Vnet await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, vnetName); await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, remoteVirtualNetworkName); // Get all Vnets getAllVnetsAP = NetworkManagementClient.VirtualNetworks.ListAsync(resourceGroupName); List <VirtualNetwork> getAllVnets = await getAllVnetsAP.ToEnumerableAsync(); Assert.IsEmpty(getAllVnets); }
public async Task VirtualNetworkPeeringTest() { string resourceGroupName = Recording.GenerateAssetName("csmrg"); string location = await NetworkManagementTestUtilities.GetResourceLocation(ResourceManagementClient, "Microsoft.Network/virtualNetworks"); await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location)); string vnet1Name = Recording.GenerateAssetName("azsmnet"); string vnet2Name = Recording.GenerateAssetName("azsmnet"); string subnet1Name = Recording.GenerateAssetName("azsmnet"); string subnet2Name = Recording.GenerateAssetName("azsmnet"); VirtualNetwork vnet = new VirtualNetwork() { 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 Subnet() { Name = subnet1Name, AddressPrefix = "10.0.1.0/24", }, new Subnet() { Name = subnet2Name, AddressPrefix = "10.0.2.0/24" } } }; // Put Vnet VirtualNetworksCreateOrUpdateOperation putVnetResponseOperation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnet1Name, vnet); Response <VirtualNetwork> putVnetResponse = await WaitForCompletionAsync(putVnetResponseOperation); Assert.AreEqual("Succeeded", putVnetResponse.Value.ProvisioningState.ToString()); // Get Vnet Response <VirtualNetwork> getVnetResponse = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnet1Name); Assert.AreEqual(vnet1Name, getVnetResponse.Value.Name); Assert.NotNull(getVnetResponse.Value.ResourceGuid); Assert.AreEqual("Succeeded", getVnetResponse.Value.ProvisioningState.ToString()); // Create vnet2 VirtualNetwork vnet2 = new VirtualNetwork() { Location = location, AddressSpace = new AddressSpace() { AddressPrefixes = { "10.1.0.0/16", } }, Subnets = { new Subnet() { Name = subnet1Name, AddressPrefix = "10.1.1.0/24" } } }; // Put Vnet2 VirtualNetworksCreateOrUpdateOperation putVnet2Operation = await NetworkManagementClient.VirtualNetworks.StartCreateOrUpdateAsync(resourceGroupName, vnet2Name, vnet2); Response <VirtualNetwork> putVnet2 = await WaitForCompletionAsync(putVnet2Operation); Assert.AreEqual("Succeeded", putVnet2.Value.ProvisioningState.ToString()); // Create peering object var peering = new VirtualNetworkPeering() { AllowForwardedTraffic = true, RemoteVirtualNetwork = new SubResource { Id = putVnet2.Value.Id } }; // Create Peering await NetworkManagementClient.VirtualNetworkPeerings.StartCreateOrUpdateAsync(resourceGroupName, vnet1Name, "peer1", peering); // Get Peering Response <VirtualNetworkPeering> getPeer = await NetworkManagementClient.VirtualNetworkPeerings.GetAsync(resourceGroupName, vnet1Name, "peer1"); Assert.AreEqual("peer1", getPeer.Value.Name); Assert.True(getPeer.Value.AllowForwardedTraffic); Assert.True(getPeer.Value.AllowVirtualNetworkAccess); Assert.False(getPeer.Value.AllowGatewayTransit); Assert.NotNull(getPeer.Value.RemoteVirtualNetwork); Assert.AreEqual(putVnet2.Value.Id, getPeer.Value.RemoteVirtualNetwork.Id); // List Peering AsyncPageable <VirtualNetworkPeering> listPeerAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnet1Name); List <VirtualNetworkPeering> listPeer = await listPeerAP.ToEnumerableAsync(); Has.One.EqualTo(listPeer); Assert.AreEqual("peer1", listPeer[0].Name); Assert.True(listPeer[0].AllowForwardedTraffic); Assert.True(listPeer[0].AllowVirtualNetworkAccess); Assert.False(listPeer[0].AllowGatewayTransit); Assert.NotNull(listPeer[0].RemoteVirtualNetwork); Assert.AreEqual(putVnet2.Value.Id, listPeer[0].RemoteVirtualNetwork.Id); // Get peering from GET vnet Response <VirtualNetwork> peeringVnet = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnet1Name); Assert.AreEqual(vnet1Name, peeringVnet.Value.Name); Has.One.EqualTo(peeringVnet.Value.VirtualNetworkPeerings); Assert.AreEqual("peer1", peeringVnet.Value.VirtualNetworkPeerings[0].Name); Assert.True(peeringVnet.Value.VirtualNetworkPeerings[0].AllowForwardedTraffic); Assert.True(peeringVnet.Value.VirtualNetworkPeerings[0].AllowVirtualNetworkAccess); Assert.False(peeringVnet.Value.VirtualNetworkPeerings[0].AllowGatewayTransit); Assert.NotNull(peeringVnet.Value.VirtualNetworkPeerings[0].RemoteVirtualNetwork); Assert.AreEqual(putVnet2.Value.Id, peeringVnet.Value.VirtualNetworkPeerings[0].RemoteVirtualNetwork.Id); // Delete Peering VirtualNetworkPeeringsDeleteOperation deleteOperation = await NetworkManagementClient.VirtualNetworkPeerings.StartDeleteAsync(resourceGroupName, vnet1Name, "peer1"); await WaitForCompletionAsync(deleteOperation); listPeerAP = NetworkManagementClient.VirtualNetworkPeerings.ListAsync(resourceGroupName, vnet1Name); listPeer = await listPeerAP.ToEnumerableAsync(); Assert.IsEmpty(listPeer); peeringVnet = await NetworkManagementClient.VirtualNetworks.GetAsync(resourceGroupName, vnet1Name); Assert.AreEqual(vnet1Name, peeringVnet.Value.Name); Assert.IsEmpty(peeringVnet.Value.VirtualNetworkPeerings); // Delete Vnets await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, vnet1Name); await NetworkManagementClient.VirtualNetworks.StartDeleteAsync(resourceGroupName, vnet2Name); }
public async Task VirtualNetworkPeeringTest() { string resourceGroupName = Recording.GenerateAssetName("csmrg"); string location = TestEnvironment.Location; var resourceGroup = await CreateResourceGroup(resourceGroupName); string vnet1Name = Recording.GenerateAssetName("azsmnet"); string vnet2Name = Recording.GenerateAssetName("azsmnet"); string subnet1Name = Recording.GenerateAssetName("azsmnet"); string subnet2Name = 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 = subnet1Name, AddressPrefix = "10.0.1.0/24", }, new SubnetData() { Name = subnet2Name, AddressPrefix = "10.0.2.0/24" } } }; // Put Vnet var virtualNetworkCollection = resourceGroup.GetVirtualNetworks(); var putVnetResponseOperation = await virtualNetworkCollection.CreateOrUpdateAsync(true, vnet1Name, vnet); Response <VirtualNetwork> putVnetResponse = await putVnetResponseOperation.WaitForCompletionAsync();; Assert.AreEqual("Succeeded", putVnetResponse.Value.Data.ProvisioningState.ToString()); // Get Vnet Response <VirtualNetwork> getVnetResponse = await virtualNetworkCollection.GetAsync(vnet1Name); Assert.AreEqual(vnet1Name, getVnetResponse.Value.Data.Name); Assert.NotNull(getVnetResponse.Value.Data.ResourceGuid); Assert.AreEqual("Succeeded", getVnetResponse.Value.Data.ProvisioningState.ToString()); // Create vnet2 var vnet2 = new VirtualNetworkData() { Location = location, AddressSpace = new AddressSpace() { AddressPrefixes = { "10.1.0.0/16", } }, Subnets = { new SubnetData() { Name = subnet1Name, AddressPrefix = "10.1.1.0/24" } } }; // Put Vnet2 var putVnet2Operation = await virtualNetworkCollection.CreateOrUpdateAsync(true, vnet2Name, vnet2); Response <VirtualNetwork> putVnet2 = await putVnet2Operation.WaitForCompletionAsync();; Assert.AreEqual("Succeeded", putVnet2.Value.Data.ProvisioningState.ToString()); // Create peering object var peering = new VirtualNetworkPeeringData() { AllowForwardedTraffic = true, RemoteVirtualNetwork = new WritableSubResource { Id = putVnet2.Value.Id } }; // Create Peering var virtualNetworkPeeringCollection = getVnetResponse.Value.GetVirtualNetworkPeerings(); await virtualNetworkPeeringCollection.CreateOrUpdateAsync(true, "peer1", peering); // Get Peering VirtualNetworkPeering getPeer = await virtualNetworkPeeringCollection.GetAsync("peer1"); Assert.AreEqual("peer1", getPeer.Data.Name); Assert.True(getPeer.Data.AllowForwardedTraffic); Assert.True(getPeer.Data.AllowVirtualNetworkAccess); Assert.False(getPeer.Data.AllowGatewayTransit); Assert.NotNull(getPeer.Data.RemoteVirtualNetwork); Assert.AreEqual(putVnet2.Value.Id, getPeer.Data.RemoteVirtualNetwork.Id); // List Peering AsyncPageable <VirtualNetworkPeering> listPeerAP = virtualNetworkPeeringCollection.GetAllAsync(); List <VirtualNetworkPeering> listPeer = await listPeerAP.ToEnumerableAsync(); Has.One.EqualTo(listPeer); Assert.AreEqual("peer1", listPeer[0].Data.Name); Assert.True(listPeer[0].Data.AllowForwardedTraffic); Assert.True(listPeer[0].Data.AllowVirtualNetworkAccess); Assert.False(listPeer[0].Data.AllowGatewayTransit); Assert.NotNull(listPeer[0].Data.RemoteVirtualNetwork); Assert.AreEqual(putVnet2.Value.Id, listPeer[0].Data.RemoteVirtualNetwork.Id); // Get peering from GET vnet VirtualNetwork peeringVnet = await virtualNetworkCollection.GetAsync(vnet1Name); Assert.AreEqual(vnet1Name, peeringVnet.Data.Name); Has.One.EqualTo(peeringVnet.Data.VirtualNetworkPeerings); Assert.AreEqual("peer1", peeringVnet.Data.VirtualNetworkPeerings[0].Name); Assert.True(peeringVnet.Data.VirtualNetworkPeerings[0].AllowForwardedTraffic); Assert.True(peeringVnet.Data.VirtualNetworkPeerings[0].AllowVirtualNetworkAccess); Assert.False(peeringVnet.Data.VirtualNetworkPeerings[0].AllowGatewayTransit); Assert.NotNull(peeringVnet.Data.VirtualNetworkPeerings[0].RemoteVirtualNetwork); Assert.AreEqual(putVnet2.Value.Id, peeringVnet.Data.VirtualNetworkPeerings[0].RemoteVirtualNetwork.Id); // Delete Peering var deleteOperation = await getPeer.DeleteAsync(true); await deleteOperation.WaitForCompletionResponseAsync();; listPeerAP = virtualNetworkPeeringCollection.GetAllAsync(); listPeer = await listPeerAP.ToEnumerableAsync(); Assert.IsEmpty(listPeer); peeringVnet = await virtualNetworkCollection.GetAsync(vnet1Name); Assert.AreEqual(vnet1Name, peeringVnet.Data.Name); Assert.IsEmpty(peeringVnet.Data.VirtualNetworkPeerings); // Delete Vnets await putVnet2.Value.DeleteAsync(true); await putVnetResponse.Value.DeleteAsync(true); }
/// <summary> /// The Put virtual network peering operation creates/updates a peering in the /// specified virtual network /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='virtualNetworkName'> /// The name of the virtual network. /// </param> /// <param name='virtualNetworkPeeringName'> /// The name of the peering. /// </param> /// <param name='virtualNetworkPeeringParameters'> /// Parameters supplied to the create/update virtual network peering operation /// </param> public static VirtualNetworkPeering BeginCreateOrUpdate(this IVirtualNetworkPeeringsOperations operations, string resourceGroupName, string virtualNetworkName, string virtualNetworkPeeringName, VirtualNetworkPeering virtualNetworkPeeringParameters) { return(Task.Factory.StartNew(s => ((IVirtualNetworkPeeringsOperations)s).BeginCreateOrUpdateAsync(resourceGroupName, virtualNetworkName, virtualNetworkPeeringName, virtualNetworkPeeringParameters), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
public PSVirtualNetworkPeering ToPsVirtualNetworkPeering(VirtualNetworkPeering vnetPeering) { var psVnetpeering = NetworkResourceManagerProfile.Mapper.Map <PSVirtualNetworkPeering>(vnetPeering); return(psVnetpeering); }
public PSVirtualNetworkPeering ToPsVirtualNetworkPeering(VirtualNetworkPeering vnetPeering) { var psVnetpeering = Mapper.Map <PSVirtualNetworkPeering>(vnetPeering); return(psVnetpeering); }
/// <summary> /// Creates or updates a peering in the specified virtual network. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='virtualNetworkName'> /// The name of the virtual network. /// </param> /// <param name='virtualNetworkPeeringName'> /// The name of the peering. /// </param> /// <param name='virtualNetworkPeeringParameters'> /// Parameters supplied to the create or update virtual network peering /// operation. /// </param> /// <param name='syncRemoteAddressSpace'> /// Parameter indicates the intention to sync the peering with the current /// address space on the remote vNet after it's updated. Possible values /// include: 'true' /// </param> public static VirtualNetworkPeering CreateOrUpdate(this IVirtualNetworkPeeringsOperations operations, string resourceGroupName, string virtualNetworkName, string virtualNetworkPeeringName, VirtualNetworkPeering virtualNetworkPeeringParameters, string syncRemoteAddressSpace = default(string)) { return(operations.CreateOrUpdateAsync(resourceGroupName, virtualNetworkName, virtualNetworkPeeringName, virtualNetworkPeeringParameters, syncRemoteAddressSpace).GetAwaiter().GetResult()); }
/// <summary> /// The Put virtual network peering operation creates/updates a peering in the /// specified virtual network /// </summary> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='virtualNetworkName'> /// The name of the virtual network. /// </param> /// <param name='virtualNetworkPeeringName'> /// The name of the peering. /// </param> /// <param name='virtualNetworkPeeringParameters'> /// Parameters supplied to the create/update virtual network peering operation /// </param> /// <param name='customHeaders'> /// Headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> /// <return> /// A response object containing the response body and response headers. /// </return> public async Task <AzureOperationResponse <VirtualNetworkPeering> > BeginCreateOrUpdateWithHttpMessagesAsync(string resourceGroupName, string virtualNetworkName, string virtualNetworkPeeringName, VirtualNetworkPeering virtualNetworkPeeringParameters, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { if (resourceGroupName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "resourceGroupName"); } if (virtualNetworkName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "virtualNetworkName"); } if (virtualNetworkPeeringName == null) { throw new ValidationException(ValidationRules.CannotBeNull, "virtualNetworkPeeringName"); } if (virtualNetworkPeeringParameters == null) { throw new ValidationException(ValidationRules.CannotBeNull, "virtualNetworkPeeringParameters"); } if (this.Client.ApiVersion == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.ApiVersion"); } if (this.Client.SubscriptionId == null) { throw new ValidationException(ValidationRules.CannotBeNull, "this.Client.SubscriptionId"); } // Tracing bool _shouldTrace = ServiceClientTracing.IsEnabled; string _invocationId = null; if (_shouldTrace) { _invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("resourceGroupName", resourceGroupName); tracingParameters.Add("virtualNetworkName", virtualNetworkName); tracingParameters.Add("virtualNetworkPeeringName", virtualNetworkPeeringName); tracingParameters.Add("virtualNetworkPeeringParameters", virtualNetworkPeeringParameters); tracingParameters.Add("cancellationToken", cancellationToken); ServiceClientTracing.Enter(_invocationId, this, "BeginCreateOrUpdate", tracingParameters); } // Construct URL var _baseUrl = this.Client.BaseUri.AbsoluteUri; var _url = new Uri(new Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/virtualNetworkPeerings/{virtualNetworkPeeringName}").ToString(); _url = _url.Replace("{resourceGroupName}", Uri.EscapeDataString(resourceGroupName)); _url = _url.Replace("{virtualNetworkName}", Uri.EscapeDataString(virtualNetworkName)); _url = _url.Replace("{virtualNetworkPeeringName}", Uri.EscapeDataString(virtualNetworkPeeringName)); _url = _url.Replace("{subscriptionId}", Uri.EscapeDataString(this.Client.SubscriptionId)); List <string> _queryParameters = new List <string>(); if (this.Client.ApiVersion != null) { _queryParameters.Add(string.Format("api-version={0}", Uri.EscapeDataString(this.Client.ApiVersion))); } if (_queryParameters.Count > 0) { _url += "?" + string.Join("&", _queryParameters); } // Create HTTP transport objects HttpRequestMessage _httpRequest = new HttpRequestMessage(); HttpResponseMessage _httpResponse = null; _httpRequest.Method = new HttpMethod("PUT"); _httpRequest.RequestUri = new Uri(_url); // Set Headers if (this.Client.GenerateClientRequestId != null && this.Client.GenerateClientRequestId.Value) { _httpRequest.Headers.TryAddWithoutValidation("x-ms-client-request-id", Guid.NewGuid().ToString()); } if (this.Client.AcceptLanguage != null) { if (_httpRequest.Headers.Contains("accept-language")) { _httpRequest.Headers.Remove("accept-language"); } _httpRequest.Headers.TryAddWithoutValidation("accept-language", this.Client.AcceptLanguage); } if (customHeaders != null) { foreach (var _header in customHeaders) { if (_httpRequest.Headers.Contains(_header.Key)) { _httpRequest.Headers.Remove(_header.Key); } _httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value); } } // Serialize Request string _requestContent = null; if (virtualNetworkPeeringParameters != null) { _requestContent = SafeJsonConvert.SerializeObject(virtualNetworkPeeringParameters, this.Client.SerializationSettings); _httpRequest.Content = new StringContent(_requestContent, Encoding.UTF8); _httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf-8"); } // Set Credentials if (this.Client.Credentials != null) { cancellationToken.ThrowIfCancellationRequested(); await this.Client.Credentials.ProcessHttpRequestAsync(_httpRequest, cancellationToken).ConfigureAwait(false); } // Send Request if (_shouldTrace) { ServiceClientTracing.SendRequest(_invocationId, _httpRequest); } cancellationToken.ThrowIfCancellationRequested(); _httpResponse = await this.Client.HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false); if (_shouldTrace) { ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse); } HttpStatusCode _statusCode = _httpResponse.StatusCode; cancellationToken.ThrowIfCancellationRequested(); string _responseContent = null; if ((int)_statusCode != 200 && (int)_statusCode != 201) { var ex = new CloudException(string.Format("Operation returned an invalid status code '{0}'", _statusCode)); try { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); CloudError _errorBody = SafeJsonConvert.DeserializeObject <CloudError>(_responseContent, this.Client.DeserializationSettings); if (_errorBody != null) { ex = new CloudException(_errorBody.Message); ex.Body = _errorBody; } } catch (JsonException) { // Ignore the exception } ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent); ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent); if (_httpResponse.Headers.Contains("x-ms-request-id")) { ex.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (_shouldTrace) { ServiceClientTracing.Error(_invocationId, ex); } _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw ex; } // Create Result var _result = new AzureOperationResponse <VirtualNetworkPeering>(); _result.Request = _httpRequest; _result.Response = _httpResponse; if (_httpResponse.Headers.Contains("x-ms-request-id")) { _result.RequestId = _httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } // Deserialize Response if ((int)_statusCode == 200) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = SafeJsonConvert.DeserializeObject <VirtualNetworkPeering>(_responseContent, this.Client.DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } // Deserialize Response if ((int)_statusCode == 201) { _responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); try { _result.Body = SafeJsonConvert.DeserializeObject <VirtualNetworkPeering>(_responseContent, this.Client.DeserializationSettings); } catch (JsonException ex) { _httpRequest.Dispose(); if (_httpResponse != null) { _httpResponse.Dispose(); } throw new SerializationException("Unable to deserialize the response.", _responseContent, ex); } } if (_shouldTrace) { ServiceClientTracing.Exit(_invocationId, _result); } return(_result); }
/// <summary> /// The Put virtual network peering operation creates/updates a peering in the /// specified virtual network /// </summary> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='virtualNetworkName'> /// The name of the virtual network. /// </param> /// <param name='virtualNetworkPeeringName'> /// The name of the peering. /// </param> /// <param name='virtualNetworkPeeringParameters'> /// Parameters supplied to the create/update virtual network peering operation /// </param> /// <param name='customHeaders'> /// The headers that will be added to request. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public async Task <AzureOperationResponse <VirtualNetworkPeering> > CreateOrUpdateWithHttpMessagesAsync(string resourceGroupName, string virtualNetworkName, string virtualNetworkPeeringName, VirtualNetworkPeering virtualNetworkPeeringParameters, Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken)) { // Send Request AzureOperationResponse <VirtualNetworkPeering> _response = await BeginCreateOrUpdateWithHttpMessagesAsync( resourceGroupName, virtualNetworkName, virtualNetworkPeeringName, virtualNetworkPeeringParameters, customHeaders, cancellationToken); return(await this.Client.GetPutOrPatchOperationResultAsync(_response, customHeaders, cancellationToken)); }
/// <summary> /// Creates or updates a peering in the specified virtual network. /// </summary> /// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='resourceGroupName'> /// The name of the resource group. /// </param> /// <param name='virtualNetworkName'> /// The name of the virtual network. /// </param> /// <param name='virtualNetworkPeeringName'> /// The name of the peering. /// </param> /// <param name='virtualNetworkPeeringParameters'> /// Parameters supplied to the create or update virtual network peering /// operation. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <VirtualNetworkPeering> BeginCreateOrUpdateAsync(this IVirtualNetworkPeeringsOperations operations, string resourceGroupName, string virtualNetworkName, string virtualNetworkPeeringName, VirtualNetworkPeering virtualNetworkPeeringParameters, CancellationToken cancellationToken = default(CancellationToken)) { using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, virtualNetworkName, virtualNetworkPeeringName, virtualNetworkPeeringParameters, null, cancellationToken).ConfigureAwait(false)) { return(_result.Body); } }
public virtual VirtualNetworkPeeringsCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string virtualNetworkName, string virtualNetworkPeeringName, VirtualNetworkPeering virtualNetworkPeeringParameters, CancellationToken cancellationToken = default) { if (resourceGroupName == null) { throw new ArgumentNullException(nameof(resourceGroupName)); } if (virtualNetworkName == null) { throw new ArgumentNullException(nameof(virtualNetworkName)); } if (virtualNetworkPeeringName == null) { throw new ArgumentNullException(nameof(virtualNetworkPeeringName)); } if (virtualNetworkPeeringParameters == null) { throw new ArgumentNullException(nameof(virtualNetworkPeeringParameters)); } using var scope = _clientDiagnostics.CreateScope("VirtualNetworkPeeringsOperations.StartCreateOrUpdate"); scope.Start(); try { var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, virtualNetworkName, virtualNetworkPeeringName, virtualNetworkPeeringParameters, cancellationToken); return(new VirtualNetworkPeeringsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUpdateRequest(resourceGroupName, virtualNetworkName, virtualNetworkPeeringName, virtualNetworkPeeringParameters).Request, originalResponse)); } catch (Exception e) { scope.Failed(e); throw; } }
public void VirtualNetworkPeeringApiTest() { var handler1 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }; var handler2 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }; using (MockContext context = MockContext.Start(this.GetType())) { var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(context, handler1); var networkManagementClient = NetworkManagementTestUtilities.GetNetworkManagementClientWithHandler(context, handler2); // var location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/virtualNetworks"); var location = "westus"; string resourceGroupName = TestUtilities.GenerateName("csmrg"); resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup { Location = location }); string vnetName = TestUtilities.GenerateName(); string remoteVirtualNetworkName = TestUtilities.GenerateName(); string vnetPeeringName = TestUtilities.GenerateName(); string subnet1Name = TestUtilities.GenerateName(); string subnet2Name = TestUtilities.GenerateName(); var vnet = new VirtualNetwork() { Location = location, AddressSpace = new AddressSpace() { AddressPrefixes = new List <string>() { "10.0.0.0/16", } }, DhcpOptions = new DhcpOptions() { DnsServers = new List <string>() { "10.1.1.1", "10.1.2.4" } }, Subnets = new List <Subnet>() { new Subnet() { Name = subnet1Name, AddressPrefix = "10.0.1.0/24", }, new Subnet() { Name = subnet2Name, AddressPrefix = "10.0.2.0/24", } } }; // Put Vnet var putVnetResponse = networkManagementClient.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnetName, vnet); Assert.Equal("Succeeded", putVnetResponse.ProvisioningState); // Get Vnet var getVnetResponse = networkManagementClient.VirtualNetworks.Get(resourceGroupName, vnetName); Assert.Equal(vnetName, getVnetResponse.Name); Assert.NotNull(getVnetResponse.ResourceGuid); Assert.Equal("Succeeded", getVnetResponse.ProvisioningState); // Get all Vnets var getAllVnets = networkManagementClient.VirtualNetworks.List(resourceGroupName); vnet.AddressSpace.AddressPrefixes[0] = "10.1.0.0/16"; vnet.Subnets[0].AddressPrefix = "10.1.1.0/24"; vnet.Subnets[1].AddressPrefix = "10.1.2.0/24"; var remoteVirtualNetwork = networkManagementClient.VirtualNetworks.CreateOrUpdate(resourceGroupName, remoteVirtualNetworkName, vnet); // Get Peerings in the vnet var listPeering = networkManagementClient.VirtualNetworkPeerings.List(resourceGroupName, vnetName); Assert.Empty(listPeering); var peering = new VirtualNetworkPeering(); peering.Name = vnetPeeringName; peering.RemoteVirtualNetwork = new Microsoft.Azure.Management.Network.Models.SubResource(); peering.RemoteVirtualNetwork.Id = remoteVirtualNetwork.Id; peering.AllowForwardedTraffic = true; peering.AllowVirtualNetworkAccess = false; // Put peering in the vnet var putPeering = networkManagementClient.VirtualNetworkPeerings.CreateOrUpdate(resourceGroupName, vnetName, vnetPeeringName, peering); Assert.NotNull(putPeering.Etag); Assert.Equal(vnetPeeringName, putPeering.Name); Assert.Equal(remoteVirtualNetwork.Id, putPeering.RemoteVirtualNetwork.Id); Assert.Equal(peering.AllowForwardedTraffic, putPeering.AllowForwardedTraffic); Assert.Equal(peering.AllowVirtualNetworkAccess, putPeering.AllowVirtualNetworkAccess); Assert.False(putPeering.UseRemoteGateways); Assert.False(putPeering.AllowGatewayTransit); Assert.Equal(VirtualNetworkPeeringState.Initiated, putPeering.PeeringState); // get peering var getPeering = networkManagementClient.VirtualNetworkPeerings.Get(resourceGroupName, vnetName, vnetPeeringName); Assert.Equal(getPeering.Etag, putPeering.Etag); Assert.Equal(vnetPeeringName, getPeering.Name); Assert.Equal(remoteVirtualNetwork.Id, getPeering.RemoteVirtualNetwork.Id); Assert.Equal(peering.AllowForwardedTraffic, getPeering.AllowForwardedTraffic); Assert.Equal(peering.AllowVirtualNetworkAccess, getPeering.AllowVirtualNetworkAccess); Assert.False(getPeering.UseRemoteGateways); Assert.False(getPeering.AllowGatewayTransit); Assert.Equal(VirtualNetworkPeeringState.Initiated, getPeering.PeeringState); // list peering listPeering = networkManagementClient.VirtualNetworkPeerings.List(resourceGroupName, vnetName); Assert.Single(listPeering); Assert.Equal(listPeering.ElementAt(0).Etag, putPeering.Etag); Assert.Equal(vnetPeeringName, listPeering.ElementAt(0).Name); Assert.Equal(remoteVirtualNetwork.Id, listPeering.ElementAt(0).RemoteVirtualNetwork.Id); Assert.Equal(peering.AllowForwardedTraffic, listPeering.ElementAt(0).AllowForwardedTraffic); Assert.Equal(peering.AllowVirtualNetworkAccess, listPeering.ElementAt(0).AllowVirtualNetworkAccess); Assert.False(listPeering.ElementAt(0).UseRemoteGateways); Assert.False(listPeering.ElementAt(0).AllowGatewayTransit); Assert.Equal(VirtualNetworkPeeringState.Initiated, listPeering.ElementAt(0).PeeringState); // delete peering networkManagementClient.VirtualNetworkPeerings.Delete(resourceGroupName, vnetName, vnetPeeringName); listPeering = networkManagementClient.VirtualNetworkPeerings.List(resourceGroupName, vnetName); Assert.Empty(listPeering); // Delete Vnet networkManagementClient.VirtualNetworks.Delete(resourceGroupName, vnetName); networkManagementClient.VirtualNetworks.Delete(resourceGroupName, remoteVirtualNetworkName); // Get all Vnets getAllVnets = networkManagementClient.VirtualNetworks.List(resourceGroupName); Assert.Empty(getAllVnets); } }
public PSVirtualNetworkPeering ToPsVirtualNetworkPeering(VirtualNetworkPeering vnetPeering) { var psVnetpeering = Mapper.Map<PSVirtualNetworkPeering>(vnetPeering); return psVnetpeering; }
public void VirtualNetworkPeeringTest() { var handler1 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }; var handler2 = new RecordedDelegatingHandler { StatusCodeToReturn = HttpStatusCode.OK }; using (MockContext context = MockContext.Start(this.GetType().FullName)) { var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(context, handler1, true); var networkManagementClient = NetworkManagementTestUtilities.GetNetworkManagementClientWithHandler(context, handler2); var location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/virtualNetworks"); string resourceGroupName = TestUtilities.GenerateName("csmrg"); resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName, new ResourceGroup { Location = location }); string vnet1Name = TestUtilities.GenerateName(); string vnet2Name = TestUtilities.GenerateName(); string subnet1Name = TestUtilities.GenerateName(); string subnet2Name = TestUtilities.GenerateName(); var vnet = new VirtualNetwork() { Location = location, AddressSpace = new AddressSpace() { AddressPrefixes = new List <string>() { "10.0.0.0/16", } }, DhcpOptions = new DhcpOptions() { DnsServers = new List <string>() { "10.1.1.1", "10.1.2.4" } }, Subnets = new List <Subnet>() { new Subnet() { Name = subnet1Name, AddressPrefix = "10.0.1.0/24", }, new Subnet() { Name = subnet2Name, AddressPrefix = "10.0.2.0/24", } } }; // Put Vnet var putVnetResponse = networkManagementClient.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnet1Name, vnet); Assert.Equal("Succeeded", putVnetResponse.ProvisioningState); // Get Vnet var getVnetResponse = networkManagementClient.VirtualNetworks.Get(resourceGroupName, vnet1Name); Assert.Equal(vnet1Name, getVnetResponse.Name); Assert.NotNull(getVnetResponse.ResourceGuid); Assert.Equal("Succeeded", getVnetResponse.ProvisioningState); // Create vnet2 var vnet2 = new VirtualNetwork() { Location = location, AddressSpace = new AddressSpace() { AddressPrefixes = new List <string>() { "10.1.0.0/16", } }, Subnets = new List <Subnet>() { new Subnet() { Name = subnet1Name, AddressPrefix = "10.1.1.0/24", } } }; // Put Vnet2 var putVnet2 = networkManagementClient.VirtualNetworks.CreateOrUpdate(resourceGroupName, vnet2Name, vnet2); Assert.Equal("Succeeded", putVnet2.ProvisioningState); // Create peering object var peering = new VirtualNetworkPeering() { AllowForwardedTraffic = true, RemoteVirtualNetwork = new Microsoft.Azure.Management.Network.Models.SubResource { Id = putVnet2.Id } }; // Create Peering networkManagementClient.VirtualNetworkPeerings.CreateOrUpdate(resourceGroupName, vnet1Name, "peer1", peering); // Get Peering var getPeer = networkManagementClient.VirtualNetworkPeerings.Get(resourceGroupName, vnet1Name, "peer1"); Assert.Equal("peer1", getPeer.Name); Assert.True(getPeer.AllowForwardedTraffic); Assert.True(getPeer.AllowVirtualNetworkAccess); Assert.False(getPeer.AllowGatewayTransit); Assert.NotNull(getPeer.RemoteVirtualNetwork); Assert.Equal(putVnet2.Id, getPeer.RemoteVirtualNetwork.Id); // List Peering var listPeer = networkManagementClient.VirtualNetworkPeerings.List(resourceGroupName, vnet1Name).ToList(); Assert.Single(listPeer); Assert.Equal("peer1", listPeer[0].Name); Assert.True(listPeer[0].AllowForwardedTraffic); Assert.True(listPeer[0].AllowVirtualNetworkAccess); Assert.False(listPeer[0].AllowGatewayTransit); Assert.NotNull(listPeer[0].RemoteVirtualNetwork); Assert.Equal(putVnet2.Id, listPeer[0].RemoteVirtualNetwork.Id); // Get peering from GET vnet var peeringVnet = networkManagementClient.VirtualNetworks.Get(resourceGroupName, vnet1Name); Assert.Equal(vnet1Name, peeringVnet.Name); Assert.Single(peeringVnet.VirtualNetworkPeerings); Assert.Equal("peer1", peeringVnet.VirtualNetworkPeerings[0].Name); Assert.True(peeringVnet.VirtualNetworkPeerings[0].AllowForwardedTraffic); Assert.True(peeringVnet.VirtualNetworkPeerings[0].AllowVirtualNetworkAccess); Assert.False(peeringVnet.VirtualNetworkPeerings[0].AllowGatewayTransit); Assert.NotNull(peeringVnet.VirtualNetworkPeerings[0].RemoteVirtualNetwork); Assert.Equal(putVnet2.Id, peeringVnet.VirtualNetworkPeerings[0].RemoteVirtualNetwork.Id); // Delete Peering networkManagementClient.VirtualNetworkPeerings.Delete(resourceGroupName, vnet1Name, "peer1"); listPeer = networkManagementClient.VirtualNetworkPeerings.List(resourceGroupName, vnet1Name).ToList(); Assert.Empty(listPeer); peeringVnet = networkManagementClient.VirtualNetworks.Get(resourceGroupName, vnet1Name); Assert.Equal(vnet1Name, peeringVnet.Name); Assert.Empty(peeringVnet.VirtualNetworkPeerings); // Delete Vnets networkManagementClient.VirtualNetworks.Delete(resourceGroupName, vnet1Name); networkManagementClient.VirtualNetworks.Delete(resourceGroupName, vnet2Name); } }