/// <summary>
/// Restore CompareExchange, Identities and Subscriptions from smuggler file when restoring snapshot.
/// </summary>
/// <param name="onProgress"></param>
/// <param name="database"></param>
/// <param name="smugglerFile"></param>
/// <param name="context"></param>
protected async Task RestoreFromSmugglerFile(Action <IOperationProgress> onProgress, DocumentDatabase database, string smugglerFile, DocumentsOperationContext context)
{
var destination = new DatabaseDestination(database);
var smugglerOptions = new DatabaseSmugglerOptionsServerSide
{
AuthorizationStatus = AuthorizationStatus.DatabaseAdmin,
OperateOnTypes = DatabaseItemType.CompareExchange | DatabaseItemType.Identities | DatabaseItemType.Subscriptions,
SkipRevisionCreation = true
};
var lastPath = GetSmugglerBackupPath(smugglerFile);
using (var zip = await GetZipArchiveForSnapshot(lastPath))
{
foreach (var entry in zip.Entries)
{
if (entry.Name == RestoreSettings.SmugglerValuesFileName)
{
using (var input = entry.Open())
using (var inputStream = GetSnapshotInputStream(input, database.Name))
using (var uncompressed = new GZipStream(inputStream, CompressionMode.Decompress))
{
var source = new StreamSource(uncompressed, context, database);
var smuggler = new Smuggler.Documents.DatabaseSmuggler(database, source, destination,
database.Time, smugglerOptions, onProgress: onProgress, token: _operationCancelToken.Token);
smuggler.Execute(ensureStepsProcessed: true, isLastFile: true);
}
break;
}
}
}
}
private void ImportSingleBackupFile(DocumentDatabase database,
Action <IOperationProgress> onProgress, RestoreResult restoreResult,
string filePath, DocumentsOperationContext context,
DatabaseDestination destination, DatabaseSmugglerOptionsServerSide options,
Action <IndexDefinitionAndType> onIndexAction = null)
{
using (var fileStream = File.Open(filePath, FileMode.Open))
using (var stream = new GZipStream(new BufferedStream(fileStream, 128 * Voron.Global.Constants.Size.Kilobyte), CompressionMode.Decompress))
using (var source = new StreamSource(stream, context, database))
{
var smuggler = new Smuggler.Documents.DatabaseSmuggler(database, source, destination,
database.Time, options, result: restoreResult, onProgress: onProgress, token: _operationCancelToken.Token)
{
OnIndexAction = onIndexAction,
};
smuggler.Execute();
}
}
private void RestoreFromLastFile(Action <IOperationProgress> onProgress, DocumentDatabase database, string lastFile, DocumentsOperationContext context, RestoreResult result)
{
var destination = new DatabaseDestination(database);
var smugglerOptions = new DatabaseSmugglerOptionsServerSide
{
AuthorizationStatus = AuthorizationStatus.DatabaseAdmin,
OperateOnTypes = DatabaseItemType.CompareExchange | DatabaseItemType.Identities,
SkipRevisionCreation = true,
KeepOriginalChangeVector = true
};
var lastPath = Path.Combine(_restoreConfiguration.BackupLocation, lastFile);
if (Path.GetExtension(lastPath) == Constants.Documents.PeriodicBackup.SnapshotExtension)
{
using (var zip = ZipFile.Open(lastPath, ZipArchiveMode.Read, System.Text.Encoding.UTF8))
{
foreach (var entry in zip.Entries)
{
if (entry.Name == RestoreSettings.SmugglerValuesFileName)
{
using (var input = entry.Open())
using (var uncompressed = new GZipStream(input, CompressionMode.Decompress))
{
var source = new StreamSource(uncompressed, context, database);
var smuggler = new Smuggler.Documents.DatabaseSmuggler(database, source, destination,
database.Time, smugglerOptions, onProgress: onProgress, token: _operationCancelToken.Token);
smuggler.Execute();
}
break;
}
}
}
}
else
{
ImportSingleBackupFile(database, onProgress, null, lastPath, context, destination, smugglerOptions);
}
result.Identities.Processed = true;
result.CompareExchange.Processed = true;
onProgress.Invoke(result.Progress);
}
private async Task ImportSingleBackupFile(DocumentDatabase database,
Action <IOperationProgress> onProgress, RestoreResult restoreResult,
string filePath, DocumentsOperationContext context,
DatabaseDestination destination, DatabaseSmugglerOptionsServerSide options, bool isLastFile,
Action <IndexDefinitionAndType> onIndexAction = null,
Action <DatabaseRecord> onDatabaseRecordAction = null)
{
using (var fileStream = await GetStream(filePath))
using (var inputStream = GetInputStream(fileStream, database.MasterKey))
using (var gzipStream = new GZipStream(inputStream, CompressionMode.Decompress))
using (var source = new StreamSource(gzipStream, context, database))
{
var smuggler = new Smuggler.Documents.DatabaseSmuggler(database, source, destination,
database.Time, options, result: restoreResult, onProgress: onProgress, token: _operationCancelToken.Token)
{
OnIndexAction = onIndexAction,
OnDatabaseRecordAction = onDatabaseRecordAction
};
smuggler.Execute(ensureStepsProcessed: false, isLastFile);
}
}
private void RestoreFromLastFile(Action <IOperationProgress> onProgress, DocumentDatabase database, string lastFile, DocumentsOperationContext context, RestoreResult result)
{
var destination = new DatabaseDestination(database);
var smugglerOptions = new DatabaseSmugglerOptionsServerSide
{
OperateOnTypes = DatabaseItemType.CmpXchg | DatabaseItemType.Identities
};
var lastPath = Path.Combine(_restoreConfiguration.BackupLocation, lastFile);
if (Path.GetExtension(lastPath) == Constants.Documents.PeriodicBackup.SnapshotExtension)
{
using (var zip = ZipFile.Open(lastPath, ZipArchiveMode.Read, System.Text.Encoding.UTF8))
{
foreach (var entry in zip.Entries)
{
if (entry.Name == RestoreSettings.SmugglerValuesFileName)
{
using (var input = entry.Open())
{
var source = new StreamSource(input, context, database);
var smuggler = new Smuggler.Documents.DatabaseSmuggler(database, source, destination,
database.Time, smugglerOptions, onProgress: onProgress, token: _operationCancelToken.Token);
smuggler.Execute();
}
break;
}
}
}
}
else
{
ImportSingleBackupFile(database, onProgress, null, lastPath, context, destination, smugglerOptions);
}
result.Identities.Processed = true;
result.CmpXchg.Processed = true;
}
