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