private async Task <string> InvokeRequest(string service, string method, object data)
{
var id = new Random().Next();
var request = new JRpcRequest {
Id = id,
Method = method.ToLowerInvariant(),
Params = JToken.FromObject(data),
};
var content = await HttpAsyncRequest("POST",
"application/json",
service,
JsonConvert.SerializeObject(request, _jsonSerializerSettings),
_timeout).ConfigureAwait(false);
if (string.IsNullOrWhiteSpace(content))
{
throw new Exception("Не получили ответ от сервиса " + service);
}
var jsonresponse = JsonConvert.DeserializeObject <JRpcResponse>(content, _jsonSerializerSettings);
if (jsonresponse.Error != null)
{
throw jsonresponse.Error;
}
return(JsonConvert.SerializeObject(jsonresponse.Result, _jsonSerializerSettings));
}
private async Task <T> InvokeRequest <T>(JrpcClientCallParams clientCallParams)
{
var id = Guid.NewGuid().ToString();
var request = new JRpcRequest {
Id = id,
Method = clientCallParams.MethodName,
Params = clientCallParams.ParametersStr,
};
var serviceInfos = JrpcRegistredServices.GetAllInfo();
var currentServiceInfo = serviceInfos.FirstOrDefault();
string clientServiceName = currentServiceInfo.Key;
string clientServiceProxyName = currentServiceInfo.Value?.FirstOrDefault();
_logger.Log(new LogEventInfo {
Level = LogLevel.Trace,
LoggerName = _logger.Name,
Message = "Request for {0}.{1} with ID {2} sent.",
Parameters = new object[] { clientCallParams.ServiceName, clientCallParams.MethodName, id },
Properties =
{
{ "service", clientCallParams.ServiceName },
{ "method", clientCallParams.MethodName },
{ "requestId", id },
{ "process", ProcessName },
{ "currentIp", CurrentIp },
{ "proxyTypeName", clientCallParams.ProxyType.FullName },
{ "currentServiceName", clientServiceName },
{ "currentProxyName", clientServiceProxyName }
}
});
var watch = Stopwatch.StartNew();
var jsonresponse = await HttpAsyncRequest <T>(METHOD, "application/json",
GetEndPoint(clientCallParams.ServiceName), request,
_timeout, clientCallParams.Credentials, clientCallParams.ProxyType, clientServiceName, clientServiceProxyName).ConfigureAwait(false);
var elaspedMs = watch.ElapsedMilliseconds;
_logger.Log(new LogEventInfo {
Level = LogLevel.Debug,
LoggerName = _logger.Name,
Message = "Response for {0}.{1} with ID {2} received.",
Parameters = new[] { clientCallParams.ServiceName, clientCallParams.MethodName, jsonresponse.Id },
Properties =
{
{ "service", clientCallParams.ServiceName },
{ "method", clientCallParams.MethodName },
{ "requestId", jsonresponse.Id },
{ "process", ProcessName },
{ "currentIp", CurrentIp },
{ "proxyTypeName", clientCallParams.ProxyType.FullName },
{ "status", jsonresponse.Error != null ? "fail" : "ok" },
{ "source", "client" },
{ "currentServiceName", clientServiceName },
{ "currentProxyName", clientServiceProxyName },
{ "clientRequestTime", elaspedMs }
}
});
if (jsonresponse.Error != null)
{
throw jsonresponse.Error;
}
var result = jsonresponse.Result;
if (result == null)
{
return(default(T));
}
return(result);
}
/// <summary>
/// Аснихронное выполнение jrpc запроса
/// </summary>
/// <param name="method"></param>
/// <param name="contentType"></param>
/// <param name="url"></param>
/// <param name="jRpcRequest"></param>
/// <param name="timeout"></param>
/// <param name="credentials"></param>
/// <param name="proxyType"></param>
/// <param name="clientServiceName"></param>
/// <param name="clientServiceProxyName"></param>
/// <returns></returns>
private async Task <JRpcResponse <T> > HttpAsyncRequest <T>(string method, string contentType, string url,
JRpcRequest jRpcRequest, TimeSpan timeout, IAbstractCredentials credentials, Type proxyType,
string clientServiceName, string clientServiceProxyName)
{
var request = (HttpWebRequest)WebRequest.Create(url);
if (request.ServicePoint.ConnectionLimit < 100)
{
request.ServicePoint.ConnectionLimit = 100;
}
request.Method = method;
request.ContentType = contentType;
request.KeepAlive = true;
request.Timeout = (int)timeout.TotalMilliseconds;
request.ReadWriteTimeout = request.Timeout;
request.AllowAutoRedirect = true;
request.MaximumAutomaticRedirections = 5;
if (credentials != null)
{
request.Headers.Add(HttpRequestHeader.Authorization, credentials.GetHeaderValue());
}
request.Headers.Add(JRpcHeaders.CLIENT_IP_HEADER_NAME, CurrentIp);
request.Headers.Add(JRpcHeaders.CLIENT_PROCESS_NAME_HEADER_NAME, ProcessName);
request.Headers.Add(JRpcHeaders.CLIENT_PROXY_INTERFACE_NAME, proxyType.FullName);
if (!string.IsNullOrEmpty(clientServiceName))
{
request.Headers.Add(JRpcHeaders.CLIENT_SERVICE_NAME, clientServiceName);
}
if (!string.IsNullOrEmpty(clientServiceProxyName))
{
request.Headers.Add(JRpcHeaders.CLIENT_SERVICE_PROXY_NAME, clientServiceProxyName);
}
var serializer = JsonSerializer.Create(_jsonSerializerSettings);
if (jRpcRequest != null)
{
using (var streamWriter =
new JsonTextWriter(new StreamWriter(await request.GetRequestStreamAsync().ConfigureAwait(false)))) {
serializer.Serialize(streamWriter, jRpcRequest);
streamWriter.Flush();
}
}
HttpWebResponse response;
try {
response = (HttpWebResponse)await request.GetResponseAsync()
.WithTimeout(request.Timeout)
.ConfigureAwait(false);
}
catch (WebException ex) {
if (ex.Status == WebExceptionStatus.ProtocolError)
{
response = (HttpWebResponse)ex.Response;
}
else
{
response = null;
}
}
catch (TimeoutException) {
_logger.Error("Timeout occurred during service invocation.");
response = null;
}
var stream = response?.GetResponseStream();
if (stream == null)
{
throw new Exception($"Response from {url} is empty.");
}
using (var sr = new StreamReader(stream)) {
using (var jsonTextReader = new JsonTextReader(sr)) {
return(serializer.Deserialize <JRpcResponse <T> >(jsonTextReader));
}
}
}
