public async Task <Response <ManagedBackupShortTermRetentionPolicy> > GetAsync(string resourceGroupName, string managedInstanceName, string restorableDroppedDatabaseId, ManagedShortTermRetentionPolicyName policyName, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (managedInstanceName == null)
{
throw new ArgumentNullException(nameof(managedInstanceName));
}
if (restorableDroppedDatabaseId == null)
{
throw new ArgumentNullException(nameof(restorableDroppedDatabaseId));
}
using var message = CreateGetRequest(resourceGroupName, managedInstanceName, restorableDroppedDatabaseId, policyName);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
ManagedBackupShortTermRetentionPolicy value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = ManagedBackupShortTermRetentionPolicy.DeserializeManagedBackupShortTermRetentionPolicy(document.RootElement);
return(Response.FromValue(value, message.Response));
}
/// <summary>
/// Creates or updates an Azure Sql Deleted Managed Database short term retention policy.
/// </summary>
/// <param name="resourceGroup">The name of the resource group</param>
/// <param name="managedInstanceName">The name of the Azure Sql Database Managed Instance</param>
/// <param name="databaseName">The name of database</param>
/// <param name="model">The input parameters for the create/update operation</param>
/// <returns>The upserted Azure Sql Database from AutoRest SDK</returns>
internal AzureSqlManagedDatabaseBackupShortTermRetentionPolicyModel UpsertDeletedManagedDatabaseRetentionPolicy(string resourceGroup, string managedInstanceName, string databaseName, AzureSqlManagedDatabaseBackupShortTermRetentionPolicyModel model)
{
ManagedBackupShortTermRetentionPolicy newPolicy = new ManagedBackupShortTermRetentionPolicy(retentionDays: model.RetentionDays);
var resp = Communicator.CreateOrUpdateShortTermRetentionDroppedDatabase(resourceGroup, managedInstanceName, databaseName, newPolicy);
return(CreateManagedDatabaseBackupShortTermRetentionPolicyModelFromResponse(resourceGroup, managedInstanceName, databaseName, resp));
}
public void ShortTermRetentionOnLiveDatabase()
{
using (SqlManagementTestContext Context = new SqlManagementTestContext(this))
{
SqlManagementClient sqlClient = Context.GetClient <SqlManagementClient>();
ResourceGroup resourceGroup = Context.CreateResourceGroup();
ManagedInstance managedInstance = CreateManagedInstance(Context, sqlClient, resourceGroup, "ShortTermRetentionOnLiveDatabase");
// Create managed database
//
string dbName = SqlManagementTestUtilities.GenerateName(_testPrefix);
var db1 = sqlClient.ManagedDatabases.CreateOrUpdate(resourceGroup.Name, managedInstance.Name, dbName, new ManagedDatabase()
{
Location = managedInstance.Location,
});
Assert.NotNull(db1);
int basicRetention = 7;
int invalidValue = 3;
int validValue = 20;
// Attempt to increase retention period to 7 days and verfiy that the operation succeeded.
ManagedBackupShortTermRetentionPolicy parameters0 = new ManagedBackupShortTermRetentionPolicy(retentionDays: basicRetention);
sqlClient.ManagedBackupShortTermRetentionPolicies.CreateOrUpdateWithHttpMessagesAsync(resourceGroup.Name, managedInstance.Name, dbName, parameters0);
Microsoft.Rest.ClientRuntime.Azure.TestFramework.TestUtilities.Wait(TimeSpan.FromSeconds(3));
ManagedBackupShortTermRetentionPolicy policy = sqlClient.ManagedBackupShortTermRetentionPolicies.Get(resourceGroup.Name, managedInstance.Name, dbName);
Assert.Equal(basicRetention, policy.RetentionDays);
// Attempt to increase retention period to 3 days and verfiy that the operation fails.
ManagedBackupShortTermRetentionPolicy parameters1 = new ManagedBackupShortTermRetentionPolicy(retentionDays: invalidValue);
sqlClient.ManagedBackupShortTermRetentionPolicies.CreateOrUpdateWithHttpMessagesAsync(resourceGroup.Name, managedInstance.Name, dbName, parameters1);
Microsoft.Rest.ClientRuntime.Azure.TestFramework.TestUtilities.Wait(TimeSpan.FromSeconds(3));
policy = sqlClient.ManagedBackupShortTermRetentionPolicies.Get(resourceGroup.Name, managedInstance.Name, dbName);
Assert.Equal(basicRetention, policy.RetentionDays);
// Attempt to increase retention period to 20 days and verfiy that the operation succeeded .
ManagedBackupShortTermRetentionPolicy parameters2 = new ManagedBackupShortTermRetentionPolicy(retentionDays: validValue);
sqlClient.ManagedBackupShortTermRetentionPolicies.CreateOrUpdateWithHttpMessagesAsync(resourceGroup.Name, managedInstance.Name, dbName, parameters2);
Microsoft.Rest.ClientRuntime.Azure.TestFramework.TestUtilities.Wait(TimeSpan.FromSeconds(3));
policy = sqlClient.ManagedBackupShortTermRetentionPolicies.Get(resourceGroup.Name, managedInstance.Name, dbName);
Assert.Equal(validValue, policy.RetentionDays);
}
}
public virtual ManagedBackupShortTermRetentionPoliciesUpdateOperation StartUpdate(string resourceGroupName, string managedInstanceName, string databaseName, ManagedShortTermRetentionPolicyName policyName, ManagedBackupShortTermRetentionPolicy parameters, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (managedInstanceName == null)
{
throw new ArgumentNullException(nameof(managedInstanceName));
}
if (databaseName == null)
{
throw new ArgumentNullException(nameof(databaseName));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _clientDiagnostics.CreateScope("ManagedBackupShortTermRetentionPoliciesOperations.StartUpdate");
scope.Start();
try
{
var originalResponse = RestClient.Update(resourceGroupName, managedInstanceName, databaseName, policyName, parameters, cancellationToken);
return(new ManagedBackupShortTermRetentionPoliciesUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateUpdateRequest(resourceGroupName, managedInstanceName, databaseName, policyName, parameters).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Sets a database's short term retention policy.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The 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='managedInstanceName'>
/// The name of the managed instance.
/// </param>
/// <param name='restorableDroppedDatabaseId'>
/// </param>
/// <param name='parameters'>
/// The short term retention policy info.
/// </param>
public static ManagedBackupShortTermRetentionPolicy CreateOrUpdate(this IManagedRestorableDroppedDatabaseBackupShortTermRetentionPoliciesOperations operations, string resourceGroupName, string managedInstanceName, string restorableDroppedDatabaseId, ManagedBackupShortTermRetentionPolicy parameters)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, managedInstanceName, restorableDroppedDatabaseId, parameters).GetAwaiter().GetResult());
}
/// <summary>
/// Sets a database's short term retention policy.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The 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='managedInstanceName'>
/// The name of the managed instance.
/// </param>
/// <param name='restorableDroppedDatabaseId'>
/// </param>
/// <param name='parameters'>
/// The short term retention policy info.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <ManagedBackupShortTermRetentionPolicy> BeginUpdateAsync(this IManagedRestorableDroppedDatabaseBackupShortTermRetentionPoliciesOperations operations, string resourceGroupName, string managedInstanceName, string restorableDroppedDatabaseId, ManagedBackupShortTermRetentionPolicy parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginUpdateWithHttpMessagesAsync(resourceGroupName, managedInstanceName, restorableDroppedDatabaseId, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public virtual async Task <ManagedRestorableDroppedDatabaseBackupShortTermRetentionPoliciesUpdateOperation> StartUpdateAsync(string resourceGroupName, string managedInstanceName, string restorableDroppedDatabaseId, ManagedShortTermRetentionPolicyName policyName, ManagedBackupShortTermRetentionPolicy parameters, CancellationToken cancellationToken = default)
{
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (managedInstanceName == null)
{
throw new ArgumentNullException(nameof(managedInstanceName));
}
if (restorableDroppedDatabaseId == null)
{
throw new ArgumentNullException(nameof(restorableDroppedDatabaseId));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
using var scope = _clientDiagnostics.CreateScope("ManagedRestorableDroppedDatabaseBackupShortTermRetentionPoliciesOperations.StartUpdate");
scope.Start();
try
{
var originalResponse = await RestClient.UpdateAsync(resourceGroupName, managedInstanceName, restorableDroppedDatabaseId, policyName, parameters, cancellationToken).ConfigureAwait(false);
return(new ManagedRestorableDroppedDatabaseBackupShortTermRetentionPoliciesUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateUpdateRequest(resourceGroupName, managedInstanceName, restorableDroppedDatabaseId, policyName, parameters).Request, originalResponse));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// Updates a managed database's short term retention policy.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The 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='managedInstanceName'>
/// The name of the managed instance.
/// </param>
/// <param name='databaseName'>
/// The name of the database.
/// </param>
/// <param name='parameters'>
/// The short term retention policy info.
/// </param>
public static ManagedBackupShortTermRetentionPolicy BeginUpdate(this IManagedBackupShortTermRetentionPoliciesOperations operations, string resourceGroupName, string managedInstanceName, string databaseName, ManagedBackupShortTermRetentionPolicy parameters)
{
return(operations.BeginUpdateAsync(resourceGroupName, managedInstanceName, databaseName, parameters).GetAwaiter().GetResult());
}
/// <summary>
/// Construct AzureSqlManagedDatabaseBackupShortTermRetentionPolicyModel object
/// </summary>
/// <param name="resourceGroup">Resource group</param>
/// <param name="managedInstanceName">Managed Instance name</param>
/// <param name="managedDatabaseName">Managed Instance name</param>
/// <param name="managedBackupRetentionPolicy">Managed Database object</param>
/// <param name="deletionDate">Deletion date of the database, if it is deleted</param>
public AzureSqlManagedDatabaseBackupShortTermRetentionPolicyModel(string resourceGroup, string managedInstanceName, string managedDatabaseName, ManagedBackupShortTermRetentionPolicy managedBackupRetentionPolicy, DateTime?deletionDate = null)
{
ResourceGroupName = resourceGroup;
InstanceName = managedInstanceName;
DatabaseName = managedDatabaseName;
DeletionDate = deletionDate;
RetentionDays = managedBackupRetentionPolicy.RetentionDays.Value;
}
public void ShortTermRetentionOnDroppedDatabase()
{
using (SqlManagementTestContext Context = new SqlManagementTestContext(this))
{
SqlManagementClient sqlClient = Context.GetClient <SqlManagementClient>();
ResourceGroup resourceGroup = Context.CreateResourceGroup();
ManagedInstance managedInstance = CreateManagedInstance(Context, sqlClient, resourceGroup, "ShortTermRetentionOnDroppedDatabase");
// Create managed database
//
string dbName = SqlManagementTestUtilities.GenerateName(_testPrefix);
var db1 = sqlClient.ManagedDatabases.CreateOrUpdate(resourceGroup.Name, managedInstance.Name, dbName, new ManagedDatabase()
{
Location = managedInstance.Location,
});
Assert.NotNull(db1);
int startingRetention = 25;
int invalidValue = 35;
int validValue = 20;
// Attempt to increase retention period to 25 days and verfiy that the operation succeeded. Since increasing of retention days for dropped database is disabled,
// we need to increase retention beforehand, and test reducing it once database is dropped.
ManagedBackupShortTermRetentionPolicy parameters0 = new ManagedBackupShortTermRetentionPolicy(retentionDays: startingRetention);
sqlClient.ManagedBackupShortTermRetentionPolicies.CreateOrUpdateWithHttpMessagesAsync(resourceGroup.Name, managedInstance.Name, dbName, parameters0);
Microsoft.Rest.ClientRuntime.Azure.TestFramework.TestUtilities.Wait(TimeSpan.FromSeconds(3));
ManagedBackupShortTermRetentionPolicy policy = sqlClient.ManagedBackupShortTermRetentionPolicies.Get(resourceGroup.Name, managedInstance.Name, dbName);
Assert.Equal(startingRetention, policy.RetentionDays);
// We need to wait for database to create its first backup. Currently if database drops too quickly it won't be restorable.
// This will be changed in couple of weeks, howerver since building up Managed Instance takes over 60mins, this wait isn't not be a problem.
// No need to sleep if we are playing back the recording.
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
Thread.Sleep(TimeSpan.FromMinutes(10));
}
// Delete the original database
sqlClient.ManagedDatabases.Delete(resourceGroup.Name, managedInstance.Name, db1.Name);
// Wait until the final backup is created and the restorable dropped database exists.
// This could be up to 10 minutes after the database is deleted, and the database must already
// have a backup (which was accomplished by the previous wait period). Let's wait up to 15
// just to give it a little more room.
IEnumerable <RestorableDroppedManagedDatabase> droppedDatabases;
DateTime startTime = DateTime.UtcNow;
TimeSpan timeout = TimeSpan.FromMinutes(15);
do
{
droppedDatabases = sqlClient.RestorableDroppedManagedDatabases.ListByInstance(resourceGroup.Name, managedInstance.Name);
if (droppedDatabases.Any())
{
// Dropped database now exists. Exit polling loop.
break;
}
// Sleep if we are running live to avoid hammering the server.
// No need to sleep if we are playing back the recording.
if (HttpMockServer.Mode == HttpRecorderMode.Record)
{
Thread.Sleep(TimeSpan.FromSeconds(30));
}
} while (DateTime.UtcNow < startTime + timeout);
// Assert that we found a restorable db before timeout ended.
Assert.True(droppedDatabases.Any(), "No dropped databases were found after waiting for " + timeout);
var rdmd = droppedDatabases.Single();
// Attempt to increase retention period to 3 days and verfiy that the operation fails.
ManagedBackupShortTermRetentionPolicy parameters1 = new ManagedBackupShortTermRetentionPolicy(retentionDays: invalidValue);
sqlClient.ManagedRestorableDroppedDatabaseBackupShortTermRetentionPolicies.CreateOrUpdateWithHttpMessagesAsync(resourceGroup.Name, managedInstance.Name, rdmd.Name, parameters1);
Microsoft.Rest.ClientRuntime.Azure.TestFramework.TestUtilities.Wait(TimeSpan.FromSeconds(3));
policy = sqlClient.ManagedRestorableDroppedDatabaseBackupShortTermRetentionPolicies.Get(resourceGroup.Name, managedInstance.Name, rdmd.Name);
Assert.Equal(startingRetention, policy.RetentionDays);
// Attempt to increase retention period to 20 days and verfiy that the operation succeeded .
ManagedBackupShortTermRetentionPolicy parameters2 = new ManagedBackupShortTermRetentionPolicy(retentionDays: validValue);
sqlClient.ManagedRestorableDroppedDatabaseBackupShortTermRetentionPolicies.CreateOrUpdateWithHttpMessagesAsync(resourceGroup.Name, managedInstance.Name, rdmd.Name, parameters2);
Microsoft.Rest.ClientRuntime.Azure.TestFramework.TestUtilities.Wait(TimeSpan.FromSeconds(3));
policy = sqlClient.ManagedRestorableDroppedDatabaseBackupShortTermRetentionPolicies.Get(resourceGroup.Name, managedInstance.Name, rdmd.Name);
Assert.Equal(validValue, policy.RetentionDays);
}
}
/// <summary>
/// Converts the response from the service to a powershell managed database object
/// </summary>
/// <param name="resourceGroup">The resource group the managed instance is in</param>
/// <param name="managedInstanceName">The name of the Azure Sql Database Managed Instance</param>
/// <param name="database">The service response</param>
/// <param name="deletionDate">Deletion date for deleted databases</param>
/// <returns>The converted model</returns>
public static AzureSqlManagedDatabaseBackupShortTermRetentionPolicyModel CreateManagedDatabaseBackupShortTermRetentionPolicyModelFromResponse(string resourceGroup, string managedInstanceName, string managedDatabaseName, ManagedBackupShortTermRetentionPolicy managedBackupShortTermRetentionPolicy, DateTime?deletionDate = null)
{
return(new AzureSqlManagedDatabaseBackupShortTermRetentionPolicyModel(resourceGroup, managedInstanceName, managedDatabaseName, managedBackupShortTermRetentionPolicy, deletionDate));
}
public void ShortTermRetentionOnLiveDatabase()
{
string testPrefix = "manageddatabaserestorescenariotest-";
using (SqlManagementTestContext Context = new SqlManagementTestContext(this))
{
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 managedInstance = sqlClient.ManagedInstances.CreateOrUpdate(resourceGroup.Name,
testPrefix + 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,
});
// Create managed database
//
string dbName = SqlManagementTestUtilities.GenerateName(testPrefix);
var db1 = sqlClient.ManagedDatabases.CreateOrUpdate(resourceGroup.Name, managedInstance.Name, dbName, new ManagedDatabase()
{
Location = managedInstance.Location,
});
Assert.NotNull(db1);
int basicRetention = 7;
int invalidValue = 3;
int validValue = 20;
// Attempt to increase retention period to 7 days and verfiy that the operation succeeded.
ManagedBackupShortTermRetentionPolicy parameters0 = new ManagedBackupShortTermRetentionPolicy(retentionDays: basicRetention);
sqlClient.ManagedBackupShortTermRetentionPolicies.CreateOrUpdateWithHttpMessagesAsync(resourceGroup.Name, managedInstance.Name, dbName, parameters0);
Microsoft.Rest.ClientRuntime.Azure.TestFramework.TestUtilities.Wait(TimeSpan.FromSeconds(3));
ManagedBackupShortTermRetentionPolicy policy = sqlClient.ManagedBackupShortTermRetentionPolicies.Get(resourceGroup.Name, managedInstance.Name, dbName);
Assert.Equal(basicRetention, policy.RetentionDays);
// Attempt to increase retention period to 3 days and verfiy that the operation fails.
ManagedBackupShortTermRetentionPolicy parameters1 = new ManagedBackupShortTermRetentionPolicy(retentionDays: invalidValue);
sqlClient.ManagedBackupShortTermRetentionPolicies.CreateOrUpdateWithHttpMessagesAsync(resourceGroup.Name, managedInstance.Name, dbName, parameters1);
Microsoft.Rest.ClientRuntime.Azure.TestFramework.TestUtilities.Wait(TimeSpan.FromSeconds(3));
policy = sqlClient.ManagedBackupShortTermRetentionPolicies.Get(resourceGroup.Name, managedInstance.Name, dbName);
Assert.Equal(basicRetention, policy.RetentionDays);
// Attempt to increase retention period to 20 days and verfiy that the operation succeeded .
ManagedBackupShortTermRetentionPolicy parameters2 = new ManagedBackupShortTermRetentionPolicy(retentionDays: validValue);
sqlClient.ManagedBackupShortTermRetentionPolicies.CreateOrUpdateWithHttpMessagesAsync(resourceGroup.Name, managedInstance.Name, dbName, parameters2);
Microsoft.Rest.ClientRuntime.Azure.TestFramework.TestUtilities.Wait(TimeSpan.FromSeconds(3));
policy = sqlClient.ManagedBackupShortTermRetentionPolicies.Get(resourceGroup.Name, managedInstance.Name, dbName);
Assert.Equal(validValue, policy.RetentionDays);
}
}
