public async Task ImportIncrementalAsync(DatabaseSmugglerImportOptions options, string fromDirectory, CancellationToken cancellationToken = default)
{
var files = Directory.GetFiles(fromDirectory)
.Where(BackupUtils.IsBackupFile)
.OrderBackups()
.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]);
var op = await ImportAsync(options, filePath, cancellationToken).ConfigureAwait(false);
await op.WaitForCompletionAsync().ConfigureAwait(false);
}
options.OperateOnTypes = oldOperateOnTypes;
var lastFilePath = Path.Combine(fromDirectory, files.Last());
var operation = await ImportAsync(options, lastFilePath, cancellationToken).ConfigureAwait(false);
await operation.WaitForCompletionAsync().ConfigureAwait(false);
}
public async Task <Operation> ExportAsync(DatabaseSmugglerExportOptions options, DatabaseSmuggler toDatabase, CancellationToken token = default)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (toDatabase == null)
{
throw new ArgumentNullException(nameof(toDatabase));
}
Operation operation = null;
var importOptions = new DatabaseSmugglerImportOptions(options);
var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
await ExportAsync(options, async stream =>
{
try
{
operation = await toDatabase.ImportAsync(importOptions, stream, token).ConfigureAwait(false);
tcs.TrySetResult(null);
}
catch (Exception e)
{
tcs.TrySetException(e);
throw;
}
}, token).ConfigureAwait(false);
await tcs.Task.ConfigureAwait(false);
return(operation);
}
public async Task <Operation> ImportAsync(DatabaseSmugglerImportOptions 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(DatabaseSmugglerImportOptions 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);
}
public async Task <Operation> ImportAsync(DatabaseSmugglerImportOptions options, Stream stream, CancellationToken token = default)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (_requestExecutor == null)
{
throw new InvalidOperationException("Cannot use Smuggler without a database defined, did you forget to call ForDatabase?");
}
using (_requestExecutor.ContextPool.AllocateOperationContext(out JsonOperationContext context))
{
var getOperationIdCommand = new GetNextOperationIdCommand();
await _requestExecutor.ExecuteAsync(getOperationIdCommand, context, sessionInfo : null, token : token).ConfigureAwait(false);
var operationId = getOperationIdCommand.Result;
var command = new ImportCommand(_requestExecutor.Conventions, context, options, stream, operationId);
await _requestExecutor.ExecuteAsync(command, context, sessionInfo : null, token : token).ConfigureAwait(false);
return(new Operation(_requestExecutor, () => _store.Changes(_databaseName), _requestExecutor.Conventions, operationId));
}
}
public async Task <Operation> ImportAsync(DatabaseSmugglerImportOptions 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 ImportCommand(JsonOperationContext context, DatabaseSmugglerImportOptions options, Stream stream, long operationId, TaskCompletionSource <object> tcs, DatabaseSmuggler parent)
{
_stream = stream ?? throw new ArgumentNullException(nameof(stream));
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
_options = DocumentConventions.Default.Serialization.DefaultConverter.ToBlittable(options, context);
_operationId = operationId;
_tcs = tcs ?? throw new ArgumentNullException(nameof(tcs));
_parent = parent ?? throw new ArgumentNullException(nameof(parent));
}
public async Task <Operation> ExportAsync(DatabaseSmugglerExportOptions options, DatabaseSmuggler toDatabase, CancellationToken token = default(CancellationToken))
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (toDatabase == null)
{
throw new ArgumentNullException(nameof(toDatabase));
}
var importOptions = new DatabaseSmugglerImportOptions(options);
var result = await ExportAsync(options, async stream =>
{
await toDatabase.ImportAsync(importOptions, stream, token).ConfigureAwait(false);
}, token).ConfigureAwait(false);
return(result);
}
private async Task <Operation> ImportInternalAsync(DatabaseSmugglerImportOptions options, Stream stream, bool leaveOpen, CancellationToken token = default)
{
var disposeStream = leaveOpen ? null : new DisposeStreamOnce(stream);
IDisposable returnContext = null;
Task requestTask = null;
try
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (_requestExecutor == null)
{
throw new InvalidOperationException("Cannot use Smuggler without a database defined, did you forget to call ForDatabase?");
}
returnContext = _requestExecutor.ContextPool.AllocateOperationContext(out JsonOperationContext context);
var getOperationIdCommand = new GetNextOperationIdCommand();
await _requestExecutor.ExecuteAsync(getOperationIdCommand, context, sessionInfo : null, token : token).ConfigureAwait(false);
var operationId = getOperationIdCommand.Result;
var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
var cancellationTokenRegistration = token.Register(() => tcs.TrySetCanceled(token));
var command = new ImportCommand(context, options, stream, operationId, tcs, this, getOperationIdCommand.NodeTag);
var task = _requestExecutor.ExecuteAsync(command, context, sessionInfo: null, token: token);
requestTask = task
.ContinueWith(t =>
{
returnContext?.Dispose();
cancellationTokenRegistration.Dispose();
using (disposeStream)
{
if (t.IsFaulted)
{
tcs.TrySetException(t.Exception);
if (Logger.IsOperationsEnabled)
{
Logger.Operations("Could not execute import", t.Exception);
}
}
}
}, token);
try
{
await tcs.Task.ConfigureAwait(false);
}
catch (Exception)
{
await requestTask.ConfigureAwait(false);
await tcs.Task.ConfigureAwait(false);
}
return(new Operation(_requestExecutor, () => _store.Changes(_databaseName, getOperationIdCommand.NodeTag), _requestExecutor.Conventions, operationId,
nodeTag: getOperationIdCommand.NodeTag, additionalTask: task));
}
catch (Exception e)
{
if (requestTask == null)
{
// handle the possible double dispose of return context
returnContext?.Dispose();
}
disposeStream?.Dispose();
throw e.ExtractSingleInnerException();
}
}
public Task <Operation> ImportAsync(DatabaseSmugglerImportOptions options, Stream stream, CancellationToken token = default)
{
return(ImportInternalAsync(options, stream, leaveOpen: true, token));
}
public Task <Operation> ImportAsync(DatabaseSmugglerImportOptions options, string fromFile, CancellationToken cancellationToken = default)
{
return(ImportInternalAsync(options, File.OpenRead(fromFile), leaveOpen: false, cancellationToken));
}
public ImportCommand(DocumentConventions conventions, JsonOperationContext context, DatabaseSmugglerImportOptions 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 ImportCommand(DocumentConventions conventions, JsonOperationContext context, DatabaseSmugglerImportOptions options, Stream stream, long operationId, TaskCompletionSource <object> tcs, DatabaseSmuggler parent, string nodeTag)
{
_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.ConvertCommandToBlittable(options, context);
_operationId = operationId;
_tcs = tcs ?? throw new ArgumentNullException(nameof(tcs));
_parent = parent ?? throw new ArgumentNullException(nameof(parent));
SelectedNodeTag = nodeTag;
}
private async Task <Operation> ImportInternalAsync(DatabaseSmugglerImportOptions options, Stream stream, bool leaveOpen, CancellationToken token = default)
{
var disposeStream = leaveOpen ? null : new DisposeStreamOnce(stream);
try
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (_requestExecutor == null)
{
throw new InvalidOperationException("Cannot use Smuggler without a database defined, did you forget to call ForDatabase?");
}
using (_requestExecutor.ContextPool.AllocateOperationContext(out JsonOperationContext context))
{
var getOperationIdCommand = new GetNextOperationIdCommand();
await _requestExecutor.ExecuteAsync(getOperationIdCommand, context, sessionInfo : null, token : token).ConfigureAwait(false);
var operationId = getOperationIdCommand.Result;
var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously);
token.Register(() => tcs.TrySetCanceled(token));
var command = new ImportCommand(_requestExecutor.Conventions, context, options, stream, operationId, tcs);
var requestTask = _requestExecutor.ExecuteAsync(command, context, sessionInfo: null, token: token)
.ContinueWith(t =>
{
using (disposeStream)
{
if (t.IsFaulted && Logger.IsOperationsEnabled)
{
Logger.Operations("Could not execute import", t.Exception);
}
}
}, token);
try
{
await tcs.Task.ConfigureAwait(false);
}
catch (Exception)
{
await requestTask.ConfigureAwait(false);
}
return(new Operation(_requestExecutor, () => _store.Changes(_databaseName), _requestExecutor.Conventions, operationId));
}
}
catch
{
disposeStream?.Dispose();
throw;
}
}
