/// <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()));
}
