/// <summary> /// Creates and initializes a retryable read 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 read context.</returns> public static async Task <RetryableReadContext> CreateAsync(IReadBinding binding, bool retryRequested, CancellationToken cancellationToken) { var context = new RetryableReadContext(binding, retryRequested); try { await context.InitializeAsync(cancellationToken).ConfigureAwait(false); if (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; } }
// public static methods /// <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 RetryableWriteContext Create(IWriteBinding binding, bool retryRequested, CancellationToken cancellationToken) { var context = new RetryableWriteContext(binding, retryRequested); try { context.Initialize(cancellationToken); 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; } }
private DisposableBindingBundle <IReadWriteBindingHandle, RetryableWriteContext> CreateReadWriteBindingsAndRetryableWriteContext(ICluster cluster, ICoreSessionHandle sessionHandle, bool async) { var effectiveReadBindings = ChannelPinningHelper.CreateReadWriteBinding(cluster, sessionHandle); var retryableReadContext = CreateRetryableWriteContext(effectiveReadBindings, async); return(new DisposableBindingBundle <IReadWriteBindingHandle, RetryableWriteContext>(effectiveReadBindings, retryableReadContext)); }
private async Task <TResult> ExecuteEndTransactionOnPrimaryAsync <TResult>(IReadOperation <TResult> operation, CancellationToken cancellationToken) { using (var sessionHandle = new NonDisposingCoreSessionHandle(this)) using (var binding = ChannelPinningHelper.CreateReadWriteBinding(_cluster, sessionHandle)) { return(await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false)); } }
private TResult ExecuteEndTransactionOnPrimary <TResult>(IReadOperation <TResult> operation, CancellationToken cancellationToken) { using (var sessionHandle = new NonDisposingCoreSessionHandle(this)) using (var binding = ChannelPinningHelper.CreateReadWriteBinding(_cluster, sessionHandle)) { return(operation.Execute(binding, cancellationToken)); } }
private IReadBinding CreateReadBinding(IClientSessionHandle session, ReadPreference readPreference) { if (session.IsInTransaction && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary) { throw new InvalidOperationException("Read preference in a transaction must be primary."); } return(ChannelPinningHelper.CreateReadBinding(_cluster, session.WrappedCoreSession.Fork(), readPreference)); }
// private methods private IAsyncCursor <TDocument> CreateCursor(IChannelSourceHandle channelSource, BsonDocument query, CursorBatch <TDocument> batch) { var getMoreChannelSource = ChannelPinningHelper.CreateGetMoreChannelSource(channelSource, batch.CursorId); return(new AsyncCursor <TDocument>( getMoreChannelSource, _collectionNamespace, query, batch.Documents, batch.CursorId, _batchSize, _limit < 0 ? Math.Abs(_limit.Value) : _limit, _resultSerializer, _messageEncoderSettings)); }
/// <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); ChannelPinningHelper.PinChannellIfRequired( context.ChannelSource, context.Channel, context.Binding.Session); return(context); } catch { context.Dispose(); throw; } }
// public static methods /// <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 RetryableWriteContext Create(IWriteBinding binding, bool retryRequested, CancellationToken cancellationToken) { var context = new RetryableWriteContext(binding, retryRequested); try { context.Initialize(cancellationToken); ChannelPinningHelper.PinChannellIfRequired( context.ChannelSource, context.Channel, context.Binding.Session); return(context); } catch { context.Dispose(); throw; } }
private IWriteBindingHandle CreateReadWriteBinding(IClientSessionHandle session) { return(ChannelPinningHelper.CreateReadWriteBinding(_cluster, session.WrappedCoreSession.Fork())); }