private BsonValue ExecuteOperation(EvalOperation operation, IWriteBinding binding, bool async) { if (async) { return operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult(); } else { return operation.Execute(binding, CancellationToken.None); } }
/// <inheritdoc/> public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false)) using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false)) using (var channelBinding = new ChannelReadWriteBinding(channelSource.Server, channel, binding.Session.Fork())) { var operation = CreateOperation(channelBinding.Session); BsonDocument result; try { result = await operation.ExecuteAsync(channelBinding, cancellationToken).ConfigureAwait(false); } catch (MongoCommandException ex) { if (!ShouldIgnoreException(ex)) { throw; } result = ex.Result; } return(result); } }
// methods public bool Execute(IWriteBinding binding, CancellationToken cancellationToken) { using (var channelSource = binding.GetWriteChannelSource(cancellationToken)) { var userExists = UserExists(channelSource, binding.Session, cancellationToken); var roles = new BsonArray(); if (_databaseNamespace.DatabaseName == "admin") { roles.Add(_readOnly ? "readAnyDatabase" : "root"); } else { roles.Add(_readOnly ? "read" : "dbOwner"); } var commandName = userExists ? "updateUser" : "createUser"; var command = new BsonDocument { { commandName, _username }, { "pwd", _passwordHash }, { "digestPassword", false }, { "roles", roles } }; var operation = new WriteCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings); operation.Execute(channelSource, binding.Session, cancellationToken); } return(true); }
/// <inheritdoc /> public virtual async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { using (var context = await RetryableWriteContext.CreateAsync(binding, _retryRequested, cancellationToken).ConfigureAwait(false)) { return(Execute(context, cancellationToken)); } }
// public methods /// <inheritdoc /> public virtual BsonDocument Execute(IWriteBinding binding, CancellationToken cancellationToken) { using (var context = RetryableWriteContext.Create(binding, _retryRequested, cancellationToken)) { return(Execute(context, cancellationToken)); } }
public Task EnsureCollectionExistsAsync(IWriteBinding binding) { var requests = new[] { new InsertRequest(new BsonDocument("_id", 1)) }; var operation = new BulkInsertOperation(_collectionNamespace, requests, _messageEncoderSettings); return(operation.ExecuteAsync(binding, CancellationToken.None)); }
// methods public async Task <bool> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false)) { var collectionNamespace = new CollectionNamespace(_databaseNamespace, "system.users"); var user = await FindUserAsync(channelSource, collectionNamespace, cancellationToken).ConfigureAwait(false); if (user == null) { user = new BsonDocument { { "_id", ObjectId.GenerateNewId() }, { "user", _username }, { "pwd", _passwordHash }, { "readOnly", _readOnly }, }; await InsertUserAsync(channelSource, collectionNamespace, user, cancellationToken).ConfigureAwait(false); } else { user["pwd"] = _passwordHash; user["readOnly"] = _readOnly; await UpdateUserAsync(channelSource, collectionNamespace, user, cancellationToken).ConfigureAwait(false); } } return(true); }
// constructors public GridFSForwardOnlyUploadStream( GridFSBucket <TFileId> bucket, IWriteBinding binding, TFileId id, string filename, BsonDocument metadata, IEnumerable <string> aliases, string contentType, int chunkSizeBytes, int batchSize, bool disableMD5) { _bucket = bucket; _binding = binding; _id = id; _filename = filename; _metadata = metadata; // can be null _aliases = aliases == null ? null : aliases.ToList(); // can be null _contentType = contentType; // can be null _chunkSizeBytes = chunkSizeBytes; _batchSize = batchSize; _batch = new List <byte[]>(); _md5 = disableMD5 ? null : IncrementalHash.CreateHash(HashAlgorithmName.MD5); _disableMD5 = disableMD5; var idSerializer = bucket.Options.SerializerRegistry.GetSerializer <TFileId>(); var idSerializationInfo = new BsonSerializationInfo("_id", idSerializer, typeof(TFileId)); _idAsBsonValue = idSerializationInfo.SerializeValue(id); }
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken)) { Ensure.IsNotNull(binding, "binding"); var result = await ExecuteCommandAsync(binding, timeout, cancellationToken); return(result["value"].AsBsonDocument); }
/// <summary> /// Creates and initializes a retryable write operation context. /// </summary> /// <param name="binding">The binding.</param> /// <param name="retryRequested">if set to <c>true</c> [retry requested].</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>A retryable write context.</returns> public static async Task <RetryableWriteContext> CreateAsync(IWriteBinding binding, bool retryRequested, CancellationToken cancellationToken) { var context = new RetryableWriteContext(binding, retryRequested); try { await context.InitializeAsync(cancellationToken).ConfigureAwait(false); if (context.Binding.Session.IsInTransaction && ChannelPinningHelper.PinChannelSourceAndChannelIfRequired( context.ChannelSource, context.Channel, context.Binding.Session, out var pinnedChannelSource, out var pinnedChannel)) { context.ReplaceChannelSource(pinnedChannelSource); context.ReplaceChannel(pinnedChannel); } return(context); } catch { context.Dispose(); throw; } }
/// <inheritdoc/> public async Task <IEnumerable <WriteConcernResult> > ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false)) using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false)) { if (SupportedFeatures.AreWriteCommandsSupported(channel.ConnectionDescription.ServerVersion) && _writeConcern.IsAcknowledged) { var emulator = CreateEmulator(); var result = await emulator.ExecuteAsync(channel, cancellationToken).ConfigureAwait(false); return(new[] { result }); } else { if (_documentSource.Batch == null) { return(await InsertMultipleBatchesAsync(channel, cancellationToken).ConfigureAwait(false)); } else { var result = await InsertSingleBatchAsync(channel, cancellationToken).ConfigureAwait(false); return(new[] { result }); } } } }
public TResult ExecuteWriteOperation <TResult>(IWriteBinding binding, IWriteOperation <TResult> operation, CancellationToken cancellationToken) { _calls.Enqueue(new WriteCall <TResult> { Binding = binding, Operation = operation, CancellationToken = cancellationToken, SessionId = binding.Session.Id, UsedImplicitSession = binding.Session.IsImplicit }); if (_results.Count > 0) { var result = _results.Dequeue(); var exception = result as Exception; if (exception != null) { throw exception; } return((TResult)result); } return(default(TResult)); }
private static Task Insert(IWriteBinding binding, BsonDocument document) { var documentSource = new BatchableSource <BsonDocument>(new[] { document }); var insertOp = new InsertOpcodeOperation <BsonDocument>(__collection, documentSource, BsonDocumentSerializer.Instance, __messageEncoderSettings); return(insertOp.ExecuteAsync(binding)); }
// public methods /// <inheritdoc/> public BsonDocument Execute(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); var operation = CreateOperation(); return(operation.Execute(binding, cancellationToken)); }
// public methods /// <inheritdoc/> public IEnumerable <WriteConcernResult> Execute(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (EventContext.BeginOperation()) using (var channelSource = binding.GetWriteChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) { if (Feature.WriteCommands.IsSupported(channel.ConnectionDescription.ServerVersion) && _writeConcern.IsAcknowledged) { var emulator = CreateEmulator(); var result = emulator.Execute(channel, channelSource.Session, cancellationToken); return(new[] { result }); } else { if (_documentSource.Batch == null) { return(InsertMultipleBatches(channel, cancellationToken)); } else { var result = InsertSingleBatch(channel, cancellationToken); return(new[] { result }); } } } }
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken)) { Ensure.IsNotNull(binding, "binding"); var protocol = CreateProtocol(); return(await protocol.ExecuteAsync(binding, timeout, cancellationToken)); }
/// <inheritdoc/> public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); var operation = CreateOperation(); return(await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false)); }
// public methods /// <inheritdoc/> public BsonDocument Execute(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); using (var channelSource = binding.GetWriteChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) using (var channelBinding = new ChannelReadWriteBinding(channelSource.Server, channel, binding.Session.Fork())) { var operation = CreateOperation(channelBinding.Session, channel.ConnectionDescription); BsonDocument result; try { result = operation.Execute(channelBinding, cancellationToken); } catch (MongoCommandException ex) { if (!ShouldIgnoreException(ex)) { throw; } result = ex.Result; } WriteConcernErrorHelper.ThrowIfHasWriteConcernError(channel.ConnectionDescription.ConnectionId, result); return(result); } }
// methods public bool Execute(IWriteBinding binding, CancellationToken cancellationToken) { using (var channelSource = binding.GetWriteChannelSource(cancellationToken)) { var collectionNamespace = new CollectionNamespace(_databaseNamespace, "system.users"); var user = FindUser(channelSource, binding.Session, collectionNamespace, cancellationToken); if (user == null) { user = new BsonDocument { { "_id", ObjectId.GenerateNewId() }, { "user", _username }, { "pwd", _passwordHash }, { "readOnly", _readOnly }, }; InsertUser(channelSource, binding.Session, collectionNamespace, user, cancellationToken); } else { user["pwd"] = _passwordHash; user["readOnly"] = _readOnly; UpdateUser(channelSource, binding.Session, collectionNamespace, user, cancellationToken); } } return(true); }
// helper methods private void EnsureDatabaseExists(IWriteBinding binding) { var collectionNamespace = new CollectionNamespace(_databaseNamespace, "test"); var requests = new[] { new InsertRequest(new BsonDocument()) }; var insertOperation = new BulkInsertOperation(collectionNamespace, requests, _messageEncoderSettings); insertOperation.Execute(binding); }
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, TimeSpan timeout, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, "binding"); var command = CreateCommand(); var operation = new WriteCommandOperation(_databaseNamespace, command, _messageEncoderSettings); return(await operation.ExecuteAsync(binding, timeout, cancellationToken).ConfigureAwait(false)); }
/// <inheritdoc/> public Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, "binding"); var command = CreateCommand(); var operation = new WriteCommandOperation <BsonDocument>(CollectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, MessageEncoderSettings); return(operation.ExecuteAsync(binding, cancellationToken)); }
public BulkWriteOperationResult Execute(IWriteBinding binding, CancellationToken cancellationToken) { using (var channelSource = binding.GetWriteChannelSource(cancellationToken)) using (var channel = channelSource.GetChannel(cancellationToken)) { return(Execute(channel, cancellationToken)); } }
// methods public bool Execute(IWriteBinding binding, CancellationToken cancellationToken) { var command = new BsonDocument("dropUser", _username); var operation = new WriteCommandOperation <BsonDocument>(_databaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings); operation.Execute(binding, cancellationToken); return(true); }
public async Task <BsonDocument> ExecuteCommandAsync(IWriteBinding binding, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken)) { Ensure.IsNotNull(binding, "binding"); var command = CreateCommand(); var operation = new WriteCommandOperation(_collectionNamespace.DatabaseNamespace, command, _messageEncoderSettings); return(await operation.ExecuteAsync(binding, timeout, cancellationToken)); }
public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken)) { Ensure.IsNotNull(binding, "binding"); var command = CreateCommand(); var operation = new WriteCommandOperation("admin", command); return(await operation.ExecuteAsync(binding, timeout, cancellationToken)); }
// helper methods private void EnsureDatabaseExists(IWriteBinding binding) { var collectionNamespace = new CollectionNamespace(_databaseNamespace, "test"); var requests = new[] { new InsertRequest(new BsonDocument()) }; var insertOperation = new BulkInsertOperation(collectionNamespace, requests, _messageEncoderSettings); insertOperation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult(); }
/// <inheritdoc/> public async Task <BsonValue> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); var operation = CreateOperation(); var result = await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false); return(result["retval"]); }
// public methods /// <inheritdoc/> public BsonValue Execute(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); var operation = CreateOperation(); var result = operation.Execute(binding, cancellationToken); return(result["retval"]); }
public async Task <BulkWriteOperationResult> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { using (var channelSource = await binding.GetWriteChannelSourceAsync(cancellationToken).ConfigureAwait(false)) using (var channel = await channelSource.GetChannelAsync(cancellationToken).ConfigureAwait(false)) { return(await ExecuteAsync(channel, cancellationToken).ConfigureAwait(false)); } }
/// <inheritdoc/> public async Task <BsonDocument> ExecuteAsync(IWriteBinding binding, CancellationToken cancellationToken) { Ensure.IsNotNull(binding, nameof(binding)); var command = CreateCommand(); var operation = new WriteCommandOperation <BsonDocument>(_collectionNamespace.DatabaseNamespace, command, BsonDocumentSerializer.Instance, _messageEncoderSettings); return(await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false)); }
// constructors public GridFSForwardOnlyUploadStream( GridFSBucket bucket, IWriteBinding binding, ObjectId id, string filename, BsonDocument metadata, IEnumerable<string> aliases, string contentType, int chunkSizeBytes, int batchSize) { _bucket = bucket; _binding = binding; _id = id; _filename = filename; _metadata = metadata; // can be null _aliases = aliases == null ? null : aliases.ToList(); // can be null _contentType = contentType; // can be null _chunkSizeBytes = chunkSizeBytes; _batchSize = batchSize; _batch = new List<byte[]>(); _md5 = MD5.Create(); }
private static Task Update(IWriteBinding binding, BsonDocument query, BsonDocument update) { var updateOp = new UpdateOpcodeOperation( _database, _collection, query, update); return updateOp.ExecuteAsync(binding); }
private static Task Update(IWriteBinding binding, BsonDocument criteria, BsonDocument update) { var updateOp = new UpdateOpcodeOperation( __collection, new UpdateRequest(UpdateType.Update, criteria, update), __messageEncoderSettings); return updateOp.ExecuteAsync(binding); }
private static Task Insert(IWriteBinding binding, BsonDocument document) { var documentSource = new BatchableSource<BsonDocument>(new[] { document }); var insertOp = new InsertOpcodeOperation<BsonDocument>(__collection, documentSource, BsonDocumentSerializer.Instance, __messageEncoderSettings); return insertOp.ExecuteAsync(binding); }
private async Task Update(IWriteBinding binding, BsonDocument filter, BsonDocument update) { var updateOp = new UpdateOpcodeOperation( _collection, new UpdateRequest(UpdateType.Update, filter, update), _messageEncoderSettings); using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30))) using (var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _cancellationTokenSource.Token)) { await updateOp.ExecuteAsync(binding, linked.Token); } }
private void EnsureCollectionExists(IWriteBinding binding, CollectionNamespace collectionNamespace) { try { var operation = new CreateCollectionOperation(collectionNamespace, _messageEncoderSettings); operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult(); } catch (MongoCommandException ex) { if (ex.Message == "Command create failed: collection already exists.") { return; } throw; } }
// helper methods private void EnsureCollectionDoesNotExist(IWriteBinding binding, CollectionNamespace collectionNamespace) { var operation = new DropCollectionOperation(collectionNamespace, _messageEncoderSettings); operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult(); }
// constructors public SplitReadWriteBinding(IReadBinding readBinding, IWriteBinding writeBinding) { _readBinding = Ensure.IsNotNull(readBinding, "readBinding"); _writeBinding = Ensure.IsNotNull(writeBinding, "writeBinding"); }
// constructors /// <summary> /// Initializes a new instance of the <see cref="SplitReadWriteBinding"/> class. /// </summary> /// <param name="readBinding">The read binding.</param> /// <param name="writeBinding">The write binding.</param> public SplitReadWriteBinding(IReadBinding readBinding, IWriteBinding writeBinding) { _readBinding = Ensure.IsNotNull(readBinding, nameof(readBinding)); _writeBinding = Ensure.IsNotNull(writeBinding, nameof(writeBinding)); }
// helper methods private void EnsureDatabaseExists(IWriteBinding binding) { var collectionNamespace = new CollectionNamespace(_databaseNamespace, "test"); var requests = new[] { new InsertRequest(new BsonDocument()) }; var insertOperation = new BulkInsertOperation(collectionNamespace, requests, _messageEncoderSettings); insertOperation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult(); }
private static Task Insert(IWriteBinding binding, BsonDocument document) { var insertOp = new InsertOpcodeOperation<BsonDocument>( _database, _collection, BsonDocumentSerializer.Instance, new BatchableSource<BsonDocument>(new[] { document })); return insertOp.ExecuteAsync(binding); }
public void Setup() { _readBinding = Substitute.For<IReadBinding>(); _writeBinding = Substitute.For<IWriteBinding>(); }
public Task DropDatabaseAsync(IWriteBinding binding) { var operation = new DropDatabaseOperation(_collectionNamespace.DatabaseNamespace, _messageEncoderSettings); return operation.ExecuteAsync(binding, CancellationToken.None); }
private BsonDocument ExecuteOperation(CreateCollectionOperation subject, IWriteBinding binding, bool async) { if (async) { return subject.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult(); } else { return subject.Execute(binding, CancellationToken.None); } }
private async Task Insert(IWriteBinding binding, BsonDocument document) { var documentSource = new BatchableSource<BsonDocument>(new[] { document }); var insertOp = new InsertOpcodeOperation<BsonDocument>(_collection, documentSource, BsonDocumentSerializer.Instance, _messageEncoderSettings); using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(30))) using (var linked = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, _cancellationTokenSource.Token)) { await insertOp.ExecuteAsync(binding, linked.Token); } }
private static Task Update(IWriteBinding binding, BsonDocument query, BsonDocument update) { var updateOp = new UpdateOpcodeOperation( __collection, query, update, __messageEncoderSettings); return updateOp.ExecuteAsync(binding); }
public Task EnsureCollectionExistsAsync(IWriteBinding binding) { var requests = new[] { new InsertRequest(new BsonDocument("_id", 1)) }; var operation = new BulkInsertOperation(_collectionNamespace, requests, _messageEncoderSettings); return operation.ExecuteAsync(binding, CancellationToken.None); }