public IDisposable RestoreDatabase(IDocumentStore store, RestoreBackupConfiguration config, TimeSpan?timeout = null)
{
var restoreOperation = new RestoreBackupOperation(config);
var operation = store.Maintenance.Server.Send(restoreOperation);
operation.WaitForCompletion(timeout ?? TimeSpan.FromSeconds(30));
return(EnsureDatabaseDeletion(config.DatabaseName, store));
}
private async Task RestoreBackup(MyBackup backup)
{
var rnd = new Random();
var restoreDbName =
$"Restored_{new string(Enumerable.Repeat(_chars, rnd.Next(5, 10)).Select(x => x[rnd.Next(x.Length)]).ToArray())}";
var restoreConfig = new RestoreBackupConfiguration
{
DatabaseName = restoreDbName,
BackupLocation = backup.BackupPath
};
var restoreBackupTask = new RestoreBackupOperation(restoreConfig);
using (var session = DocumentStore.OpenAsyncSession())
{
var succeeded = true;
try
{
ReportInfo($"Starting to restore DB: {restoreDbName}");
var re = DocumentStore.GetRequestExecutor(DocumentStore.Database);
var restoreBackupTaskCommand = restoreBackupTask.GetCommand(DocumentStore.Conventions, session.Advanced.Context);
await re.ExecuteAsync(re.TopologyNodes.First(q => q.ClusterTag == backup.BackupStatus.NodeTag),
null, session.Advanced.Context, restoreBackupTaskCommand, shouldRetry : false);
var getOperationStateTask = new GetOperationStateOperation(restoreBackupTaskCommand.Result.OperationId);
var getOperationStateTaskCommand = getOperationStateTask.GetCommand(DocumentStore.Conventions, session.Advanced.Context);
await re.ExecuteAsync(re.TopologyNodes.First(q => q.ClusterTag == backup.BackupStatus.NodeTag),
null, session.Advanced.Context, getOperationStateTaskCommand, shouldRetry : false);
while (getOperationStateTaskCommand.Result.Status == OperationStatus.InProgress)
{
await Task.Delay(2000);
await re.ExecuteAsync(re.TopologyNodes.First(q => q.ClusterTag == backup.BackupStatus.NodeTag),
null, session.Advanced.Context, getOperationStateTaskCommand, shouldRetry : false);
}
}
catch (Exception e)
{
ReportFailure($"Restoring DB: {restoreDbName} Failed", e);
succeeded = false;
}
for (var i = 0; i < MyBackupsList.Count; i++)
{
if (MyBackupsList[i].BackupTaskId == backup.BackupTaskId)
{
MyBackupsList[i].RestoreResult = succeeded ? RestoreResult.Succeeded : RestoreResult.Failed;
break;
}
}
}
}
public RestoreBackupTask(ServerStore serverStore,
RestoreBackupConfiguration restoreConfiguration,
string nodeTag,
OperationCancelToken operationCancelToken)
{
_serverStore = serverStore;
_restoreConfiguration = restoreConfiguration;
_nodeTag = nodeTag;
_operationCancelToken = operationCancelToken;
ValidateArguments(out _restoringToDefaultDataDirectory);
}
public RestoreFromLocal(ServerStore serverStore, RestoreBackupConfiguration restoreConfiguration, string nodeTag, OperationCancelToken operationCancelToken) : base(serverStore, restoreConfiguration, nodeTag, operationCancelToken)
{
if (string.IsNullOrWhiteSpace(restoreConfiguration.BackupLocation))
{
throw new ArgumentException("Backup location can't be null or empty");
}
if (Directory.Exists(restoreConfiguration.BackupLocation) == false)
{
throw new ArgumentException($"Backup location doesn't exist, path: {_backupLocation}");
}
_backupLocation = restoreConfiguration.BackupLocation;
}
public RestoreBackupTask(ServerStore serverStore,
RestoreBackupConfiguration restoreConfiguration,
JsonOperationContext context,
string nodeTag,
CancellationToken cancellationToken)
{
_serverStore = serverStore;
_restoreConfiguration = restoreConfiguration;
_context = context;
_nodeTag = nodeTag;
_cancellationToken = cancellationToken;
ValidateArguments();
}
/// <summary>
/// Restores a RavenDB 4 Backup
/// </summary>
protected override void RestoreDb()
{
var restoreCfg = new RestoreBackupConfiguration
{
DatabaseName = o.Db,
BackupLocation = o.Backup
};
var restoreTask = new RestoreBackupOperation(restoreCfg);
store.Maintenance.Server.Send(restoreTask).WaitForCompletion();
o.DbSize = GetDbSize();
}
public Restore()
{
using (var store = new DocumentStore())
{
#region restore_3
RestoreBackupConfiguration config = new RestoreBackupConfiguration()
{
BackupLocation = @"C:\backups\Northwind",
DatabaseName = "Northwind"
};
RestoreBackupOperation restoreOperation = new RestoreBackupOperation(config);
store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion();
#endregion
}
}
public async Task CanExportImportCompareExchangeWithExpiration()
{
using var server = GetNewServer();
int count = 15;
var expiry = DateTime.Now.AddMinutes(2);
var longExpiry = DateTime.Now.AddMinutes(4);
var compareExchangesWithShortExpiration = new Dictionary <string, User>();
var compareExchangesWithLongExpiration = new Dictionary <string, User>();
var compareExchanges = new Dictionary <string, User>();
var amountToAdd = count / 3;
var backupPath = NewDataPath(suffix: "BackupFolder");
var databaseName = GetDatabaseName() + "restore";
using (var store = GetDocumentStore(new Options
{
Server = server
}))
{
await AddCompareExchangesWithExpire(amountToAdd, compareExchanges, store, expiry : null);
await AddCompareExchangesWithExpire(amountToAdd, compareExchangesWithShortExpiration, store, expiry);
await AddCompareExchangesWithExpire(amountToAdd, compareExchangesWithLongExpiration, store, longExpiry);
await AssertCompareExchanges(compareExchangesWithShortExpiration, store, expiry);
await AssertCompareExchanges(compareExchangesWithLongExpiration, store, longExpiry);
await AssertCompareExchanges(compareExchanges, store, expiry : null);
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
Name = "full",
FullBackupFrequency = "0 0 1 1 *",
BackupType = BackupType.Backup
};
var result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config));
var documentDatabase = await server.ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore(store.Database);
var periodicBackupRunner = documentDatabase.PeriodicBackupRunner;
var op = periodicBackupRunner.StartBackupTask(result.TaskId, isFullBackup: true);
var value = WaitForValue(() =>
{
var status = store.Maintenance.Send(new GetOperationStateOperation(op)).Status;
return(status);
}, OperationStatus.Completed);
Assert.Equal(OperationStatus.Completed, value);
var backupDirectory = Directory.GetDirectories(backupPath).First();
var restoreConfig = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory,
DatabaseName = databaseName
};
var restoreOperation = new RestoreBackupOperation(restoreConfig);
var o = await store.Maintenance.Server.SendAsync(restoreOperation);
await o.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
using (var store2 = GetDocumentStore(new Options
{
Server = server,
CreateDatabase = false,
ModifyDatabaseName = s => databaseName
}))
{
var stats1 = await store.Maintenance.SendAsync(new GetDetailedStatisticsOperation());
Assert.Equal(count, stats1.CountOfCompareExchange);
var stats = await store2.Maintenance.SendAsync(new GetDetailedStatisticsOperation());
Assert.Equal(count, stats.CountOfCompareExchange);
server.ServerStore.Observer.Time.UtcDateTime = () => DateTime.UtcNow.AddMinutes(3);
var val = await WaitForValueAsync(async() =>
{
var stats = await store2.Maintenance.SendAsync(new GetDetailedStatisticsOperation());
return(stats.CountOfCompareExchange);
}, count - amountToAdd);
Assert.Equal(count - amountToAdd, val);
server.ServerStore.Observer.Time.UtcDateTime = () => DateTime.UtcNow.AddMinutes(5);
var nextVal = await WaitForValueAsync(async() =>
{
var stats = await store2.Maintenance.SendAsync(new GetDetailedStatisticsOperation());
return(stats.CountOfCompareExchange);
}, amountToAdd);
Assert.Equal(amountToAdd, nextVal);
stats1 = await store.Maintenance.SendAsync(new GetDetailedStatisticsOperation());
Assert.Equal(amountToAdd, stats1.CountOfCompareExchange);
stats = await store2.Maintenance.SendAsync(new GetDetailedStatisticsOperation());
Assert.Equal(amountToAdd, stats.CountOfCompareExchange);
}
}
}
public async Task CanPassNodeTagToRestoreBackupOperation()
{
var myBackupsList = new List <MyBackup>();
var backupPath = NewDataPath(suffix: "BackupFolder");
var clusterSize = 3;
var databaseName = GetDatabaseName();
var cluster = await CreateRaftCluster(clusterSize, false);
using (var store = new DocumentStore
{
Urls = new[] { cluster.Leader.WebUrl },
Database = databaseName,
}.Initialize())
{
var doc = new DatabaseRecord(databaseName);
var databaseResult = await store.Maintenance.Server.SendAsync(new CreateDatabaseOperation(doc, clusterSize));
await store.Maintenance.SendAsync(new CreateSampleDataOperation());
var myNodesList = databaseResult.Topology.AllNodes.ToList();
Assert.True(clusterSize == myNodesList.Count, $"clusterSize({clusterSize}) == myNodesList.Count({myNodesList.Count})");
foreach (var node in myNodesList)
{
var myGuid = Guid.NewGuid();
var backupConfig = Backup.CreateBackupConfiguration(Path.Combine(backupPath, myGuid.ToString()), name: $"Task_{node}_{myGuid}", mentorNode: node);
var result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(backupConfig));
await WaitForRaftIndexToBeAppliedOnClusterNodes(result.RaftCommandIndex, cluster.Nodes);
OngoingTask res = null;
await WaitForValueAsync(async() =>
{
res = await store.Maintenance.SendAsync(new GetOngoingTaskInfoOperation(result.TaskId, OngoingTaskType.Backup));
return(res.ResponsibleNode.NodeTag);
}, node, interval : 333);
Assert.NotNull(res);
Assert.True(node == res.MentorNode, $"node({node}) == res.MentorNode({res.MentorNode})");
Assert.True(node == res.ResponsibleNode.NodeTag, $"node({node}) == res.ResponsibleNode.NodeTag({res.ResponsibleNode.NodeTag})");
myBackupsList.Add(new MyBackup
{
BackupTaskId = result.TaskId,
Guid = myGuid,
NodeTag = res.ResponsibleNode.NodeTag
});
}
foreach (var myBackup in myBackupsList)
{
var res = await store.Maintenance.SendAsync(new StartBackupOperation(isFullBackup : true, myBackup.BackupTaskId));
Assert.True(myBackup.NodeTag == res.Result.ResponsibleNode, $"myBackup.NodeTag({myBackup.NodeTag}) == res.ResponsibleNode({res.Result.ResponsibleNode})");
var operation = new GetPeriodicBackupStatusOperation(myBackup.BackupTaskId);
PeriodicBackupStatus status = null;
var value = WaitForValue(() =>
{
status = store.Maintenance.Send(operation).Status;
if (status?.LastEtag == null)
{
return(false);
}
return(true);
}, true);
Assert.True(value, $"Got status: {status != null}, exception: {status?.Error?.Exception}, LocalBackup.Exception: {status?.LocalBackup?.Exception}");
Assert.True(status != null, $"status != null, exception: {status?.Error?.Exception}, LocalBackup.Exception: {status?.LocalBackup?.Exception}");
Assert.True(myBackup.NodeTag == status.NodeTag, $"myBackup.NodeTag({myBackup.NodeTag}) == status.NodeTag({status.NodeTag})");
var prePath = Path.Combine(backupPath, myBackup.Guid.ToString());
myBackup.BackupPath = Path.Combine(prePath, status.FolderName);
}
var dbs = new List <string>();
foreach (var myBackup in myBackupsList)
{
var name = $"restored_DB1_{myBackup.NodeTag}";
var restoreConfig = new RestoreBackupConfiguration
{
DatabaseName = name,
BackupLocation = myBackup.BackupPath
};
dbs.Add(name);
var restoreBackupTask = store.Maintenance.Server.Send(new RestoreBackupOperation(restoreConfig, myBackup.NodeTag));
restoreBackupTask.WaitForCompletion(TimeSpan.FromSeconds(30));
}
var dbNames = await store.Maintenance.Server.SendAsync(new GetDatabaseNamesOperation(0, int.MaxValue));
Assert.Equal(clusterSize + 1, dbNames.Length);
dbs.ForEach(db => Assert.True(dbNames.Contains(db), $"numOfDbs.Contains(db), db = {db}"));
}
}
public RestoreBackupOperation(RestoreBackupConfiguration restoreConfiguration)
{
_restoreConfiguration = restoreConfiguration;
}
public async Task SkipExportingTheServerWideBackup2()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
var serverWideBackupConfiguration = new ServerWideBackupConfiguration
{
Disabled = false,
FullBackupFrequency = "0 2 * * 0",
IncrementalBackupFrequency = "0 2 * * 1",
LocalSettings = new LocalSettings
{
FolderPath = backupPath
}
};
await store.Maintenance.Server.SendAsync(new PutServerWideBackupConfigurationOperation(serverWideBackupConfiguration));
var record = await store.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(store.Database));
var backup = record.PeriodicBackups.First();
var backupTaskId = backup.TaskId;
// save another backup task in the database record
var backupConfiguration = new PeriodicBackupConfiguration
{
Disabled = true,
FullBackupFrequency = "0 2 * * 0",
IncrementalBackupFrequency = "0 2 * * 1"
};
await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(backupConfiguration));
await store.Maintenance.SendAsync(new StartBackupOperation(true, backupTaskId));
string backupDirectory = null;
var value = WaitForValue(() =>
{
var status = store.Maintenance.Send(new GetPeriodicBackupStatusOperation(backupTaskId)).Status;
backupDirectory = status?.LocalBackup.BackupDirectory;
return(status?.LastEtag);
}, 0);
Assert.Equal(0, value);
var files = Directory.GetFiles(backupDirectory)
.Where(BackupUtils.IsBackupFile)
.OrderBackups()
.ToArray();
var databaseName = GetDatabaseName() + "restore";
var restoreConfig = new RestoreBackupConfiguration
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = files.OrderBackups().Last()
};
var restoreOperation = new RestoreBackupOperation(restoreConfig);
store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion(TimeSpan.FromSeconds(30));
// old server should have 2: 1 server-wide and 1 regular backup
using (var store2 = GetDocumentStore(new Options
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName,
}))
{
var record2 = await store.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(store2.Database));
Assert.Equal(2, record2.PeriodicBackups.Count);
}
// new server should have only one backup
var server = GetNewServer();
using (var store3 = GetDocumentStore(new Options
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName,
Server = server
}))
{
store3.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion(TimeSpan.FromSeconds(30));
var record3 = await store3.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(databaseName));
Assert.Equal(1, record3.PeriodicBackups.Count);
}
}
}
public async Task CreateFullAndIncrementalBackupWithIdentitiesInTheMiddle()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User
{
Id = "users|",
Name = "Toli"
});
session.Store(new User
{
Id = "users|",
Name = "Mitzi"
});
session.SaveChanges();
}
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
Name = "full",
FullBackupFrequency = "* */6 * * *",
BackupType = BackupType.Backup
};
var result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config));
var documentDatabase = (await GetDocumentDatabaseInstanceFor(store));
RunBackup(result.TaskId, documentDatabase, true, store);
Dictionary <string, long> identities = store.Maintenance.Send(new GetIdentitiesOperation());
config.IncrementalBackupFrequency = "* */2 * * *";
config.TaskId = result.TaskId;
result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config));
RunBackup(result.TaskId, documentDatabase, false, store);
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
RestoreBackupConfiguration config2 = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = Directory.GetFiles(backupDirectory).Last()
};
RestoreBackupOperation restoreOperation = new RestoreBackupOperation(config2);
store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion();
using (var store2 = GetDocumentStore(new Options()
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName
}))
{
Dictionary <string, long> identities2 = store2.Maintenance.Send(new GetIdentitiesOperation());
Assert.Equal(identities.First().Key, identities2.First().Key);
Assert.Equal(identities.First().Value, identities2.First().Value);
};
}
}
public RestoreBackupOperation(RestoreBackupConfiguration restoreConfiguration)
#endregion
{
}
public async Task restore_settings_tests()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore(new Options
{
ModifyDatabaseName = s => $"{s}_2"
}))
{
var restoreConfiguration = new RestoreBackupConfiguration();
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
var e = Assert.Throws <RavenException>(() => store.Admin.Server.Send(restoreBackupTask));
Assert.Contains("Database name can't be null or empty", e.InnerException.Message);
restoreConfiguration.DatabaseName = store.Database;
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Admin.Server.Send(restoreBackupTask));
Assert.Contains("Cannot restore data to an existing database", e.InnerException.Message);
restoreConfiguration.DatabaseName = "test";
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Admin.Server.Send(restoreBackupTask));
Assert.Contains("Backup location can't be null or empty", e.InnerException.Message);
restoreConfiguration.BackupLocation = "~\\this-path-doesn't-exist\\";
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Admin.Server.Send(restoreBackupTask));
Assert.Contains("Backup location doesn't exist", e.InnerException.Message);
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User { Name = "oren" }, "users/1");
await session.SaveChangesAsync();
}
var config = new PeriodicBackupConfiguration
{
BackupType = BackupType.Backup,
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
IncrementalBackupFrequency = "* * * * *" //every minute
};
var result = await store.Admin.Server.SendAsync(new UpdatePeriodicBackupOperation(config, store.Database));
var periodicBackupTaskId = result.TaskId;
var operation = new GetPeriodicBackupStatusOperation(store.Database, periodicBackupTaskId);
SpinWait.SpinUntil(() =>
{
var getPeriodicBackupResult = store.Admin.Server.Send(operation);
return(getPeriodicBackupResult.Status?.LastEtag > 0);
}, TimeSpan.FromMinutes(2));
restoreConfiguration.BackupLocation = backupPath;
restoreConfiguration.DataDirectory = backupPath;
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Admin.Server.Send(restoreBackupTask));
Assert.Contains("New data directory must be empty of any files or folders", e.InnerException.Message);
restoreConfiguration.BackupLocation = backupPath;
var emptyFolder = NewDataPath(suffix: "BackupFolderRestore");
restoreConfiguration.DataDirectory = emptyFolder;
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Admin.Server.Send(restoreBackupTask));
Assert.Contains("Journals directory must be empty of any files or folders", e.InnerException.Message);
restoreConfiguration.BackupLocation = backupPath;
restoreConfiguration.DataDirectory = emptyFolder;;
restoreConfiguration.IndexingStoragePath = backupPath;
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Admin.Server.Send(restoreBackupTask));
Assert.Contains("Indexes directory must be empty of any files or folders", e.InnerException.Message);
}
}
public async Task can_backup_and_restore_snapshot()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User { Name = "oren" }, "users/1");
await session.SaveChangesAsync();
}
var config = new PeriodicBackupConfiguration
{
BackupType = BackupType.Snapshot,
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
IncrementalBackupFrequency = "* * * * *" //every minute
};
var result = await store.Admin.Server.SendAsync(new UpdatePeriodicBackupOperation(config, store.Database));
var periodicBackupTaskId = result.TaskId;
var operation = new GetPeriodicBackupStatusOperation(store.Database, periodicBackupTaskId);
SpinWait.SpinUntil(() =>
{
var getPeriodicBackupResult = store.Admin.Server.Send(operation);
return(getPeriodicBackupResult.Status?.LastEtag > 0);
}, TimeSpan.FromMinutes(2));
var etagForBackups = store.Admin.Server.Send(operation).Status.LastEtag;
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User { Name = "ayende" }, "users/2");
await session.StoreAsync(new User { Name = "ayende" }, "users/3");
await session.SaveChangesAsync();
}
SpinWait.SpinUntil(() =>
{
var newLastEtag = store.Admin.Server.Send(operation).Status.LastEtag;
return(newLastEtag != etagForBackups);
}, TimeSpan.FromMinutes(2));
// restore the database with a different name
const string restoredDatabaseName = "restored_database_snapshot";
var restoreConfiguration = new RestoreBackupConfiguration
{
BackupLocation = Directory.GetDirectories(backupPath).First(),
DatabaseName = restoredDatabaseName
};
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
var restoreResult = store.Admin.Server.Send(restoreBackupTask);
var stateRequest = new GetOperationStateOperation(restoreResult.OperationId, true);
store.Admin.Server.Send(stateRequest);
SpinWait.SpinUntil(() =>
{
var state = store.Admin.Server.Send(stateRequest);
return(state.Status == OperationStatus.Completed);
}, TimeSpan.FromMinutes(2));
using (var session = store.OpenAsyncSession(restoredDatabaseName))
{
var users = await session.LoadAsync <User>(new[] { "users/1", "users/2" });
Assert.True(users.Any(x => x.Value.Name == "oren"));
Assert.True(users.Any(x => x.Value.Name == "ayende"));
}
}
}
public async Task CreateFullAndIncrementalBackupWithCompareExchangeInTheMiddle()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Toli"
}, "users/1");
session.SaveChanges();
}
var config = Backup.CreateBackupConfiguration(backupPath);
var backupTaskId = await Backup.UpdateConfigAndRunBackupAsync(Server, config, store);
CompareExchangeResult <string> compareExchangeResult
= store.Operations.Send(
new PutCompareExchangeValueOperation <string>("users/1", "Mitzi", 0));
WaitForValue(() => compareExchangeResult.Successful, true);
await Backup.RunBackupAsync(Server, backupTaskId, store, isFullBackup : false);
compareExchangeResult
= store.Operations.Send(
new PutCompareExchangeValueOperation <string>("users/1", "Mitzi2", compareExchangeResult.Index));
WaitForValue(() => compareExchangeResult.Successful, true);
await Backup.RunBackupAsync(Server, backupTaskId, store, isFullBackup : false);
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
var files = Directory.GetFiles(backupDirectory)
.Where(BackupUtils.IsBackupFile)
.OrderBackups()
.ToArray();
RestoreBackupConfiguration config2 = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = files.Last()
};
RestoreBackupOperation restoreOperation = new RestoreBackupOperation(config2);
store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion();
using (var store2 = GetDocumentStore(new Options()
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName
}))
{
using (var session = store2.OpenSession())
{
var doc = session.Load <User>("users/1");
Assert.NotNull(doc);
};
CompareExchangeValue <string> readResult =
store2.Operations.Send(new GetCompareExchangeValueOperation <string>("users/1"));
Assert.Equal("Mitzi2", readResult.Value);
};
}
}
public async Task CreateFullAndIncrementalBackupWithIndexInTheMiddle()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Toli"
}, "users/1");
session.SaveChanges();
}
var config = Backup.CreateBackupConfiguration(backupPath);
var backupTaskId = await Backup.UpdateConfigAndRunBackupAsync(Server, config, store);
var input = new IndexDefinition
{
Name = "Users_ByName",
Maps =
{
"from user in docs.Users select new { user.Name }"
},
Type = IndexType.Map
};
await store
.Maintenance
.SendAsync(new PutIndexesOperation(new[] { input }));
await Backup.RunBackupAsync(Server, backupTaskId, store, isFullBackup : false);
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
var files = Directory.GetFiles(backupDirectory)
.Where(BackupUtils.IsBackupFile)
.OrderBackups()
.ToArray();
RestoreBackupConfiguration config2 = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = files.Last()
};
RestoreBackupOperation restoreOperation = new RestoreBackupOperation(config2);
store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion(TimeSpan.FromSeconds(30));
using (var store2 = GetDocumentStore(new Options()
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName
}))
{
var stats = store2.Maintenance.ForDatabase(databaseName).Send(new GetStatisticsOperation());
Assert.Equal(1, stats.CountOfIndexes);
Assert.Equal(1, stats.CountOfDocuments);
};
}
}
public async Task CreateFullAndIncrementalBackupWithIdentitiesInTheMiddle()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User
{
Id = "users|",
Name = "Toli"
});
session.Store(new User
{
Id = "users|",
Name = "Mitzi"
});
session.SaveChanges();
}
var config = Backup.CreateBackupConfiguration(backupPath);
var backupTaskId = await Backup.UpdateConfigAndRunBackupAsync(Server, config, store);
Dictionary <string, long> identities = store.Maintenance.Send(new GetIdentitiesOperation());
await Backup.RunBackupAsync(Server, backupTaskId, store, isFullBackup : false);
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
var files = Directory.GetFiles(backupDirectory)
.Where(BackupUtils.IsBackupFile)
.OrderBackups()
.ToArray();
RestoreBackupConfiguration config2 = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = files.Last()
};
RestoreBackupOperation restoreOperation = new RestoreBackupOperation(config2);
store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion();
using (var store2 = GetDocumentStore(new Options()
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName
}))
{
Dictionary <string, long> identities2 = store2.Maintenance.Send(new GetIdentitiesOperation());
Assert.Equal(identities.First().Key, identities2.First().Key);
Assert.Equal(identities.First().Value, identities2.First().Value);
};
}
}
public RestoreBackupCommand(RestoreBackupConfiguration restoreConfiguration)
{
_restoreConfiguration = restoreConfiguration;
}
public async Task restore_settings_tests()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore(new Options
{
ModifyDatabaseName = s => $"{s}_2"
}))
{
var restoreConfiguration = new RestoreBackupConfiguration();
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
var e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("Database name can't be null or empty", e.InnerException.Message);
restoreConfiguration.DatabaseName = store.Database;
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("Cannot restore data to an existing database", e.InnerException.Message);
restoreConfiguration.DatabaseName = "test-" + Guid.NewGuid();
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("Backup location can't be null or empty", e.InnerException.Message);
restoreConfiguration.BackupLocation = "this-path-doesn't-exist\\";
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("Backup location doesn't exist", e.InnerException.Message);
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User { Name = "oren" }, "users/1");
await session.SaveChangesAsync();
}
var config = new PeriodicBackupConfiguration
{
BackupType = BackupType.Backup,
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
IncrementalBackupFrequency = "* * * * *" //every minute
};
var backupTaskId = (await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config))).TaskId;
await store.Maintenance.SendAsync(new StartBackupOperation(true, backupTaskId));
var operation = new GetPeriodicBackupStatusOperation(backupTaskId);
var value = WaitForValue(() =>
{
var status = store.Maintenance.Send(operation).Status;
return(status?.LastEtag);
}, 1);
Assert.Equal(1, value);
restoreConfiguration.BackupLocation = backupPath;
restoreConfiguration.DataDirectory = backupPath;
restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
e = Assert.Throws <RavenException>(() => store.Maintenance.Server.Send(restoreBackupTask));
Assert.Contains("New data directory must be empty of any files or folders", e.InnerException.Message);
var emptyFolder = NewDataPath(suffix: "BackupFolderRestore");
restoreConfiguration.BackupLocation = backupPath;
restoreConfiguration.DataDirectory = emptyFolder;
}
}
static async Task MainInternal()
{
using (var docStore = new DocumentStore
{
Urls = new[] { "http://127.0.0.1:8080" },
Database = "Products"
}.Initialize())
{
#region logical_full_backup_every_3_hours
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
//Backup files local path
FolderPath = @"E:\RavenBackups"
},
//Full Backup period (Cron expression for a 3-hours period)
FullBackupFrequency = "0 */3 * * *",
//Type can be Backup or Snapshot
BackupType = BackupType.Backup,
//Task Name
Name = "fullBackupTask",
};
var operation = new UpdatePeriodicBackupOperation(config);
var result = await docStore.Maintenance.SendAsync(operation);
#endregion
}
using (var docStore = new DocumentStore
{
Urls = new[] { "http://127.0.0.1:8080" },
Database = "Products"
}.Initialize())
{
#region encrypted_logical_full_backup
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
//Backup files local path
FolderPath = @"E:\RavenBackups"
},
//Full Backup period (Cron expression for a 3-hours period)
FullBackupFrequency = "0 */3 * * *",
//Type can be Backup or Snapshot
BackupType = BackupType.Backup,
//Task Name
Name = "fullBackupTask"
};
var operation = new UpdatePeriodicBackupOperation(config);
var result = await docStore.Maintenance.SendAsync(operation);
#endregion
}
using (var docStore = new DocumentStore
{
Urls = new[] { "http://127.0.0.1:8080" },
Database = "Products"
}.Initialize())
{
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = @"E:\RavenBackups"
},
#region backup_type_snapshot
//Type can be Backup or Snapshot
BackupType = BackupType.Snapshot,
#endregion
#region backup_full_backup
//Full Backup period (Cron expression for a 6-hours period)
FullBackupFrequency = "0 */6 * * *",
#endregion
#region backup_incremental_backup
//Cron expression: set incremental backup period ("*/20 * * * *" is a 20-minutes period)
IncrementalBackupFrequency = "*/20 * * * *",
#endregion
};
}
using (var docStore = new DocumentStore
{
Urls = new[] { "http://127.0.0.1:8080" },
Database = "Products"
}.Initialize())
{
#region backup_remote_destinations
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = @"E:\RavenBackups"
},
//FTP Backup settings
FtpSettings = new FtpSettings
{
Url = "192.168.10.4",
Port = 8080,
UserName = "******",
Password = "******"
},
//Azure Backup settings
AzureSettings = new AzureSettings
{
StorageContainer = "storageContainer",
RemoteFolderName = "remoteFolder",
AccountName = "JohnAccount",
AccountKey = "key"
},
//Amazon S3 bucket settings.
S3Settings = new S3Settings
{
AwsAccessKey = "your access key here",
AwsSecretKey = "your secret key here",
AwsRegionName = "OPTIONAL",
BucketName = "john-bucket",
},
//Amazon Glacier settings.
GlacierSettings = new GlacierSettings
{
AwsAccessKey = "your access key here",
AwsSecretKey = "your secret key here",
AwsRegionName = "OPTIONAL",
VaultName = "john-glacier",
}
};
var operation = new UpdatePeriodicBackupOperation(config);
var result = await docStore.Maintenance.SendAsync(operation);
#endregion
}
using (var docStore = new DocumentStore
{
Urls = new[] { "http://127.0.0.1:8080" },
Database = "Products"
}.Initialize())
{
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = @"E:\RavenBackups"
},
//FTP Backup settings
FtpSettings = new FtpSettings
{
Url = "192.168.10.4",
Port = 8080,
UserName = "******",
Password = "******"
},
//Azure Backup settings
AzureSettings = new AzureSettings
{
StorageContainer = "storageContainer",
RemoteFolderName = "remoteFolder",
AccountName = "JohnAccount",
AccountKey = "key"
}
};
#region initiate_immediate_backup_execution
var operation = new UpdatePeriodicBackupOperation(config);
var result = await docStore.Maintenance.SendAsync(operation);
//run a backup task immediately
await docStore.Maintenance.SendAsync(new StartBackupOperation(true, result.TaskId));
#endregion
#region get_backup_execution_results
//Provide GetPeriodicBackupStatusOperation with the task ID returned by RavenDB
var backupStatus = new GetPeriodicBackupStatusOperation(result.TaskId);
#endregion
}
using (var docStore = new DocumentStore
{
Urls = new[] { "http://127.0.0.1:8080" },
Database = "Products"
}.Initialize())
{
#region restore_to_single_node
var restoreConfiguration = new RestoreBackupConfiguration();
//New database name
restoreConfiguration.DatabaseName = "newProductsDatabase";
//Local path with a backup file
var backupPath = @"C:\Users\RavenDB\backups\2018-12-26-16-17.ravendb-Products-A-backup";
restoreConfiguration.BackupLocation = backupPath;
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
docStore.Maintenance.Server.Send(restoreBackupTask);
#endregion
#region restore_disable_ongoing_tasks_false
//Disable or Enable ongoing tasks after restoration.
//Default setting is FALSE, so tasks DO run when backup is restored.
restoreConfiguration.DisableOngoingTasks = false;
#endregion
#region restore_last_file_name_to_restore
//Last incremental backup file to restore from
restoreConfiguration.LastFileNameToRestore = @"2018-12-26-12-00.ravendb-incremental-backup";
#endregion
#region restore_to_specific__data_directory
//Restore to a pre-chosen folder
var dataPath = @"C:\Users\RavenDB\backups\2018-12-26-16-17.ravendb-Products-A-backup\restoredDatabaseLocation";
restoreConfiguration.DataDirectory = dataPath;
#endregion
#region restore_disable_ongoing_tasks_true
//Do or do not run ongoing tasks after restoration.
//Default setting is FALSE, to allow tasks' execution when the backup is restored.
restoreConfiguration.DisableOngoingTasks = true;
#endregion
}
#region encrypted_database
// path to the certificate you received during the server setup
var cert = new X509Certificate2(@"C:\Users\RavenDB\authentication_key\admin.client.certificate.RavenDBdom.pfx");
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
// Backup & Restore here
}
#endregion
// path to the authentication key you received during the server setup
cert = new X509Certificate2(@"C:\Users\RavenDB\authentication_key\admin.client.certificate.RavenDBdom.pfx");
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
#region restore_encrypted_database
// restore encrypted database
// restore configuration
var restoreConfiguration = new RestoreBackupConfiguration();
//New database name
restoreConfiguration.DatabaseName = "newEncryptedDatabase";
//Backup-file location
var backupPath = @"C:\Users\RavenDB\2019-01-06-11-11.ravendb-encryptedDatabase-A-snapshot";
restoreConfiguration.BackupLocation = backupPath;
restoreConfiguration.EncryptionKey = "1F0K2R/KkcwbkK7n4kYlv5eqisy/pMnSuJvZ2sJ/EKo=";
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
docStore.Maintenance.Server.Send(restoreBackupTask);
#endregion
}
}
public async Task CreateFullBackupWithSeveralCompareExchange()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
var user = new User
{
Name = "💩"
};
await store.Operations.SendAsync(new PutCompareExchangeValueOperation <User>("emojis/poo", user, 0));
var user2 = new User
{
Name = "💩🤡"
};
await store.Operations.SendAsync(new PutCompareExchangeValueOperation <User>("emojis/pooclown", user2, 0));
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
Name = "full",
FullBackupFrequency = "* */6 * * *",
BackupType = BackupType.Backup
};
var result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config));
var documentDatabase = (await GetDocumentDatabaseInstanceFor(store));
RunBackup(result.TaskId, documentDatabase, true, store); // FULL BACKUP
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
var files = Directory.GetFiles(backupDirectory)
.Where(BackupUtils.IsBackupFile)
.OrderBackups()
.ToArray();
var restoreConfig = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = files.Last()
};
var restoreOperation = new RestoreBackupOperation(restoreConfig);
store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion(TimeSpan.FromSeconds(30));
using (var store2 = GetDocumentStore(new Options()
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName
}))
{
using (var session = store2.OpenAsyncSession(new SessionOptions
{
TransactionMode = TransactionMode.ClusterWide
}))
{
var user1 = (await session.Advanced.ClusterTransaction.GetCompareExchangeValueAsync <User>("emojis/poo"));
var user3 = (await session.Advanced.ClusterTransaction.GetCompareExchangeValueAsync <User>("emojis/pooclown"));
Assert.Equal(user.Name, user1.Value.Name);
Assert.Equal(user2.Name, user3.Value.Name);
}
}
}
}
public async Task CreateFullAndIncrementalBackupWithCompareExchangeInTheMiddle()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Toli"
}, "users/1");
session.SaveChanges();
}
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
Name = "full",
FullBackupFrequency = "* */6 * * *",
BackupType = BackupType.Backup
};
var result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config));
var documentDatabase = (await GetDocumentDatabaseInstanceFor(store));
RunBackup(result.TaskId, documentDatabase, true, store);
CompareExchangeResult <string> compareExchangeResult
= store.Operations.Send(
new PutCompareExchangeValueOperation <string>("users/1", "Mitzi", 0));
config.IncrementalBackupFrequency = "* */2 * * *";
config.TaskId = result.TaskId;
result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config));
RunBackup(result.TaskId, documentDatabase, false, store);
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
RestoreBackupConfiguration config2 = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = Directory.GetFiles(backupDirectory).Last()
};
RestoreBackupOperation restoreOperation = new RestoreBackupOperation(config2);
store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion();
using (var store2 = GetDocumentStore(new Options()
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName
}))
{
using (var session = store2.OpenSession())
{
var doc = session.Load <User>("users/1");
Assert.NotNull(doc);
};
CompareExchangeValue <string> readResult =
store2.Operations.Send(new GetCompareExchangeValueOperation <string>("users/1"));
Assert.Equal("Mitzi", readResult.Value);
};
}
}
static async Task MainInternal()
{
#region encrypted_database
// path to the certificate you received during the server setup
var cert = new X509Certificate2(@"C:\Users\RavenDB\authentication_key\admin.client.certificate.RavenDBdom.pfx");
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
// Backup & Restore procedures here
}
#endregion
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
//Backup files local path
FolderPath = @"E:\RavenBackups"
},
//Full Backup period (Cron expression for a 3-hours period)
FullBackupFrequency = "0 */3 * * *",
//Type can be Backup or Snapshot
BackupType = BackupType.Backup,
//Task Name
Name = "fullBackupTask",
BackupEncryptionSettings = new BackupEncryptionSettings
{
#region use_database_encryption_key
//Use the same encryption key as the database
EncryptionMode = EncryptionMode.UseDatabaseKey
#endregion
}
};
var operation = new UpdatePeriodicBackupOperation(config);
var result = await docStore.Maintenance.SendAsync(operation);
}
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
#region use_database_encryption_key_full_sample
var config = new PeriodicBackupConfiguration
{
//additional settings here..
//..
//This is a logical-backup
BackupType = BackupType.Backup,
BackupEncryptionSettings = new BackupEncryptionSettings
{
//Use the same encryption key as the database
EncryptionMode = EncryptionMode.UseDatabaseKey
}
};
var operation = new UpdatePeriodicBackupOperation(config);
var result = await docStore.Maintenance.SendAsync(operation);
#endregion
}
using (var docStore = new DocumentStore)
{
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
//Backup files local path
FolderPath = @"E:\RavenBackups"
},
//Full Backup period (Cron expression for a 3-hours period)
FullBackupFrequency = "0 */3 * * *",
//Type can be Backup or Snapshot
BackupType = BackupType.Backup,
//Task Name
Name = "fullBackupTask",
BackupEncryptionSettings = new BackupEncryptionSettings
{
#region use_provided_encryption_key
//Use an encryption key of your choice
EncryptionMode = EncryptionMode.UseProvidedKey,
Key = "OI7Vll7DroXdUORtc6Uo64wdAk1W0Db9ExXXgcg5IUs="
#endregion
}
};
var operation = new UpdatePeriodicBackupOperation(config);
var result = await docStore.Maintenance.SendAsync(operation);
}
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
var config = new PeriodicBackupConfiguration
{
// additional settings here..
//..
#region use_provided_encryption_key_full_sample
BackupEncryptionSettings = new BackupEncryptionSettings
{
//Use an encryption key of your choice
EncryptionMode = EncryptionMode.UseProvidedKey,
Key = "OI7Vll7DroXdUORtc6Uo64wdAk1W0Db9ExXXgcg5IUs="
}
#endregion
};
var operation = new UpdatePeriodicBackupOperation(config);
var result = await docStore.Maintenance.SendAsync(operation);
}
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
var config = new PeriodicBackupConfiguration
{
// additional settings here..
//..
#region explicitly_choose_no_encryption
BackupEncryptionSettings = new BackupEncryptionSettings
{
//No encryption
EncryptionMode = EncryptionMode.None
}
#endregion
};
var operation = new UpdatePeriodicBackupOperation(config);
var result = await docStore.Maintenance.SendAsync(operation);
}
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
#region restore_encrypted_backup
// restore encrypted database
var restoreConfiguration = new RestoreBackupConfiguration();
//New database name
restoreConfiguration.DatabaseName = "newEncryptedDatabase";
//Backup-file location
var backupPath = @"C:\Users\RavenDB\2019-01-06-11-11.ravendb-encryptedDatabase-A-snapshot";
restoreConfiguration.BackupLocation = backupPath;
restoreConfiguration.BackupEncryptionSettings = new BackupEncryptionSettings
{
Key = "OI7Vll7DroXdUORtc6Uo64wdAk1W0Db9ExXXgcg5IUs="
};
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
docStore.Maintenance.Server.Send(restoreBackupTask);
#endregion
}
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
// restore encrypted database
var restoreConfiguration = new RestoreBackupConfiguration();
//New database name
restoreConfiguration.DatabaseName = "newEncryptedDatabase";
//Backup-file location
var backupPath = @"C:\Users\RavenDB\2019-01-06-11-11.ravendb-encryptedDatabase-A-snapshot";
restoreConfiguration.BackupLocation = backupPath;
#region restore_encrypted_database
//Restore the database using the key you encrypted it with
restoreConfiguration.BackupEncryptionSettings = new BackupEncryptionSettings
{
Key = "OI7Vll7DroXdUORtc6Uo64wdAk1W0Db9ExXXgcg5IUs="
};
//Encrypt the restored database using this key
restoreConfiguration.EncryptionKey = "1F0K2R/KkcwbkK7n4kYlv5eqisy/pMnSuJvZ2sJ/EKo=";
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
docStore.Maintenance.Server.Send(restoreBackupTask);
#endregion
}
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
var restoreConfiguration = new RestoreBackupConfiguration();
//New database name
restoreConfiguration.DatabaseName = "newEncryptedDatabase";
//Backup-file location
var backupPath = @"C:\Users\RavenDB\2019-01-06-11-11.ravendb-encryptedDatabase-A-snapshot";
restoreConfiguration.BackupLocation = backupPath;
#region restore_unencrypted_database
restoreConfiguration.BackupEncryptionSettings = new BackupEncryptionSettings
{
//No encryption
EncryptionMode = EncryptionMode.None
};
#endregion
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
docStore.Maintenance.Server.Send(restoreBackupTask);
}
using (var docStore = new DocumentStore
{
Urls = new[] { "https://a.RavenDBdom.development.run" },
Database = "encryptedDatabase",
Certificate = cert
}.Initialize())
{
// restore encrypted database
// restore configuration
var restoreConfiguration = new RestoreBackupConfiguration();
//New database name
restoreConfiguration.DatabaseName = "newEncryptedDatabase";
// restoreConfiguration.EncryptionKey = "1F0K2R/KkcwbkK7n4kYlv5eqisy/pMnSuJvZ2sJ/EKo=";
#region encrypting_logical_backup_with_new_key
//Restore using your own key
restoreConfiguration.BackupEncryptionSettings = new BackupEncryptionSettings
{
Key = "OI7Vll7DroXdUORtc6Uo64wdAk1W0Db9ExXXgcg5IUs="
};
#endregion
#region restore_encrypting_logical_backup_with_database_key
//Restore using the DB-encryption key
restoreConfiguration.EncryptionKey = "1F0K2R/KkcwbkK7n4kYlv5eqisy/pMnSuJvZ2sJ/EKo=";
//Backup-file location
var backupPath = @"C:\Users\RavenDB\2019-01-06-11-11.ravendb-encryptedDatabase-A-snapshot";
restoreConfiguration.BackupLocation = backupPath;
var restoreBackupTask = new RestoreBackupOperation(restoreConfiguration);
docStore.Maintenance.Server.Send(restoreBackupTask);
#endregion
}
public async Task CreateFullAndIncrementalBackupWithIndexInTheMiddle()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new User
{
Name = "Toli"
}, "users/1");
session.SaveChanges();
}
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
Name = "full",
FullBackupFrequency = "* */6 * * *",
BackupType = BackupType.Backup
};
var result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config));
var documentDatabase = (await GetDocumentDatabaseInstanceFor(store));
RunBackup(result.TaskId, documentDatabase, true, store);
var input = new IndexDefinition
{
Name = "Users_ByName",
Maps =
{
"from user in docs.Users select new { user.Name }"
},
Type = IndexType.Map
};
await store
.Maintenance
.SendAsync(new PutIndexesOperation(new[] { input }));
config.IncrementalBackupFrequency = "* */300 * * *";
config.TaskId = result.TaskId;
result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config));
RunBackup(result.TaskId, documentDatabase, false, store);
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
RestoreBackupConfiguration config2 = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = Directory.GetFiles(backupDirectory).Last()
};
RestoreBackupOperation restoreOperation = new RestoreBackupOperation(config2);
store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion(TimeSpan.FromSeconds(30));
using (var store2 = GetDocumentStore(new Options()
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName
}))
{
var stats = store2.Maintenance.ForDatabase(databaseName).Send(new GetStatisticsOperation());
Assert.Equal(1, stats.CountOfIndexes);
Assert.Equal(1, stats.CountOfDocuments);
};
}
}
public async Task ShouldPreserveTombstoneFlagsAfterRestore()
{
using (var store = GetDocumentStore())
{
var configuration = new RevisionsConfiguration
{
Default = new RevisionsCollectionConfiguration
{
Disabled = false,
MinimumRevisionsToKeep = 10
},
Collections = new Dictionary <string, RevisionsCollectionConfiguration>
{
["Users"] = new RevisionsCollectionConfiguration
{
Disabled = false,
MinimumRevisionsToKeep = 5
}
}
};
await RevisionsHelper.SetupRevisions(store, Server.ServerStore, configuration);
using (var session = store.OpenSession())
{
session.Store(new User()
{
Name = "Arek"
}, "users/arek");
session.SaveChanges();
}
using (var session = store.OpenSession())
{
session.Delete("users/arek"); // this will create tombstone with HasRevisions flags
session.SaveChanges();
}
var backupPath = NewDataPath(suffix: "BackupFolder");
var config = Backup.CreateBackupConfiguration(backupPath);
var backupTaskId = await Backup.UpdateConfigAndRunBackupAsync(Server, config, store);
// restore
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
var files = Directory.GetFiles(backupDirectory)
.Where(BackupUtils.IsBackupFile)
.OrderBackups()
.ToArray();
RestoreBackupConfiguration config2 = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = files.Last()
};
RestoreBackupOperation restoreOperation = new RestoreBackupOperation(config2);
await store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
using (var storeOfRestoredDb = GetDocumentStore(new Options()
{
CreateDatabase = false, ModifyDatabaseName = s => databaseName
}))
{
var db = await GetDatabase(storeOfRestoredDb.Database);
using (db.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext ctx))
using (ctx.OpenReadTransaction())
{
var tombstones = db.DocumentsStorage.GetTombstonesFrom(ctx, 0, 0, int.MaxValue).ToList();
Assert.Equal(1, tombstones.Count);
Assert.Equal(DocumentFlags.HasRevisions, tombstones[0].Flags);
}
}
}
}
private async Task RestoreBackup(MyBackup backup)
{
var rnd = new Random();
var restoreDbName =
$"Restored_{new string(Enumerable.Repeat(_chars, rnd.Next(5, 10)).Select(x => x[rnd.Next(x.Length)]).ToArray())}";
var restoreConfig = new RestoreBackupConfiguration
{
DatabaseName = restoreDbName,
BackupLocation = backup.BackupPath
};
var restoreBackupTask = new RestoreBackupOperation(restoreConfig);
using (var session = DocumentStore.OpenAsyncSession())
{
var reasonableTimeForBackup = Stopwatch.StartNew();
var succeeded = true;
try
{
ReportInfo($"Starting to restore DB: {restoreDbName}");
var re = DocumentStore.GetRequestExecutor(DocumentStore.Database);
var restoreBackupTaskCommand =
restoreBackupTask.GetCommand(DocumentStore.Conventions, session.Advanced.Context);
await re.ExecuteAsync(re.TopologyNodes.First(q => q.ClusterTag.Equals(backup.BackupStatus.NodeTag)),
null, session.Advanced.Context, restoreBackupTaskCommand, shouldRetry : false)
.ConfigureAwait(false);
var getOperationStateTask =
new GetOperationStateOperation(restoreBackupTaskCommand.Result.OperationId);
var getOperationStateTaskCommand =
getOperationStateTask.GetCommand(DocumentStore.Conventions, session.Advanced.Context);
await re.ExecuteAsync(re.TopologyNodes.First(q => q.ClusterTag.Equals(backup.BackupStatus.NodeTag)),
null, session.Advanced.Context, getOperationStateTaskCommand, shouldRetry : false)
.ConfigureAwait(false);
while (getOperationStateTaskCommand.Result == null || getOperationStateTaskCommand.Result.Status == OperationStatus.InProgress)
{
await Task.Delay(2000).ConfigureAwait(false);
await re.ExecuteAsync(re.TopologyNodes.First(q => q.ClusterTag.Equals(backup.BackupStatus.NodeTag)),
null, session.Advanced.Context, getOperationStateTaskCommand, shouldRetry : false)
.ConfigureAwait(false);
if (reasonableTimeForBackup.Elapsed > TimeSpan.FromMinutes(5))
{
ReportFailure($"Restoring DB: {restoreDbName} Failed, taskID {backup.BackupTaskId} - Waited {reasonableTimeForBackup.Elapsed} and task didn't finished", null);
succeeded = true; // marking as success in order to delete
// TODO : RavenDB-13684
break;
}
}
}
catch (RavenException re)
{
if (re.InnerException is ArgumentException ae)
{
ReportInfo($"Probably somebody deleted the backup files, taskID {backup.BackupTaskId}, exception: {ae}");
}
else
{
ReportFailure($"Restoring DB: {restoreDbName} Failed, taskID {backup.BackupTaskId}", re);
}
}
catch (Exception e)
{
ReportFailure($"Restoring DB: {restoreDbName} Failed, taskID {backup.BackupTaskId}", e);
succeeded = false;
}
if (succeeded)
{
MyRestoreDbsList.Add(restoreDbName);
}
for (var i = 0; i < MyBackupsList.Count; i++)
{
if (MyBackupsList[i].BackupTaskId == backup.BackupTaskId)
{
MyBackupsList[i].RestoreResult = succeeded ? RestoreResult.Succeeded : RestoreResult.Failed;
break;
}
}
}
}
public async Task CanPassNodeTagToRestoreBackupOperation()
{
var myBackupsList = new List <MyBackup>();
var myNodesList = new List <string>();
var backupPath = NewDataPath(suffix: "BackupFolder");
var clusterSize = 3;
var databaseName = GetDatabaseName();
var leader = await CreateRaftClusterAndGetLeader(clusterSize, false, useSsl : false);
using (var store = new DocumentStore
{
Urls = new[] { leader.WebUrl },
Database = databaseName,
}.Initialize())
{
var doc = new DatabaseRecord(databaseName);
var databaseResult = await store.Maintenance.Server.SendAsync(new CreateDatabaseOperation(doc, clusterSize));
store.Maintenance.Send(new CreateSampleDataOperation());
myNodesList.AddRange(databaseResult.Topology.AllNodes);
foreach (var node in myNodesList)
{
var myGuid = Guid.NewGuid();
var backupConfig = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = Path.Combine(backupPath, myGuid.ToString())
},
FullBackupFrequency = "0 */3 * * *",
BackupType = BackupType.Backup,
Name = $"Task_{node}_{myGuid}",
MentorNode = node
};
var result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(backupConfig));
var res = await store.Maintenance.SendAsync(new GetOngoingTaskInfoOperation(result.TaskId, OngoingTaskType.Backup));
myBackupsList.Add(new MyBackup
{
BackupTaskId = result.TaskId,
Guid = myGuid,
NodeTag = res.ResponsibleNode.NodeTag
});
}
foreach (var myBackup in myBackupsList)
{
await store.Maintenance.SendAsync(new StartBackupOperation(true, myBackup.BackupTaskId));
var backupOperation = new GetPeriodicBackupStatusOperation(myBackup.BackupTaskId);
var getPeriodicBackupResult = store.Maintenance.Send(backupOperation);
var value = WaitForValue(() =>
{
getPeriodicBackupResult = store.Maintenance.Send(backupOperation);
return(getPeriodicBackupResult.Status?.LastEtag > 0);
}, true);
Assert.Equal(true, value);
Assert.NotNull(getPeriodicBackupResult);
Assert.Equal(myBackup.NodeTag, getPeriodicBackupResult.Status.NodeTag);
var prePath = Path.Combine(backupPath, myBackup.Guid.ToString());
myBackup.BackupPath = Path.Combine(prePath, getPeriodicBackupResult.Status.FolderName);
}
foreach (var myBackup in myBackupsList)
{
var restoreConfig = new RestoreBackupConfiguration
{
DatabaseName = $"restored_DB1_{myBackup.NodeTag}",
BackupLocation = myBackup.BackupPath
};
var restoreBackupTask = store.Maintenance.Server.Send(new RestoreBackupOperation(restoreConfig, myBackup.NodeTag));
restoreBackupTask.WaitForCompletion(TimeSpan.FromSeconds(30));
}
var numOfDbs = await store.Maintenance.Server.SendAsync(new GetDatabaseNamesOperation(0, int.MaxValue));
Assert.Equal(clusterSize + 1, numOfDbs.Length);
}
}
public async Task BackupWithIdentityAndCompareExchangeShouldHaveOnlyOwnValues()
{
var backupPath = NewDataPath(suffix: "BackupFolder1");
var cmpXchg1 = new User {
Name = "👺"
};
using (var store = GetDocumentStore(new Options {
ModifyDatabaseName = s => "a"
}))
using (var store2 = GetDocumentStore(new Options
{
ModifyDatabaseName = s => "aa"
}))
{
using (var session = store.OpenAsyncSession())
{
var bestUser = new User
{
Name = "Egor1"
};
await session.StoreAsync(bestUser, "a|");
await session.SaveChangesAsync();
}
await store.Operations.SendAsync(new PutCompareExchangeValueOperation <User>("emojis/goblin", cmpXchg1, 0));
using (var session = store2.OpenAsyncSession())
{
var bestUser = new User
{
Name = "Egor2"
};
await session.StoreAsync(bestUser, "aa|");
await session.SaveChangesAsync();
}
var cmpXchg2 = new User {
Name = "🤡"
};
await store2.Operations.SendAsync(new PutCompareExchangeValueOperation <User>("emojis/clown", cmpXchg2, 0));
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
Name = "full",
FullBackupFrequency = "* */6 * * *",
BackupType = BackupType.Backup
};
var result = await store.Maintenance.SendAsync(new UpdatePeriodicBackupOperation(config));
var documentDatabase = (await GetDocumentDatabaseInstanceFor(store));
PeriodicBackupTestsSlow.RunBackup(result.TaskId, documentDatabase, true, store); // FULL BACKUP
}
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
var files = Directory.GetFiles(backupDirectory)
.Where(BackupUtils.IsBackupFile)
.OrderBackups()
.ToArray();
var restoreConfig = new RestoreBackupConfiguration
{
BackupLocation = backupDirectory,
DatabaseName = databaseName,
LastFileNameToRestore = files.Last()
};
using (var store2 = GetDocumentStore(new Options
{
CreateDatabase = false,
ModifyDatabaseName = s => databaseName
}))
{
var restoreOperation = new RestoreBackupOperation(restoreConfig);
store2.Maintenance.Server.Send(restoreOperation)
.WaitForCompletion(TimeSpan.FromSeconds(30));
using (var session = store2.OpenAsyncSession(new SessionOptions
{
TransactionMode = TransactionMode.ClusterWide
}))
{
var stats = store2.Maintenance.ForDatabase(databaseName).Send(new GetDetailedStatisticsOperation());
Assert.Equal(1, stats.CountOfIdentities);
Assert.Equal(1, stats.CountOfCompareExchange);
Assert.Equal(1, stats.CountOfDocuments);
var bestUser = await session.LoadAsync <User>("a/1");
var mediocreUser1 = await session.LoadAsync <User>("aa/1");
Assert.NotNull(bestUser);
Assert.Null(mediocreUser1);
Assert.Equal("Egor1", bestUser.Name);
var cmpXchg = await session.Advanced.ClusterTransaction.GetCompareExchangeValueAsync <User>("emojis/goblin");
Assert.Equal(cmpXchg1.Name, cmpXchg.Value.Name);
var cmpXchg2 = await session.Advanced.ClusterTransaction.GetCompareExchangeValueAsync <User>("emojis/clown");
Assert.Null(cmpXchg2);
}
}
}
public async Task TombstonesOfArtificialDocumentsShouldNotBeRestored()
{
using (var store = GetDocumentStore())
{
new Users_ByName_Count().Execute(store);
using (var session = store.OpenSession())
{
session.Store(new User()
{
Name = "Arek"
}, "users/arek");
session.SaveChanges();
}
Indexes.WaitForIndexing(store);
using (var session = store.OpenSession())
{
session.Delete("users/arek"); // delete source document so we'll have tombstones of artificial documents generated by the index
session.SaveChanges();
}
Indexes.WaitForIndexing(store);
var backupPath = NewDataPath(suffix: "BackupFolder");
var config = Backup.CreateBackupConfiguration(backupPath);
var backupTaskId = await Backup.UpdateConfigAndRunBackupAsync(Server, config, store);
// restore
var backupDirectory = Directory.GetDirectories(backupPath).First();
var databaseName = GetDatabaseName() + "restore";
var files = Directory.GetFiles(backupDirectory)
.Where(BackupUtils.IsBackupFile)
.OrderBackups()
.ToArray();
RestoreBackupConfiguration config2 = new RestoreBackupConfiguration()
{
BackupLocation = backupDirectory, DatabaseName = databaseName, LastFileNameToRestore = files.Last()
};
RestoreBackupOperation restoreOperation = new RestoreBackupOperation(config2);
await store.Maintenance.Server.Send(restoreOperation)
.WaitForCompletionAsync(TimeSpan.FromSeconds(30));
using (var storeOfRestoredDb = GetDocumentStore(new Options()
{
CreateDatabase = false, ModifyDatabaseName = s => databaseName
}))
{
var db = await GetDatabase(storeOfRestoredDb.Database);
using (db.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext ctx))
using (ctx.OpenReadTransaction())
{
var tombstones = db.DocumentsStorage.GetTombstonesFrom(ctx, 0, 0, int.MaxValue).ToList();
Assert.Equal(1, tombstones.Count);
Assert.Equal("users/arek", tombstones[0].LowerId);
}
}
}
}
