private static void ValidateBackupConfiguration(ServerWideBackupConfiguration serverWideConfiguration, PeriodicBackupConfiguration backupConfiguration, string databaseName)
{
Assert.Equal(PutServerWideBackupConfigurationCommand.GetTaskNameForDatabase(serverWideConfiguration.Name), backupConfiguration.Name);
Assert.Equal(serverWideConfiguration.Disabled, backupConfiguration.Disabled);
Assert.Equal(serverWideConfiguration.FullBackupFrequency, backupConfiguration.FullBackupFrequency);
Assert.Equal(serverWideConfiguration.IncrementalBackupFrequency, backupConfiguration.IncrementalBackupFrequency);
Assert.Equal($"{serverWideConfiguration.LocalSettings.FolderPath}{Path.DirectorySeparatorChar}{databaseName}", backupConfiguration.LocalSettings.FolderPath);
Assert.Equal(serverWideConfiguration.S3Settings.BucketName, backupConfiguration.S3Settings.BucketName);
Assert.Equal($"{serverWideConfiguration.S3Settings.RemoteFolderName}/{databaseName}", backupConfiguration.S3Settings.RemoteFolderName);
Assert.Equal(serverWideConfiguration.AzureSettings.AccountKey, backupConfiguration.AzureSettings.AccountKey);
Assert.Equal(serverWideConfiguration.AzureSettings.AccountName, backupConfiguration.AzureSettings.AccountName);
Assert.Equal($"{serverWideConfiguration.AzureSettings.RemoteFolderName}/{databaseName}", backupConfiguration.AzureSettings.RemoteFolderName);
Assert.Equal($"{serverWideConfiguration.FtpSettings.Url}/{databaseName}", backupConfiguration.FtpSettings.Url);
}
public async Task CreatePeriodicBackupFailsWhenUsingReservedName()
{
using (var store = GetDocumentStore())
{
var putConfiguration = new ServerWideBackupConfiguration
{
Disabled = true,
FullBackupFrequency = "0 2 * * 0",
IncrementalBackupFrequency = "0 2 * * 1"
};
await store.Maintenance.Server.SendAsync(new PutServerWideBackupConfigurationOperation(putConfiguration));
var databaseRecord = await store.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(store.Database));
var currentBackupConfiguration = databaseRecord.PeriodicBackups.First();
var serverWideBackupTaskId = currentBackupConfiguration.TaskId;
var backupConfiguration = new PeriodicBackupConfiguration
{
Disabled = true,
TaskId = currentBackupConfiguration.TaskId,
FullBackupFrequency = "0 2 * * 0",
IncrementalBackupFrequency = "0 2 * * 1"
};
var taskName = PutServerWideBackupConfigurationCommand.GetTaskNameForDatabase(putConfiguration.GetDefaultTaskName());
var e = await Assert.ThrowsAsync <RavenException>(() => store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(backupConfiguration)));
var expectedError = $"Can't delete task id: {currentBackupConfiguration.TaskId}, name: '{taskName}', because it is a server-wide backup task";
Assert.Contains(expectedError, e.Message);
backupConfiguration.TaskId = 0;
backupConfiguration.Name = currentBackupConfiguration.Name;
e = await Assert.ThrowsAsync <RavenException>(() => store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(backupConfiguration)));
expectedError = $"Can't create task: '{taskName}'. A regular (non server-wide) backup task name can't start with prefix '{ServerWideBackupConfiguration.NamePrefix}'";
Assert.Contains(expectedError, e.Message);
e = await Assert.ThrowsAsync <RavenException>(() => store.Maintenance.SendAsync(new DeleteOngoingTaskOperation(serverWideBackupTaskId, OngoingTaskType.Backup)));
expectedError = $"Can't delete task id: {serverWideBackupTaskId}, name: '{taskName}', because it is a server-wide backup task";
Assert.Contains(expectedError, e.Message);
}
}
public async Task CanStoreAndEditServerWideBackupForIdleDatabase()
{
using var server = GetNewServer(new ServerCreationOptions
{
CustomSettings = new Dictionary <string, string>
{
[RavenConfiguration.GetKey(x => x.Databases.MaxIdleTime)] = "10",
[RavenConfiguration.GetKey(x => x.Databases.FrequencyToCheckForIdle)] = "3",
[RavenConfiguration.GetKey(x => x.Core.RunInMemory)] = "false"
}
});
using (var store = GetDocumentStore(new Options {
Server = server, RunInMemory = false
}))
{
var fullFreq = "0 2 1 1 *";
var incFreq = "0 2 * * 0";
var putConfiguration = new ServerWideBackupConfiguration
{
FullBackupFrequency = fullFreq,
IncrementalBackupFrequency = incFreq,
LocalSettings = new LocalSettings
{
FolderPath = "test/folder"
}
};
Assert.Equal(1, WaitForValue(() => server.ServerStore.IdleDatabases.Count, 1, timeout: 60000, interval: 1000));
var result = await store.Maintenance.Server.SendAsync(new PutServerWideBackupConfigurationOperation(putConfiguration));
var serverWideConfiguration = await store.Maintenance.Server.SendAsync(new GetServerWideBackupConfigurationOperation(result.Name));
Assert.NotNull(serverWideConfiguration);
Assert.Equal(fullFreq, serverWideConfiguration.FullBackupFrequency);
Assert.Equal(incFreq, serverWideConfiguration.IncrementalBackupFrequency);
Assert.Equal(1, server.ServerStore.IdleDatabases.Count);
// update the backup configuration
putConfiguration.Name = serverWideConfiguration.Name;
putConfiguration.TaskId = serverWideConfiguration.TaskId;
putConfiguration.FullBackupFrequency = "0 2 * * 0";
var oldName = result.Name;
result = await store.Maintenance.Server.SendAsync(new PutServerWideBackupConfigurationOperation(putConfiguration));
Exception ex = null;
try
{
await server.ServerStore.Cluster.WaitForIndexNotification(result.RaftCommandIndex, TimeSpan.FromMinutes(1));
}
catch (Exception e)
{
ex = e;
}
finally
{
Assert.Null(ex);
}
var record = await store.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(store.Database));
Assert.Equal(1, record.PeriodicBackups.Count);
PeriodicBackupConfiguration periodicBackupConfiguration = record.PeriodicBackups.First();
var newServerWideConfiguration = await store.Maintenance.Server.SendAsync(new GetServerWideBackupConfigurationOperation(result.Name));
// compare with periodic backup task
Assert.NotEqual(newServerWideConfiguration.TaskId, periodicBackupConfiguration.TaskId); // backup task id in db record doesn't change
Assert.Equal(PutServerWideBackupConfigurationCommand.GetTaskNameForDatabase(oldName), periodicBackupConfiguration.Name);
Assert.Equal(incFreq, periodicBackupConfiguration.FullBackupFrequency);
Assert.Equal(incFreq, periodicBackupConfiguration.IncrementalBackupFrequency);
Assert.NotEqual(serverWideConfiguration.FullBackupFrequency, periodicBackupConfiguration.FullBackupFrequency);
// compare with previous server wide backup
Assert.NotEqual(serverWideConfiguration.TaskId, newServerWideConfiguration.TaskId); // task id in server storage get increased with each change
Assert.Equal(oldName, result.Name);
Assert.Equal(incFreq, newServerWideConfiguration.FullBackupFrequency);
Assert.Equal(incFreq, newServerWideConfiguration.IncrementalBackupFrequency);
Assert.NotEqual(serverWideConfiguration.FullBackupFrequency, newServerWideConfiguration.FullBackupFrequency);
Assert.Equal(1, server.ServerStore.IdleDatabases.Count);
}
}
