public void Subscribe(ManagedInstance instance)
{
_instances.Add(instance.Id, instance);
instance.Statistics.PropertyChanged += OnStatisticsChanged;
instance.Unmonitored += OnUnmonitored;
}
internal static Task <ManagedDatabase[]> CreateManagedDatabasesAsync(
SqlManagementClient sqlClient,
string resourceGroupName,
ManagedInstance managedInstance,
string testPrefix,
int count)
{
List <Task <ManagedDatabase> > createDbTasks = new List <Task <ManagedDatabase> >();
for (int i = 0; i < count; i++)
{
string name = SqlManagementTestUtilities.GenerateName();
createDbTasks.Add(sqlClient.ManagedDatabases.CreateOrUpdateAsync(
resourceGroupName,
managedInstance.Name,
name,
new ManagedDatabase()
{
Location = managedInstance.Location
}));
}
// Wait for all databases to be created.
return(Task.WhenAll(createDbTasks));
}
public void FailoverReadableSecondaryInstance()
{
using (SqlManagementTestContext context = new SqlManagementTestContext(this))
{
SqlManagementClient sqlClient = context.GetClient <SqlManagementClient>();
var rg = context.CreateResourceGroup(ManagedInstanceTestUtilities.Region);
ManagedInstance managedInstance = context.CreateManagedInstance(rg);
Assert.NotNull(managedInstance);
var resourceGroupName = rg.Name;
// Wait for first full backup to finish
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
Thread.Sleep(TimeSpan.FromMinutes(6));
}
try
{
sqlClient.ManagedInstances.Failover(resourceGroupName, managedInstance.Name, ReplicaType.ReadableSecondary);
}
catch (Exception ex)
{
Assert.Contains("failover is not supported", ex.Message);
}
}
}
/// <summary>
/// Restores the given snapshot back to the application
/// </summary>
/// <param name="snapshot">Deserialzable object created by Backup()</param>
/// <param name="form">If given, its visual representation will also be restored</param>
public static void Restore(SettingsSnapshot snapshot, Form form = null)
{
Singleton <SyncthingInstanceManager> .Instance.Clear();
foreach (var definition in snapshot.Instances)
{
try
{
var instance = new ManagedInstance
{
Id = definition.Id,
CustomName = definition.Name,
UseHttps = definition.UseHttps,
ApiKey = definition.ApiKey
};
foreach (var storedEndpoint in definition.Endpoints)
{
instance.PossibleEndpoints.Add(new RestEndpoint
{
Hostname = storedEndpoint.Hostname,
Port = storedEndpoint.Port,
Priority = storedEndpoint.Priority,
IsPingable = true
});
}
Singleton <SyncthingInstanceManager> .Instance.Add(instance);
}
catch (InvalidOperationException)
{
// Ignore instances without an endpoint
}
}
}
public void FailoverReadableSecondaryInstance()
{
using (SqlManagementTestContext context = new SqlManagementTestContext(this))
{
ResourceGroup resourceGroup = new ResourceGroup(
TestEnvironmentUtilities.DefaultLocationId, name: "mibrkic");
SqlManagementClient sqlClient = context.GetClient <SqlManagementClient>();
string managedInstanceName = "sqlcl-failovertests-dotnetsdk1";
VirtualNetwork vnet = ManagedInstanceTestFixture.CreateVirtualNetwork(context, resourceGroup, TestEnvironmentUtilities.DefaultLocationId);
Microsoft.Azure.Management.Sql.Models.Sku sku = new Microsoft.Azure.Management.Sql.Models.Sku
{
Name = "MIBC8G5",
Tier = "BusinessCritical"
};
ManagedInstance managedInstance = sqlClient.ManagedInstances.CreateOrUpdate(resourceGroup.Name,
managedInstanceName + SqlManagementTestUtilities.GenerateName(methodName: "failover_readable_secondary"), new ManagedInstance()
{
AdministratorLogin = SqlManagementTestUtilities.DefaultLogin,
AdministratorLoginPassword = SqlManagementTestUtilities.DefaultPassword,
Sku = sku,
SubnetId = vnet.Subnets[0].Id,
Tags = new Dictionary <string, string>(),
Location = TestEnvironmentUtilities.DefaultLocationId,
});
Assert.NotNull(managedInstance);
sqlClient.ManagedInstances.Failover(resourceGroup.Name, managedInstance.Name, ReplicaType.ReadableSecondary);
}
}
private async Task <ManagedInstanceVulnerabilityAssessment> SetPolicy(SqlManagementTestContext context, SqlManagementClient sqlClient, ResourceGroup resourceGroup,
ManagedInstance managedInstance)
{
// Modify the policy properties, send and receive and see it its still ok
ManagedServerSecurityAlertPolicy updatedManagedServerPolicy = new ManagedServerSecurityAlertPolicy
{
State = SecurityAlertsPolicyState.Enabled,
EmailAccountAdmins = true
};
//Set security alert policy for server
sqlClient.ManagedServerSecurityAlertPolicies.CreateOrUpdate(resourceGroup.Name, managedInstance.Name, updatedManagedServerPolicy);
VulnerabilityAssessmentTestUtilities.StorageContainerInfo StorageContainerInfo = await VulnerabilityAssessmentTestUtilities.CreateStorageContainer(context, resourceGroup);
ManagedInstanceVulnerabilityAssessment policy = new ManagedInstanceVulnerabilityAssessment()
{
StorageContainerPath = StorageContainerInfo.StorageContainerPath.ToString(),
StorageContainerSasKey = StorageContainerInfo.StorageAccountAccessKey,
RecurringScans = new VulnerabilityAssessmentRecurringScansProperties()
{
IsEnabled = false,
Emails = new List <string>()
{
"*****@*****.**", "*****@*****.**"
},
EmailSubscriptionAdmins = true
}
};
return(sqlClient.ManagedInstanceVulnerabilityAssessments.CreateOrUpdate(resourceGroup.Name, managedInstance.Name, policy));
}
public ManagedInstanceTestFixture()
{
Context = new SqlManagementTestContext(this);
try
{
SqlManagementClient sqlClient = Context.GetClient <SqlManagementClient>();
ResourceGroup = Context.CreateResourceGroup();
// Create vnet and get the subnet id
VirtualNetwork vnet = CreateVirtualNetwork(Context, ResourceGroup, TestEnvironmentUtilities.DefaultLocationId);
Sku sku = new Sku();
sku.Name = "MIGP8G4";
sku.Tier = "GeneralPurpose";
ManagedInstance = sqlClient.ManagedInstances.CreateOrUpdate(ResourceGroup.Name,
"crud-tests-" + SqlManagementTestUtilities.GenerateName(), new ManagedInstance()
{
AdministratorLogin = SqlManagementTestUtilities.DefaultLogin,
AdministratorLoginPassword = SqlManagementTestUtilities.DefaultPassword,
Sku = sku,
SubnetId = vnet.Subnets[0].Id,
Tags = new Dictionary <string, string>(),
Location = TestEnvironmentUtilities.DefaultLocationId,
});
}
catch (Exception ex)
{
Context.Dispose();
}
}
public static void ValidateManagedInstance(
ManagedInstance actual,
IDictionary <string, string> tags = null,
string instancePoolId = null,
bool shouldCheckState = false)
{
Assert.NotNull(actual);
if (shouldCheckState)
{
Assert.Equal("Succeeded", actual.ProvisioningState);
}
if (tags != null)
{
// Remove our default tag before validation
actual.Tags.Remove(ManagedInstanceTestUtilities.Tags.First().Key);
SqlManagementTestUtilities.AssertCollection(tags, actual.Tags);
}
if (instancePoolId != null)
{
Assert.Equal(actual.InstancePoolId, instancePoolId);
}
}
private void createManagedInstances(SqlManagementTestContext context, ResourceGroup resourceGroup, IList <string> managedInstanceNames)
{
SqlManagementClient sqlClient = context.GetClient <SqlManagementClient>();
Sku sku = new Sku();
sku.Name = "MIGP8G4";
sku.Tier = "GeneralPurpose";
VirtualNetwork vnet = ManagedInstanceTestFixture.CreateVirtualNetwork(context, resourceGroup, TestEnvironmentUtilities.DefaultLocationId);
foreach (string miName in managedInstanceNames)
{
ManagedInstance managedInstance = sqlClient.ManagedInstances.CreateOrUpdate(resourceGroup.Name, miName, new ManagedInstance()
{
AdministratorLogin = SqlManagementTestUtilities.DefaultLogin,
AdministratorLoginPassword = SqlManagementTestUtilities.DefaultPassword,
SubnetId = vnet.Subnets[0].Id,
Tags = new Dictionary <string, string>(),
Location = TestEnvironmentUtilities.DefaultLocationId,
Sku = sku,
});
Assert.NotNull(managedInstance);
}
}
public void TestInvoke()
{
ManagedObjectName name = new ManagedObjectName("domain.org:type=httpServer");
try
{
Object httpServer = server.Instantiate(httpServerType.Assembly.FullName, httpServerType.FullName);
ManagedInstance inst = server.RegisterManagedObject(httpServer, name);
bool state = (bool)server.GetAttribute(name, "Started");
AssertEquals(false, state);
server.Invoke(name, "Start", null, null);
state = (bool)server.GetAttribute(name, "Started");
AssertEquals(true, state);
server.Invoke(name, "Stop", null, null);
state = (bool)server.GetAttribute(name, "Started");
AssertEquals(false, state);
}
finally
{
server.UnregisterManagedObject(name);
}
}
/// <summary>
/// create a default private endpoint for managed instance.
/// please make sure your MI built using CreateDefaultManagedInstance() or vnet AddressPrefixes = 10.10.0.0/16
/// </summary>
/// <param name="managedInstance"></param>
/// <param name="location"></param>
/// <param name="resourceGroup"></param>
/// <param name=""></param>
/// <returns></returns>
protected async Task <PrivateEndpoint> CreateDefaultPrivateEndpoint(ManagedInstance managedInstance, VirtualNetwork vnet, Location location, ResourceGroup resourceGroup)
{
// Add new subnet
SubnetData subnetData = new SubnetData()
{
AddressPrefix = "10.10.5.0/24",
PrivateEndpointNetworkPolicies = "Disabled"
};
var privateEndpointSubnet = await vnet.GetSubnets().CreateOrUpdateAsync($"private-endpoint-subnet", subnetData);
// Create private endpoint
string privateEndpointName = $"{managedInstance.Data.Name}-private-endpoint";
var endpointCollection = resourceGroup.GetPrivateEndpoints();
PrivateEndpointData data = new PrivateEndpointData()
{
Subnet = new SubnetData()
{
Id = privateEndpointSubnet.Value.Data.Id
},
Location = location,
PrivateLinkServiceConnections =
{
new PrivateLinkServiceConnection()
{
Name = privateEndpointName,
PrivateLinkServiceId = managedInstance.Data.Id.ToString(),
GroupIds = { "managedInstance" },
}
},
};
var privateEndpoint = await resourceGroup.GetPrivateEndpoints().CreateOrUpdateAsync(privateEndpointName, data);
return(privateEndpoint.Value);
}
public NeedQueueForm(ManagedInstance instance)
{
InitializeComponent();
_instance = instance;
Text = String.Format("Downloading to {0}", _instance.Information.DisplayName);
}
private void createManagedInstances(SqlManagementTestContext context, ResourceGroup resourceGroup, IList <string> managedInstanceNames)
{
foreach (string miName in managedInstanceNames)
{
ManagedInstance managedInstance = context.CreateManagedInstance(resourceGroup, miName);
Assert.NotNull(managedInstance);
}
}
public void TestCreation()
{
ManagedObjectName name = new ManagedObjectName("domain.org");
ManagedInstance instance1 = new ManagedInstance("typename", name);
AssertEquals("typename", instance1.TypeName);
AssertEquals(name, instance1.Name);
}
public ManagedInstance CreateManagedInstance(ResourceGroup resourceGroup, ManagedInstance initialManagedInstance, string name = null)
{
SqlManagementClient sqlClient = GetClient <SqlManagementClient>();
string miName = name ?? SqlManagementTestUtilities.GenerateName("net-sdk-crud-tests-");
var payload = this.GetManagedInstancePayload(initialManagedInstance);
return(sqlClient.ManagedInstances.CreateOrUpdate(resourceGroup.Name, miName, payload));
}
public static void ValidateManagedInstance(ManagedInstance actual, string name, string login, Dictionary <string, string> tags, string location)
{
Assert.NotNull(actual);
Assert.Equal(name, actual.Name);
Assert.Equal(login, actual.AdministratorLogin);
SqlManagementTestUtilities.AssertCollection(tags, actual.Tags);
// Location is being returned two different ways across different APIs.
Assert.Equal(location.ToLower().Replace(" ", ""), actual.Location.ToLower().Replace(" ", ""));
}
public async Task Get()
{
#region Snippet:Managing_Sql_GetAManagedInstance
ManagedInstanceCollection managedInstanceCollection = resourceGroup.GetManagedInstances();
ManagedInstance managedInstance = await managedInstanceCollection.GetAsync("myManagedInstance");
Console.WriteLine(managedInstance.Data.Name);
#endregion
}
public void TestUpdateEncryptionProtector()
{
using (SqlManagementTestContext context = new SqlManagementTestContext(this))
{
SqlManagementClient sqlClient = context.GetClient <SqlManagementClient>();
ResourceManagementClient resourceClient = context.GetClient <ResourceManagementClient>();
ResourceGroup resourceGroup = context.CreateResourceGroup();
string resourceGroupName = resourceGroup.Name;
ManagedInstance managedInstance = context.CreateManagedInstance(resourceGroup, new ManagedInstance()
{
Identity = new ResourceIdentity()
{
Type = IdentityType.SystemAssignedUserAssigned,
UserAssignedIdentities = ManagedInstanceTestUtilities.UserIdentity
},
PrimaryUserAssignedIdentityId = ManagedInstanceTestUtilities.UAMI
});
managedInstance = sqlClient.ManagedInstances.Get(resourceGroupName, managedInstance.Name);
var keyBundle = SqlManagementTestUtilities.CreateKeyVaultKeyWithManagedInstanceAccess(context, resourceGroup, managedInstance);
// Create server key
string serverKeyName = SqlManagementTestUtilities.GetServerKeyNameFromKeyBundle(keyBundle);
string serverKeyUri = keyBundle.Key.Kid;
var managedInstanceKey = sqlClient.ManagedInstanceKeys.CreateOrUpdate(resourceGroup.Name, managedInstance.Name, serverKeyName, new ManagedInstanceKey()
{
ServerKeyType = "AzureKeyVault",
Uri = serverKeyUri
});
SqlManagementTestUtilities.ValidateManagedInstanceKey(managedInstanceKey, serverKeyName, "AzureKeyVault", serverKeyUri);
// Update to Key Vault
sqlClient.ManagedInstanceEncryptionProtectors.CreateOrUpdate(resourceGroup.Name, managedInstance.Name, new ManagedInstanceEncryptionProtector()
{
ServerKeyName = serverKeyName,
ServerKeyType = "AzureKeyVault"
});
ManagedInstanceEncryptionProtector encProtector1 = sqlClient.ManagedInstanceEncryptionProtectors.Get(resourceGroup.Name, managedInstance.Name);
Assert.Equal("AzureKeyVault", encProtector1.ServerKeyType);
Assert.Equal(serverKeyName, encProtector1.ServerKeyName);
// Update to Service Managed
sqlClient.ManagedInstanceEncryptionProtectors.CreateOrUpdate(resourceGroup.Name, managedInstance.Name, new ManagedInstanceEncryptionProtector()
{
ServerKeyName = "ServiceManaged",
ServerKeyType = "ServiceManaged"
});
ManagedInstanceEncryptionProtector encProtector2 = sqlClient.ManagedInstanceEncryptionProtectors.Get(resourceGroup.Name, managedInstance.Name);
Assert.Equal("ServiceManaged", encProtector2.ServerKeyType);
Assert.Equal("ServiceManaged", encProtector2.ServerKeyName);
}
}
public async Task DeleteManagedInstance()
{
#region Snippet:Managing_Sql_DeleteAManagedInstance
ManagedInstanceCollection managedInstanceCollection = resourceGroup.GetManagedInstances();
ManagedInstance managedInstance = await managedInstanceCollection.GetAsync("myManagedInstance");
await managedInstance.DeleteAsync(WaitUntil.Completed);
#endregion
}
protected BaseWorker(ManagedInstance instance, WorkerDirective directive)
{
ManagedInstance = instance;
_directive = directive;
ConfigureStateMachine();
RegisterEventHandlers();
Log.Logger.Debug(
"{instance} ~ {thread} and configured it with {@directive}",
instance.CustomName, GetType(), instance.Directives);
}
/// <summary>
/// Creates a key vault, grants the managed instance and current user access to that vault,
/// and creates a key in the vault.
/// </summary>
internal static KeyBundle CreateKeyVaultKeyWithManagedInstanceAccess(
SqlManagementTestContext context,
ResourceGroup resourceGroup,
ManagedInstance managedInstance)
{
if (managedInstance.Identity == null)
{
throw new InvalidOperationException("managedInstance has no identity");
}
return(CreateKeyVaultKeyAccessibleByIdentity(context, resourceGroup, managedInstance.Identity));
}
public void TestEndpointCertificates()
{
string suiteName = this.GetType().Name;
using (SqlManagementTestContext context = new SqlManagementTestContext(this))
{
// Test setup (rg, mi):
SqlManagementClient sqlClient = context.GetClient <SqlManagementClient>();
//ResourceGroup rg = new ResourceGroup(location: "eastus2euap", id: "/subscriptions/8313371e-0879-428e-b1da-6353575a9192/resourceGroups/CustomerExperienceTeam_RG", name: "CustomerExperienceTeam_RG");
//ManagedInstance managedInstance = sqlClient.ManagedInstances.Get(rg.Name, "chimera-ps-cli-v2");
ResourceGroup rg = context.CreateResourceGroup(ManagedInstanceTestUtilities.Region);
ManagedInstance managedInstance = context.CreateManagedInstance(rg);
Assert.NotNull(managedInstance);
var resourceGroupName = rg.Name;
var managedInstanceName = managedInstance.Name;
var exceptionGet = Assert.Throws <CloudException>(() => sqlClient.EndpointCertificates.Get(resourceGroupName, managedInstanceName, "invalid_endpoint_type"));
Assert.Equal("ResourceNotFound", exceptionGet.Body.Code);
var certServiceBroker = sqlClient.EndpointCertificates.Get(resourceGroupName, managedInstanceName, endpointTypeServiceBroker);
Assert.NotNull(certServiceBroker);
Assert.NotNull(certServiceBroker.PublicBlob);
Assert.True(Regex.Match(certServiceBroker.PublicBlob, @"^[0-9a-fA-F]+$").Success);
Assert.Equal(endpointTypeServiceBroker, certServiceBroker.Name);
Assert.Equal(makeEndpointCertID(managedInstance.Id, endpointTypeServiceBroker), certServiceBroker.Id);
Assert.Equal(endpointCertType, certServiceBroker.Type);
var certDatabaseMirroring = sqlClient.EndpointCertificates.Get(resourceGroupName, managedInstanceName, endpointTypeDatabaseMirroring);
Assert.NotNull(certDatabaseMirroring);
Assert.NotNull(certDatabaseMirroring.PublicBlob);
Assert.True(Regex.Match(certDatabaseMirroring.PublicBlob, @"^[0-9a-fA-F]+$").Success);
Assert.Equal(endpointTypeDatabaseMirroring, certDatabaseMirroring.Name);
Assert.Equal(makeEndpointCertID(managedInstance.Id, endpointTypeDatabaseMirroring), certDatabaseMirroring.Id);
Assert.Equal(endpointCertType, certDatabaseMirroring.Type);
var certList = sqlClient.EndpointCertificates.ListByInstance(resourceGroupName, managedInstanceName);
Assert.NotNull(certList);
var listCertDBM = certList.Where(cert => cert.Name.Equals(endpointTypeDatabaseMirroring)).FirstOrDefault();
var listCertSB = certList.Where(cert => cert.Name.Equals(endpointTypeServiceBroker)).FirstOrDefault();
Assert.NotNull(listCertDBM.PublicBlob);
Assert.True(Regex.Match(listCertDBM.PublicBlob, @"^[0-9a-fA-F]+$").Success);
Assert.Equal(endpointTypeDatabaseMirroring, listCertDBM.Name);
Assert.Equal(makeEndpointCertID(managedInstance.Id, endpointTypeDatabaseMirroring), listCertDBM.Id);
Assert.Equal(endpointCertType, listCertDBM.Type);
Assert.NotNull(listCertSB.PublicBlob);
Assert.True(Regex.Match(listCertSB.PublicBlob, @"^[0-9a-fA-F]+$").Success);
Assert.Equal(endpointTypeServiceBroker, listCertSB.Name);
Assert.Equal(makeEndpointCertID(managedInstance.Id, endpointTypeServiceBroker), listCertSB.Id);
Assert.Equal(endpointCertType, listCertSB.Type);
}
}
public async Task TestMissingApiKey()
{
var instance = new ManagedInstance
{
PossibleEndpoints = GetDefaultRestEndpointCollection()
};
instance.Watch();
await Task.Delay(TimeSpan.FromSeconds(3));
Assert.IsTrue(instance.IsInState(ManagedInstance.State.Disconnected));
}
public void TestSetManagedInstanceActiveDirectoryAdministrator()
{
string aadAdmin = "aadadmin";
string managedInstanceName = "miaadadmin";
using (SqlManagementTestContext context = new SqlManagementTestContext(this))
{
Guid objectId = new Guid(TestEnvironmentUtilities.GetUserObjectId());
Guid tenantId = new Guid(TestEnvironmentUtilities.GetTenantId());
SqlManagementClient sqlClient = context.GetClient <SqlManagementClient>();
ResourceGroup resourceGroup = context.CreateResourceGroup();
// Create vnet and get the subnet id
VirtualNetwork vnet = ManagedInstanceTestFixture.CreateVirtualNetwork(context, resourceGroup, TestEnvironmentUtilities.DefaultLocationId);
Sku sku = new Sku();
sku.Name = "MIGP8G4";
sku.Tier = "GeneralPurpose";
ManagedInstance instance = sqlClient.ManagedInstances.CreateOrUpdate(resourceGroup.Name,
"crud-tests-" + managedInstanceName, new ManagedInstance()
{
AdministratorLogin = SqlManagementTestUtilities.DefaultLogin,
AdministratorLoginPassword = SqlManagementTestUtilities.DefaultPassword,
Sku = sku,
SubnetId = vnet.Subnets[0].Id,
Tags = new Dictionary <string, string>(),
Location = TestEnvironmentUtilities.DefaultLocationId,
});
Assert.NotNull(instance);
// Add new Active Directory Admin
ManagedInstanceAdministrator newAdmin = new ManagedInstanceAdministrator(login: aadAdmin, sid: objectId, tenantId: tenantId);
ManagedInstanceAdministrator createResult = sqlClient.ManagedInstanceAdministrators.CreateOrUpdate(resourceGroup.Name, instance.Name, newAdmin);
Assert.Equal(aadAdmin, createResult.Login);
// Get the current Active Directory Admin
ManagedInstanceAdministrator getResult = sqlClient.ManagedInstanceAdministrators.Get(resourceGroup.Name, instance.Name);
Assert.Equal(aadAdmin, getResult.Login);
Assert.Equal(objectId, getResult.Sid);
Assert.Equal(tenantId, getResult.TenantId);
// Delete the Active Directory Admin on server
sqlClient.ManagedInstanceAdministrators.Delete(resourceGroup.Name, instance.Name);
// List all Active Directory Admins for isntance.
Microsoft.Azure.Management.Sql.Models.Page1 <ManagedInstanceAdministrator> admins = (Microsoft.Azure.Management.Sql.Models.Page1 <ManagedInstanceAdministrator>)sqlClient.ManagedInstanceAdministrators.ListByInstance(resourceGroup.Name, instance.Name);
Assert.True(admins == null || !admins.GetEnumerator().MoveNext());
}
}
public async Task TestMissingEndpoints()
{
var instance = new ManagedInstance
{
ApiKey = "unittest"
};
instance.Watch();
await Task.Delay(TimeSpan.FromSeconds(3));
Assert.IsTrue(instance.IsInState(ManagedInstance.State.Disconnected));
}
public void TestCreateUpdateDropManagedInstanceKeys()
{
using (SqlManagementTestContext context = new SqlManagementTestContext(this))
{
SqlManagementClient sqlClient = context.GetClient <SqlManagementClient>();
ResourceManagementClient resourceClient = context.GetClient <ResourceManagementClient>();
var resourceGroup = context.CreateResourceGroup(ManagedInstanceTestUtilities.Region);
ManagedInstance managedInstance = context.CreateManagedInstance(resourceGroup, new ManagedInstance()
{
Identity = new ResourceIdentity()
{
Type = IdentityType.SystemAssignedUserAssigned,
UserAssignedIdentities = ManagedInstanceTestUtilities.UserIdentity,
},
PrimaryUserAssignedIdentityId = ManagedInstanceTestUtilities.UAMI
});
var keyBundle = SqlManagementTestUtilities.CreateKeyVaultKeyWithManagedInstanceAccess(context, resourceGroup, managedInstance);
string serverKeyName = SqlManagementTestUtilities.GetServerKeyNameFromKeyBundle(keyBundle);
string keyUri = keyBundle.Key.Kid;
var managedInstanceKey = sqlClient.ManagedInstanceKeys.CreateOrUpdate(
resourceGroupName: resourceGroup.Name,
managedInstanceName: managedInstance.Name,
keyName: serverKeyName,
parameters: new ManagedInstanceKey()
{
ServerKeyType = "AzureKeyVault",
Uri = keyUri
});
SqlManagementTestUtilities.ValidateManagedInstanceKey(managedInstanceKey, serverKeyName, "AzureKeyVault", keyUri);
// Validate key exists by getting key
var key1 = sqlClient.ManagedInstanceKeys.Get(
resourceGroupName: resourceGroup.Name,
managedInstanceName: managedInstance.Name,
keyName: serverKeyName);
SqlManagementTestUtilities.ValidateManagedInstanceKey(key1, serverKeyName, "AzureKeyVault", keyUri);
// Validate key exists by listing keys
var keyList = sqlClient.ManagedInstanceKeys.ListByInstance(
resourceGroupName: resourceGroup.Name,
managedInstanceName: managedInstance.Name);
Assert.True(keyList.Count() > 0);
}
}
public ManagedInstanceTestFixture()
{
Context = new SqlManagementTestContext(this);
try
{
SqlManagementClient sqlClient = Context.GetClient <SqlManagementClient>();
ResourceGroup = Context.CreateResourceGroup(ManagedInstanceTestUtilities.Region);
ManagedInstance = Context.CreateManagedInstance(ResourceGroup);
}
catch (Exception ex)
{
Context.Dispose();
}
}
public void TestCreateManagedObject()
{
ManagedObjectName name = new ManagedObjectName("domain.org:type=httpServer");
try
{
ManagedInstance inst = server.CreateManagedObject(
httpServerType.Assembly.FullName, httpServerType.FullName, name);
AssertNotNull(inst);
AssertEquals(httpServerType.FullName, inst.TypeName);
AssertEquals(name, inst.Name);
}
finally
{
server.UnregisterManagedObject(name);
}
}
public async Task GetIfExists()
{
#region Snippet:Managing_Sql_GetAManagedInstanceIfExists
ManagedInstanceCollection managedInstanceCollection = resourceGroup.GetManagedInstances();
ManagedInstance managedInstance = await managedInstanceCollection.GetIfExistsAsync("foo");
if (managedInstance != null)
{
Console.WriteLine(managedInstance.Data.Name);
}
if (await managedInstanceCollection.ExistsAsync("bar"))
{
Console.WriteLine("Virtual network 'bar' exists.");
}
#endregion
}
public void TestCreateUpdateDropManagedInstanceKeys()
{
using (SqlManagementTestContext context = new SqlManagementTestContext(this))
{
string resourceGroupName = ManagedInstanceResourceGroup;
string managedInstanceName = ManagedInstanceName;
SqlManagementClient sqlClient = context.GetClient <SqlManagementClient>();
ResourceManagementClient resourceClient = context.GetClient <ResourceManagementClient>();
ResourceGroup resourceGroup = resourceClient.ResourceGroups.Get(resourceGroupName);
ManagedInstance managedInstance = sqlClient.ManagedInstances.Get(resourceGroupName, managedInstanceName);
var keyBundle = SqlManagementTestUtilities.CreateKeyVaultKeyWithManagedInstanceAccess(context, resourceGroup, managedInstance);
string serverKeyName = SqlManagementTestUtilities.GetServerKeyNameFromKeyBundle(keyBundle);
string keyUri = keyBundle.Key.Kid;
var managedInstanceKey = sqlClient.ManagedInstanceKeys.CreateOrUpdate(
resourceGroupName: resourceGroup.Name,
managedInstanceName: managedInstance.Name,
keyName: serverKeyName,
parameters: new ManagedInstanceKey()
{
ServerKeyType = "AzureKeyVault",
Uri = keyUri
});
SqlManagementTestUtilities.ValidateManagedInstanceKey(managedInstanceKey, serverKeyName, "AzureKeyVault", keyUri);
// Validate key exists by getting key
var key1 = sqlClient.ManagedInstanceKeys.Get(
resourceGroupName: resourceGroup.Name,
managedInstanceName: managedInstance.Name,
keyName: serverKeyName);
SqlManagementTestUtilities.ValidateManagedInstanceKey(key1, serverKeyName, "AzureKeyVault", keyUri);
// Validate key exists by listing keys
var keyList = sqlClient.ManagedInstanceKeys.ListByInstance(
resourceGroupName: resourceGroup.Name,
managedInstanceName: managedInstance.Name);
Assert.True(keyList.Count() > 0);
}
}
public Synchronization(ManagedInstance instance)
: base(instance)
{
}
public Statistic(ManagedInstance instance)
: base(instance)
{
}
protected BaseType(ManagedInstance instance)
{
_instance = instance;
}
public Information(ManagedInstance instance)
: base(instance)
{
}
