public override void ExecuteCmdlet()
{
try
{
CosmosDBManagementClient.DatabaseAccounts.Get(ResourceGroupName, AccountName);
}
catch (CloudException e)
{
throw e;
}
try
{
CosmosDBManagementClient.SqlResources.GetSqlDatabase(ResourceGroupName, AccountName, DatabaseName);
}
catch (CloudException e)
{
if (e.Response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
throw new ResourceNotFoundException(message: string.Format(ExceptionMessage.NotFound, DatabaseName), innerException: e);
}
throw e;
}
try
{
CosmosDBManagementClient.SqlResources.GetSqlContainer(ResourceGroupName, AccountName, DatabaseName, Name);
}
catch (CloudException e)
{
if (e.Response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
throw new ResourceNotFoundException(message: string.Format(ExceptionMessage.NotFound, Name), innerException: e);
}
throw e;
}
ContinuousBackupRestoreLocation continuousBackupRestoreLocation = new ContinuousBackupRestoreLocation
{
Location = Location
};
BackupInformation backupInformation = CosmosDBManagementClient.SqlResources.RetrieveContinuousBackupInformation(ResourceGroupName, AccountName, DatabaseName, Name, continuousBackupRestoreLocation);
WriteObject(new PSSqlBackupInformation(backupInformation));
return;
}
public void RetrieveMongoCollectionContinuousBackupInfoTest()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
CosmosDBManagementClient cosmosDBManagementClient = this.fixture.CosmosDBManagementClient;
var resourceGroupName = this.fixture.ResourceGroupName;
var databaseAccountName = this.fixture.GetDatabaseAccountName(TestFixture.AccountType.Mongo36);
string location = this.fixture.Location;
var databaseName = TestUtilities.GenerateName("database");
var collectionName = TestUtilities.GenerateName("collection");
ContinuousBackupRestoreLocation restoreLocation = new ContinuousBackupRestoreLocation(location);
this.CreateMongoDBResources(cosmosDBManagementClient, databaseAccountName, databaseName, collectionName);
var result = cosmosDBManagementClient.DatabaseAccounts.Get(this.fixture.ResourceGroupName, databaseAccountName);
DateTime?oldTime = result.SystemData.CreatedAt;
Assert.NotNull(oldTime);
BackupInformation backupInformation = cosmosDBManagementClient.MongoDBResources.RetrieveContinuousBackupInformation(
resourceGroupName,
databaseAccountName,
databaseName,
collectionName,
restoreLocation);
Assert.NotNull(backupInformation);
Assert.NotNull(backupInformation.ContinuousBackupInformation);
Assert.True(DateTime.Parse(backupInformation.ContinuousBackupInformation.LatestRestorableTimestamp) > oldTime);
oldTime = DateTime.Parse(backupInformation.ContinuousBackupInformation.LatestRestorableTimestamp);
BackupInformation mongobackupInformation = cosmosDBManagementClient.MongoDBResources.RetrieveContinuousBackupInformation(
resourceGroupName,
databaseAccountName,
databaseName,
collectionName,
restoreLocation);
Assert.NotNull(mongobackupInformation);
Assert.NotNull(mongobackupInformation.ContinuousBackupInformation);
Assert.True(DateTime.Parse(mongobackupInformation.ContinuousBackupInformation.LatestRestorableTimestamp) > oldTime);
}
}
public void RetrieveSqlContainerContinuousBackupInfoTest()
{
using (var context = MockContext.Start(this.GetType()))
{
fixture.Init(context);
CosmosDBManagementClient cosmosDBManagementClient = this.fixture.CosmosDBManagementClient;
var resourceGroupName = this.fixture.ResourceGroupName;
var databaseAccountName = this.fixture.GetDatabaseAccountName(TestFixture.AccountType.PitrSql);
string location = this.fixture.Location;
var databaseName = TestUtilities.GenerateName("database");
var containerName = TestUtilities.GenerateName("container");
ContinuousBackupRestoreLocation restoreLocation = new ContinuousBackupRestoreLocation(location);
var result = this.CreateSQLResources(cosmosDBManagementClient, databaseAccountName, databaseName, containerName);
DateTime oldTime = DateTimeOffset.FromUnixTimeSeconds((int)result.Resource._ts).DateTime.AddSeconds(-1);
BackupInformation backupInformation = cosmosDBManagementClient.SqlResources.RetrieveContinuousBackupInformation(
resourceGroupName,
databaseAccountName,
databaseName,
containerName,
restoreLocation);
Assert.NotNull(backupInformation);
Assert.NotNull(backupInformation.ContinuousBackupInformation);
Assert.True(DateTime.Parse(backupInformation.ContinuousBackupInformation.LatestRestorableTimestamp) > oldTime);
oldTime = DateTime.Parse(backupInformation.ContinuousBackupInformation.LatestRestorableTimestamp);
BackupInformation sqlbackupInformation = cosmosDBManagementClient.SqlResources.RetrieveContinuousBackupInformation(
resourceGroupName,
databaseAccountName,
databaseName,
containerName,
restoreLocation);
Assert.NotNull(sqlbackupInformation);
Assert.NotNull(sqlbackupInformation.ContinuousBackupInformation);
Assert.True(DateTime.Parse(sqlbackupInformation.ContinuousBackupInformation.LatestRestorableTimestamp) >= oldTime);
}
}
/// <summary>
/// Retrieves continuous backup information for a table.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group. The name is case insensitive.
/// </param>
/// <param name='accountName'>
/// Cosmos DB database account name.
/// </param>
/// <param name='tableName'>
/// Cosmos DB table name.
/// </param>
/// <param name='location'>
/// The name of the continuous backup restore location.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <BackupInformation> BeginRetrieveContinuousBackupInformationAsync(this ITableResourcesOperations operations, string resourceGroupName, string accountName, string tableName, ContinuousBackupRestoreLocation location, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.BeginRetrieveContinuousBackupInformationWithHttpMessagesAsync(resourceGroupName, accountName, tableName, location, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Retrieves continuous backup information for a table.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group. The name is case insensitive.
/// </param>
/// <param name='accountName'>
/// Cosmos DB database account name.
/// </param>
/// <param name='tableName'>
/// Cosmos DB table name.
/// </param>
/// <param name='location'>
/// The name of the continuous backup restore location.
/// </param>
public static BackupInformation BeginRetrieveContinuousBackupInformation(this ITableResourcesOperations operations, string resourceGroupName, string accountName, string tableName, ContinuousBackupRestoreLocation location)
{
return(operations.BeginRetrieveContinuousBackupInformationAsync(resourceGroupName, accountName, tableName, location).GetAwaiter().GetResult());
}
public void RetrieveContinuousBackupInfoTest()
{
var handler1 = new RecordedDelegatingHandler {
StatusCodeToReturn = HttpStatusCode.OK
};
using (MockContext context = MockContext.Start(this.GetType()))
{
// Create client
CosmosDBManagementClient cosmosDBManagementClient = CosmosDBTestUtilities.GetCosmosDBClient(context, handler1);
ContinuousBackupRestoreLocation restoreLocation = new ContinuousBackupRestoreLocation(location);
SqlContainerCreateUpdateParameters sqlContainerCreateUpdateParameters = new SqlContainerCreateUpdateParameters()
{
Resource = new SqlContainerResource(containerName, partitionKey: new ContainerPartitionKey(new List <String>()
{
"/id"
})),
Options = new CreateUpdateOptions
{
Throughput = 400
}
};
SqlContainerGetResults createContainerResult = cosmosDBManagementClient.SqlResources.CreateUpdateSqlContainer(
resourceGroupName,
databaseAccountName,
databaseName,
containerName,
sqlContainerCreateUpdateParameters);
Assert.NotNull(createContainerResult);
Assert.NotNull(createContainerResult.Id);
BackupInformation backupInformation = cosmosDBManagementClient.SqlResources.RetrieveContinuousBackupInformation(
resourceGroupName,
databaseAccountName,
databaseName,
containerName,
restoreLocation);
Assert.NotNull(backupInformation);
Assert.NotNull(backupInformation.ContinuousBackupInformation);
Assert.True(Int32.Parse(backupInformation.ContinuousBackupInformation.LatestRestorableTimestamp) > 0);
int prevRestoreTime = Int32.Parse(backupInformation.ContinuousBackupInformation.LatestRestorableTimestamp);
ThroughputSettingsUpdateParameters throughputSettingsUpdateParameters = new ThroughputSettingsUpdateParameters()
{
Resource = new ThroughputSettingsResource()
{
Throughput = 4000
}
};
ThroughputSettingsGetResults throughputSettingsGetResults = cosmosDBManagementClient.SqlResources.UpdateSqlContainerThroughput(
resourceGroupName,
databaseAccountName,
databaseName,
containerName,
throughputSettingsUpdateParameters);
Assert.NotNull(throughputSettingsGetResults);
Assert.NotNull(throughputSettingsGetResults.Id);
backupInformation = cosmosDBManagementClient.SqlResources.RetrieveContinuousBackupInformation(
resourceGroupName,
databaseAccountName,
databaseName,
containerName,
restoreLocation);
Assert.NotNull(backupInformation);
Assert.NotNull(backupInformation.ContinuousBackupInformation);
Assert.True(Int32.Parse(backupInformation.ContinuousBackupInformation.LatestRestorableTimestamp) >= prevRestoreTime);
cosmosDBManagementClient.SqlResources.DeleteSqlContainer(resourceGroupName, databaseAccountName, databaseName, containerName);
}
}
public virtual ArmOperation<BackupInformation> RetrieveContinuousBackupInformation(bool waitForCompletion, ContinuousBackupRestoreLocation location, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(location, nameof(location));
using var scope = _sqlContainerSqlResourcesClientDiagnostics.CreateScope("SqlContainer.RetrieveContinuousBackupInformation");
scope.Start();
try
{
var response = _sqlContainerSqlResourcesRestClient.RetrieveContinuousBackupInformation(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, location, cancellationToken);
var operation = new CosmosDBArmOperation<BackupInformation>(new BackupInformationOperationSource(), _sqlContainerSqlResourcesClientDiagnostics, Pipeline, _sqlContainerSqlResourcesRestClient.CreateRetrieveContinuousBackupInformationRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, location).Request, response, OperationFinalStateVia.Location);
if (waitForCompletion)
operation.WaitForCompletion(cancellationToken);
return operation;
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public async virtual Task <ArmOperation <BackupInformation> > RetrieveContinuousBackupInformationAsync(bool waitForCompletion, ContinuousBackupRestoreLocation location, CancellationToken cancellationToken = default)
{
Argument.AssertNotNull(location, nameof(location));
using var scope = _mongoDBCollectionMongoDBResourcesClientDiagnostics.CreateScope("MongoDBCollection.RetrieveContinuousBackupInformation");
scope.Start();
try
{
var response = await _mongoDBCollectionMongoDBResourcesRestClient.RetrieveContinuousBackupInformationAsync(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, location, cancellationToken).ConfigureAwait(false);
var operation = new CosmosDBArmOperation <BackupInformation>(new BackupInformationOperationSource(), _mongoDBCollectionMongoDBResourcesClientDiagnostics, Pipeline, _mongoDBCollectionMongoDBResourcesRestClient.CreateRetrieveContinuousBackupInformationRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, location).Request, response, OperationFinalStateVia.Location);
if (waitForCompletion)
{
await operation.WaitForCompletionAsync(cancellationToken).ConfigureAwait(false);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
public virtual SqlResourceRetrieveContinuousBackupInformationOperation RetrieveContinuousBackupInformation(ContinuousBackupRestoreLocation location, bool waitForCompletion = true, CancellationToken cancellationToken = default)
{
if (location == null)
{
throw new ArgumentNullException(nameof(location));
}
using var scope = _clientDiagnostics.CreateScope("SqlContainer.RetrieveContinuousBackupInformation");
scope.Start();
try
{
var response = _sqlResourcesRestClient.RetrieveContinuousBackupInformation(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, location, cancellationToken);
var operation = new SqlResourceRetrieveContinuousBackupInformationOperation(_clientDiagnostics, Pipeline, _sqlResourcesRestClient.CreateRetrieveContinuousBackupInformationRequest(Id.SubscriptionId, Id.ResourceGroupName, Id.Parent.Parent.Name, Id.Parent.Name, Id.Name, location).Request, response);
if (waitForCompletion)
{
operation.WaitForCompletion(cancellationToken);
}
return(operation);
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
