private void EnsureSnapshotProcessed(
DocumentsOperationContext context,
SmugglerResult snapshotSmugglerResult,
long indexesCount)
{
_backupResult.SnapshotBackup.Processed = true;
_backupResult.DatabaseRecord.Processed = true;
_backupResult.RevisionDocuments.Attachments.Processed = true;
_backupResult.Tombstones.Processed = true;
_backupResult.Indexes.Processed = true;
_backupResult.Indexes.ReadCount = indexesCount;
var summary = _database.GetDatabaseSummary(context);
_backupResult.Documents.Processed = true;
_backupResult.Documents.ReadCount = summary.DocumentsCount;
_backupResult.Documents.Attachments.Processed = true;
_backupResult.Documents.Attachments.ReadCount = summary.AttachmentsCount;
_backupResult.RevisionDocuments.Processed = true;
_backupResult.RevisionDocuments.ReadCount = summary.RevisionsCount;
_backupResult.Conflicts.Processed = true;
_backupResult.Conflicts.ReadCount = summary.ConflictsCount;
_backupResult.Identities.Processed = true;
_backupResult.Identities.ReadCount = snapshotSmugglerResult.Identities.ReadCount;
_backupResult.CompareExchange.Processed = true;
_backupResult.CompareExchange.ReadCount = snapshotSmugglerResult.CompareExchange.ReadCount;
}
private InternalBackupResult CreateLocalBackupOrSnapshot(PeriodicBackupStatus status, string backupFilePath, long?startDocumentEtag, long?startRaftIndex)
{
var internalBackupResult = new InternalBackupResult();
using (status.LocalBackup.UpdateStats(_isFullBackup))
{
// will rename the file after the backup is finished
var tempBackupFilePath = backupFilePath + InProgressExtension;
try
{
BackupTypeValidation();
AddInfo($"Started {GetBackupDescription(_configuration.BackupType, _isFullBackup)}");
if (_configuration.BackupType == BackupType.Backup ||
_configuration.BackupType == BackupType.Snapshot && _isFullBackup == false)
{
// smuggler backup
var options = new DatabaseSmugglerOptionsServerSide
{
AuthorizationStatus = AuthorizationStatus.DatabaseAdmin,
IncludeArtificial = true // we want to include artificial in backup
};
options.OperateOnTypes |= DatabaseItemType.Tombstones;
options.OperateOnTypes |= DatabaseItemType.CompareExchangeTombstones;
var currentBackupResult = CreateBackup(options, tempBackupFilePath, startDocumentEtag, startRaftIndex);
if (_isFullBackup)
{
internalBackupResult = currentBackupResult;
}
else
{
if (_backupResult.GetLastEtag() == _previousBackupStatus.LastEtag &&
_backupResult.GetLastRaftIndex() == _previousBackupStatus.LastRaftIndex.LastEtag)
{
internalBackupResult.LastDocumentEtag = startDocumentEtag ?? 0;
internalBackupResult.LastDatabaseChangeVector = _previousBackupStatus.LastDatabaseChangeVector;
internalBackupResult.LastRaftIndex = startRaftIndex ?? 0;
}
else
{
internalBackupResult = currentBackupResult;
}
}
}
else
{
// snapshot backup
ValidateFreeSpaceForSnapshot(tempBackupFilePath);
(internalBackupResult.LastDocumentEtag, internalBackupResult.LastDatabaseChangeVector) = _database.ReadLastEtagAndChangeVector();
internalBackupResult.LastRaftIndex = GetDatabaseEtagForBackup();
var databaseSummary = _database.GetDatabaseSummary();
var indexesCount = _database.IndexStore.Count;
var totalSw = Stopwatch.StartNew();
var sw = Stopwatch.StartNew();
var compressionLevel = _configuration.SnapshotSettings?.CompressionLevel ?? CompressionLevel.Optimal;
var smugglerResult = _database.FullBackupTo(tempBackupFilePath, compressionLevel,
info =>
{
AddInfo(info.Message);
_backupResult.SnapshotBackup.ReadCount += info.FilesCount;
if (sw.ElapsedMilliseconds > 0 && info.FilesCount > 0)
{
AddInfo($"Backed up {_backupResult.SnapshotBackup.ReadCount} " +
$"file{(_backupResult.SnapshotBackup.ReadCount > 1 ? "s" : string.Empty)}");
sw.Restart();
}
}, TaskCancelToken.Token);
EnsureSnapshotProcessed(databaseSummary, smugglerResult, indexesCount);
AddInfo($"Backed up {_backupResult.SnapshotBackup.ReadCount} files, " +
$"took: {totalSw.ElapsedMilliseconds:#,#;;0}ms");
}
IOExtensions.RenameFile(tempBackupFilePath, backupFilePath);
status.LocalBackup.Exception = null;
}
catch (Exception e)
{
status.LocalBackup.Exception = e.ToString();
// deleting the temp backup file if the backup failed
DeleteFile(tempBackupFilePath);
throw;
}
}
if (_backupToLocalFolder)
{
var sp = Stopwatch.StartNew();
var localRetentionPolicy = new LocalRetentionPolicyRunner(_retentionPolicyParameters, _configuration.LocalSettings.FolderPath);
localRetentionPolicy.Execute();
sp.Stop();
status.LocalRetentionDurationInMs = sp.ElapsedMilliseconds;
}
return(internalBackupResult);
}
public async Task <IOperationResult> Execute(Action <IOperationProgress> onProgress)
{
var databaseName = RestoreFromConfiguration.DatabaseName;
var result = new RestoreResult
{
DataDirectory = RestoreFromConfiguration.DataDirectory
};
try
{
var filesToRestore = await GetOrderedFilesToRestore();
using (_serverStore.ContextPool.AllocateOperationContext(out JsonOperationContext serverContext))
{
if (onProgress == null)
{
onProgress = _ => { }
}
;
Stopwatch sw = null;
RestoreSettings restoreSettings = null;
var firstFile = filesToRestore[0];
var extension = Path.GetExtension(firstFile);
var snapshotRestore = false;
if ((extension == Constants.Documents.PeriodicBackup.SnapshotExtension) ||
(extension == Constants.Documents.PeriodicBackup.EncryptedSnapshotExtension))
{
onProgress.Invoke(result.Progress);
snapshotRestore = true;
sw = Stopwatch.StartNew();
if (extension == Constants.Documents.PeriodicBackup.EncryptedSnapshotExtension)
{
_hasEncryptionKey = RestoreFromConfiguration.EncryptionKey != null ||
RestoreFromConfiguration.BackupEncryptionSettings?.Key != null;
}
// restore the snapshot
restoreSettings = await SnapshotRestore(serverContext, firstFile, onProgress, result);
if (restoreSettings != null && RestoreFromConfiguration.SkipIndexes)
{
// remove all indexes from the database record
restoreSettings.DatabaseRecord.AutoIndexes = null;
restoreSettings.DatabaseRecord.Indexes = null;
}
// removing the snapshot from the list of files
filesToRestore.RemoveAt(0);
}
else
{
result.SnapshotRestore.Skipped = true;
result.SnapshotRestore.Processed = true;
onProgress.Invoke(result.Progress);
}
if (restoreSettings == null)
{
restoreSettings = new RestoreSettings
{
DatabaseRecord = new DatabaseRecord(databaseName)
{
// we only have a smuggler restore
// use the encryption key to encrypt the database
Encrypted = _hasEncryptionKey
}
};
DatabaseHelper.Validate(databaseName, restoreSettings.DatabaseRecord, _serverStore.Configuration);
}
var databaseRecord = restoreSettings.DatabaseRecord;
if (databaseRecord.Settings == null)
{
databaseRecord.Settings = new Dictionary <string, string>();
}
var runInMemoryConfigurationKey = RavenConfiguration.GetKey(x => x.Core.RunInMemory);
databaseRecord.Settings.Remove(runInMemoryConfigurationKey);
if (_serverStore.Configuration.Core.RunInMemory)
{
databaseRecord.Settings[runInMemoryConfigurationKey] = "false";
}
var dataDirectoryConfigurationKey = RavenConfiguration.GetKey(x => x.Core.DataDirectory);
databaseRecord.Settings.Remove(dataDirectoryConfigurationKey); // removing because we want to restore to given location, not to serialized in backup one
if (_restoringToDefaultDataDirectory == false)
{
databaseRecord.Settings[dataDirectoryConfigurationKey] = RestoreFromConfiguration.DataDirectory;
}
if (_hasEncryptionKey)
{
// save the encryption key so we'll be able to access the database
_serverStore.PutSecretKey(RestoreFromConfiguration.EncryptionKey,
databaseName, overwrite: false);
}
var addToInitLog = new Action <string>(txt => // init log is not save in mem during RestoreBackup
{
var msg = $"[RestoreBackup] {DateTime.UtcNow} :: Database '{databaseName}' : {txt}";
if (Logger.IsInfoEnabled)
{
Logger.Info(msg);
}
});
var configuration = _serverStore
.DatabasesLandlord
.CreateDatabaseConfiguration(databaseName, ignoreDisabledDatabase: true, ignoreBeenDeleted: true, ignoreNotRelevant: true, databaseRecord);
using (var database = new DocumentDatabase(databaseName, configuration, _serverStore, addToInitLog))
{
// smuggler needs an existing document database to operate
var options = InitializeOptions.SkipLoadingDatabaseRecord;
if (snapshotRestore)
{
options |= InitializeOptions.GenerateNewDatabaseId;
}
database.Initialize(options);
databaseRecord.Topology = new DatabaseTopology();
// restoring to the current node only
databaseRecord.Topology.Members.Add(_nodeTag);
// we are currently restoring, shouldn't try to access it
databaseRecord.DatabaseState = DatabaseStateStatus.RestoreInProgress;
var(index, _) = await _serverStore.WriteDatabaseRecordAsync(databaseName, databaseRecord, null, RaftIdGenerator.NewId(), restoreSettings.DatabaseValues, isRestore : true);
await _serverStore.Cluster.WaitForIndexNotification(index);
using (database.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
if (snapshotRestore)
{
await RestoreFromSmugglerFile(onProgress, database, firstFile, context);
await SmugglerRestore(database, filesToRestore, context, databaseRecord, onProgress, result);
result.SnapshotRestore.Processed = true;
var summary = database.GetDatabaseSummary();
result.Documents.ReadCount += summary.DocumentsCount;
result.Documents.Attachments.ReadCount += summary.AttachmentsCount;
result.Counters.ReadCount += summary.CounterEntriesCount;
result.RevisionDocuments.ReadCount += summary.RevisionsCount;
result.Conflicts.ReadCount += summary.ConflictsCount;
result.Indexes.ReadCount += databaseRecord.GetIndexesCount();
result.CompareExchange.ReadCount += summary.CompareExchangeCount;
result.CompareExchangeTombstones.ReadCount += summary.CompareExchangeTombstonesCount;
result.Identities.ReadCount += summary.IdentitiesCount;
result.AddInfo($"Successfully restored {result.SnapshotRestore.ReadCount} files during snapshot restore, took: {sw.ElapsedMilliseconds:#,#;;0}ms");
onProgress.Invoke(result.Progress);
}
else
{
await SmugglerRestore(database, filesToRestore, context, databaseRecord, onProgress, result);
}
DisableOngoingTasksIfNeeded(databaseRecord);
result.DatabaseRecord.Processed = true;
result.Documents.Processed = true;
result.RevisionDocuments.Processed = true;
result.Conflicts.Processed = true;
result.Indexes.Processed = true;
result.Counters.Processed = true;
result.Identities.Processed = true;
result.CompareExchange.Processed = true;
result.Subscriptions.Processed = true;
onProgress.Invoke(result.Progress);
}
}
// after the db for restore is done, we can safely set the db state to normal and write the DatabaseRecord
databaseRecord.DatabaseState = DatabaseStateStatus.Normal;
var(updateIndex, _) = await _serverStore.WriteDatabaseRecordAsync(databaseName, databaseRecord, null, RaftIdGenerator.DontCareId, isRestore : true);
await _serverStore.Cluster.WaitForIndexNotification(updateIndex);
if (databaseRecord.Topology.RelevantFor(_serverStore.NodeTag))
{
// we need to wait for the database record change to be propagated properly
var db = await _serverStore.DatabasesLandlord.TryGetOrCreateResourceStore(databaseName);
await db.RachisLogIndexNotifications.WaitForIndexNotification(updateIndex, _operationCancelToken.Token);
}
return(result);
}
}
catch (Exception e)
{
if (Logger.IsOperationsEnabled)
{
Logger.Operations("Failed to restore database", e);
}
var alert = AlertRaised.Create(
RestoreFromConfiguration.DatabaseName,
"Failed to restore database",
$"Could not restore database named {RestoreFromConfiguration.DatabaseName}",
AlertType.RestoreError,
NotificationSeverity.Error,
details: new ExceptionDetails(e));
_serverStore.NotificationCenter.Add(alert);
using (_serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
{
bool databaseExists;
using (context.OpenReadTransaction())
{
databaseExists = _serverStore.Cluster.DatabaseExists(context, RestoreFromConfiguration.DatabaseName);
}
if (databaseExists == false)
{
// delete any files that we already created during the restore
IOExtensions.DeleteDirectory(RestoreFromConfiguration.DataDirectory);
}
else
{
var deleteResult = await _serverStore.DeleteDatabaseAsync(RestoreFromConfiguration.DatabaseName, true, new[] { _serverStore.NodeTag }, RaftIdGenerator.DontCareId);
await _serverStore.Cluster.WaitForIndexNotification(deleteResult.Index);
}
}
result.AddError($"Error occurred during restore of database {databaseName}. Exception: {e.Message}");
onProgress.Invoke(result.Progress);
throw;
}
finally
{
Dispose();
}
}
public async Task <IOperationResult> Execute(Action <IOperationProgress> onProgress)
{
var databaseName = _restoreConfiguration.DatabaseName;
var result = new RestoreResult
{
DataDirectory = _restoreConfiguration.DataDirectory
};
try
{
if (onProgress == null)
{
onProgress = _ => { }
}
;
Stopwatch sw = null;
RestoreSettings restoreSettings = null;
var firstFile = _filesToRestore[0];
var lastFile = _filesToRestore.Last();
var extension = Path.GetExtension(firstFile);
var snapshotRestore = false;
if (extension == Constants.Documents.PeriodicBackup.SnapshotExtension)
{
onProgress.Invoke(result.Progress);
snapshotRestore = true;
sw = Stopwatch.StartNew();
// restore the snapshot
restoreSettings = SnapshotRestore(firstFile,
_restoreConfiguration.DataDirectory,
onProgress,
result);
// removing the snapshot from the list of files
_filesToRestore.RemoveAt(0);
}
else
{
result.SnapshotRestore.Skipped = true;
result.SnapshotRestore.Processed = true;
onProgress.Invoke(result.Progress);
}
if (restoreSettings == null)
{
restoreSettings = new RestoreSettings
{
DatabaseRecord = new DatabaseRecord(databaseName)
{
// we only have a smuggler restore
// use the encryption key to encrypt the database
Encrypted = _hasEncryptionKey
}
};
DatabaseHelper.Validate(databaseName, restoreSettings.DatabaseRecord, _serverStore.Configuration);
}
var databaseRecord = restoreSettings.DatabaseRecord;
if (databaseRecord.Settings == null)
{
databaseRecord.Settings = new Dictionary <string, string>();
}
var runInMemoryConfigurationKey = RavenConfiguration.GetKey(x => x.Core.RunInMemory);
databaseRecord.Settings.Remove(runInMemoryConfigurationKey);
if (_serverStore.Configuration.Core.RunInMemory)
{
databaseRecord.Settings[runInMemoryConfigurationKey] = "false";
}
var dataDirectoryConfigurationKey = RavenConfiguration.GetKey(x => x.Core.DataDirectory);
databaseRecord.Settings.Remove(dataDirectoryConfigurationKey); // removing because we want to restore to given location, not to serialized in backup one
if (_restoringToDefaultDataDirectory == false)
{
databaseRecord.Settings[dataDirectoryConfigurationKey] = _restoreConfiguration.DataDirectory;
}
if (_hasEncryptionKey)
{
// save the encryption key so we'll be able to access the database
_serverStore.PutSecretKey(_restoreConfiguration.EncryptionKey,
databaseName, overwrite: false);
}
var addToInitLog = new Action <string>(txt => // init log is not save in mem during RestoreBackup
{
var msg = $"[RestoreBackup] {DateTime.UtcNow} :: Database '{databaseName}' : {txt}";
if (Logger.IsInfoEnabled)
{
Logger.Info(msg);
}
});
using (var database = new DocumentDatabase(databaseName,
new RavenConfiguration(databaseName, ResourceType.Database)
{
Core =
{
DataDirectory = new PathSetting(_restoreConfiguration.DataDirectory),
RunInMemory = false
}
}, _serverStore, addToInitLog))
{
// smuggler needs an existing document database to operate
var options = InitializeOptions.SkipLoadingDatabaseRecord;
if (snapshotRestore)
{
options |= InitializeOptions.GenerateNewDatabaseId;
}
database.Initialize(options);
if (snapshotRestore)
{
result.SnapshotRestore.Processed = true;
var summary = database.GetDatabaseSummary();
result.Documents.ReadCount += summary.DocumentsCount;
result.Documents.Attachments.ReadCount += summary.AttachmentsCount;
result.Counters.ReadCount += summary.CountersCount;
result.RevisionDocuments.ReadCount += summary.RevisionsCount;
result.Conflicts.ReadCount += summary.ConflictsCount;
result.Indexes.ReadCount += databaseRecord.GetIndexesCount();
result.AddInfo($"Successfully restored {result.SnapshotRestore.ReadCount} " +
$"files during snapshot restore, took: {sw.ElapsedMilliseconds:#,#;;0}ms");
onProgress.Invoke(result.Progress);
}
using (database.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
SmugglerRestore(_restoreConfiguration.BackupLocation, database, context, databaseRecord, onProgress, result);
result.DatabaseRecord.Processed = true;
result.Documents.Processed = true;
result.RevisionDocuments.Processed = true;
result.Conflicts.Processed = true;
result.Indexes.Processed = true;
result.Counters.Processed = true;
onProgress.Invoke(result.Progress);
databaseRecord.Topology = new DatabaseTopology();
// restoring to the current node only
databaseRecord.Topology.Members.Add(_nodeTag);
databaseRecord.Disabled = true; // we are currently restoring, shouldn't try to access it
_serverStore.EnsureNotPassive();
DisableOngoingTasksIfNeeded(databaseRecord);
var(index, _) = await _serverStore.WriteDatabaseRecordAsync(databaseName, databaseRecord, null, restoreSettings.DatabaseValues, isRestore : true);
await _serverStore.Cluster.WaitForIndexNotification(index);
// restore identities & cmpXchg values
RestoreFromLastFile(onProgress, database, lastFile, context, result);
}
}
// after the db for restore is done, we can safely set the db status to active
databaseRecord = _serverStore.LoadDatabaseRecord(databaseName, out _);
databaseRecord.Disabled = false;
var(updateIndex, _) = await _serverStore.WriteDatabaseRecordAsync(databaseName, databaseRecord, null);
await _serverStore.Cluster.WaitForIndexNotification(updateIndex);
return(result);
}
catch (Exception e)
{
if (Logger.IsOperationsEnabled)
{
Logger.Operations("Failed to restore database", e);
}
var alert = AlertRaised.Create(
_restoreConfiguration.DatabaseName,
"Failed to restore database",
$"Could not restore database named {_restoreConfiguration.DatabaseName}",
AlertType.RestoreError,
NotificationSeverity.Error,
details: new ExceptionDetails(e));
_serverStore.NotificationCenter.Add(alert);
if (_serverStore.LoadDatabaseRecord(_restoreConfiguration.DatabaseName, out var _) == null)
{
// delete any files that we already created during the restore
IOExtensions.DeleteDirectory(_restoreConfiguration.DataDirectory);
}
else
{
var deleteResult = await _serverStore.DeleteDatabaseAsync(_restoreConfiguration.DatabaseName, true, new[] { _serverStore.NodeTag });
await _serverStore.Cluster.WaitForIndexNotification(deleteResult.Index);
}
result.AddError($"Error occurred during restore of database {databaseName}. Exception: {e.Message}");
onProgress.Invoke(result.Progress);
throw;
}
finally
{
_operationCancelToken.Dispose();
}
}
private long CreateLocalBackupOrSnapshot(
PeriodicBackupStatus status, string backupFilePath,
long?startDocumentEtag, Action <IOperationProgress> onProgress)
{
long lastEtag;
using (status.LocalBackup.UpdateStats(_isFullBackup))
{
try
{
// will rename the file after the backup is finished
var tempBackupFilePath = backupFilePath + InProgressExtension;
if (_configuration.BackupType == BackupType.Backup ||
_configuration.BackupType == BackupType.Snapshot && _isFullBackup == false)
{
var backupType = _configuration.BackupType == BackupType.Snapshot ? "snapshot " : string.Empty;
AddInfo($"Started an incremental {backupType}backup", onProgress);
// smuggler backup
var options = new DatabaseSmugglerOptionsServerSide
{
AuthorizationStatus = AuthorizationStatus.DatabaseAdmin,
};
if (_isFullBackup == false)
{
options.OperateOnTypes |= DatabaseItemType.Tombstones;
}
var lastEtagFromStorage = CreateBackup(options, tempBackupFilePath, startDocumentEtag, onProgress);
if (_isFullBackup)
{
lastEtag = lastEtagFromStorage;
}
else if (_database.ReadLastEtag() == _previousBackupStatus.LastEtag)
{
lastEtag = startDocumentEtag ?? 0;
}
else
{
lastEtag = _backupResult.GetLastEtag();
}
}
else
{
// snapshot backup
AddInfo("Started a snapshot backup", onProgress);
lastEtag = _database.ReadLastEtag();
var databaseSummary = _database.GetDatabaseSummary();
var indexesCount = _database.IndexStore.Count;
var totalSw = Stopwatch.StartNew();
var sw = Stopwatch.StartNew();
var smugglerResult = _database.FullBackupTo(tempBackupFilePath,
info =>
{
AddInfo(info.Message, onProgress);
_backupResult.SnapshotBackup.ReadCount += info.FilesCount;
if (sw.ElapsedMilliseconds > 0 && info.FilesCount > 0)
{
AddInfo($"Backed up {_backupResult.SnapshotBackup.ReadCount} " +
$"file{(_backupResult.SnapshotBackup.ReadCount > 1 ? "s" : string.Empty)}", onProgress);
sw.Restart();
}
}, TaskCancelToken.Token);
EnsureSnapshotProcessed(databaseSummary, smugglerResult, indexesCount);
AddInfo($"Backed up {_backupResult.SnapshotBackup.ReadCount} files, " +
$"took: {totalSw.ElapsedMilliseconds:#,#;;0}ms", onProgress);
}
IOExtensions.RenameFile(tempBackupFilePath, backupFilePath);
}
catch (Exception e)
{
status.LocalBackup.Exception = e.ToString();
throw;
}
}
return(lastEtag);
}
public async Task <IOperationResult> Execute(Action <IOperationProgress> onProgress)
{
try
{
if (onProgress == null)
{
onProgress = _ => { }
}
;
var result = new RestoreResult
{
DataDirectory = _restoreConfiguration.DataDirectory
};
Stopwatch sw = null;
RestoreSettings restoreSettings = null;
var firstFile = _filesToRestore[0];
var extension = Path.GetExtension(firstFile);
var snapshotRestore = false;
if (extension == Constants.Documents.PeriodicBackup.SnapshotExtension)
{
onProgress.Invoke(result.Progress);
snapshotRestore = true;
sw = Stopwatch.StartNew();
// restore the snapshot
restoreSettings = SnapshotRestore(firstFile,
_restoreConfiguration.DataDirectory,
onProgress,
result);
// removing the snapshot from the list of files
_filesToRestore.RemoveAt(0);
}
else
{
result.SnapshotRestore.Skipped = true;
result.SnapshotRestore.Processed = true;
onProgress.Invoke(result.Progress);
}
var databaseName = _restoreConfiguration.DatabaseName;
if (restoreSettings == null)
{
restoreSettings = new RestoreSettings
{
DatabaseRecord = new DatabaseRecord(databaseName)
{
// we only have a smuggler restore
// use the encryption key to encrypt the database
Encrypted = _hasEncryptionKey
}
};
DatabaseHelper.Validate(databaseName, restoreSettings.DatabaseRecord);
}
var databaseRecord = restoreSettings.DatabaseRecord;
if (databaseRecord.Settings == null)
{
databaseRecord.Settings = new Dictionary <string, string>();
}
databaseRecord.Settings[RavenConfiguration.GetKey(x => x.Core.RunInMemory)] = "false";
databaseRecord.Settings[RavenConfiguration.GetKey(x => x.Core.DataDirectory)] = _restoreConfiguration.DataDirectory;
if (_hasEncryptionKey)
{
// save the encryption key so we'll be able to access the database
_serverStore.PutSecretKey(_restoreConfiguration.EncryptionKey,
databaseName, overwrite: false);
}
using (var database = new DocumentDatabase(databaseName,
new RavenConfiguration(databaseName, ResourceType.Database)
{
Core =
{
DataDirectory = new PathSetting(_restoreConfiguration.DataDirectory),
RunInMemory = false
}
}, _serverStore))
{
// smuggler needs an existing document database to operate
var options = InitializeOptions.SkipLoadingDatabaseRecord;
if (snapshotRestore)
{
options |= InitializeOptions.GenerateNewDatabaseId;
}
database.Initialize(options);
if (snapshotRestore)
{
result.SnapshotRestore.Processed = true;
var summary = database.GetDatabaseSummary();
result.Documents.ReadCount += summary.DocumentsCount;
result.Documents.Attachments.ReadCount += summary.AttachmentsCount;
result.RevisionDocuments.ReadCount += summary.RevisionsCount;
result.Indexes.ReadCount += databaseRecord.GetIndexesCount();
result.Identities.ReadCount += restoreSettings.Identities.Count;
result.AddInfo($"Successfully restored {result.SnapshotRestore.ReadCount} " +
$"files during snapshot restore, took: {sw.ElapsedMilliseconds:#,#;;0}ms");
onProgress.Invoke(result.Progress);
}
SmugglerRestore(_restoreConfiguration.BackupLocation, database, databaseRecord, restoreSettings, onProgress, result);
}
result.Documents.Processed = true;
result.RevisionDocuments.Processed = true;
result.Indexes.Processed = true;
result.Identities.Processed = true;
onProgress.Invoke(result.Progress);
databaseRecord.Topology = new DatabaseTopology();
// restoring to the current node only
databaseRecord.Topology.Members.Add(_nodeTag);
await _serverStore.WriteDatabaseRecordAsync(databaseName, databaseRecord, null, restoreSettings.DatabaseValues, isRestore : true);
var index = await WriteIdentitiesAsync(databaseName, restoreSettings.Identities);
await _serverStore.Cluster.WaitForIndexNotification(index);
return(result);
}
catch (OperationCanceledException)
{
// database shutdown
throw;
}
catch (Exception e)
{
if (Logger.IsOperationsEnabled)
{
Logger.Operations("Failed to restore database", e);
}
var alert = AlertRaised.Create(
"Failed to restore database",
$"Could not restore database named {_restoreConfiguration.DatabaseName}",
AlertType.RestoreError,
NotificationSeverity.Error,
details: new ExceptionDetails(e));
_serverStore.NotificationCenter.Add(alert);
// delete any files that we already created during the restore
IOExtensions.DeleteDirectory(_restoreConfiguration.DataDirectory);
throw;
}
finally
{
_operationCancelToken.Dispose();
}
}
private InternalBackupResult CreateLocalBackupOrSnapshot(
PeriodicBackupStatus status, string backupFilePath, long?startDocumentEtag, long?startRaftIndex)
{
var internalBackupResult = new InternalBackupResult();
using (status.LocalBackup.UpdateStats(_isFullBackup))
{
try
{
// will rename the file after the backup is finished
var tempBackupFilePath = backupFilePath + InProgressExtension;
BackupTypeValidation();
if (_configuration.BackupType == BackupType.Backup ||
_configuration.BackupType == BackupType.Snapshot && _isFullBackup == false)
{
var backupType = _configuration.BackupType == BackupType.Snapshot ? "snapshot " : string.Empty;
var backupSizeType = _isFullBackup ? "a full" : "an incremental";
AddInfo($"Started {backupSizeType} {backupType}backup");
// smuggler backup
var options = new DatabaseSmugglerOptionsServerSide
{
AuthorizationStatus = AuthorizationStatus.DatabaseAdmin,
};
if (_isFullBackup == false)
{
options.OperateOnTypes |= DatabaseItemType.Tombstones;
options.OperateOnTypes |= DatabaseItemType.CompareExchangeTombstones;
}
var currentBackupResult = CreateBackup(options, tempBackupFilePath, startDocumentEtag, startRaftIndex);
if (_isFullBackup)
{
internalBackupResult = currentBackupResult;
}
else
{
if (_backupResult.GetLastEtag() == _previousBackupStatus.LastEtag && _backupResult.GetLastRaftIndex() == _previousBackupStatus.LastRaftIndex.LastEtag)
{
internalBackupResult.LastDocumentEtag = startDocumentEtag ?? 0;
internalBackupResult.LastRaftIndex = startRaftIndex ?? 0;
}
else
{
internalBackupResult = currentBackupResult;
}
}
}
else
{
// snapshot backup
AddInfo("Started a snapshot backup");
internalBackupResult.LastDocumentEtag = _database.ReadLastEtag();
internalBackupResult.LastRaftIndex = GetDatabaseEtagForBackup();
var databaseSummary = _database.GetDatabaseSummary();
var indexesCount = _database.IndexStore.Count;
var totalSw = Stopwatch.StartNew();
var sw = Stopwatch.StartNew();
var smugglerResult = _database.FullBackupTo(tempBackupFilePath,
info =>
{
AddInfo(info.Message);
_backupResult.SnapshotBackup.ReadCount += info.FilesCount;
if (sw.ElapsedMilliseconds > 0 && info.FilesCount > 0)
{
AddInfo($"Backed up {_backupResult.SnapshotBackup.ReadCount} " +
$"file{(_backupResult.SnapshotBackup.ReadCount > 1 ? "s" : string.Empty)}");
sw.Restart();
}
}, TaskCancelToken.Token);
EnsureSnapshotProcessed(databaseSummary, smugglerResult, indexesCount);
AddInfo($"Backed up {_backupResult.SnapshotBackup.ReadCount} files, " +
$"took: {totalSw.ElapsedMilliseconds:#,#;;0}ms");
}
IOExtensions.RenameFile(tempBackupFilePath, backupFilePath);
}
catch (Exception e)
{
status.LocalBackup.Exception = e.ToString();
throw;
}
}
if (_backupToLocalFolder)
{
var localRetentionPolicy = new LocalRetentionPolicyRunner(_retentionPolicyParameters, _configuration.LocalSettings.FolderPath);
localRetentionPolicy.Execute();
}
return(internalBackupResult);
}
