public void Backup(BackupInformation backup)
{
try
{
//var dump = new MongoDump(backup);
//dump.BackupDatabase();
backup.Status = ProcessStatuses.Started;
backup.Log("Backup started");
backup.MongoServer.BackupDatabase(backup);
if (backup.Compress)
{
Compression.Zip(backup);
Directory.Delete(backup.Directory, true);
}
if (backup.DropDatabase)
{
backup.MongoServer.DropDatabase(backup.DatabaseName);
}
backup.Log("Backup completed");
}
catch (Exception ex)
{
backup.Log(ex.Message, LogLevel.Error);
}
}
public async Task SqlContainerRetrieveContinuousBackupInformation()
{
var container = await CreateSqlContainer(null);
BackupInformation backupInfo = (await container.RetrieveContinuousBackupInformationAsync(WaitUntil.Completed, new ContinuousBackupRestoreLocation {
Location = AzureLocation.WestUS
})).Value;
long restoreTime = DateTimeOffset.Parse(backupInfo.ContinuousBackupInformation.LatestRestorableTimestamp).ToUnixTimeMilliseconds();
Assert.True(restoreTime > 0);
SqlContainerCreateUpdateData updateOptions = new SqlContainerCreateUpdateData(container.Id, _containerName, container.Data.ResourceType, null,
new Dictionary <string, string>(),// TODO: use original tags see defect: https://github.com/Azure/autorest.csharp/issues/1590
AzureLocation.WestUS, container.Data.Resource, new CreateUpdateOptions {
Throughput = TestThroughput2
});
container = (await SqlContainerCollection.CreateOrUpdateAsync(WaitUntil.Completed, _containerName, updateOptions)).Value;
backupInfo = (await container.RetrieveContinuousBackupInformationAsync(WaitUntil.Completed, new ContinuousBackupRestoreLocation {
Location = AzureLocation.WestUS
})).Value;
long latestRestoreTime = DateTimeOffset.Parse(backupInfo.ContinuousBackupInformation.LatestRestorableTimestamp).ToUnixTimeMilliseconds();
Assert.True(latestRestoreTime > 0);
Assert.True(latestRestoreTime > restoreTime);
}
public PSSqlBackupInformation(BackupInformation backupInformation)
{
if (backupInformation == null || backupInformation.ContinuousBackupInformation == null)
{
return;
}
LatestRestorableTimestamp = backupInformation.ContinuousBackupInformation.LatestRestorableTimestamp;
}
private void backupButton_Click(object sender, EventArgs e)
{
var backupInfo = new BackupInformation(BackupDatabaseName, BackupFile, EventAggregator, MongoServer)
{
Compress = true,
DropDatabase = dropDatabaseCheck.Checked
};
EventAggregator.Publish(new Message <BackupInformation>(backupInfo)
{
MessageType = MessageTypes.Backup
});
}
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 static void Zip(BackupInformation backup)
{
var folderName = backup.Directory;
var outputFile = backup.File;
backup.Log("Compression started.");
ZipOutputStream zipStream = null;
try
{
FileStream fsOut = File.Create(outputFile);
zipStream = new ZipOutputStream(fsOut);
zipStream.SetLevel(3); //0-9, 9 being the highest level of compression
zipStream.Password = null; // optional. Null is the same as not setting. Required if using AES.
// This setting will strip the leading part of the folder path in the entries, to
// make the entries relative to the starting folder.
// To include the full path for each entry up to the drive root, assign folderOffset = 0.
int folderOffset = folderName.Length + (folderName.EndsWith("\\") ? 0 : 1);
CompressFolder(folderName, zipStream, folderOffset);
backup.Log("Compression completed.");
}
catch (Exception ex)
{
backup.Log(ex.Message, LogLevel.Error);
}
finally
{
if (zipStream != null)
{
zipStream.IsStreamOwner = true; // Makes the Close also Close the underlying stream
zipStream.Close();
}
}
}
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);
}
}
public void BackupDatabase(BackupInformation backup)
{
var currentDB = Client.GetDatabase(backup.DatabaseName);
var collections = currentDB.ListCollections().ToListAsync().Result;
if (!Directory.Exists(backup.Directory))
{
Directory.CreateDirectory(backup.Directory);
}
if (!Directory.Exists(backup.DatabaseDirectory))
{
Directory.CreateDirectory(backup.DatabaseDirectory);
}
collections.ForEach(c =>
{
var name = c["name"].AsString;
var collection = currentDB.GetCollection <BsonDocument>(c["name"].AsString);
collection.DumpData(backup.DatabaseDirectory, name);
collection.DumpInformation(backup.DatabaseDirectory, name);
backup.Log($"{name} has been backed up");
});
}
public static void PerformBackup(BackupInformation b)
{
string backupDeviceName = BaseBackupLocation +
b.Database +
DateTime.Now.Date.ToString("yyyyMMdd") +
".bak";
BackupDeviceItem bdi =
new BackupDeviceItem(backupDeviceName, DeviceType.File);
Backup bu = new Backup();
bu.Database = b.Database;
bu.Devices.Add(bdi);
bu.Initialize = true;
// add percent complete handler
// bu.PercentComplete += new PercentCompleteEventHandler(Backup_PercentComplete);
// add complete event handler
bu.Complete += new ServerMessageEventHandler(Backup_Complete);
Server server = new Server(b.Server);
bu.SqlBackup(server);
}
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);
}
}
