public async Task <Operation> ImportAsync(DatabaseSmugglerOptions options, Stream stream, CancellationToken token = default(CancellationToken))
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
JsonOperationContext context;
using (_requestExecutor.ContextPool.AllocateOperationContext(out context))
{
var getOperationIdCommand = new GetNextOperationIdCommand();
await _requestExecutor.ExecuteAsync(getOperationIdCommand, context, token).ConfigureAwait(false);
var operationId = getOperationIdCommand.Result;
var command = new ImportCommand(_requestExecutor.Conventions, context, options, stream, operationId);
await _requestExecutor.ExecuteAsync(command, context, token).ConfigureAwait(false);
return(new Operation(_requestExecutor, () => _store.Changes(), _requestExecutor.Conventions, operationId));
}
}
public async Task ImportIncrementalAsync(DatabaseSmugglerOptions options, string fromDirectory, CancellationToken cancellationToken = default(CancellationToken))
{
var files = Directory.GetFiles(fromDirectory)
.Where(file =>
{
var extension = Path.GetExtension(file);
return
(Constants.Documents.PeriodicBackup.IncrementalBackupExtension.Equals(extension, StringComparison.OrdinalIgnoreCase) ||
Constants.Documents.PeriodicBackup.FullBackupExtension.Equals(extension, StringComparison.OrdinalIgnoreCase));
})
.OrderBy(File.GetLastWriteTimeUtc)
.ToArray();
if (files.Length == 0)
{
return;
}
var oldOperateOnTypes = ConfigureOptionsForIncrementalImport(options);
for (var i = 0; i < files.Length - 1; i++)
{
var filePath = Path.Combine(fromDirectory, files[i]);
await ImportAsync(options, filePath, cancellationToken).ConfigureAwait(false);
}
options.OperateOnTypes = oldOperateOnTypes;
var lastFilePath = Path.Combine(fromDirectory, files.Last());
await ImportAsync(options, lastFilePath, cancellationToken).ConfigureAwait(false);
}
internal static DatabaseItemType ConfigureOptionsForIncrementalImport(DatabaseSmugglerOptions options)
{
options.OperateOnTypes |= DatabaseItemType.Tombstones;
options.OperateOnTypes |= DatabaseItemType.CompareExchangeTombstones;
// we import the indexes and Subscriptions from the last file only,
var oldOperateOnTypes = options.OperateOnTypes;
options.OperateOnTypes &= ~DatabaseItemType.Indexes;
options.OperateOnTypes &= ~DatabaseItemType.Subscriptions;
return(oldOperateOnTypes);
}
internal static DatabaseItemType ConfigureOptionsForIncrementalImport(DatabaseSmugglerOptions options)
{
options.OperateOnTypes |= DatabaseItemType.Tombstones;
// we import the indexes and identities from the last file only,
// as the previous files can hold indexes and identities which were deleted and shouldn't be imported
var oldOperateOnTypes = options.OperateOnTypes;
options.OperateOnTypes = options.OperateOnTypes &
~(DatabaseItemType.Indexes | DatabaseItemType.CompareExchange | DatabaseItemType.Identities);
return(oldOperateOnTypes);
}
public async Task <Operation> ExportAsync(DatabaseSmugglerOptions options, string toFile, CancellationToken token = default(CancellationToken))
{
using (var file = File.OpenWrite(toFile))
{
var result = await ExportAsync(options, async stream =>
{
await stream.CopyToAsync(file, 8192, token).ConfigureAwait(false);
}, token).ConfigureAwait(false);
await file.FlushAsync(token).ConfigureAwait(false);
return(result);
}
}
public async Task <Operation> ImportAsync(DatabaseSmugglerOptions options, string fromFile, CancellationToken cancellationToken = default(CancellationToken))
{
var countOfFileParts = 0;
Operation result;
do
{
using (var fileStream = File.OpenRead(fromFile))
{
result = await ImportAsync(options, fileStream, cancellationToken).ConfigureAwait(false);
}
fromFile = $"{fromFile}.part{++countOfFileParts:D3}";
} while (File.Exists(fromFile));
return(result);
}
public async Task <Operation> ExportAsync(DatabaseSmugglerOptions options, DatabaseSmuggler toDatabase, CancellationToken token = default(CancellationToken))
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (toDatabase == null)
{
throw new ArgumentNullException(nameof(toDatabase));
}
var result = await ExportAsync(options, async stream =>
{
await toDatabase.ImportAsync(options, stream, token).ConfigureAwait(false);
}, token).ConfigureAwait(false);
return(result);
}
public ImportCommand(DocumentConventions conventions, JsonOperationContext context, DatabaseSmugglerOptions options, Stream stream, long operationId)
{
_stream = stream ?? throw new ArgumentNullException(nameof(stream));
if (conventions == null)
{
throw new ArgumentNullException(nameof(conventions));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
_options = EntityToBlittable.ConvertEntityToBlittable(options, conventions, context);
_operationId = operationId;
}
public ExportCommand(DocumentConventions conventions, JsonOperationContext context, DatabaseSmugglerOptions options, Func <Stream, Task> handleStreamResponse, long operationId)
{
if (conventions == null)
{
throw new ArgumentNullException(nameof(conventions));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
_handleStreamResponse = handleStreamResponse ?? throw new ArgumentNullException(nameof(handleStreamResponse));
_options = EntityToBlittable.ConvertEntityToBlittable(options, conventions, context);
_operationId = operationId;
}
