-
Notifications
You must be signed in to change notification settings - Fork 7
Expand file tree
/
Copy pathProxyManager.cs
More file actions
122 lines (99 loc) · 4.82 KB
/
Copy pathProxyManager.cs
File metadata and controls
122 lines (99 loc) · 4.82 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
using Microsoft.Extensions.Options;
using NetCoreStack.Proxy.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
namespace NetCoreStack.Proxy
{
internal class ProxyManager : IProxyManager
{
private readonly IProxyTypeManager _typeManager;
private readonly IHttpClientAccessor _httpClientAccessor;
private readonly IOptions<ProxyOptions> _options;
private readonly IDefaultHeaderProvider _headerProvider;
private readonly IProxyEndpointManager _endpointManager;
private readonly IProxyContentStreamProvider _streamProvider;
public ProxyManager(IProxyTypeManager typeManager,
IDefaultHeaderProvider headerProvider,
IHttpClientAccessor httpClientAccessor,
IProxyEndpointManager endpointManager,
IProxyContentStreamProvider streamProvider,
IOptions<ProxyOptions> options,
IEnumerable<IProxyRequestFilter> requestFilters)
{
_typeManager = typeManager ?? throw new ArgumentNullException(nameof(typeManager));
_headerProvider = headerProvider ?? throw new ArgumentNullException(nameof(headerProvider));
_httpClientAccessor = httpClientAccessor ?? throw new ArgumentNullException(nameof(httpClientAccessor));
_endpointManager = endpointManager ?? throw new ArgumentNullException(nameof(endpointManager));
_streamProvider = streamProvider ?? throw new ArgumentNullException(nameof(endpointManager));
_options = options ?? throw new ArgumentNullException(nameof(options));
RequestFilters = new List<IProxyRequestFilter>();
if (requestFilters != null && requestFilters.Any())
{
HasFilter = true;
RequestFilters = requestFilters.ToList();
}
}
public HttpClient HttpClient
{
get
{
return _httpClientAccessor.HttpClient;
}
}
public bool HasFilter { get; }
public List<IProxyRequestFilter> RequestFilters { get; }
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;
}
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);
}
public HttpClient GetHttpClient()
{
return _httpClientAccessor.HttpClient;
}
}
}