public PSVirtualNetworkGateway ToPsVirtualNetworkGateway(VirtualNetworkGateway vnetGateway)
{
var psVirtualNetworkGateway = Mapper.Map <PSVirtualNetworkGateway>(vnetGateway);
psVirtualNetworkGateway.Tag = TagsConversionHelper.CreateTagHashtable(vnetGateway.Tags);
return(psVirtualNetworkGateway);
}
internal void Bind(VirtualNetworkGateway virtualNetworkGateway, TargetTreeView targetTreeView)
{
try
{
_IsBinding = true;
_VirtualNetworkGateway = virtualNetworkGateway;
_TargetTreeView = targetTreeView;
txtTargetName.Text = _VirtualNetworkGateway.TargetName;
}
finally
{
_IsBinding = false;
}
}
/// <summary>
/// Creates or updates a virtual network gateway in the specified resource
/// group.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='virtualNetworkGatewayName'>
/// The name of the virtual network gateway.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to create or update virtual network gateway operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <VirtualNetworkGateway> CreateOrUpdateAsync(this IVirtualNetworkGatewaysOperations operations, string resourceGroupName, string virtualNetworkGatewayName, VirtualNetworkGateway parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, virtualNetworkGatewayName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Creates or updates a virtual network gateway in the specified resource
/// group.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='virtualNetworkGatewayName'>
/// The name of the virtual network gateway.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to create or update virtual network gateway operation.
/// </param>
public static VirtualNetworkGateway BeginCreateOrUpdate(this IVirtualNetworkGatewaysOperations operations, string resourceGroupName, string virtualNetworkGatewayName, VirtualNetworkGateway parameters)
{
return(operations.BeginCreateOrUpdateAsync(resourceGroupName, virtualNetworkGatewayName, parameters).GetAwaiter().GetResult());
}
public void TroubleshootApiTest()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler2 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler3 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
var handler4 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(context, handler1);
var networkManagementClient = NetworkManagementTestUtilities.GetNetworkManagementClientWithHandler(context, handler2);
var computeManagementClient = NetworkManagementTestUtilities.GetComputeManagementClientWithHandler(context, handler3);
var storageManagementClient = NetworkManagementTestUtilities.GetStorageManagementClientWithHandler(context, handler4);
string location = "westcentralus";
string resourceGroupName = TestUtilities.GenerateName();
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
new ResourceGroup
{
Location = location
});
// CreateVirtualNetworkGateway API
// Prerequisite:- Create PublicIPAddress(Gateway Ip) using Put PublicIPAddress API
string publicIpName = TestUtilities.GenerateName();
string domainNameLabel = TestUtilities.GenerateName();
var nic1publicIp = TestHelper.CreateDefaultPublicIpAddress(publicIpName, resourceGroupName, domainNameLabel, location, networkManagementClient);
//Prerequisite:-Create Virtual Network using Put VirtualNetwork API
string vnetName = TestUtilities.GenerateName();
string subnetName = "GatewaySubnet";
var virtualNetwork = TestHelper.CreateVirtualNetwork(vnetName, subnetName, resourceGroupName, location, networkManagementClient);
var getSubnetResponse = networkManagementClient.Subnets.Get(resourceGroupName, vnetName, subnetName);
// CreateVirtualNetworkGateway API
string virtualNetworkGatewayName = TestUtilities.GenerateName();
string ipConfigName = TestUtilities.GenerateName();
var virtualNetworkGateway = new VirtualNetworkGateway()
{
Location = location,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
EnableBgp = false,
GatewayDefaultSite = null,
GatewayType = VirtualNetworkGatewayType.Vpn,
VpnType = VpnType.RouteBased,
IpConfigurations = new List <VirtualNetworkGatewayIPConfiguration>()
{
new VirtualNetworkGatewayIPConfiguration()
{
Name = ipConfigName,
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
PublicIPAddress = new SubResource()
{
Id = nic1publicIp.Id
},
Subnet = new SubResource()
{
Id = getSubnetResponse.Id
}
}
},
Sku = new VirtualNetworkGatewaySku()
{
Name = VirtualNetworkGatewaySkuName.Basic,
Tier = VirtualNetworkGatewaySkuTier.Basic
}
};
var putVirtualNetworkGatewayResponse = networkManagementClient.VirtualNetworkGateways.CreateOrUpdate(resourceGroupName, virtualNetworkGatewayName, virtualNetworkGateway);
// GetVirtualNetworkGateway API
var getVirtualNetworkGatewayResponse = networkManagementClient.VirtualNetworkGateways.Get(resourceGroupName, virtualNetworkGatewayName);
string networkWatcherName = TestUtilities.GenerateName();
NetworkWatcher properties = new NetworkWatcher();
properties.Location = location;
//Create network Watcher
var createNetworkWatcher = networkManagementClient.NetworkWatchers.CreateOrUpdate(resourceGroupName, networkWatcherName, properties);
//Create storage
string storageName = TestUtilities.GenerateName();
var storageParameters = new StorageAccountCreateParameters()
{
Location = location,
Kind = Kind.Storage,
Sku = new Sku
{
Name = SkuName.StandardLRS
}
};
var account = storageManagementClient.StorageAccounts.Create(resourceGroupName, storageName, storageParameters);
TroubleshootingParameters parameters = new TroubleshootingParameters()
{
TargetResourceId = getVirtualNetworkGatewayResponse.Id,
StorageId = account.Id,
StoragePath = "https://nwtestdbdzq4xsvskrei6.blob.core.windows.net/vhds",
};
//Get troubleshooting
var troubleshoot = networkManagementClient.NetworkWatchers.GetTroubleshooting(resourceGroupName, networkWatcherName, parameters);
QueryTroubleshootingParameters qParameters = new QueryTroubleshootingParameters()
{
TargetResourceId = getVirtualNetworkGatewayResponse.Id
};
//Query last troubleshoot
var queryTroubleshoot = networkManagementClient.NetworkWatchers.GetTroubleshootingResult(resourceGroupName, networkWatcherName, qParameters);
//TO DO: make verification once fixed for troubleshoot API deployed
}
}
public async Task TroubleshootApiTest()
{
string resourceGroupName = Recording.GenerateAssetName("azsmnet");
string location = "westus2";
await ResourceGroupsOperations.CreateOrUpdateAsync(resourceGroupName, new ResourceGroup(location));
// CreateVirtualNetworkGateway API
// Prerequisite:- Create PublicIPAddress(Gateway Ip) using Put PublicIPAddress API
string publicIpName = Recording.GenerateAssetName("azsmnet");
string domainNameLabel = Recording.GenerateAssetName("azsmnet");
PublicIPAddress nic1publicIp = await CreateDefaultPublicIpAddress(publicIpName, resourceGroupName, domainNameLabel, location, NetworkManagementClient);
//Prerequisite:-Create Virtual Network using Put VirtualNetwork API
string vnetName = Recording.GenerateAssetName("azsmnet");
string subnetName = "GatewaySubnet";
await CreateVirtualNetwork(vnetName, subnetName, resourceGroupName, location, NetworkManagementClient);
Response <Subnet> getSubnetResponse = await NetworkManagementClient.Subnets.GetAsync(resourceGroupName, vnetName, subnetName);
// CreateVirtualNetworkGateway API
string virtualNetworkGatewayName = Recording.GenerateAssetName("azsmnet");
string ipConfigName = Recording.GenerateAssetName("azsmnet");
VirtualNetworkGateway virtualNetworkGateway = new VirtualNetworkGateway()
{
Location = location,
Tags = { { "key", "value" } },
EnableBgp = false,
GatewayDefaultSite = null,
GatewayType = VirtualNetworkGatewayType.Vpn,
VpnType = VpnType.RouteBased,
IpConfigurations =
{
new VirtualNetworkGatewayIPConfiguration()
{
Name = ipConfigName,
PrivateIPAllocationMethod = IPAllocationMethod.Dynamic,
PublicIPAddress = new SubResource()
{
Id = nic1publicIp.Id
}, Subnet = new SubResource()
{
Id = getSubnetResponse.Value.Id
}
}
},
Sku = new VirtualNetworkGatewaySku()
{
Name = VirtualNetworkGatewaySkuName.Basic, Tier = VirtualNetworkGatewaySkuTier.Basic
}
};
VirtualNetworkGatewaysCreateOrUpdateOperation putVirtualNetworkGatewayResponseOperation =
await NetworkManagementClient.VirtualNetworkGateways.StartCreateOrUpdateAsync(resourceGroupName, virtualNetworkGatewayName, virtualNetworkGateway);
await WaitForCompletionAsync(putVirtualNetworkGatewayResponseOperation);
// GetVirtualNetworkGateway API
Response <VirtualNetworkGateway> getVirtualNetworkGatewayResponse =
await NetworkManagementClient.VirtualNetworkGateways.GetAsync(resourceGroupName, virtualNetworkGatewayName);
//TODO:There is no need to perform a separate create NetworkWatchers operation
//Create network Watcher
//string networkWatcherName = Recording.GenerateAssetName("azsmnet");
//NetworkWatcher properties = new NetworkWatcher { Location = location };
//await NetworkManagementClient.NetworkWatchers.CreateOrUpdateAsync(resourceGroupName, networkWatcherName, properties);
//Create storage
string storageName = Recording.GenerateAssetName("azsmnet");
var storageParameters = new StorageAccountCreateParameters(new Sku(SkuName.StandardLRS), Kind.Storage, location);
Operation <StorageAccount> accountOperation = await StorageManagementClient.StorageAccounts.StartCreateAsync(resourceGroupName, storageName, storageParameters);
Response <StorageAccount> account = await WaitForCompletionAsync(accountOperation);
TroubleshootingParameters parameters = new TroubleshootingParameters(getVirtualNetworkGatewayResponse.Value.Id, account.Value.Id, "https://nwtestdbdzq4xsvskrei6.blob.core.windows.net/vhds");
//Get troubleshooting
NetworkWatchersGetTroubleshootingOperation troubleshootOperation = await NetworkManagementClient.NetworkWatchers.StartGetTroubleshootingAsync("NetworkWatcherRG", "NetworkWatcher_westus2", parameters);
await WaitForCompletionAsync(troubleshootOperation);
QueryTroubleshootingParameters qParameters = new QueryTroubleshootingParameters(getVirtualNetworkGatewayResponse.Value.Id);
//Query last troubleshoot
NetworkWatchersGetTroubleshootingResultOperation queryTroubleshootOperation = await NetworkManagementClient.NetworkWatchers.StartGetTroubleshootingResultAsync("NetworkWatcherRG", "NetworkWatcher_westus2", qParameters);
await WaitForCompletionAsync(queryTroubleshootOperation);
//TODO: make verification once fixed for troubleshoot API deployed
}
public void VirtualNetworkGatewayConnectionSharedKeyOperationsApisTest()
{
var handler = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (var context = UndoContext.Current)
{
context.Start();
var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(handler);
var networkResourceProviderClient = NetworkManagementTestUtilities.GetNetworkResourceProviderClient(handler);
var location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/connections");
string resourceGroupName = TestUtilities.GenerateName("csmrg");
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
new ResourceGroup
{
Location = location
});
// 1. SetVirtualNetworkGatewayConnectionSharedKey API
// Pre-requsite:- CreateVirtualNetworkGatewayConnection first
// Create VirtualNetworkGateway1
// a. Create PublicIPAddress(Gateway Ip) using Put PublicIpAddress API
string publicIpName = TestUtilities.GenerateName();
string domainNameLabel = TestUtilities.GenerateName();
var nic1publicIp = TestHelper.CreateDefaultPublicIpAddress(publicIpName, resourceGroupName, domainNameLabel, location, networkResourceProviderClient);
Console.WriteLine("PublicIPAddress(Gateway Ip) :{0}", nic1publicIp.Id);
// b. Create Virtual Network using Put VirtualNetwork API
string vnetName = TestUtilities.GenerateName();
string subnetName = "GatewaySubnet";
var virtualNetwork = TestHelper.CreateVirtualNetwork(vnetName, subnetName, resourceGroupName, location, networkResourceProviderClient);
var getSubnetResponse = networkResourceProviderClient.Subnets.Get(resourceGroupName, vnetName, subnetName);
Console.WriteLine("Virtual Network GatewaySubnet Id: {0}", getSubnetResponse.Subnet.Id);
// c. CreateVirtualNetworkGateway API
string virtualNetworkGatewayName = TestUtilities.GenerateName();
string ipConfigName = TestUtilities.GenerateName();
var virtualNetworkGateway = new VirtualNetworkGateway()
{
Location = location,
Name = virtualNetworkGatewayName,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
EnableBgp = false,
GatewayType = VirtualNetworkGatewayType.Vpn,
VpnType = VpnType.RouteBased,
IpConfigurations = new List <VirtualNetworkGatewayIpConfiguration>()
{
new VirtualNetworkGatewayIpConfiguration()
{
Name = ipConfigName,
PrivateIpAllocationMethod = IpAllocationMethod.Dynamic,
PublicIpAddress = new ResourceId()
{
Id = nic1publicIp.Id
},
Subnet = new ResourceId()
{
Id = getSubnetResponse.Subnet.Id
}
}
}
};
var putVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.CreateOrUpdate(resourceGroupName, virtualNetworkGatewayName, virtualNetworkGateway);
Assert.Equal(HttpStatusCode.OK, putVirtualNetworkGatewayResponse.StatusCode);
Assert.Equal("Succeeded", putVirtualNetworkGatewayResponse.Status);
var getVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.Get(resourceGroupName, virtualNetworkGatewayName);
// Create LocalNetworkGateway2
string localNetworkGatewayName = TestUtilities.GenerateName();
string gatewayIp = "192.168.3.4";
var localNetworkGateway = new LocalNetworkGateway()
{
Location = location,
Name = localNetworkGatewayName,
Tags = new Dictionary <string, string>()
{
{ "test", "value" }
},
GatewayIpAddress = gatewayIp,
LocalNetworkAddressSpace = new AddressSpace()
{
AddressPrefixes = new List <string>()
{
"192.168.0.0/16",
}
}
};
var putLocalNetworkGatewayResponse = networkResourceProviderClient.LocalNetworkGateways.CreateOrUpdate(resourceGroupName, localNetworkGatewayName, localNetworkGateway);
Assert.Equal(HttpStatusCode.OK, putLocalNetworkGatewayResponse.StatusCode);
Assert.Equal("Succeeded", putLocalNetworkGatewayResponse.Status);
var getLocalNetworkGatewayResponse = networkResourceProviderClient.LocalNetworkGateways.Get(resourceGroupName, localNetworkGatewayName);
getLocalNetworkGatewayResponse.LocalNetworkGateway.Location = location;
// CreaetVirtualNetworkGatewayConnection API
string VirtualNetworkGatewayConnectionName = TestUtilities.GenerateName();
var virtualNetworkGatewayConneciton = new VirtualNetworkGatewayConnection()
{
Location = location,
Name = VirtualNetworkGatewayConnectionName,
VirtualNetworkGateway1 = getVirtualNetworkGatewayResponse.VirtualNetworkGateway,
LocalNetworkGateway2 = getLocalNetworkGatewayResponse.LocalNetworkGateway,
ConnectionType = VirtualNetworkGatewayConnectionType.IPsec,
RoutingWeight = 3,
SharedKey = "abc"
};
var putVirtualNetworkGatewayConnectionResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.CreateOrUpdate(resourceGroupName, VirtualNetworkGatewayConnectionName, virtualNetworkGatewayConneciton);
Assert.Equal(HttpStatusCode.OK, putVirtualNetworkGatewayConnectionResponse.StatusCode);
Assert.Equal("Succeeded", putVirtualNetworkGatewayConnectionResponse.Status);
// SetVirtualNetworkGatewayConnectionSharedKey API on created connection above:- virtualNetworkGatewayConneciton
string connectionSharedKeyName = VirtualNetworkGatewayConnectionName;
var connectionSharedKey = new ConnectionSharedKey()
{
Value = "TestSharedKeyValue"
};
var putConnectionSharedKeyResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.SetSharedKey(resourceGroupName, connectionSharedKeyName, connectionSharedKey);
Assert.Equal(HttpStatusCode.OK, putConnectionSharedKeyResponse.StatusCode);
Assert.Equal("Succeeded", putConnectionSharedKeyResponse.Status);
// 2. GetVirtualNetworkGatewayConnectionSharedKey API
var getconnectionSharedKeyResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.GetSharedKey(resourceGroupName, connectionSharedKeyName);
Assert.Equal(HttpStatusCode.OK, getconnectionSharedKeyResponse.StatusCode);
Console.WriteLine("ConnectionSharedKey details:- Value: {0}", getconnectionSharedKeyResponse.Value);
// 3A. VirtualNetworkGatewayConnectionResetSharedKey API
var connectionResetSharedKey = new ConnectionResetSharedKey()
{
KeyLength = 50
};
var resetConnectionResetSharedKeyResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.ResetSharedKey(resourceGroupName, connectionSharedKeyName, connectionResetSharedKey);
Assert.Equal(HttpStatusCode.OK, resetConnectionResetSharedKeyResponse.StatusCode);
Assert.Equal("Succeeded", resetConnectionResetSharedKeyResponse.Status);
// 3B. GetVirtualNetworkGatewayConnectionSharedKey API after VirtualNetworkGatewayConnectionResetSharedKey API was called
getconnectionSharedKeyResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.GetSharedKey(resourceGroupName, connectionSharedKeyName);
Assert.Equal(HttpStatusCode.OK, getconnectionSharedKeyResponse.StatusCode);
Console.WriteLine("ConnectionSharedKey details:- Value: {0}", getconnectionSharedKeyResponse.Value);
}
}
public void VirtualNetworkGatewayConnectionOperationsApisTest()
{
var handler = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (var context = UndoContext.Current)
{
context.Start();
var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(handler);
var networkResourceProviderClient = NetworkManagementTestUtilities.GetNetworkResourceProviderClient(handler);
var location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/connections");
string resourceGroupName = TestUtilities.GenerateName("csmrg");
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
new ResourceGroup
{
Location = location
});
// 1. CreateVirtualNetworkGatewayConnection API
// A. Prerequisite:- Create VirtualNetworkGateway1
// a. Create PublicIPAddress(Gateway Ip) using Put PublicIpAddress API
string publicIpName = TestUtilities.GenerateName();
string domainNameLabel = TestUtilities.GenerateName();
var nic1publicIp = TestHelper.CreateDefaultPublicIpAddress(publicIpName, resourceGroupName, domainNameLabel, location, networkResourceProviderClient);
Console.WriteLine("PublicIPAddress(Gateway Ip) :{0}", nic1publicIp.Id);
// b. Create Virtual Network using Put VirtualNetwork API
string vnetName = TestUtilities.GenerateName();
string subnetName = "GatewaySubnet";
var virtualNetwork = TestHelper.CreateVirtualNetwork(vnetName, subnetName, resourceGroupName, location, networkResourceProviderClient);
var getSubnetResponse = networkResourceProviderClient.Subnets.Get(resourceGroupName, vnetName, subnetName);
Console.WriteLine("Virtual Network GatewaySubnet Id: {0}", getSubnetResponse.Subnet.Id);
//c. CreateVirtualNetworkGateway API
string virtualNetworkGatewayName = TestUtilities.GenerateName();
string ipConfigName = TestUtilities.GenerateName();
var virtualNetworkGateway = new VirtualNetworkGateway()
{
Location = location,
Name = virtualNetworkGatewayName,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
EnableBgp = false,
GatewayType = VirtualNetworkGatewayType.Vpn,
VpnType = VpnType.RouteBased,
IpConfigurations = new List <VirtualNetworkGatewayIpConfiguration>()
{
new VirtualNetworkGatewayIpConfiguration()
{
Name = ipConfigName,
PrivateIpAllocationMethod = IpAllocationMethod.Dynamic,
PublicIpAddress = new ResourceId()
{
Id = nic1publicIp.Id
},
Subnet = new ResourceId()
{
Id = getSubnetResponse.Subnet.Id
}
}
}
};
var putVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.CreateOrUpdate(resourceGroupName, virtualNetworkGatewayName, virtualNetworkGateway);
Assert.Equal(HttpStatusCode.OK, putVirtualNetworkGatewayResponse.StatusCode);
Assert.Equal("Succeeded", putVirtualNetworkGatewayResponse.Status);
var getVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.Get(resourceGroupName, virtualNetworkGatewayName);
//B. Create LocalNetworkGateway2
string localNetworkGatewayName = TestUtilities.GenerateName();
string gatewayIp = "192.168.3.4";
var localNetworkGateway = new LocalNetworkGateway()
{
Location = location,
Name = localNetworkGatewayName,
Tags = new Dictionary <string, string>()
{
{ "test", "value" }
},
GatewayIpAddress = gatewayIp,
LocalNetworkAddressSpace = new AddressSpace()
{
AddressPrefixes = new List <string>()
{
"192.168.0.0/16",
}
}
};
var putLocalNetworkGatewayResponse = networkResourceProviderClient.LocalNetworkGateways.CreateOrUpdate(resourceGroupName, localNetworkGatewayName, localNetworkGateway);
Assert.Equal(HttpStatusCode.OK, putLocalNetworkGatewayResponse.StatusCode);
Assert.Equal("Succeeded", putLocalNetworkGatewayResponse.Status);
var getLocalNetworkGatewayResponse = networkResourceProviderClient.LocalNetworkGateways.Get(resourceGroupName, localNetworkGatewayName);
getLocalNetworkGatewayResponse.LocalNetworkGateway.Location = location;
// C. CreaetVirtualNetworkGatewayConnection API
string VirtualNetworkGatewayConnectionName = TestUtilities.GenerateName();
var virtualNetworkGatewayConneciton = new VirtualNetworkGatewayConnection()
{
Location = location,
Name = VirtualNetworkGatewayConnectionName,
VirtualNetworkGateway1 = getVirtualNetworkGatewayResponse.VirtualNetworkGateway,
LocalNetworkGateway2 = getLocalNetworkGatewayResponse.LocalNetworkGateway,
ConnectionType = VirtualNetworkGatewayConnectionType.IPsec,
RoutingWeight = 3,
SharedKey = "abc"
};
var putVirtualNetworkGatewayConnectionResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.CreateOrUpdate(resourceGroupName, VirtualNetworkGatewayConnectionName, virtualNetworkGatewayConneciton);
Assert.Equal(HttpStatusCode.OK, putVirtualNetworkGatewayConnectionResponse.StatusCode);
Assert.Equal("Succeeded", putVirtualNetworkGatewayConnectionResponse.Status);
// 2. GetVirtualNetworkGatewayConnection API
var getVirtualNetworkGatewayConnectionResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.Get(resourceGroupName, VirtualNetworkGatewayConnectionName);
Assert.Equal(HttpStatusCode.OK, getVirtualNetworkGatewayConnectionResponse.StatusCode);
Console.WriteLine("GatewayConnection details:- GatewayLocation: {0}, GatewayConnectionId:{1}, VirtualNetworkGateway1 name={2} & Id={3}, LocalNetworkGateway2 name={4} & Id={5}, ConnectionType={6} RoutingWeight={7} SharedKey={8}",
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.Location, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.Id,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.Name,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.VirtualNetworkGateway1.Name, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.VirtualNetworkGateway1.Id,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.LocalNetworkGateway2.Name, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.LocalNetworkGateway2.Id,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.ConnectionType, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.RoutingWeight,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.SharedKey);
Assert.Equal(VirtualNetworkGatewayConnectionType.IPsec, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.ConnectionType);
Assert.Equal(3, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.RoutingWeight);
Assert.Equal("abc", getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.SharedKey);
// 3A. UpdateVirtualNetworkGatewayConnection API :- RoutingWeight = 3 => 4, SharedKey = "abc"=> "xyz"
virtualNetworkGatewayConneciton.RoutingWeight = 4;
virtualNetworkGatewayConneciton.SharedKey = "xyz";
putVirtualNetworkGatewayConnectionResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.CreateOrUpdate(resourceGroupName, VirtualNetworkGatewayConnectionName, virtualNetworkGatewayConneciton);
Assert.Equal(HttpStatusCode.OK, putVirtualNetworkGatewayConnectionResponse.StatusCode);
Assert.Equal("Succeeded", putVirtualNetworkGatewayConnectionResponse.Status);
// 3B. GetVirtualNetworkGatewayConnection API after Updating RoutingWeight = 3 => 4, SharedKey = "abc"=> "xyz"
getVirtualNetworkGatewayConnectionResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.Get(resourceGroupName, VirtualNetworkGatewayConnectionName);
Assert.Equal(HttpStatusCode.OK, getVirtualNetworkGatewayConnectionResponse.StatusCode);
Console.WriteLine("GatewayConnection details:- GatewayLocation: {0}, GatewayConnectionId:{1}, VirtualNetworkGateway1 name={2} & Id={3}, LocalNetworkGateway2 name={4} & Id={5}, ConnectionType={6} RoutingWeight={7} SharedKey={8}",
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.Location, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.Id,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.Name,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.VirtualNetworkGateway1.Name, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.VirtualNetworkGateway1.Id,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.LocalNetworkGateway2.Name, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.LocalNetworkGateway2.Id,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.ConnectionType, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.RoutingWeight,
getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.SharedKey);
Assert.Equal(4, getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.RoutingWeight);
Assert.Equal("xyz", getVirtualNetworkGatewayConnectionResponse.VirtualNetworkGatewayConnection.SharedKey);
// 4. ListVitualNetworkGatewayConnections API
var listVirtualNetworkGatewayConectionResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.List(resourceGroupName);
Assert.Equal(HttpStatusCode.OK, listVirtualNetworkGatewayConectionResponse.StatusCode);
Console.WriteLine("ListVirtualNetworkGatewayConnections count ={0} ", listVirtualNetworkGatewayConectionResponse.VirtualNetworkGatewayConnections.Count);
Assert.Equal(1, listVirtualNetworkGatewayConectionResponse.VirtualNetworkGatewayConnections.Count);
// 5A. DeleteVirtualNetworkGatewayConnection API
var deleteVirtualNetworkGatewayConnectionResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.Delete(resourceGroupName, VirtualNetworkGatewayConnectionName);
Assert.Equal(HttpStatusCode.OK, deleteVirtualNetworkGatewayConnectionResponse.StatusCode);
// 5B. ListVitualNetworkGatewayConnections API after DeleteVirtualNetworkGatewayConnection API called
listVirtualNetworkGatewayConectionResponse = networkResourceProviderClient.VirtualNetworkGatewayConnections.List(resourceGroupName);
Assert.Equal(HttpStatusCode.OK, listVirtualNetworkGatewayConectionResponse.StatusCode);
Console.WriteLine("ListVirtualNetworkGatewayConnections count ={0} ", listVirtualNetworkGatewayConectionResponse.VirtualNetworkGatewayConnections.Count);
Assert.Equal(0, listVirtualNetworkGatewayConectionResponse.VirtualNetworkGatewayConnections.Count);
}
}
public void VirtualNetworkGatewayOperationsApisTest()
{
var handler = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (var context = UndoContext.Current)
{
context.Start();
var resourcesClient = ResourcesManagementTestUtilities.GetResourceManagementClientWithHandler(handler);
var networkResourceProviderClient = NetworkManagementTestUtilities.GetNetworkResourceProviderClient(handler);
var location = NetworkManagementTestUtilities.GetResourceLocation(resourcesClient, "Microsoft.Network/virtualnetworkgateways");
string resourceGroupName = TestUtilities.GenerateName("csmrg");
resourcesClient.ResourceGroups.CreateOrUpdate(resourceGroupName,
new ResourceGroup
{
Location = location
});
// 1. CreateVirtualNetworkGateway API
// A. Prerequisite:- Create PublicIPAddress(Gateway Ip) using Put PublicIpAddress API
string publicIpName = TestUtilities.GenerateName();
string domainNameLabel = TestUtilities.GenerateName();
var nic1publicIp = TestHelper.CreateDefaultPublicIpAddress(publicIpName, resourceGroupName, domainNameLabel, location, networkResourceProviderClient);
Console.WriteLine("PublicIPAddress(Gateway Ip) :{0}", nic1publicIp.Id);
// B.Prerequisite:- Create Virtual Network using Put VirtualNetwork API
string vnetName = TestUtilities.GenerateName();
string subnetName = "GatewaySubnet";
var virtualNetwork = TestHelper.CreateVirtualNetwork(vnetName, subnetName, resourceGroupName, location, networkResourceProviderClient);
var getSubnetResponse = networkResourceProviderClient.Subnets.Get(resourceGroupName, vnetName, subnetName);
Console.WriteLine("Virtual Network GatewaySubnet Id: {0}", getSubnetResponse.Subnet.Id);
// C. CreateVirtualNetworkGateway API
string virtualNetworkGatewayName = TestUtilities.GenerateName();
string ipConfigName = TestUtilities.GenerateName();
var virtualNetworkGateway = new VirtualNetworkGateway()
{
Location = location,
Name = virtualNetworkGatewayName,
Tags = new Dictionary <string, string>()
{
{ "key", "value" }
},
EnableBgp = false,
GatewayType = VirtualNetworkGatewayType.Vpn,
VpnType = VpnType.RouteBased,
IpConfigurations = new List <VirtualNetworkGatewayIpConfiguration>()
{
new VirtualNetworkGatewayIpConfiguration()
{
Name = ipConfigName,
PrivateIpAllocationMethod = IpAllocationMethod.Dynamic,
PublicIpAddress = new ResourceId()
{
Id = nic1publicIp.Id
},
Subnet = new ResourceId()
{
Id = getSubnetResponse.Subnet.Id
}
}
}
};
var putVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.CreateOrUpdate(resourceGroupName, virtualNetworkGatewayName, virtualNetworkGateway);
Assert.Equal(HttpStatusCode.OK, putVirtualNetworkGatewayResponse.StatusCode);
Assert.Equal("Succeeded", putVirtualNetworkGatewayResponse.Status);
// 2. GetVirtualNetworkGateway API
var getVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.Get(resourceGroupName, virtualNetworkGatewayName);
Assert.Equal(HttpStatusCode.OK, getVirtualNetworkGatewayResponse.StatusCode);
Console.WriteLine("Gateway details:- GatewayLocation: {0}, GatewayId:{1}, GatewayName={2}, GatewayType={3}, VpnType={4}",
getVirtualNetworkGatewayResponse.VirtualNetworkGateway.Location,
getVirtualNetworkGatewayResponse.VirtualNetworkGateway.Id, getVirtualNetworkGatewayResponse.VirtualNetworkGateway.Name,
getVirtualNetworkGatewayResponse.VirtualNetworkGateway.GatewayType, getVirtualNetworkGatewayResponse.VirtualNetworkGateway.VpnType);
//Assert.Equal(VirtualNetworkGatewayType.Vpn, getVirtualNetworkGatewayResponse.VirtualNetworkGateway.GatewayType);
//Assert.Equal(VpnType.RouteBased, getVirtualNetworkGatewayResponse.VirtualNetworkGateway.VpnType);
// 3A. ResetVirtualNetworkGateway API
var resetVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.Reset(resourceGroupName, virtualNetworkGatewayName, virtualNetworkGateway);
Assert.Equal(HttpStatusCode.OK, resetVirtualNetworkGatewayResponse.StatusCode);
Assert.Equal("Succeeded", resetVirtualNetworkGatewayResponse.Status);
// 3B. GetVirtualNetworkgateway API after ResetVirtualNetworkGateway API was called
getVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.Get(resourceGroupName, virtualNetworkGatewayName);
Assert.Equal(HttpStatusCode.OK, getVirtualNetworkGatewayResponse.StatusCode);
Console.WriteLine("Gateway details:- GatewayLocation: {0}, GatewayId:{1}, GatewayName={2}, GatewayType={3} ",
getVirtualNetworkGatewayResponse.VirtualNetworkGateway.Location,
getVirtualNetworkGatewayResponse.VirtualNetworkGateway.Id, getVirtualNetworkGatewayResponse.VirtualNetworkGateway.Name,
getVirtualNetworkGatewayResponse.VirtualNetworkGateway.GatewayType);
// 4. ListVitualNetworkGateways API
var listVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.List(resourceGroupName);
Assert.Equal(HttpStatusCode.OK, listVirtualNetworkGatewayResponse.StatusCode);
Console.WriteLine("ListVirtualNetworkGateways count ={0} ", listVirtualNetworkGatewayResponse.VirtualNetworkGateways.Count);
Assert.Equal(1, listVirtualNetworkGatewayResponse.VirtualNetworkGateways.Count);
// 5A. DeleteVirtualNetworkGateway API
var deleteVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.Delete(resourceGroupName, virtualNetworkGatewayName);
Assert.Equal(HttpStatusCode.OK, deleteVirtualNetworkGatewayResponse.StatusCode);
// 5B. ListVitualNetworkGateways API after deleting VirtualNetworkGateway
listVirtualNetworkGatewayResponse = networkResourceProviderClient.VirtualNetworkGateways.List(resourceGroupName);
Assert.Equal(HttpStatusCode.OK, listVirtualNetworkGatewayResponse.StatusCode);
Console.WriteLine("ListVirtualNetworkGateways count ={0} ", listVirtualNetworkGatewayResponse.VirtualNetworkGateways.Count);
Assert.Equal(0, listVirtualNetworkGatewayResponse.VirtualNetworkGateways.Count);
}
}
/// <summary>
/// The Put VirtualNetworkGateway operation creates/updates a virtual network
/// gateway in the specified resource group through Network resource provider.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='virtualNetworkGatewayName'>
/// The name of the virtual network gateway.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the Begin Create or update Virtual Network Gateway
/// operation through Network resource provider.
/// </param>
public static VirtualNetworkGateway BeginCreateOrUpdate(this IVirtualNetworkGatewaysOperations operations, string resourceGroupName, string virtualNetworkGatewayName, VirtualNetworkGateway parameters)
{
return(Task.Factory.StartNew(s => ((IVirtualNetworkGatewaysOperations)s).BeginCreateOrUpdateAsync(resourceGroupName, virtualNetworkGatewayName, parameters), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
/// <summary>
/// The Reset VirtualNetworkGateway operation resets the primary of the
/// virtual network gateway in the specified resource group through Network
/// resource provider.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='virtualNetworkGatewayName'>
/// The name of the virtual network gateway.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the Begin Reset Virtual Network Gateway operation
/// through Network resource provider.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <VirtualNetworkGateway> BeginResetAsync(this IVirtualNetworkGatewaysOperations operations, string resourceGroupName, string virtualNetworkGatewayName, VirtualNetworkGateway parameters, CancellationToken cancellationToken = default(CancellationToken))
{
AzureOperationResponse <VirtualNetworkGateway> result = await operations.BeginResetWithHttpMessagesAsync(resourceGroupName, virtualNetworkGatewayName, parameters, null, cancellationToken).ConfigureAwait(false);
return(result.Body);
}
public async void LoadDocuments(string path)
{
string[] files = Directory.GetFiles(path, "*.xml");
Array.Sort(files);
foreach (var filename in files)
{
var doc = new XmlDocument();
doc.Load(filename);
var title = Path.GetFileNameWithoutExtension(filename);
var parts = title.Split('-');
string resourceType;
var info = new Hashtable();
switch (parts[1].ToLower())
{
case "azurelocations":
resourceType = "azurelocations";
foreach (XmlNode azureLocationXml in doc.SelectNodes("/Locations/Location"))
{
_AzureASMLocations.Add(new Location(_AzureContext, azureLocationXml));
}
break;
case "cloudservice":
resourceType = "CloudService";
info.Add("name", parts[2]);
_CloudServices.Add(new CloudService(_AzureContext, doc));
break;
case "virtualmachine":
resourceType = "VirtualMachine";
info.Add("cloudservicename", parts[2]);
info.Add("virtualmachinename", parts[3]);
info.Add("deploymentname", parts[4]);
info.Add("loadbalancername", String.Empty);
info.Add("virtualnetworkname", String.Empty);
CloudService parentCloudService = this.GetAzureAsmCloudService(parts[2]).Result;
VirtualMachine asmVirtualMachine = new VirtualMachine(_AzureContext, parentCloudService, this._AzureContext.SettingsProvider, doc, info);
await asmVirtualMachine.InitializeChildren();
asmVirtualMachine.OSVirtualHardDisk.TargetStorageAccount = asmVirtualMachine.OSVirtualHardDisk.SourceStorageAccount;
asmVirtualMachine.TargetVirtualNetwork = asmVirtualMachine.SourceVirtualNetwork;
asmVirtualMachine.TargetSubnet = asmVirtualMachine.SourceSubnet;
foreach (Disk dataDisk in asmVirtualMachine.DataDisks)
{
dataDisk.TargetStorageAccount = dataDisk.SourceStorageAccount;
}
parentCloudService.VirtualMachines.Add(asmVirtualMachine);
break;
case "storageaccountkeys":
resourceType = "StorageAccountKeys";
info.Add("name", parts[2]);
this.GetAzureAsmStorageAccount(parts[2]).Result.Keys = new StorageAccountKeys(_AzureContext, doc);
break;
case "storageaccount":
resourceType = "StorageAccount";
info.Add("name", parts[2]);
_StorageAccounts.Add(new StorageAccount(_AzureContext, doc));
break;
case "virtualnetworks":
resourceType = "VirtualNetworks";
foreach (XmlNode virtualnetworksite in doc.SelectNodes("//VirtualNetworkSite"))
{
VirtualNetwork asmVirtualNetwork = new VirtualNetwork(_AzureContext, virtualnetworksite);
await asmVirtualNetwork.InitializeChildrenAsync();
_VirtualNetworks.Add(asmVirtualNetwork);
}
break;
case "clientrootcertificates":
resourceType = "ClientRootCertificates";
info.Add("virtualnetworkname", parts[2]);
foreach (XmlNode clientRootCertificateXml in doc.SelectNodes("//ClientRootCertificate"))
{
_ClientRootCertificates.Add(new ClientRootCertificate(_AzureContext, _VirtualNetworks[0], clientRootCertificateXml));
}
break;
case "clientrootcertificate":
resourceType = "ClientRootCertificate";
info.Add("virtualnetworkname", parts[2]);
info.Add("thumbprint", parts[3]);
break;
case "virtualnetworkgateway":
resourceType = "VirtualNetworkGateway";
info.Add("virtualnetworkname", parts[2]);
_VirtualNetworkGateway = new VirtualNetworkGateway(_AzureContext, _VirtualNetworks[0], doc);
_VirtualNetworks[0].Gateway = _VirtualNetworkGateway;
break;
case "virtualnetworkgatewaysharedkey":
resourceType = "VirtualNetworkGatewaySharedKey";
info.Add("virtualnetworkname", parts[2]);
info.Add("localnetworksitename", parts[3]);
break;
case "networksecuritygroup":
resourceType = "NetworkSecurityGroup";
info.Add("name", parts[2]);
_NetworkSecurityGroup = new NetworkSecurityGroup(_AzureContext, doc.SelectSingleNode("NetworkSecurityGroup"));
break;
case "routetable":
resourceType = "RouteTable";
info.Add("name", parts[2]);
_AsmRouteTable = new RouteTable(_AzureContext, doc);
break;
case "reservedips":
resourceType = "ReservedIPs";
break;
default:
throw new Exception();
}
SetResponse(resourceType, info, doc);
}
}
/// <summary>
/// The Put VirtualNetworkGateway operation creates/updates a virtual
/// network gateway in the specified resource group through Network
/// resource provider.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.Network.IVirtualNetworkGatewayOperations.
/// </param>
/// <param name='resourceGroupName'>
/// Required. The name of the resource group.
/// </param>
/// <param name='virtualNetworkGatewayName'>
/// Required. The name of the virtual network gateway.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Begin Create or update Virtual
/// Network Gateway operation through Network resource provider.
/// </param>
/// <returns>
/// Response for PutVirtualNetworkGateway Api servive call
/// </returns>
public static Task <VirtualNetworkGatewayPutResponse> BeginCreateOrUpdatingAsync(this IVirtualNetworkGatewayOperations operations, string resourceGroupName, string virtualNetworkGatewayName, VirtualNetworkGateway parameters)
{
return(operations.BeginCreateOrUpdatingAsync(resourceGroupName, virtualNetworkGatewayName, parameters, CancellationToken.None));
}
/// <summary>
/// The Reset VirtualNetworkGateway operation resets the primary of the
/// virtual network gateway in the specified resource group through
/// Network resource provider.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.Network.IVirtualNetworkGatewayOperations.
/// </param>
/// <param name='resourceGroupName'>
/// Required. The name of the resource group.
/// </param>
/// <param name='virtualNetworkGatewayName'>
/// Required. The name of the virtual network gateway.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Begin Reset Virtual Network
/// Gateway operation through Network resource provider.
/// </param>
/// <returns>
/// The response body contains the status of the specified asynchronous
/// operation, indicating whether it has succeeded, is inprogress, or
/// has failed. Note that this status is distinct from the HTTP status
/// code returned for the Get Operation Status operation itself. If
/// the asynchronous operation succeeded, the response body includes
/// the HTTP status code for the successful request. If the
/// asynchronous operation failed, the response body includes the HTTP
/// status code for the failed request and error information regarding
/// the failure.
/// </returns>
public static Task <AzureAsyncOperationResponse> ResetAsync(this IVirtualNetworkGatewayOperations operations, string resourceGroupName, string virtualNetworkGatewayName, VirtualNetworkGateway parameters)
{
return(operations.ResetAsync(resourceGroupName, virtualNetworkGatewayName, parameters, CancellationToken.None));
}
/// <summary>
/// The Reset VirtualNetworkGateway operation resets the primary of the
/// virtual network gateway in the specified resource group through
/// Network resource provider.
/// </summary>
/// <param name='operations'>
/// Reference to the
/// Microsoft.Azure.Management.Network.IVirtualNetworkGatewayOperations.
/// </param>
/// <param name='resourceGroupName'>
/// Required. The name of the resource group.
/// </param>
/// <param name='virtualNetworkGatewayName'>
/// Required. The name of the virtual network gateway.
/// </param>
/// <param name='parameters'>
/// Required. Parameters supplied to the Begin Reset Virtual Network
/// Gateway operation through Network resource provider.
/// </param>
/// <returns>
/// The response body contains the status of the specified asynchronous
/// operation, indicating whether it has succeeded, is inprogress, or
/// has failed. Note that this status is distinct from the HTTP status
/// code returned for the Get Operation Status operation itself. If
/// the asynchronous operation succeeded, the response body includes
/// the HTTP status code for the successful request. If the
/// asynchronous operation failed, the response body includes the HTTP
/// status code for the failed request and error information regarding
/// the failure.
/// </returns>
public static AzureAsyncOperationResponse Reset(this IVirtualNetworkGatewayOperations operations, string resourceGroupName, string virtualNetworkGatewayName, VirtualNetworkGateway parameters)
{
return(Task.Factory.StartNew((object s) =>
{
return ((IVirtualNetworkGatewayOperations)s).ResetAsync(resourceGroupName, virtualNetworkGatewayName, parameters);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
