コード例 #1
0
        /// <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);
        }
コード例 #2
0
        /// <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);
        }
コード例 #3
0
        /// <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);
        }
コード例 #4
0
        /// <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);
        }
コード例 #5
0
        /// <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);
        }
コード例 #6
0
        /// <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);
        }
コード例 #7
0
        /// <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);
        }
コード例 #8
0
        /// <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);
        }