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; } }