protected Task <TResult> ExecuteOperationAsync <TResult>(IWriteOperation <TResult> operation, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
using (var binding = new WritableServerBinding(_cluster))
{
return(operation.ExecuteAsync(binding, timeout, cancellationToken));
}
}
protected async Task <TResult> ExecuteOperationAsync <TResult>(IWriteOperation <TResult> operation)
{
using (var binding = CoreTestConfiguration.GetReadWriteBinding())
{
return(await operation.ExecuteAsync(binding, CancellationToken.None));
}
}
protected async Task <TResult> ExecuteOperationAsync <TResult>(IWriteOperation <TResult> operation)
{
using (var binding = CreateReadWriteBinding())
using (var bindingHandle = new ReadWriteBindingHandle(binding))
{
return(await operation.ExecuteAsync(bindingHandle, CancellationToken.None));
}
}
protected void VerifySessionIdWasSentWhenSupported <TResult>(IWriteOperation <TResult> operation, string commandName, bool async)
{
VerifySessionIdWasSentWhenSupported(
(binding, cancellationToken) => operation.ExecuteAsync(binding, cancellationToken),
(binding, cancellationToken) => operation.Execute(binding, cancellationToken),
commandName,
async);
}
protected TResult ExecuteOperation <TResult>(IWriteOperation <TResult> operation, IReadWriteBinding binding, bool async)
{
if (async)
{
return(operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult());
}
else
{
return(operation.Execute(binding, CancellationToken.None));
}
}
/// <summary>
/// Executes a write operation using a channel source.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="operation">The write operation.</param>
/// <param name="channelSource">The channel source.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A Task whose result is the result of the operation.</returns>
public static async Task <TResult> ExecuteAsync <TResult>(
this IWriteOperation <TResult> operation,
IChannelSourceHandle channelSource,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(operation, "operation");
using (var writeBinding = new ChannelSourceReadWriteBinding(channelSource.Fork(), ReadPreference.Primary))
{
return(await operation.ExecuteAsync(writeBinding, cancellationToken).ConfigureAwait(false));
}
}
public static async Task <TResult> ExecuteAsync <TResult>(
this IWriteOperation <TResult> operation,
IConnectionSourceHandle connectionSource,
TimeSpan timeout,
CancellationToken cancellationToken)
{
Ensure.IsNotNull(operation, "operation");
using (var writeBinding = new ConnectionSourceReadWriteBinding(connectionSource.Fork(), ReadPreference.Primary))
{
return(await operation.ExecuteAsync(writeBinding, timeout, cancellationToken));
}
}
protected void VerifySessionIdWasNotSentIfUnacknowledgedWrite <TResult>(
IWriteOperation <TResult> operation,
string commandName,
bool async,
bool useImplicitSession)
{
VerifySessionIdSending(
(binding, cancellationToken) => operation.ExecuteAsync(binding, cancellationToken),
(binding, cancellationToken) => operation.Execute(binding, cancellationToken),
AssertSessionIdWasNotSentIfUnacknowledgedWrite,
commandName,
async,
useImplicitSession);
}
private TResult ExecuteOperation <TResult>(IWriteOperation <TResult> operation, bool async)
{
using (var binding = CoreTestConfiguration.GetReadWriteBinding())
{
if (async)
{
return(operation.ExecuteAsync(binding, CancellationToken.None).GetAwaiter().GetResult());
}
else
{
return(operation.Execute(binding, CancellationToken.None));
}
}
}
public async Task <TResult> ExecuteWriteOperationAsync <TResult>(IWriteBinding binding, IWriteOperation <TResult> operation, TimeSpan timeout, CancellationToken cancellationToken)
{
using (var cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
{
cancellationTokenSource.CancelAfter(timeout);
try
{
return(await operation.ExecuteAsync(binding, cancellationTokenSource.Token).ConfigureAwait(false));
}
catch (OperationCanceledException ex)
{
if (cancellationTokenSource.IsCancellationRequested && !cancellationToken.IsCancellationRequested)
{
var msg = string.Format("Operation timed out after {0}.", timeout);
throw new TimeoutException(msg, ex);
}
throw;
}
}
}
protected async Task <TResult> ExecuteOperationAsync <TResult>(IWriteOperation <TResult> operation, IWriteBinding binding)
{
return(await operation.ExecuteAsync(binding, CancellationToken.None));
}
public Task <TResult> ExecuteWriteOperationAsync <TResult>(IWriteBinding binding, IWriteOperation <TResult> operation, CancellationToken cancellationToken)
{
return(operation.ExecuteAsync(binding, cancellationToken));
}
public static TResult Execute <TResult>(this IWriteOperation <TResult> operation, IWriteBinding binding, CancellationToken cancellationToken = default(CancellationToken))
{
return(operation.ExecuteAsync(binding, cancellationToken).GetAwaiter().GetResult());
}
public async Task <TResult> ExecuteWriteOperationAsync <TResult>(IWriteBinding binding, IWriteOperation <TResult> operation, CancellationToken cancellationToken)
{
return(await operation.ExecuteAsync(binding, cancellationToken).ConfigureAwait(false));
}
public static TResult Execute <TResult>(this IWriteOperation <TResult> operation, IConnectionSourceHandle connectionSource, TimeSpan timeout = default(TimeSpan), CancellationToken cancellationToken = default(CancellationToken))
{
return(operation.ExecuteAsync(connectionSource, timeout, cancellationToken).GetAwaiter().GetResult());
}
public static TResult Execute <TResult>(this IWriteOperation <TResult> operation, IChannelSourceHandle channelSource, CancellationToken cancellationToken = default(CancellationToken))
{
return(operation.ExecuteAsync(channelSource, cancellationToken).GetAwaiter().GetResult());
}
