/// <summary>
/// Executes an <see cref="IViewQuery"/> asynchronously. If it fails, the response is checked and
/// if certain criteria are met the request is retried until it times out.
/// </summary>
/// <typeparam name="T">The Type of View result body.</typeparam>
/// <param name="execute">A delegate with the send logic that is executed on each attempt. </param>
/// <param name="query">The <see cref="IViewQuery"/> to execute.</param>
/// <param name="configInfo">The <see cref="IConfigInfo"/> that represents the logical topology of the cluster.</param>
/// <param name="cancellationToken">For canceling the async operation.</param>
/// <returns>A <see cref="Task{IViewResult}"/> object representing the asynchronous operation.</returns>
static async Task <IViewResult <T> > RetryViewEveryAsync <T>(Func <IViewQueryable, IConfigInfo, Task <IViewResult <T> > > execute,
IViewQueryable query,
IConfigInfo configInfo,
CancellationToken cancellationToken)
{
while (true)
{
var result = await execute(query, configInfo).ContinueOnAnyContext();
if (query.RetryAttempts++ >= configInfo.ClientConfig.MaxViewRetries ||
result.Success ||
result.CannotRetry())
{
return(result);
}
Log.Debug(m => m("trying again: {0}", query.RetryAttempts));
var sleepTime = (int)Math.Pow(2, query.RetryAttempts);
var task = Task.Delay(sleepTime, cancellationToken).ContinueOnAnyContext();
try
{
await task;
}
catch (TaskCanceledException)
{
return(result);
}
}
}
/// <summary>
/// Executes a <see cref="IViewQuery"/> asynchronously against a View.
/// </summary>
/// <typeparam name="T">The Type parameter of the result returned by the query.</typeparam>
/// <param name="query">The <see cref="IViewQuery"/> to execute on.</param>
/// <returns>A <see cref="Task{T}"/> that can be awaited on for the results.</returns>
public override async Task <IViewResult <T> > ExecuteAsync <T>(IViewQueryable query)
{
var uri = query.RawUri();
var viewResult = new StreamingViewResult <T>();
try
{
var response = await HttpClient.GetAsync(uri).ContinueOnAnyContext();
viewResult = new StreamingViewResult <T>(
response.IsSuccessStatusCode,
response.StatusCode,
Success,
await response.Content.ReadAsStreamAsync().ContinueOnAnyContext()
);
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e =>
{
ProcessError(e, viewResult);
Log.Error(uri.ToString(), e);
return(true);
});
}
catch (TaskCanceledException e)
{
const string error = "The request has timed out.";
ProcessError(e, error, viewResult);
Log.Error(uri.ToString(), e);
}
return(viewResult);
}
/// <summary>
/// Sends a request for a View to the server asynchronously.
/// </summary>
/// <typeparam name="T">The <see cref="Type" /> T of the body for each row result.</typeparam>
/// <param name="query">The <see cref="IViewQuery" /> representing the query.</param>
/// <returns>
/// An <see cref="Task{IViewResult}" /> object representing the asynchronous operation.
/// </returns>
public Task <IViewResult <T> > SendAsync <T>(IViewQueryable query)
{
Task <IViewResult <T> > result;
try
{
query.BaseUri(CachedViewBaseUri);
result = query.IsStreaming
? _streamingViewClient.ExecuteAsync <T>(query)
: ViewClient.ExecuteAsync <T>(query);
}
catch (Exception e)
{
var tcs = new TaskCompletionSource <IViewResult <T> >();
tcs.SetResult(new ViewResult <T>
{
Exception = e,
Message = e.Message,
Error = e.Message,
Success = false,
StatusCode = HttpStatusCode.BadRequest,
Rows = new List <ViewRow <T> >()
});
result = tcs.Task;
}
return(result);
}
/// <summary>
/// Sends a request for a View to the server.
/// </summary>
/// <typeparam name="T">The <see cref="Type" /> T of the body for each row result.</typeparam>
/// <param name="query">The <see cref="IViewQuery" /> representing the query.</param>
/// <returns>
/// An <see cref="IViewResult{T}" /> representing the result of the query.
/// </returns>
public IViewResult <T> Send <T>(IViewQueryable query)
{
IViewResult <T> result;
try
{
query.BaseUri(CachedViewBaseUri);
result = query.IsStreaming
? _streamingViewClient.Execute <T>(query)
: ViewClient.Execute <T>(query);
}
catch (Exception e)
{
result = new ViewResult <T>
{
Exception = e,
Message = e.Message,
Error = e.Message,
Success = false,
StatusCode = HttpStatusCode.BadRequest,
Rows = new List <ViewRow <T> >()
};
}
return(result);
}
internal static ISpanBuilder BuildSpan(this ITracer tracer, IViewQueryable query, string operationName)
{
return(tracer.BuildSpan(operationName)
.WithTag(CouchbaseTags.OperationId, GetOrGenerateOperationId(query.ActiveSpan))
.WithTag(CouchbaseTags.Service, CouchbaseTags.ServiceView)
.AsChildOf(query.ActiveSpan));
}
/// <summary>
/// Executes a <see cref="IViewQuery"/> asynchronously against a View.
/// </summary>
/// <typeparam name="T">The Type parameter of the result returned by the query.</typeparam>
/// <param name="query">The <see cref="IViewQuery"/> to execute on.</param>
/// <returns>A <see cref="Task{T}"/> that can be awaited on for the results.</returns>
public async Task <IViewResult <T> > ExecuteAsync <T>(IViewQueryable query)
{
var uri = query.RawUri();
var viewResult = new ViewResult <T>();
try
{
var result = await HttpClient.GetAsync(uri).ContinueOnAnyContext();
var content = result.Content;
using (var stream = await content.ReadAsStreamAsync().ContinueOnAnyContext())
{
viewResult = Mapper.Map <ViewResultData <T> >(stream).ToViewResult();
viewResult.Success = result.IsSuccessStatusCode;
viewResult.StatusCode = result.StatusCode;
viewResult.Message = Success;
}
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e =>
{
ProcessError(e, viewResult);
Log.Error(uri, e);
return(true);
});
}
catch (TaskCanceledException e)
{
const string error = "The request has timed out.";
ProcessError(e, error, viewResult);
Log.Error(uri, e);
}
return(viewResult);
}
/// <summary>
/// Executes a <see cref="IViewQuery"/> asynchronously against a View.
/// </summary>
/// <typeparam name="T">The Type parameter of the result returned by the query.</typeparam>
/// <param name="query">The <see cref="IViewQuery"/> to execute on.</param>
/// <returns>A <see cref="Task{T}"/> that can be awaited on for the results.</returns>
public override async Task <IViewResult <T> > ExecuteAsync <T>(IViewQueryable query)
{
var uri = query.RawUri();
var viewResult = new ViewResult <T>();
var body = query.CreateRequestBody();
try
{
Log.Debug("Sending view request to: {0}", uri.ToString());
var content = new StringContent(body, Encoding.UTF8, MediaType.Json);
var response = await HttpClient.PostAsync(uri, content).ContinueOnAnyContext();
if (response.IsSuccessStatusCode)
{
using (var stream = await response.Content.ReadAsStreamAsync().ContinueOnAnyContext())
{
viewResult = DataMapper.Map <ViewResultData <T> >(stream).ToViewResult();
viewResult.Success = response.IsSuccessStatusCode;
viewResult.StatusCode = response.StatusCode;
viewResult.Message = Success;
}
}
else
{
viewResult = new ViewResult <T>
{
Success = false,
StatusCode = response.StatusCode,
Message = response.ReasonPhrase
};
}
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e =>
{
ProcessError(e, viewResult);
Log.Error(uri.ToString(), e);
return(true);
});
}
catch (TaskCanceledException e)
{
const string error = "The request has timed out.";
ProcessError(e, error, viewResult);
Log.Error(uri.ToString(), e);
}
catch (HttpRequestException e)
{
ProcessError(e, viewResult);
Log.Error(uri.ToString(), e);
}
UpdateLastActivity();
return(viewResult);
}
/// <summary>
/// Executes a <see cref="IViewQuery"/> synchronously against a View.
/// </summary>
/// <typeparam name="T">The Type parameter of the result returned by the query.</typeparam>
/// <param name="query">The <see cref="IViewQuery"/> to execute on.</param>
/// <returns>The <see cref="IViewResult{T}"/> instance which is the results of the query.</returns>
public IViewResult <T> Execute <T>(IViewQueryable query)
{
// Cache and clear the current SynchronizationContext before we begin.
// This eliminates the chance for deadlocks when we wait on an async task sychronously.
using (new SynchronizationContextExclusion())
{
return(ExecuteAsync <T>(query).Result);
}
}
internal static ISpanBuilder BuildSpan(this ITracer tracer, IViewQueryable query, string operationName)
{
return(tracer.BuildSpan(operationName)
.AddDefaultTags()
.WithTag(CouchbaseTags.OperationId, GetOrGenerateOperationId(tracer.ActiveSpan))
.WithTag(CouchbaseTags.ViewDesignDoc, query.DesignDocName)
.WithTag(CouchbaseTags.ViewName, query.ViewName)
.WithTag(CouchbaseTags.Service, CouchbaseTags.ServiceView)
.AsChildOf(tracer.ActiveSpan));
}
internal static IScope StartParentScope(this ITracer tracer, IViewQueryable query, bool addIgnoreTag = false)
{
var builder = tracer.BuildSpan(query);
if (addIgnoreTag)
{
builder.WithIgnoreTag();
}
return(builder.StartActive());
}
public ViewQueryObservable(IBucket bucket, IViewQueryable query)
{
if (bucket == null)
{
throw new ArgumentNullException("bucket");
}
if (query == null)
{
throw new ArgumentNullException("query");
}
_bucket = bucket;
_query = query;
}
internal static ISpan StartParentSpan(this ITracer tracer, IViewQueryable query, bool addIgnoreTag = false)
{
var builder = tracer.BuildSpan(query);
if (addIgnoreTag)
{
builder.WithIgnoreTag();
}
var span = builder.Start();
query.ActiveSpan = span;
return(span);
}
/// <summary>
/// Sends a View request to the server to be executed using async/await
/// </summary>
/// <typeparam name="T">The Type of the body of the Views return value or row.</typeparam>
/// <param name="query">An <see cref="IViewQuery" /> to be executed.</param>
/// <returns>
/// The result of the View request as an <see cref="Task{IViewResult}" /> to be awaited on where T is the Type of each row.
/// </returns>
/// <exception cref="ServiceNotSupportedException">The cluster does not support View services.</exception>
public override async Task <IViewResult <T> > SendWithRetryAsync <T>(IViewQueryable query)
{
IViewResult <T> viewResult = null;
try
{
//Is the cluster configured for View services?
if (!ConfigInfo.IsViewCapable)
{
throw new ServiceNotSupportedException(
ExceptionUtil.GetMessage(ExceptionUtil.ServiceNotSupportedMsg, "View"));
}
using (var cancellationTokenSource = new CancellationTokenSource(ConfigInfo.ClientConfig.ViewRequestTimeout))
{
var task = RetryViewEveryAsync(async(e, c) =>
{
var server = c.GetViewNode();
return(await server.SendAsync <T>(query).ContinueOnAnyContext());
},
query, ConfigInfo, cancellationTokenSource.Token).ConfigureAwait(false);
viewResult = await task;
}
}
catch (Exception e)
{
Log.Info(e);
const string message = "View request failed, check Error and Exception fields for details.";
viewResult = new ViewResult <T>
{
Message = message,
Error = e.Message,
StatusCode = HttpStatusCode.BadRequest,
Success = false,
Exception = e
};
}
return(viewResult);
}
/// <summary>
/// Executes a <see cref="IViewQuery"/> synchronously against a View.
/// </summary>
/// <typeparam name="T">The Type parameter of the result returned by the query.</typeparam>
/// <param name="query">The <see cref="IViewQuery"/> to execute on.</param>
/// <returns>The <see cref="IViewResult{T}"/> instance which is the results of the query.</returns>
public IViewResult <T> Execute <T>(IViewQueryable query)
{
var viewResult = new ViewResult <T>();
try
{
var request = WebRequest.Create(query.RawUri());
request.Timeout = _clientConfig.ViewRequestTimeout;
WriteAuthenticationHeaders(request, _bucketConfig.Name, _bucketConfig.Password);
using (var response = request.GetResponse() as HttpWebResponse)
{
var stream = response.GetResponseStream();
viewResult = Mapper.Map <ViewResult <T> >(stream);
response.Close();
viewResult.Success = response.StatusCode == HttpStatusCode.OK;
viewResult.StatusCode = response.StatusCode;
}
}
catch (WebException e)
{
if (e.Response != null)
{
var stream = e.Response.GetResponseStream();
if (stream != null && stream.Length > 0)
{
viewResult = Mapper.Map <ViewResult <T> >(stream);
}
}
viewResult.Exception = e;
viewResult.StatusCode = GetStatusCode(e.Message);
Log.Error(e);
}
catch (Exception e)
{
ProcessError(e, viewResult);
Log.Error(e);
}
return(viewResult);
}
/// <summary>
/// Sends a View request with retry.
/// </summary>
/// <typeparam name="T">The Type T of the <see cref="ViewRow{T}"/> value.</typeparam>
/// <param name="viewQuery">The view query.</param>
/// <returns>A <see cref="IViewResult{T}"/> with the results of the query.</returns>
/// <exception cref="ServiceNotSupportedException">The cluster does not support View services.</exception>
public override IViewResult <T> SendWithRetry <T>(IViewQueryable viewQuery)
{
IViewResult <T> viewResult;
try
{
EnsureNotEphemeral(ConfigInfo.BucketConfig.BucketType);
EnsureServiceAvailable(ConfigInfo.IsViewCapable, "View");
viewResult = RetryRequest(
ConfigInfo.GetViewNode,
(server, request) => server.Send <T>(request),
(request, result) =>
{
if (!(result.Success || !result.ShouldRetry() || request.RetryAttempts >= ConfigInfo.ClientConfig.MaxViewRetries))
{
request.RetryAttempts++;
return(true);
}
return(false);
},
viewQuery
);
}
catch (Exception e)
{
Log.Info(e);
const string message = "View request failed, check Error and Exception fields for details.";
viewResult = new ViewResult <T>
{
Message = message,
Error = e.Message,
StatusCode = HttpStatusCode.BadRequest,
Success = false,
Exception = e
};
}
return(viewResult);
}
/// <summary>
/// Sends a View request with retry.
/// </summary>
/// <typeparam name="T">The Type T of the <see cref="ViewRow{T}"/> value.</typeparam>
/// <param name="viewQuery">The view query.</param>
/// <returns>A <see cref="IViewResult{T}"/> with the results of the query.</returns>
/// <exception cref="ServiceNotSupportedException">The cluster does not support View services.</exception>
public override IViewResult <T> SendWithRetry <T>(IViewQueryable viewQuery)
{
IViewResult <T> viewResult = null;
try
{
//Is the cluster configured for View services?
if (!ConfigInfo.IsViewCapable)
{
throw new ServiceNotSupportedException(
ExceptionUtil.GetMessage(ExceptionUtil.ServiceNotSupportedMsg, "View"));
}
do
{
var server = ConfigInfo.GetViewNode();
viewResult = server.Send <T>(viewQuery);
} while (
!viewResult.Success &&
!viewResult.CannotRetry() &&
viewQuery.RetryAttempts++ <= ConfigInfo.ClientConfig.MaxViewRetries);
}
catch (Exception e)
{
Log.Info(e);
const string message = "View request failed, check Error and Exception fields for details.";
viewResult = new ViewResult <T>
{
Message = message,
Error = e.Message,
StatusCode = HttpStatusCode.BadRequest,
Success = false,
Exception = e
};
}
return(viewResult);
}
/// <summary>
/// Sends a View request to the server to be executed using async/await
/// </summary>
/// <typeparam name="T">The Type of the body of the Views return value or row.</typeparam>
/// <param name="query">An <see cref="IViewQuery" /> to be executed.</param>
/// <returns>
/// The result of the View request as an <see cref="Task{IViewResult}" /> to be awaited on where T is the Type of each row.
/// </returns>
/// <exception cref="ServiceNotSupportedException">The cluster does not support View services.</exception>
public override async Task <IViewResult <T> > SendWithRetryAsync <T>(IViewQueryable query)
{
IViewResult <T> viewResult;
try
{
EnsureNotEphemeral(ConfigInfo.BucketConfig.BucketType);
EnsureServiceAvailable(ConfigInfo.IsViewCapable, "View");
viewResult = await RetryRequestAsync(
ConfigInfo.GetViewNode,
(server, request, token) =>
{
request.RetryAttempts++;
return(server.SendAsync <T>(request));
},
(request, result) => !(result.Success || !result.ShouldRetry() || request.RetryAttempts >= ConfigInfo.ClientConfig.MaxViewRetries),
query,
CancellationToken.None,
ConfigInfo.ClientConfig.ViewRequestTimeout
).ContinueOnAnyContext();
}
catch (Exception e)
{
Log.Info(e);
const string message = "View request failed, check Error and Exception fields for details.";
viewResult = new ViewResult <T>
{
Message = message,
Error = e.Message,
StatusCode = HttpStatusCode.BadRequest,
Success = false,
Exception = e
};
}
return(viewResult);
}
/// <inheritdoc />
public async Task <IViewResult <TKey, TValue> > ExecuteAsync <TKey, TValue>(IViewQueryable query)
{
var uri = query.RawUri();
ViewResultBase <TKey, TValue> viewResult;
var body = query.CreateRequestBody();
try
{
Log.LogDebug("Sending view request to: {0}", uri.ToString());
var content = new StringContent(body, Encoding.UTF8, MediaType.Json);
var response = await HttpClient.PostAsync(uri, content).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
if (_serializer is IStreamingTypeDeserializer streamingTypeDeserializer)
{
viewResult = new StreamingViewResult <TKey, TValue>(
response.StatusCode,
Success,
await response.Content.ReadAsStreamAsync().ConfigureAwait(false),
streamingTypeDeserializer
);
}
else
{
viewResult = new BlockViewResult <TKey, TValue>(
response.StatusCode,
Success,
await response.Content.ReadAsStreamAsync().ConfigureAwait(false),
_serializer
);
}
await viewResult.InitializeAsync().ConfigureAwait(false);
}
else
{
if (_serializer is IStreamingTypeDeserializer streamingTypeDeserializer)
{
viewResult = new StreamingViewResult <TKey, TValue>(
response.StatusCode,
await response.Content.ReadAsStringAsync().ConfigureAwait(false),
streamingTypeDeserializer
);
}
else
{
viewResult = new BlockViewResult <TKey, TValue>(
response.StatusCode,
await response.Content.ReadAsStringAsync().ConfigureAwait(false),
_serializer
);
}
await viewResult.InitializeAsync().ConfigureAwait(false);
if (viewResult.ShouldRetry())
{
UpdateLastActivity();
return(viewResult);
}
if (viewResult.ViewNotFound())
{
throw new ViewNotFoundException(uri.ToString());
}
}
}
catch (OperationCanceledException e)
{
Log.LogDebug(LoggingEvents.ViewEvent, e, "View request timeout.");
throw new AmbiguousTimeoutException("The view query was timed out via the Token.", e);
}
catch (HttpRequestException e)
{
Log.LogDebug(LoggingEvents.QueryEvent, e, "View request cancelled.");
throw new RequestCanceledException("The view query was canceled.", e);
}
UpdateLastActivity();
return(viewResult);
}
/// <summary>
/// Executes a <see cref="IViewQuery"/> asynchronously against a View.
/// </summary>
/// <typeparam name="T">The Type parameter of the result returned by the query.</typeparam>
/// <param name="query">The <see cref="IViewQuery"/> to execute on.</param>
/// <returns>A <see cref="Task{T}"/> that can be awaited on for the results.</returns>
public override async Task <IViewResult <T> > ExecuteAsync <T>(IViewQueryable query)
{
var uri = query.RawUri();
var viewResult = new StreamingViewResult <T>();
string body;
using (ClientConfiguration.Tracer.BuildSpan(query, CouchbaseOperationNames.RequestEncoding).Start())
{
body = query.CreateRequestBody();
}
try
{
Log.Debug("Sending view request to: {0}", uri.ToString());
var content = new StringContent(body, Encoding.UTF8, MediaType.Json);
HttpResponseMessage response;
using (ClientConfiguration.Tracer.BuildSpan(query, CouchbaseOperationNames.DispatchToServer).Start())
{
response = await HttpClient.PostAsync(uri, content).ContinueOnAnyContext();
}
if (response.IsSuccessStatusCode)
{
viewResult = new StreamingViewResult <T>(
response.IsSuccessStatusCode,
response.StatusCode,
Success,
await response.Content.ReadAsStreamAsync().ContinueOnAnyContext(),
ClientConfiguration.Tracer.BuildSpan(query, CouchbaseOperationNames.ResponseDecoding).Start()
);
}
else
{
viewResult = new StreamingViewResult <T>
{
Success = false,
StatusCode = response.StatusCode,
Message = response.ReasonPhrase
};
}
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e =>
{
ProcessError(e, viewResult);
Log.Error(uri.ToString(), e);
return(true);
});
}
catch (TaskCanceledException e)
{
const string error = "The request has timed out.";
ProcessError(e, error, viewResult);
Log.Error(uri.ToString(), e);
}
catch (HttpRequestException e)
{
ProcessError(e, viewResult);
Log.Error(uri.ToString(), e);
}
UpdateLastActivity();
return(viewResult);
}
/// <summary>
/// Executes a <see cref="IViewQuery"/> asynchronously against a View.
/// </summary>
/// <typeparam name="T">The Type parameter of the result returned by the query.</typeparam>
/// <param name="query">The <see cref="IViewQuery"/> to execute on.</param>
/// <returns>A <see cref="Task{T}"/> that can be awaited on for the results.</returns>
public abstract Task <IViewResult <T> > ExecuteAsync <T>(IViewQueryable query);
/// <summary>
/// Executes a <see cref="IViewQuery"/> asynchronously against a View.
/// </summary>
/// <typeparam name="T">The Type parameter of the result returned by the query.</typeparam>
/// <param name="query">The <see cref="IViewQuery"/> to execute on.</param>
/// <returns>A <see cref="Task{T}"/> that can be awaited on for the results.</returns>
public override async Task <IViewResult <T> > ExecuteAsync <T>(IViewQueryable query)
{
var uri = query.RawUri();
var viewResult = new ViewResult <T>();
string body;
using (ClientConfiguration.Tracer.BuildSpan(query, CouchbaseOperationNames.RequestEncoding).Start())
{
body = query.CreateRequestBody();
}
try
{
Log.Debug("Sending view request to: {0}", uri.ToString());
var content = new StringContent(body, Encoding.UTF8, MediaType.Json);
HttpResponseMessage response;
using (ClientConfiguration.Tracer.BuildSpan(query, CouchbaseOperationNames.DispatchToServer).Start())
{
response = await HttpClient.PostAsync(uri, content).ContinueOnAnyContext();
}
if (response.IsSuccessStatusCode)
{
using (ClientConfiguration.Tracer.BuildSpan(query, CouchbaseOperationNames.ResponseDecoding).Start())
using (var stream = await response.Content.ReadAsStreamAsync().ContinueOnAnyContext())
{
viewResult = DataMapper.Map <ViewResultData <T> >(stream).ToViewResult();
viewResult.Success = response.IsSuccessStatusCode;
viewResult.StatusCode = response.StatusCode;
viewResult.Message = Success;
}
}
else
{
viewResult = new ViewResult <T>
{
Success = false,
StatusCode = response.StatusCode,
Message = response.ReasonPhrase
};
}
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e =>
{
ProcessError(e, viewResult);
Log.Error(uri.ToString(), e);
return(true);
});
}
catch (OperationCanceledException e)
{
var operationContext = OperationContext.CreateViewContext(query.BucketName, uri?.Authority);
if (_viewTimeout.HasValue)
{
operationContext.TimeoutMicroseconds = _viewTimeout.Value;
}
ProcessError(e, operationContext.ToString(), viewResult);
Log.Error(uri.ToString(), e);
}
catch (HttpRequestException e)
{
ProcessError(e, viewResult);
Log.Error(uri.ToString(), e);
}
UpdateLastActivity();
return(viewResult);
}
/// <summary>
/// Sends a View request to the server to be executed using async/await
/// </summary>
/// <typeparam name="T">The Type of the body of the Views return value or row.</typeparam>
/// <param name="query">An <see cref="IViewQuery" /> to be executed.</param>
/// <returns>
/// The result of the View request as an <see cref="Task{IViewResult}" /> to be awaited on where T is the Type of each row.
/// </returns>
/// <exception cref="System.NotImplementedException"></exception>
public virtual Task <IViewResult <T> > SendWithRetryAsync <T>(IViewQueryable query)
{
throw new NotImplementedException();
}
public Task <IViewResult <T> > SendAsync <T>(IViewQueryable query)
{
throw new NotImplementedException();
}
internal static ISpanBuilder BuildSpan(this ITracer tracer, IViewQueryable query)
{
const string operationName = "view";
return(tracer.BuildSpan(query, operationName));
}
public IViewResult <T> Send <T>(IViewQueryable query)
{
throw new NotImplementedException();
}
public IViewResult <T> Execute <T>(IViewQueryable query)
{
return(ExecuteAsync <T>(query).ConfigureAwait(false).GetAwaiter().GetResult());
}
public static IObservable <ViewRow <T> > QueryObservable <T>(this IBucket bucket, IViewQueryable query)
{
if (bucket == null)
{
throw new ArgumentNullException("bucket");
}
if (query == null)
{
throw new ArgumentNullException("query");
}
return(new ViewQueryObservable <T>(bucket, query));
}
/// <summary>
/// Executes a <see cref="IViewQuery"/> asynchronously against a View.
/// </summary>
/// <typeparam name="T">The Type parameter of the result returned by the query.</typeparam>
/// <param name="query">The <see cref="IViewQuery"/> to execute on.</param>
/// <returns>A <see cref="Task{T}"/> that can be awaited on for the results.</returns>
public async Task <IViewResult <T> > ExecuteAsync <T>(IViewQueryable query)
{
var uri = query.RawUri();
ViewResult <T> viewResult = null;
string body;
//using (ClientConfiguration.Tracer.BuildSpan(query, CouchbaseOperationNames.RequestEncoding).StartActive())
//{
body = query.CreateRequestBody();
//}
try
{
//Log.Debug("Sending view request to: {0}", uri.ToString());
var content = new StringContent(body, Encoding.UTF8, MediaType.Json);
HttpResponseMessage response;
//using (ClientConfiguration.Tracer.BuildSpan(query, CouchbaseOperationNames.DispatchToServer).StartActive())
//{
response = await HttpClient.PostAsync(uri, content).ConfigureAwait(false);
//}
if (response.IsSuccessStatusCode)
{
viewResult = new ViewResult <T>(
response.StatusCode,
Success,
await response.Content.ReadAsStreamAsync().ConfigureAwait(false)
//ClientConfiguration.Tracer.BuildSpan(query, CouchbaseOperationNames.ResponseDecoding).StartActive().Span
);
}
else
{
viewResult = new ViewResult <T>(response.StatusCode, response.ReasonPhrase);
}
}
catch (AggregateException ae)
{
ae.Flatten().Handle(e =>
{
viewResult = CreateErrorResult <T>(e);
//Log.Error(uri.ToString(), e);
return(true);
});
}
catch (OperationCanceledException e)
{
var operationContext = OperationContext.CreateViewContext(query.BucketName, uri?.Authority);
if (_viewTimeout.HasValue)
{
operationContext.TimeoutMicroseconds = _viewTimeout.Value;
}
viewResult = CreateErrorResult <T>(e, operationContext.ToString());
//Log.Error(uri.ToString(), e);
}
catch (HttpRequestException e)
{
viewResult = CreateErrorResult <T>(e);
//Log.Error(uri.ToString(), e);
}
UpdateLastActivity();
return(viewResult);
}
