public void TestListSqlVirtualMachineGroup()
{
using (SqlVirtualMachineTestContext context = new SqlVirtualMachineTestContext(this))
{
// Create SQL VM group
ISqlVirtualMachineGroupsOperations sqlOperations = context.getSqlClient().SqlVirtualMachineGroups;
StorageAccount storageAccount = VirtualMachineTestBase.CreateStorageAccount(context);
SqlVirtualMachineGroup group = SqlVirtualMachineTestBase.CreateSqlVirtualMachineGroup(context, storageAccount, "test-group");
// List
IPage <SqlVirtualMachineGroup> list = sqlOperations.List();
IEnumerator <SqlVirtualMachineGroup> iter = list.GetEnumerator();
int count = 0;
while (iter.MoveNext())
{
SqlVirtualMachineGroup group2 = iter.Current;
if (group.Id.Equals(group2.Id))
{
SqlVirtualMachineTestBase.ValidateSqlVirtualMachineGroups(group, group2);
count++;
}
}
iter.Dispose();
Assert.Equal(1, count);
}
}
public void TestCreateUpdateGetSqlVirtualMachineGroup()
{
using (SqlVirtualMachineTestContext context = new SqlVirtualMachineTestContext(this))
{
// Create SQL VM group
ISqlVirtualMachineGroupsOperations sqlOperations = context.getSqlClient().SqlVirtualMachineGroups;
StorageAccount storageAccount = VirtualMachineTestBase.CreateStorageAccount(context);
SqlVirtualMachineGroup group = SqlVirtualMachineTestBase.CreateSqlVirtualMachineGroup(context, storageAccount, "test-group");
// Update
string key = "test", value = "updateTag";
sqlOperations.Update(context.resourceGroup.Name, group.Name, new SqlVirtualMachineGroupUpdate()
{
Tags = new Dictionary <string, string>
{
{ key, value }
}
});
// Get
SqlVirtualMachineGroup group2 = sqlOperations.Get(context.resourceGroup.Name, group.Name);
SqlVirtualMachineTestBase.ValidateSqlVirtualMachineGroups(group, group2, false);
Assert.Equal(1, group2.Tags.Keys.Count);
Assert.Equal(value, group2.Tags[key]);
}
}
public static SqlVirtualMachineGroup CreateSqlVirtualMachineGroup(SqlVirtualMachineTestContext context, StorageAccount storageAccount, string groupName = null, WsfcDomainProfile profile = null)
{
ISqlVirtualMachineGroupsOperations sqlOperations = context.getSqlClient().SqlVirtualMachineGroups;
StorageAccountListKeysResult storageAccountKeys = context.client.storageClient.StorageAccounts.ListKeys(context.resourceGroup.Name, storageAccount.Name);
IEnumerator <StorageAccountKey> iter = storageAccountKeys.Keys.GetEnumerator();
iter.MoveNext();
string key = iter.Current.Value;
string blobAccount = storageAccount.PrimaryEndpoints.Blob;
if (groupName == null)
{
groupName = context.generateResourceName();
}
SqlVirtualMachineGroup group = sqlOperations.CreateOrUpdate(context.resourceGroup.Name, groupName, new SqlVirtualMachineGroup
{
Location = context.location,
SqlImageOffer = Constants.imageOffer,
SqlImageSku = Constants.imageSku,
WsfcDomainProfile = (profile != null)? profile : new WsfcDomainProfile
{
SqlServiceAccount = getUsername(Constants.sqlService, Constants.domainName),
ClusterOperatorAccount = getUsername(Constants.adminLogin, Constants.domainName),
DomainFqdn = Constants.domainName + ".com",
StorageAccountUrl = blobAccount,
StorageAccountPrimaryKey = key
}
});
group.Validate();
return(group);
}
public static void ValidateSqlVirtualMachineGroups(SqlVirtualMachineGroup group1, SqlVirtualMachineGroup group2, bool sameTags = true)
{
Assert.Equal(group1.Id, group2.Id);
Assert.Equal(group1.Name, group2.Name);
Assert.Equal(group1.SqlImageOffer, group2.SqlImageOffer);
if (sameTags)
{
Assert.True(ValidateTags(group1, group2));
}
}
/// <summary>
/// Convert a Management.SqlVirtualMachine.Models.SqlVirtualMachineModel to AzureSqlVirtualMachineModel
/// </summary>
/// <param name="resourceGroupName">The resource group the sql virtual machine is in</param>
/// <param name="resp">The management client sql virtual machine response to convert</param>
/// <returns>The converted sql virtual machine model</returns>
private AzureSqlVMModel CreateSqlVirtualMachineModelFromResponse(SqlVirtualMachineModel resp)
{
// Extract the resource group name from the ID.
// ID is in the form:
// /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rgName/providers/Microsoft.SqlVirtualMachine/SqlVirtualMachine/sqlVirtualMachineName
string[] segments = resp.Id.Split('/');
AzureSqlVMModel model = new AzureSqlVMModel(segments[4])
{
Name = resp.Name,
Location = resp.Location,
Sku = resp.SqlImageSku,
Offer = resp.SqlImageOffer,
VirtualMachineId = resp.VirtualMachineResourceId,
SqlManagementType = resp.SqlManagement,
LicenseType = resp.SqlServerLicenseType,
Tags = TagsConversionHelper.CreateTagDictionary(TagsConversionHelper.CreateTagHashtable(resp.Tags), false),
ResourceId = resp.Id
};
// Retrieve group
if (!string.IsNullOrEmpty(resp.SqlVirtualMachineGroupResourceId))
{
var client = AzureSession.Instance.ClientFactory.CreateArmClient <SqlVirtualMachineManagementClient>(DefaultContext, AzureEnvironment.Endpoint.ResourceManager);
string[] groupId = resp.SqlVirtualMachineGroupResourceId.Split('/');
SqlVirtualMachineGroup group = client.SqlVirtualMachineGroups.Get(groupId[4], groupId[8]);
model.SqlVirtualMachineGroup = new AzureSqlVMGroupModel(groupId[4])
{
Name = group.Name,
Location = group.Location,
Sku = group.SqlImageSku,
Offer = group.SqlImageOffer,
ResourceId = group.Id,
Tag = TagsConversionHelper.CreateTagDictionary(TagsConversionHelper.CreateTagHashtable(group.Tags), false),
WsfcDomainProfile = group.WsfcDomainProfile
};
}
return(model);
}
public void TestCreateGetDeleteSqlVirtualMachineGroup()
{
using (SqlVirtualMachineTestContext context = new SqlVirtualMachineTestContext(this))
{
// Create SQL VM group
ISqlVirtualMachineGroupsOperations sqlOperations = context.getSqlClient().SqlVirtualMachineGroups;
StorageAccount storageAccount = VirtualMachineTestBase.CreateStorageAccount(context);
SqlVirtualMachineGroup group = SqlVirtualMachineTestBase.CreateSqlVirtualMachineGroup(context, storageAccount, "test-group");
// Recover
SqlVirtualMachineGroup group2 = sqlOperations.Get(context.resourceGroup.Name, group.Name);
SqlVirtualMachineTestBase.ValidateSqlVirtualMachineGroups(group, group2);
// Delete
sqlOperations.Delete(context.resourceGroup.Name, group.Name);
// Recover
IPage <SqlVirtualMachineGroup> list = sqlOperations.ListByResourceGroup(context.resourceGroup.Name);
IEnumerator <SqlVirtualMachineGroup> iter = list.GetEnumerator();
Assert.False(iter.MoveNext());
}
}
/// <summary>
/// Convert a Management.SqlVirtualMachine.Models.SqlVirtualMachineGroupModel to AzureSqlVirtualMachineGroupModel
/// </summary>
/// <param name="resourceGroupName">The resource group the sql virtual machine group is in</param>
/// <param name="resp">The management client sql virtual machine group response to convert</param>
/// <returns>The converted sql virtual machine group model</returns>
private static AzureSqlVMGroupModel CreateSqlVirtualMachineGroupModelFromResponse(SqlVirtualMachineGroup resp)
{
// Extract the resource group name from the ID.
string[] segments = resp.Id.Split('/');
AzureSqlVMGroupModel model = new AzureSqlVMGroupModel(segments[4])
{
Name = resp.Name,
Location = resp.Location,
Sku = resp.SqlImageSku,
Offer = resp.SqlImageOffer,
WsfcDomainProfile = resp.WsfcDomainProfile,
Tags = TagsConversionHelper.CreateTagDictionary(TagsConversionHelper.CreateTagHashtable(resp.Tags), true),
ResourceId = resp.Id
};
return(model);
}
/// <summary>
/// Creates or updates a Sql Virtual Machine group
/// </summary>
public SqlVirtualMachineGroup CreateOrUpdate(string resourceGroupName, string groupName, SqlVirtualMachineGroup parameters)
{
return(GetCurrentSqlClient().SqlVirtualMachineGroups.CreateOrUpdate(resourceGroupName, groupName, parameters));
}
/// <summary>
/// Creates or updates a SQL virtual machine group.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the resource group that contains the resource. You can obtain this
/// value from the Azure Resource Manager API or the portal.
/// </param>
/// <param name='sqlVirtualMachineGroupName'>
/// Name of the SQL virtual machine group.
/// </param>
/// <param name='parameters'>
/// The SQL virtual machine group.
/// </param>
public static SqlVirtualMachineGroup CreateOrUpdate(this ISqlVirtualMachineGroupsOperations operations, string resourceGroupName, string sqlVirtualMachineGroupName, SqlVirtualMachineGroup parameters)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, sqlVirtualMachineGroupName, parameters).GetAwaiter().GetResult());
}
/// <summary>
/// Creates or updates a SQL virtual machine group.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the resource group that contains the resource. You can obtain this
/// value from the Azure Resource Manager API or the portal.
/// </param>
/// <param name='sqlVirtualMachineGroupName'>
/// Name of the SQL virtual machine group.
/// </param>
/// <param name='parameters'>
/// The SQL virtual machine group.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <SqlVirtualMachineGroup> BeginCreateOrUpdateAsync(this ISqlVirtualMachineGroupsOperations operations, string resourceGroupName, string sqlVirtualMachineGroupName, SqlVirtualMachineGroup parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginCreateOrUpdateWithHttpMessagesAsync(resourceGroupName, sqlVirtualMachineGroupName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public static SqlVirtualMachineModel CreateSqlVirtualMachine(SqlVirtualMachineTestContext context, SqlVirtualMachineGroup group = null, VirtualMachine virtualMachine = null)
{
ISqlVirtualMachinesOperations sqlOperations = context.getSqlClient().SqlVirtualMachines;
VirtualMachine vm = virtualMachine == null?VirtualMachineTestBase.CreateVM(context) : virtualMachine;
SqlVirtualMachineModel sqlVM = sqlOperations.CreateOrUpdate(context.resourceGroup.Name, vm.Name, new SqlVirtualMachineModel()
{
Location = context.location,
VirtualMachineResourceId = vm.Id,
SqlServerLicenseType = SqlServerLicenseType.PAYG,
SqlManagement = SqlManagementMode.Full,
SqlImageSku = Constants.imageSku,
SqlImageOffer = Constants.imageOffer,
SqlVirtualMachineGroupResourceId = (group != null) ? group.Id : null,
ServerConfigurationsManagementSettings = new ServerConfigurationsManagementSettings()
{
SqlConnectivityUpdateSettings = new SqlConnectivityUpdateSettings()
{
SqlAuthUpdateUserName = Constants.sqlLogin,
SqlAuthUpdatePassword = Constants.adminPassword,
ConnectivityType = "Private",
Port = 1433
},
SqlStorageUpdateSettings = new SqlStorageUpdateSettings()
{
DiskCount = 1,
DiskConfigurationType = "NEW",
StartingDeviceId = 2
},
SqlWorkloadTypeUpdateSettings = new SqlWorkloadTypeUpdateSettings()
{
SqlWorkloadType = "OLTP"
}
},
AutoPatchingSettings = new AutoPatchingSettings(false)
});
sqlVM.Validate();
return(sqlVM);
}
public static bool ValidateTags(SqlVirtualMachineGroup group1, SqlVirtualMachineGroup group2)
{
return(ValidateTags(group1.Tags, group2.Tags));
}
private static SqlVirtualMachineModel prepareMachine(SqlVirtualMachineTestContext context, SqlVirtualMachineGroup group, VirtualMachine vm, string domain, string login, string password)
{
// Create the sql virtual machine
SqlVirtualMachineModel sqlVM = CreateSqlVirtualMachine(context, virtualMachine: vm);
// Join domain
IVirtualMachineExtensionsOperations operations = context.client.computeClient.VirtualMachineExtensions;
VirtualMachineExtension joinDomain = operations.CreateOrUpdate(context.resourceGroup.Name, vm.Name, "joindomain", new VirtualMachineExtension()
{
Location = context.location,
Publisher = "Microsoft.Compute",
VirtualMachineExtensionType = "JsonADDomainExtension",
TypeHandlerVersion = "1.3",
AutoUpgradeMinorVersion = true,
Settings = new JoinDomainSettings()
{
Name = domain + ".com",
OUPath = "",
User = domain + "\\" + login,
Restart = "true",
Options = "3"
},
ProtectedSettings = new JoinDomainProtectedSettings()
{
Password = password
}
});
// Join sql virtual machine group
context.getSqlClient().SqlVirtualMachines.CreateOrUpdate(context.resourceGroup.Name, sqlVM.Name, new SqlVirtualMachineModel()
{
Location = context.location,
SqlVirtualMachineGroupResourceId = group.Id,
VirtualMachineResourceId = sqlVM.VirtualMachineResourceId,
WsfcDomainCredentials = new WsfcDomainCredentials()
{
ClusterBootstrapAccountPassword = password,
ClusterOperatorAccountPassword = password,
SqlServiceAccountPassword = password
}
});
return(sqlVM);
}
public static AvailabilityGroupListener CreateAGListener(SqlVirtualMachineTestContext context, string agListenerName, string groupName)
{
MockClient client = context.client;
string domainName = Constants.domainName;
string adminLogin = Constants.adminLogin;
string adminPassword = Constants.adminPassword;
// Create domain
NetworkSecurityGroup nsg = CreateNsg(context);
VirtualNetwork vnet = CreateVirtualNetwork(context, networkSecurityGroup: nsg);
NetworkInterface nic = CreateNetworkInterface(context, virtualNetwork: vnet, networkSecurityGroup: nsg);
VirtualMachine vm = CreateVM(context, nic: nic);
VirtualMachineExtension domain = CreateDomain(context, vm, domainName, adminLogin, adminPassword);
Assert.NotNull(domain);
// Update DNS
Subnet subnet = vnet.Subnets[0];
UpdateVnetDNS(context, vnet, nsg, nic, subnet);
// Create SqlVirtualMachineGroup
StorageAccount storageAccount = CreateStorageAccount(context);
StorageAccountListKeysResult storageAccountKeys = client.storageClient.StorageAccounts.ListKeys(context.resourceGroup.Name, storageAccount.Name);
IEnumerator <StorageAccountKey> iter = storageAccountKeys.Keys.GetEnumerator();
iter.MoveNext();
string key = iter.Current.Value;
WsfcDomainProfile profile = new WsfcDomainProfile()
{
ClusterBootstrapAccount = getUsername(adminLogin, domainName),
ClusterOperatorAccount = getUsername(adminLogin, domainName),
SqlServiceAccount = getUsername(Constants.sqlService, domainName),
StorageAccountUrl = "https://" + storageAccount.Name + ".blob.core.windows.net/",
StorageAccountPrimaryKey = key,
DomainFqdn = domainName + ".com",
OuPath = ""
};
SqlVirtualMachineGroup group = CreateSqlVirtualMachineGroup(context, storageAccount, groupName: groupName, profile: profile);
// Create availability set
AvailabilitySet availabilitySet = client.computeClient.AvailabilitySets.CreateOrUpdate(context.resourceGroup.Name, context.generateResourceName(), new AvailabilitySet()
{
Location = context.location,
PlatformFaultDomainCount = 3,
PlatformUpdateDomainCount = 2,
Sku = new Microsoft.Azure.Management.Compute.Models.Sku
{
Name = "Aligned"
}
});
// Create two sql virtual machines
NetworkInterface nic1 = CreateNetworkInterface(context, virtualNetwork: vnet);
NetworkInterface nic2 = CreateNetworkInterface(context, virtualNetwork: vnet);
VirtualMachine vm1 = CreateVM(context, nic: nic1, availabilitySet: availabilitySet);
VirtualMachine vm2 = CreateVM(context, nic: nic2, availabilitySet: availabilitySet);
SqlVirtualMachineModel sqlVM1 = prepareMachine(context, group, vm1, domainName, adminLogin, adminPassword);
SqlVirtualMachineModel sqlVM2 = prepareMachine(context, group, vm2, domainName, adminLogin, adminPassword);
// Create load balancer
LoadBalancer loadBalancer = client.networkClient.LoadBalancers.CreateOrUpdate(context.resourceGroup.Name, context.generateResourceName(), new LoadBalancer()
{
Location = context.location,
Sku = new LoadBalancerSku("Basic"),
FrontendIPConfigurations = new List <FrontendIPConfiguration> (new FrontendIPConfiguration[]
{
new FrontendIPConfiguration()
{
Name = "LoadBalancerFrontEnd",
PrivateIPAllocationMethod = "Dynamic",
Subnet = subnet
}
})
});
// Run deployment to create an availability group with the two machines created
string AgName = "AvGroup";
VirtualMachineExtension availabilityGroup = context.client.computeClient.VirtualMachineExtensions.CreateOrUpdate(context.resourceGroup.Name, vm1.Name, "agCreation", new VirtualMachineExtension(context.location, name: AgName)
{
VirtualMachineExtensionType = "CustomScriptExtension",
Publisher = "Microsoft.Compute",
TypeHandlerVersion = "1.9",
AutoUpgradeMinorVersion = true,
Settings = new CustomScriptExtensionSettings
{
FileUris = new List <string>(new string[] {
"https://agtemplatestorage.blob.core.windows.net/templates/Deploy.ps1",
"https://agtemplatestorage.blob.core.windows.net/templates/sqlvm6.sql",
"https://agtemplatestorage.blob.core.windows.net/templates/sqlvm7.sql",
"https://agtemplatestorage.blob.core.windows.net/templates/sqlvm8.sql",
"https://agtemplatestorage.blob.core.windows.net/test/sqlvm9.sql",
"https://agtemplatestorage.blob.core.windows.net/templates/sqlvm10.sql"
}),
CommandToExecute = "powershell -ExecutionPolicy Unrestricted -File Deploy.ps1 " + AgName + " " + vm1.Name + " " + vm2.Name + " " + Constants.sqlLogin + " " + adminPassword + " " + domainName + "\\" + Constants.sqlService,
ContentVersion = "1.0.0.0"
}
});
// Create availability group listener
return(context.getSqlClient().AvailabilityGroupListeners.CreateOrUpdate(context.resourceGroup.Name, group.Name, agListenerName, new AvailabilityGroupListener()
{
LoadBalancerConfigurations = new List <LoadBalancerConfiguration>(new LoadBalancerConfiguration[]
{
new LoadBalancerConfiguration()
{
PrivateIpAddress = new PrivateIPAddress(ipAddress: "10.0.0.11", subnetResourceId: subnet.Id),
ProbePort = 59999,
LoadBalancerResourceId = loadBalancer.Id,
SqlVirtualMachineInstances = new List <string>()
{
sqlVM1.Id, sqlVM2.Id
}
}
}),
AvailabilityGroupName = AgName,
Port = 1433
}));
}
