public void Log(IRequestContext requestContext, object requestDto)
{
var httpReq = requestContext.Get<IHttpRequest>();
var entry = new RequestLogEntry {
Id = Interlocked.Increment(ref requestId),
DateTime = DateTime.UtcNow,
HttpMethod = httpReq.HttpMethod,
AbsoluteUri = httpReq.AbsoluteUri,
IpAddress = requestContext.IpAddress,
PathInfo = httpReq.PathInfo,
Referer = httpReq.Headers[HttpHeaders.Referer],
Headers = httpReq.Headers.ToDictionary(),
UserAuthId = httpReq.GetItemOrCookie(HttpHeaders.XUserAuthId),
SessionId = httpReq.GetSessionId(),
Items = httpReq.Items,
};
if (HideRequestBodyForRequestDtoTypes != null
&& requestDto != null
&& !HideRequestBodyForRequestDtoTypes.Contains(requestDto.GetType()))
{
entry.RequestDto = requestDto;
entry.FormData = httpReq.FormData.ToDictionary();
}
logEntries.Enqueue(entry);
RequestLogEntry dummy;
if (logEntries.Count > capacity)
logEntries.TryDequeue(out dummy);
}
/// <summary>
/// Initializes a new instance of the <see cref="TextCursor" /> class.
/// </summary>
/// <param name="inputText">The input text.</param>
/// <param name="context">The context.</param>
/// <exception cref="System.ArgumentNullException">inputText</exception>
public TextCursor(string inputText, IRequestContext context)
{
if (inputText == null) throw new ArgumentNullException(nameof(inputText));
_tokens = inputText.Split(TOKEN_SEPARATOR);
Context = context;
Reset();
}
public override ScopeMatchResult Matches(IRequestContext requestContext, INotification notification)
{
var res = new ScopeMatchResult();
res.Add(requestContext.CollectionName);
res.Success = this.CollectionNames.Any(c => requestContext.CollectionName.SameAs(c));
return res;
}
public Task<IUser> GetUser(IRequestContext context)
{
if (context.Session == null) return null;
object result;
return Task.FromResult<IUser>
(context.Session.Items.TryGetValue(SessionKey, out result) ? result as IUser : null);
}
private async Task GetTradesStream(IRequestContext context, IMessage message)
{
Log.Debug("Received GetTradesStream from {username}", context.UserSession.Username ?? "<UNKNOWN USER>");
var replyTo = message.ReplyTo;
var endPoint = await _broker.GetPrivateEndPoint<TradesDto>(replyTo);
_subscription = _service.GetTradesStream()
.Select(x =>
{
if (x.IsStateOfTheWorld && x.Trades.Count > MaxSotwTrades)
{
return new TradesDto(new List<TradeDto>(x.Trades.Skip(x.Trades.Count - MaxSotwTrades)), true, false);
}
return x;
})
.Do(o =>
{
Log.Debug(
$"Sending trades update to {replyTo}. Count: {o.Trades.Count}. IsStateOfTheWorld: {o.IsStateOfTheWorld}. IsStale: {o.IsStale}");
})
.TakeUntil(endPoint.TerminationSignal)
.Finally(() => Log.Debug("Tidying up subscription from {replyTo}.", replyTo))
.Subscribe(endPoint);
}
protected override async Task SendBodyAsync(IRequestContext context)
{
if (Xslt != null) {
if (Model is XDocument)
await TransformAsync(context, ((XDocument)Model).CreateNavigator());
else if (Model is IXPathNavigable)
await TransformAsync(context, ((IXPathNavigable)Model));
else {
var ser = Serializer ?? new XmlSerializer(Model.GetType());
var doc = new XDocument();
using (var writer = doc.CreateWriter())
ser.Serialize(writer, Model);
await TransformAsync(context, doc.CreateNavigator());
}
}
else {
using (var writer = context.Response.GetStreamWriter()) {
if (Model is XDocument)
((XDocument)Model).Save(writer);
else if (Model is XmlDocument)
((XmlDocument)Model).Save(writer);
else if (Model is IXPathNavigable)
using (var xWriter = new XmlTextWriter(writer))
((IXPathNavigable)Model).CreateNavigator().WriteSubtree(xWriter);
else
(Serializer ?? new XmlSerializer(Model.GetType()))
.Serialize(writer, Model);
}
}
}
/// <summary>
/// Signs the request.
/// </summary>
/// <param name="requestContext">The request context.</param>
private static void SignRequest(IRequestContext requestContext)
{
ImmutableCredentials immutableCredentials = requestContext.ImmutableCredentials;
// credentials would be null in the case of anonymous users getting public resources from S3
if (immutableCredentials == null)
return;
using (requestContext.Metrics.StartEvent(Metric.RequestSigningTime))
{
if (immutableCredentials.UseToken)
{
ClientProtocol protocol = requestContext.Signer.Protocol;
switch (protocol)
{
case ClientProtocol.QueryStringProtocol:
requestContext.Request.Parameters["SecurityToken"] = immutableCredentials.Token;
break;
case ClientProtocol.RestProtocol:
requestContext.Request.Headers[HeaderKeys.XAmzSecurityTokenHeader] = immutableCredentials.Token;
break;
default:
throw new InvalidDataException("Cannot determine protocol");
}
}
requestContext.Signer.Sign(requestContext.Request, requestContext.ClientConfig, requestContext.Metrics,
immutableCredentials.AccessKey, immutableCredentials.SecretKey);
}
}
private Task ActivateCurrencyPair(IRequestContext context, IMessage message)
{
var payload =
JsonConvert.DeserializeObject<ActivateCurrencyPairRequestDto>(Encoding.UTF8.GetString(message.Payload));
return _service.ActivateCurrencyPair(context, payload);
}
/// <summary>
/// Convenience method to confirm that no Exception was caught.
/// </summary>
/// <param name="context">Context under test</param>
///
public void AssertNoFault(IRequestContext context)
{
if (context.HasFault)
{
FaultText(context.Fault);
}
}
public Task<Reminder> AddReminderAsync(string message, string when, IRequestContext context)
{
var reminder = new Reminder(message, when);
_reminders.Add(reminder);
context.Clear();
return Task.FromResult(reminder);
}
public async Task<object> ControllerFound(IRequestContext context, object controller)
{
foreach (var interceptor in _interceptors) {
controller = await interceptor.ControllerFound(context, controller);
}
return controller;
}
public void SerializeToStream(IRequestContext requestContext, object dto, IHttpResponse httpRes)
{
var httpReq = requestContext.Get<IHttpRequest>();
if (AppHost.ViewEngines.Any(x => x.ProcessRequest(httpReq, httpRes, dto))) return;
if (requestContext.ResponseContentType != ContentType.Html
&& httpReq.ResponseContentType != ContentType.JsonReport) return;
// Serialize then escape any potential script tags to avoid XSS when displaying as HTML
var json = JsonDataContractSerializer.Instance.SerializeToString(dto) ?? "null";
json = json.Replace("<", "<").Replace(">", ">");
var url = httpReq.AbsoluteUri
.Replace("format=html", "")
.Replace("format=shtm", "")
.TrimEnd('?', '&');
url += url.Contains("?") ? "&" : "?";
var now = DateTime.UtcNow;
var requestName = httpReq.OperationName ?? dto.GetType().Name;
string html = GetHtmlTemplate()
.Replace("${Dto}", json)
.Replace("${Title}", string.Format(TitleFormat, requestName, now))
.Replace("${MvcIncludes}", MiniProfiler.Profiler.RenderIncludes().ToString())
.Replace("${Header}", string.Format(HtmlTitleFormat, requestName, now))
.Replace("${ServiceUrl}", url);
var utf8Bytes = html.ToUtf8Bytes();
httpRes.OutputStream.Write(utf8Bytes, 0, utf8Bytes.Length);
}
public async Task<object> ControllerResult(IRequestContext context, object controller, object result)
{
foreach (var interceptor in _interceptors) {
result = await interceptor.ControllerResult(context, controller, result);
}
return result;
}
public async Task<object[]> ModelBound(IRequestContext context, object[] model, MethodInfo method)
{
foreach (var interceptor in _interceptors) {
model = await interceptor.ModelBound(context, model, method);
}
return model;
}
public async Task<IResult> NegotiatedResult(IRequestContext context, IResult result)
{
foreach (var interceptor in _interceptors) {
result = await interceptor.NegotiatedResult(context, result);
}
return result;
}
public async Task<Exception> Exception(IRequestContext context, Exception ex, bool handling)
{
foreach (var interceptor in _interceptors) {
ex = await interceptor.Exception(context, ex, handling);
}
return ex;
}
public override void HandleRequest(IRequestContext ctx)
{
bool b = ctx.QueryString["httpstatus"] != null;
var srv = ctx.UrlVariables.ContainsKey("service") ? ctx.UrlVariables["service"] : null;
foreach (var h in ServiceResolver.GetAllInstances<IHealthCheck>())
{
if (string.IsNullOrEmpty(srv) || srv == h.Name)
{
ctx.Output.WriteLine("status.{0}={1}", h.Name, h.IsEverythingOK ? "ok" : "error");
ctx.Output.WriteLine("latency.{0}={1}", h.Name, (int) h.ProcessingLatency.TotalSeconds);
ctx.Output.WriteLine("alert.{0}={1}", h.Name, h.AlertText);
ctx.Output.WriteLine("lastSuccessfulRun.{0}={1}", h.Name, h.FailingSince.ToString("yyyy-MM-ddTHH:mm:ss"));
ctx.Output.WriteLine();
ServiceResolver.ReleaseInstance(h);
if (b && !h.IsEverythingOK)
{
ctx.ResponseStatus = 500;
break;
}
}
}
if (!b)
{
ctx.Output.WriteLine("#add ?httpstatus=1 parameter to get http 500 on error");
}
}
/// <summary>
/// This is the one where all the magic happens.
/// </summary>
/// <returns>The outcome of the policy Execution as per ISubscriber's contract</returns>
/// <param name="requestContext">TFS Request Context</param>
/// <param name="notification">The <paramref name="notification"/> containing the WorkItemChangedEvent</param>
public ProcessingResult ProcessEvent(IRequestContext requestContext, INotification notification)
{
var result = new ProcessingResult();
Policy[] policies = this.FilterPolicies(this.settings.Policies, requestContext, notification).ToArray();
if (policies.Any())
{
IWorkItem workItem = this.store.GetWorkItem(notification.WorkItemId);
foreach (var policy in policies)
{
this.logger.ApplyingPolicy(policy.Name);
this.ApplyRules(workItem, policy.Rules);
}
this.SaveChangedWorkItems();
result.StatusCode = 0;
result.StatusMessage = "Success";
}
else
{
result.StatusCode = 1;
result.StatusMessage = "No operation";
}
return result;
}
public async Task<IRequestContext> BeginRequest(IRequestContext context)
{
foreach (var interceptor in _interceptors) {
context = await interceptor.BeginRequest(context);
}
return context;
}
public static void SerializeToStream(IRequestContext context, object response, Stream stream)
{
var drinkCardResponse = response as DrinkCardResponse;
if (drinkCardResponse != null)
{
using (var writer = new StreamWriter(stream))
{
foreach (var drinkCard in drinkCardResponse.Cards)
{
writer.WriteLine("Id: {0}", drinkCard.Id);
writer.WriteLine("Name: {0}", drinkCard.Name);
writer.WriteLine("CardType: {0}", drinkCard.CardType);
writer.WriteLine("Drinks:");
foreach (var drink in drinkCard.Drinks)
{
writer.WriteLine("\t{0}", drink.Name);
}
writer.WriteLine();
}
}
}
}
/// <summary>
/// Check if specified servlet can handle the request (match the URL)
/// </summary>
/// <param name="rqctx"></param>
/// <param name="srvlet"></param>
/// <returns></returns>
private bool CanHandleRequest(IRequestContext rqctx, string servletUrlPattern)
{
Regex re;
if (!_urlPatterns.TryGetValue(servletUrlPattern, out re))
{
lock (_urlPatterns)
{
if (!_urlPatterns.TryGetValue(servletUrlPattern, out re))
{
re = new Regex(servletUrlPattern);
_urlPatterns[servletUrlPattern] = re;
}
}
}
Match m = re.Match(rqctx.DispatchUrl);
if (!m.Success) return false;
Dictionary<string, string> vars = new Dictionary<string, string>();
for (int i = 0; i < m.Groups.Count; i++)
{
string name = re.GroupNameFromNumber(i);
vars[name] = m.Groups[i].Value;
}
rqctx.UrlVariables = vars;
return true;
}
/// <summary>
/// Convenience method to confirm
/// that there are no alerts or fault.
/// </summary>
/// <param name="context">Context under test</param>
///
public void AssertNominal(IRequestContext context)
{
AssertNoFault(context);
bool hasAlerts = context.HasAlerts;
if (hasAlerts)
{
// TODO: Use new TextOnly method here.
StringBuilder outer = new StringBuilder();
IDictionary store = context.Alerts;
ICollection keys = store.Keys;
foreach (string key in keys)
{
StringBuilder inner = new StringBuilder();
inner.Append(key);
inner.Append(": ");
IList messages = store[key] as IList;
foreach (string message in messages)
{
inner.Append(message);
inner.Append(";");
}
outer.Append(inner.ToString());
outer.Append("/n");
}
Assert.Fail(outer.ToString());
}
}
public Task<string> ProcessTextAsync(string text, IRequestContext context, CancellationToken cancellationToken)
{
var words = text.Split(' ');
var correctTextBuilder = new StringBuilder();
foreach (var word in words)
{
decimal number = 0;
string correctedWord = null;
if (!decimal.TryParse(word, out number))
{
if (word.Length > 1)
{
correctedWord = _spellCorrect.Correct(word);
}
}
if (correctedWord != null)
{
correctTextBuilder.AppendFormat("{0} ", correctedWord);
}
else
{
correctTextBuilder.AppendFormat("{0} ", word);
}
}
return Task.FromResult(correctTextBuilder.ToString().Trim());
}
public override void HandleRequest(IRequestContext ctx)
{
string v;
if (!ctx.UrlVariables.TryGetValue(RcParam, out v))
v = ctx.QueryString[RcParam];
if (v == null || v.Length == 0)
v = "index.htm";
ctx.ResponseContentType = MimeTypes.GetMimeTypeForExtension(Path.GetExtension(v));
string pth = Path.GetFullPath(Path.Combine(BaseDirectory, v));
if (Path.GetDirectoryName(pth).Length < BaseDirectory.Length)
{
log.Warn("Trying to get content above the root dir: {0}", pth);
throw new NotFoundException();
}
if (!File.Exists(pth)) throw new NotFoundException();
FileInfo fi = new FileInfo(pth);
ctx.ResponseContentLength = (int) fi.Length;
using (Stream stm = fi.OpenRead())
{
CopyStream(stm, ctx.OutputStream);
}
}
protected virtual void SendHeaders(IRequestContext context)
{
// Location: header should be absolute per RFC 2616 para 14.30. Enforce this.
string location;
if (Headers.TryGetValue("Location", out location)) {
Uri u;
if (!Uri.TryCreate(location, UriKind.Absolute, out u)) {
var parts = location.Split(new char[] { '?' }, 2);
if (parts.Length == 2) {
u = context.Request.GetAbsoluteUrl(new VirtualPath(parts[0]));
Headers["Location"] = u.ToString() + "?" + parts[1];
}
else {
u = context.Request.GetAbsoluteUrl(new VirtualPath(location));
Headers["Location"] = u.ToString();
}
}
}
context.Response.Status = Status;
foreach (var key in Headers.Keys) {
context.Response.AddHeader(key, Headers[key]);
}
if (MimeType != null) {
context.Response.Headers.MimeType = MimeType;
}
if (Encoding != null) {
context.Response.Headers.Encoding = Encoding;
}
}
public WatchController(IWatchService watchService, IImageService imageService, IOrderService orderService, IRequestContext requestContext)
{
_watchService = watchService;
_imageService = imageService;
_orderService = orderService;
_requestContext = requestContext;
}
public bool IsAuthorized(IRequestContext requestContext, IUserProvider userProvider, UserRole userRole)
{
if (userRole == UserRole.None)
{
userRole = UserRole.ReadOnly;
}
string userName = requestContext.UserName,
password = requestContext.Password;
if (userName == null || password == null)
{
return false;
}
var ip = GetIp(true);
/*
if (ip != requestContext.ClientId)
{
return false;
}
* */
HttpContext.Current.Trace.Write("requestContext.ClientId = " + requestContext.ClientId);
HttpContext.Current.Trace.Write("ip = " + ip);
var result = userProvider.Validate(userName, password);
return result != null && result.Result;
}
public override void HandleRequest(IRequestContext ctx)
{
foreach (var s in ServiceResolver.GetAllInstances<IServlet>())
{
ctx.Output.WriteLine("{0} :: {1}", s.MatchUrl, s.GetType().Name);
ServiceResolver.ReleaseInstance(s);
}
}
protected override Task SendBodyAsync(IRequestContext context)
{
using (var textWriter = context.Response.GetStreamWriter()) {
var serializer = new JsonSerializer();
serializer.Serialize(textWriter, Model);
}
return Task.FromResult(0);
}
protected string GetTemplate(IRequestContext context)
{
return template
.Replace("{{code}}", Status.Code.ToString())
.Replace("{{title}}", HttpUtility.HtmlEncode(Status.Description))
.Replace("{{description}}", HttpUtility.HtmlEncode(Status.Message))
.Replace("{{base}}", context.Request.PathBase.ToString());
}
private void WriteContentToRequestBody(TRequestContent requestContent, IHttpRequest <TRequestContent> httpRequest, IRequestContext requestContext)
{
IRequest request = requestContext.Request;
if (request.Content != null && request.Content.Length != 0)
{
byte[] content = request.Content;
requestContext.Metrics.AddProperty(Metric.RequestSize, content.Length);
httpRequest.WriteToRequestBody(requestContent, content, requestContext.Request.Headers);
}
else
{
Stream stream;
if (request.ContentStream == null)
{
stream = new MemoryStream();
stream.Write(request.Content, 0, request.Content.Length);
stream.Position = 0L;
}
else
{
stream = request.ContentStream;
}
EventHandler <StreamTransferProgressArgs> streamUploadProgressCallback = ((IAmazonWebServiceRequest)request.OriginalRequest).StreamUploadProgressCallback;
if (streamUploadProgressCallback != null)
{
stream = httpRequest.SetupProgressListeners(stream, requestContext.ClientConfig.ProgressUpdateInterval, CallbackSender, streamUploadProgressCallback);
}
Stream contentStream = (request.UseChunkEncoding && request.AWS4SignerResult != null) ? new ChunkedUploadWrapperStream(stream, requestContext.ClientConfig.BufferSize, request.AWS4SignerResult) : stream;
httpRequest.WriteToRequestBody(requestContent, contentStream, requestContext.Request.Headers, requestContext);
}
}
public RetrieveRequestHandler(IRequestContext context)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
StateBag = new Dictionary <string, object>();
behaviors = new Lazy <IRetrieveBehavior[]>(() => GetBehaviors().ToArray());
}
/// <summary>
/// Writes a stream to the request body.
/// </summary>
/// <param name="requestContent">The destination where the content stream is written.</param>
/// <param name="contentStream">The content stream to be written.</param>
/// <param name="contentHeaders">HTTP content headers.</param>
/// <param name="requestContext">The request context.</param>
public async Task WriteToRequestBodyAsync(Stream requestContent, Stream contentStream,
IDictionary <string, string> contentHeaders, IRequestContext requestContext)
{
bool gotException = false;
try
{
var buffer = new byte[requestContext.ClientConfig.BufferSize];
int bytesRead = 0;
int bytesToRead = buffer.Length;
while ((bytesRead = await contentStream.ReadAsync(buffer, 0, bytesToRead, requestContext.CancellationToken).ConfigureAwait(false)) > 0)
{
requestContext.CancellationToken.ThrowIfCancellationRequested();
await requestContent.WriteAsync(buffer, 0, bytesRead, requestContext.CancellationToken).ConfigureAwait(false);
}
}
catch
{
gotException = true;
// If an exception occurred while reading the input stream,
// Abort the request to signal failure to the server and prevent
// potentially writing an incomplete stream to the server.
this.Abort();
throw;
}
finally
{
// Only bubble up exception from the close method if we haven't already got an exception
// reading and writing from the streams.
try
{
requestContent.Close();
}
catch
{
if (!gotException)
{
throw;
}
}
}
}
/// <summary>
/// Configures a request as per the request context.
/// </summary>
/// <param name="requestContext">The request context.</param>
public void ConfigureRequest(IRequestContext requestContext)
{
// Advanced configurations (like timeout) are not supported
// in the WWW API.
}
public OrderItemsRepository(IRequestContext context)
: base(context)
{
}
public MyDeleteHandler(IRequestContext context)
: base(context)
{
}
public virtual IActivityScope ValidateDocument(IRequestContext context) => EmptyScope;
public virtual void ValidationErrors(IRequestContext context, IReadOnlyList <IError> errors)
{
}
public virtual void AddedDocumentToCache(IRequestContext context)
{
}
public virtual void RetrievedDocumentFromStorage(IRequestContext context)
{
}
public virtual void AddedOperationToCache(IRequestContext context)
{
}
protected override void EnrichContext(IRequestContext requestContext, HttpRequest request)
{
requestContext.SetValue(request.Headers);
requestContext.SetValue(request.HttpContext.User);
requestContext.SetValue(new QueryCacheContext(true, new TimeSpan(0, 5, 0)));
}
public virtual void RetrievedOperationFromCache(IRequestContext context)
{
}
public MyListHandler(IRequestContext context)
: base(context)
{
}
public virtual void SyntaxError(IRequestContext context, IError error)
{
}
public virtual void RequestError(IRequestContext context, Exception exception)
{
}
public MyRetrieveHandler(IRequestContext context)
: base(context)
{
}
public virtual IActivityScope ExecuteRequest(IRequestContext context) => EmptyScope;
public MySaveHandler(IRequestContext context)
: base(context)
{
}
public static async Task <Document> GetImageDocumentAsync(int?top, string query, IRequestContext context)
{
if (top == null)
{
top = 1;
}
int skip;
skip = context.GetVariable <int>(nameof(skip));
context.SetVariable(nameof(query), query);
var imageQuery = SearchContainer
.Image(query, null, "pt-BR", "Off", null, null, null)
.AddQueryOption($"${nameof(top)}", top)
.AddQueryOption($"${nameof(skip)}", skip);
var result = await Task.Factory.FromAsync(
(c, s) => imageQuery.BeginExecute(c, s), r => imageQuery.EndExecute(r), null);
var imageResults = result.ToList();
if (imageResults.Count == 0)
{
return(new PlainText()
{
Text = $"Nenhuma imagem para o termo '{query}' encontrada."
});
}
Document document;
if (imageResults.Count == 1)
{
document = GetMediaLink(imageResults.First());
}
else
{
document = new DocumentCollection()
{
Total = imageResults.Count,
ItemType = MediaLink.MediaType,
Items = imageResults.Select(GetMediaLink).Cast <Document>().ToArray()
};
}
context.SetVariable(nameof(skip), top + skip);
return(document);
}
public CategoryLangRepository(IRequestContext context)
: base(context)
{
}
public ExecutionContext(IRequestContext requestContext, IResponseContext responseContext)
{
RequestContext = requestContext;
ResponseContext = responseContext;
}
/// <summary>
/// Configures a request as per the request context.
/// </summary>
/// <param name="requestContext">The request context.</param>
public virtual void ConfigureRequest(IRequestContext requestContext)
{
// Set HttpWebRequest specific properties which are
// not exposed in the IHttpRequest interface.
var clientConfig = requestContext.ClientConfig;
var originalRequest = requestContext.OriginalRequest;
// If System.Net.WebRequest.AllowAutoRedirect is set to true (default value),
// redirects for GET requests are automatically followed and redirects for POST
// requests are thrown back as exceptions.
// If System.Net.WebRequest.AllowAutoRedirect is set to false (e.g. S3),
// redirects are returned as responses.
_request.AllowAutoRedirect = clientConfig.AllowAutoRedirect;
// Configure timeouts.
if (requestContext.Request.ContentStream != null)
{
_request.Timeout = int.MaxValue;
_request.ReadWriteTimeout = int.MaxValue;
_request.AllowWriteStreamBuffering = false;
}
// Override the Timeout and ReadWriteTimeout values if set at the request or config level.
// Public Timeout and ReadWriteTimeout properties are present on client config objects.
var timeout = ClientConfig.GetTimeoutValue(clientConfig.Timeout,
originalRequest.TimeoutInternal);
var readWriteTimeout = ClientConfig.GetTimeoutValue(clientConfig.ReadWriteTimeout,
originalRequest.ReadWriteTimeoutInternal);
if (timeout != null)
{
_request.Timeout = (int)timeout.Value.TotalMilliseconds;
}
if (readWriteTimeout != null)
{
_request.ReadWriteTimeout = (int)readWriteTimeout.Value.TotalMilliseconds;
}
// Set proxy related properties
IWebProxy proxy = requestContext.ClientConfig.GetWebProxy();
if (proxy != null)
{
requestContext.Metrics.AddProperty(Metric.ProxyHost, requestContext.ClientConfig.ProxyHost);
requestContext.Metrics.AddProperty(Metric.ProxyPort, requestContext.ClientConfig.ProxyPort);
_request.Proxy = proxy;
}
// Set service point properties.
_request.ServicePoint.ConnectionLimit = clientConfig.ConnectionLimit;
_request.ServicePoint.UseNagleAlgorithm = clientConfig.UseNagleAlgorithm;
_request.ServicePoint.MaxIdleTime = clientConfig.MaxIdleTime;
_request.ServicePoint.Expect100Continue = originalRequest.GetExpect100Continue();
var tcpKeepAlive = clientConfig.TcpKeepAlive;
_request.ServicePoint.SetTcpKeepAlive(tcpKeepAlive.Enabled, (int)tcpKeepAlive.Timeout.Value.TotalMilliseconds,
(int)tcpKeepAlive.Interval.Value.TotalMilliseconds);
}
private static void SetMetrics(IRequestContext requestContext)
{
requestContext.Metrics.AddProperty(Metric.ServiceName, requestContext.Request.ServiceName);
requestContext.Metrics.AddProperty(Metric.ServiceEndpoint, requestContext.Request.Endpoint);
requestContext.Metrics.AddProperty(Metric.MethodName, requestContext.Request.RequestName);
}
// Token: 0x0600012D RID: 301 RVA: 0x00006E8A File Offset: 0x0000508A
public OAuthActAsUserAnchorMailbox(OAuthActAsUser actAsUser, IRequestContext requestContext) : base(AnchorSource.OAuthActAsUser, actAsUser, requestContext)
{
this.actAsUser = actAsUser;
}
public virtual void BatchDispatched(IRequestContext context)
{
}
protected virtual void EncodeBody(IKafkaWriter writer, IRequestContext context)
{
}
internal OwaPLTStreamProxy(StreamProxy.StreamProxyType streamProxyType, Stream source, Stream target, byte[] buffer, IRequestContext requestContext) : base(streamProxyType, source, target, buffer, requestContext)
{
}
// this diagnostic event is raised when a request is executed ...
public override IActivityScope ExecuteRequest(IRequestContext context)
{
// ... we will return an activity scope that is used to signal when the request is
// finished.
return(new RequestScope(_logger, context));
}
public static IRequestContext UseRequestTimeout(this IRequestContext context, TimeSpan time)
{
context.Properties.TryAdd(RequestTimeout, time);
return(context);
}
