Example #1
0
 public ResponseContext(HttpResponseMessage response,
                        RequestDescriptor requestDescriptor,
                        Type genericReturnType = null)
 {
     Response          = response ?? throw new ArgumentNullException(nameof(response));
     RequestDescriptor = requestDescriptor ?? throw new ArgumentNullException(nameof(requestDescriptor));
 }
Example #2
0
        private object CreateContextProperties(RequestDescriptor descriptor, MethodInfo targetMethod)
        {
            var properties = new
            {
                EnvironmentName = Environment.MachineName,
                Message         = $"Proxy call from Sandbox: {Environment.MachineName} to API method: {targetMethod?.Name}",
                Method          = descriptor?.Request?.Method,
                Authority       = descriptor?.Request?.RequestUri?.Authority,
                LocalPath       = descriptor?.Request?.RequestUri?.LocalPath,
                RequestRegion   = descriptor?.RegionKey
            };

            return(properties);
        }
Example #3
0
        private async Task <ResponseContext> InternalInvokeAsync(MethodInfo targetMethod, object[] args, Type genericReturnType = null)
        {
            var culture = _proxyContext.CultureFactory?.Invoke();

            var descriptor = new RequestDescriptor(targetMethod,
                                                   _proxyContext.ProxyType,
                                                   _proxyContext.ClientIp,
                                                   _proxyContext.UserAgent,
                                                   _proxyContext.Query,
                                                   culture,
                                                   args);

            RequestContext requestContext = await _proxyManager.CreateRequestAsync(descriptor);

            ResponseContext responseContext = null;

            try
            {
                HttpResponseMessage response = null;
                string metadata = string.Empty;

                if (_proxyManager.HasFilter)
                {
                    await Task.WhenAll(_proxyManager.RequestFilters.Select(t => t.InvokeAsync(requestContext)));
                }

                response = await _proxyManager.HttpClient.SendAsync(requestContext.Request);

                responseContext = await ProxyResultExecutor.ExecuteAsync(response,
                                                                         requestContext,
                                                                         genericReturnType);
            }
            catch (Exception ex)
            {
                var properties = CreateContextProperties(requestContext, targetMethod);
                var result     = properties.GetConfigurationContextDetail(properties);
                throw new ProxyException(result, ex);
            }

            if ((int)responseContext.Response.StatusCode == StatusCodes.Status404NotFound)
            {
                var properties = CreateContextProperties(requestContext, targetMethod);
                var result     = properties.GetConfigurationContextDetail(properties);
                throw new ProxyException(result, new HttpRequestException());
            }

            return(responseContext);
        }
Example #4
0
        private async Task <ResponseContext> InternalInvokeAsync(MethodInfo targetMethod, object[] args, Type genericReturnType = null)
        {
            var requestContext = new RequestContext(targetMethod,
                                                    _proxyContext.ProxyType,
                                                    _proxyContext.ClientIp,
                                                    _proxyContext.UserAgent,
                                                    _proxyContext.TokenCookie,
                                                    _proxyContext.QueryString,
                                                    args);

            RequestDescriptor descriptor = await _proxyManager.CreateDescriptorAsync(requestContext);

            ResponseContext responseContext = null;

            try
            {
                HttpResponseMessage response = null;
                var    httpClient            = _proxyManager.HttpClient;
                string metadata = string.Empty;
                response = await httpClient.SendAsync(descriptor.Request);

                responseContext = await ProxyResultExecutor.ExecuteAsync(response,
                                                                         descriptor,
                                                                         genericReturnType);
            }
            catch (Exception ex)
            {
                var properties = CreateContextProperties(descriptor, targetMethod);
                var result     = properties.GetConfigurationContextDetail(properties);
                throw new ProxyException(result, ex);
            }

            if ((int)responseContext.Response.StatusCode == StatusCodes.Status404NotFound)
            {
                var properties = CreateContextProperties(descriptor, targetMethod);
                var result     = properties.GetConfigurationContextDetail(properties);
                throw new ProxyException(result, new HttpRequestException());
            }

            return(responseContext);
        }
        public async Task CreateRequestContentAsync(RequestDescriptor requestContext,
                                                    HttpRequestMessage request,
                                                    ProxyMethodDescriptor descriptor,
                                                    UriBuilder uriBuilder)
        {
            await Task.CompletedTask;

            var httpMethod         = descriptor.HttpMethod;
            var contentModelBinder = ContentBinderFactory.GetContentModelBinder(_serviceProvider, httpMethod, descriptor.ContentType);

            var bindingContext = new ContentModelBindingContext(httpMethod, descriptor, uriBuilder)
            {
                ContentType          = descriptor.ContentType,
                ModelContentResolver = ContentResolver,
                Args = requestContext.Args,
            };

            contentModelBinder.BindContent(bindingContext);
            bindingContext.TrySetContent(request);
            request.RequestUri = bindingContext.Uri;
        }
Example #6
0
        public async Task <RequestContext> CreateRequestAsync(RequestDescriptor requestDescriptor)
        {
            var proxyDescriptor = _typeManager.ProxyDescriptors.FirstOrDefault(x => x.ProxyType == requestDescriptor.ProxyType);

            if (proxyDescriptor == null)
            {
                throw new ArgumentOutOfRangeException("Proxy type could not be found!");
            }

            var regionKey = proxyDescriptor.RegionKey;

            ProxyMethodDescriptor methodDescriptor;

            if (!proxyDescriptor.Methods.TryGetValue(requestDescriptor.TargetMethod, out methodDescriptor))
            {
                throw new ArgumentOutOfRangeException("Method (Action) info could not be found!");
            }

            HttpRequestMessage request = CreateHttpRequest(methodDescriptor, requestDescriptor);

            request.Method = methodDescriptor.HttpMethod;
            var methodPath = requestDescriptor.TargetMethod.Name;

            if (methodDescriptor.MethodMarkerTemplate.HasValue())
            {
                methodPath = methodDescriptor.MethodMarkerTemplate;
            }

            UriBuilder uriBuilder = _endpointManager.CreateUriBuilder(methodDescriptor, proxyDescriptor.Route, regionKey, methodPath);
            TimeSpan?  timeout    = methodDescriptor.Timeout;

            await _streamProvider.CreateRequestContentAsync(requestDescriptor, request, methodDescriptor, uriBuilder);

            return(new RequestContext(request,
                                      methodDescriptor,
                                      proxyDescriptor.RegionKey,
                                      timeout));
        }
Example #7
0
        private HttpRequestMessage CreateHttpRequest(ProxyMethodDescriptor methodDescriptor, RequestDescriptor requestDescriptor)
        {
            HttpRequestMessage requestMessage = new HttpRequestMessage();

            var headers = new Dictionary <string, string>();

            if (!string.IsNullOrEmpty(requestDescriptor.ClientIp))
            {
                headers.Add("X-Forwarded-For", requestDescriptor.ClientIp);
            }

            if (!string.IsNullOrEmpty(requestDescriptor.UserAgent))
            {
                headers.Add("User-Agent", requestDescriptor.UserAgent);
            }

            if (requestDescriptor.Culture != null)
            {
                headers.Add("Accept-Language", requestDescriptor.Culture.Name);
            }

            headers.Merge(_headerProvider.Headers, true);

            headers.Merge(methodDescriptor.Headers, true);

            foreach (KeyValuePair <string, string> entry in headers)
            {
                requestMessage.Headers.Add(entry.Key, entry.Value);
            }

            return(requestMessage);
        }