public RequestExecution(IRequestHandler parent, IInternalSession session, IRequest request, IRequestObserver requestObserver)
{
_parent = parent;
_session = session;
_request = request;
_host = null;
_requestObserver = requestObserver;
}
public async Task <byte[]> ToBinaryAsync(TimeSpan?timeout = null,
CancellationToken cancellationToken = default,
IRequestObserver observer = null)
{
var resp = await ExecuteAsync(timeout, cancellationToken, observer);
resp.ValidateResponse();
return(resp.Data);
}
public async Task <string> ToTextAsync(TimeSpan?timeout = null,
CancellationToken cancellationToken = default,
IRequestObserver observer = null)
{
var resp = await ExecuteAsync(timeout, cancellationToken, observer);
resp.ValidateResponse();
return(resp.ParseAsText());
}
public WebServer(string host, int port, bool useRealIP = false, IRequestObserver requestObserver = null, ICatchAll catchAll = null)
{
Host = host;
Port = port;
UseRealIP = useRealIP;
RequestObserver = requestObserver;
CatchAll = catchAll;
ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Handlers = new List<Handler>();
}
public async Task <T> ToJsonAsync <T>(TimeSpan?timeout = null,
CancellationToken cancellationToken = default,
IRequestObserver observer = null)
{
var resp = await ExecuteAsync(timeout, cancellationToken, observer);
resp.ValidateResponse();
if (resp.Data is null || resp.Data.Length == 0)
{
throw new NoResponseException();
}
return(resp.ParseAsJson().ToObject <T>(Utils.JsonDeserializer));
}
internal RequestBuilder(IRequestObserver observer, HttpClient client, string path, UriKind kind = UriKind.Relative)
{
Observer = observer;
_client = client;
var uri = new Uri(path, kind);
if (!uri.IsAbsoluteUri)
{
uri = new Uri(client.BaseAddress, uri);
}
_keyValue = HttpUtility.ParseQueryString(uri.Query);
_uri = new Uri(uri.GetLeftPart(UriPartial.Path));
Message = new HttpRequestMessage();
}
private static Task <Response> DoRequestAsync(
HttpMethod method,
string url,
Dictionary <string, string> parameters = null,
Dictionary <string, string> data = null,
JToken json = null,
Dictionary <string, string> headers = null,
string authUser = null,
string authPass = null,
string authBearerToken = null,
TimeSpan?timeout = null,
CancellationToken cancellationToken = default,
IRequestObserver observer = null)
{
var b = Method(method, url);
if (headers != null)
{
b.Header(headers);
}
if (parameters != null)
{
b.Parameter(parameters);
}
if (data != null)
{
b.Form(data);
}
if (json != null)
{
b.Json(json);
}
if (authUser != null)
{
b.AuthBasic(authUser, authPass);
}
if (authBearerToken != null)
{
b.AuthBearer(authBearerToken);
}
return(b.ExecuteAsync(timeout, cancellationToken, observer));
}
/// <summary>
/// Creates a new instance using a request, the statement and the execution profile.
/// </summary>
public RequestHandler(
IInternalSession session, ISerializer serializer, IRequest request, IStatement statement, IRequestOptions requestOptions)
{
_session = session ?? throw new ArgumentNullException(nameof(session));
_requestObserver = session.ObserverFactory.CreateRequestObserver();
_requestResultHandler = new TcsMetricsRequestResultHandler(_requestObserver);
_request = request;
Serializer = serializer ?? throw new ArgumentNullException(nameof(session));
Statement = statement;
RequestOptions = requestOptions ?? throw new ArgumentNullException(nameof(requestOptions));
RetryPolicy = RequestOptions.RetryPolicy;
if (statement?.RetryPolicy != null)
{
RetryPolicy = statement.RetryPolicy.Wrap(RetryPolicy);
}
_queryPlan = RequestHandler.GetQueryPlan(session, statement, RequestOptions.LoadBalancingPolicy).GetEnumerator();
}
public RequestManagerService(IRequestObserver requestObserver, IRequestProcessorResolver requestProcessorResolver)
{
_requestObserver = requestObserver;
_requestProcessorResolver = requestProcessorResolver;
}
public void AddObserver(IRequestObserver observer)
{
this._observer.Add(observer);
}
public IRequestExecution Create(
IRequestHandler parent, IInternalSession session, IRequest request, IRequestObserver requestObserver)
{
return(new RequestExecution(parent, session, request, requestObserver));
}
public static async Task <Response> ExecuteAsync(HttpClientConfig httpClientConfig,
RequestData requestData,
TimeSpan?timeout = null,
CancellationToken cancellationToken = default,
IRequestObserver observer = null)
{
observer = observer ?? Config.DefaultObserver;
timeout = timeout ?? Config.DefaultTimeout;
// Create a request
var request = BuildRequest(requestData);
// Observing
var requestTag = observer.CreateTag();
observer.BeforeSent(requestTag, requestData, request);
// Timeout
var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
if (timeout != Timeout.InfiniteTimeSpan)
{
cts.CancelAfter(timeout.Value);
}
// Perform the request
var stopwatch = Stopwatch.StartNew();
try {
var httpClient = Shared.GetHttpClient(httpClientConfig);
var response = await httpClient.SendAsync(request, cts.Token).ConfigureAwait(false);
observer.OnSent(requestTag, requestData, request, stopwatch.Elapsed);
var respData = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
var resp = new Response(response, respData);
observer.OnReceived(requestTag, requestData, request, stopwatch.Elapsed, resp);
if (requestData.ValidateResponse)
{
resp.ValidateResponse();
}
return(resp);
}
catch (OperationCanceledException) when(!cancellationToken.IsCancellationRequested)
{
observer.OnTimeout(requestTag, requestData, request, stopwatch.Elapsed);
throw new TimeoutException();
}
catch (OperationCanceledException) when(cancellationToken.IsCancellationRequested)
{
observer.OnCancelled(requestTag, requestData, request, stopwatch.Elapsed);
throw new TaskCanceledException();
}
catch (Exception e) {
observer.OnFailed(requestTag, requestData, request, stopwatch.Elapsed, e);
throw;
}
}
public HomeController(IRequestObserver log)
{
_log = log;
}
public TcsMetricsRequestResultHandler(IRequestObserver requestObserver)
{
_requestObserver = requestObserver;
_taskCompletionSource = new TaskCompletionSource <RowSet>();
_requestObserver.OnRequestStart();
}
/// <summary>
/// Создает обработчик запроса
/// </summary>
/// <param name="builder">Строитель запроса</param>
/// <param name="observer">Наблюдатель запроса</param>
/// <param name="task">Задача запроса</param>
public RequestHandler(RequestBuilder builder, IRequestObserver observer, Task <T> task)
{
Builder = builder;
Observer = observer;
Task = task;
}
public Task <Response> ExecuteAsync(TimeSpan?timeout = null,
CancellationToken cancellationToken = default,
IRequestObserver observer = null)
{
return(RequestExecutor.ExecuteAsync(HttpConfig, RequestData, timeout, cancellationToken, observer));
}
public WebClient AddObserver(IRequestObserver observer)
{
this._observer.Add(observer);
return(this);
}
