private void UpdateStickyLocationHint(DeliveryResponse deliveryResponse)
{
var tntId = deliveryResponse?.Id?.TntId;
if (tntId != null &&
deliveryResponse.Status >= (int)HttpStatusCode.OK &&
deliveryResponse.Status < (int)HttpStatusCode.Ambiguous)
{
Interlocked.Exchange(ref this.stickyLocationHint, CookieUtils.LocationHintFromTntId(tntId));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TargetDeliveryResponse"/> class.
/// </summary>
/// <param name="request">Request</param>
/// <param name="response">Response</param>
/// <param name="status">Status</param>
/// <param name="message">Message</param>
/// <param name="locations">Locations</param>
public TargetDeliveryResponse(
TargetDeliveryRequest request,
DeliveryResponse response,
HttpStatusCode status,
string message = "",
Locations locations = default)
{
this.Request = request;
this.Response = response;
this.Status = status;
this.Message = message;
this.Locations = locations;
}
internal static DeliveryResponse ConvertResponseOptions(DeliveryResponse deliveryResponse)
{
var allOptions = new List <List <Option> >
{
deliveryResponse.Execute?.PageLoad?.Options, deliveryResponse.Prefetch?.PageLoad?.Options,
};
allOptions.AddRange(deliveryResponse.Execute?.Mboxes?.Select(response => response.Options) ?? Array.Empty <List <Option> >());
allOptions.AddRange(deliveryResponse.Prefetch?.Mboxes?.Select(response => response.Options) ?? Array.Empty <List <Option> >());
allOptions.AddRange(deliveryResponse.Prefetch?.Views?.Select(response => response.Options) ?? Array.Empty <List <Option> >());
allOptions.ForEach(ConvertOptionsContent);
return(deliveryResponse);
}
public async Task <DeliveryResponse> TestRequest(DeliveryRequest req)
{
DeliveryResponse result = new DeliveryResponse();
if (req == null)
{
return(result);
}
_httpClient.DefaultRequestHeaders.Accept.Clear();
if (req.TestSettings != null)
{
_httpClient.Timeout = TimeSpan.FromMilliseconds(req.TestSettings.TimeOutMs);
}
req.PayloadHeaders.ToList().ForEach(h =>
{
if (h.Header == "Content-Type")
{
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(h.Value));
}
else
{
_httpClient.DefaultRequestHeaders.Add(h.Header, h.Value);
}
});
if (req.Method.Equals("GET"))
{
try
{
var response = await _httpClient.GetAsync(req.Url);
result.IsSuccess = response.IsSuccessStatusCode;
if (response.IsSuccessStatusCode == false)
{
result.StatusText = response.ReasonPhrase;
}
else
{
result.Content = await response.Content.ReadAsStringAsync();
}
result.Status = response.StatusCode;
result.RequestMessage = response.RequestMessage.ToString();
}
catch (Exception ex)
{
result.StatusText = ex.Message;
return(result);
}
}
else if (req.Method.Equals("POST"))
{
if (req.BodyTabSelectedIndex == 0)
{
var hContent = new StringContent(req.PayloadBody);
hContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
try
{
var response = await _httpClient.PostAsync(req.Url, hContent);
result.IsSuccess = response.IsSuccessStatusCode;
if (response.IsSuccessStatusCode == false)
{
result.StatusText = response.ReasonPhrase;
}
else
{
result.Content = await response.Content.ReadAsStringAsync();
}
result.Status = response.StatusCode;
result.RequestMessage = response.RequestMessage.ToString();
}
catch (Exception ex)
{
result.StatusText = ex.Message;
return(result);
}
}
else if (req.BodyTabSelectedIndex == 1)
{
var form = new MultipartFormDataContent();
Dictionary <string, string> parameters = new Dictionary <string, string>();
req.FormContent.ToList().ForEach(s =>
{
parameters.Add(s.Key, s.Value);
});
HttpContent FormItems = new FormUrlEncodedContent(parameters);
form.Add(FormItems);
try
{
var response = await _httpClient.PostAsync(req.Url, form);
result.IsSuccess = response.IsSuccessStatusCode;
if (response.IsSuccessStatusCode == false)
{
result.StatusText = response.ReasonPhrase;
}
else
{
result.Content = await response.Content.ReadAsStringAsync();
}
result.Status = response.StatusCode;
result.RequestMessage = response.RequestMessage.ToString();
}
catch (Exception ex)
{
result.StatusText = ex.Message;
return(result);
}
}
}
else if (req.Method.Equals("UPDATE"))
{
var hContent = new StringContent(req.PayloadBody);
hContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
try
{
var response = await _httpClient.PutAsync(req.Url, hContent);
result.IsSuccess = response.IsSuccessStatusCode;
if (response.IsSuccessStatusCode == false)
{
result.StatusText = response.ReasonPhrase;
}
else
{
result.Content = await response.Content.ReadAsStringAsync();
}
result.Status = response.StatusCode;
result.RequestMessage = response.RequestMessage.ToString();
}
catch (Exception ex)
{
result.StatusText = ex.Message;
return(result);
}
}
else if (req.Method.Equals("DELETE"))
{
try
{
var response = await _httpClient.DeleteAsync(req.Url);
result.IsSuccess = response.IsSuccessStatusCode;
if (response.IsSuccessStatusCode == false)
{
result.StatusText = response.ReasonPhrase;
}
else
{
result.Content = await response.Content.ReadAsStringAsync();
}
result.Status = response.StatusCode;
result.RequestMessage = response.RequestMessage.ToString();
}
catch (Exception ex)
{
result.StatusText = ex.Message;
return(result);
}
}
else
{
result.Content = "Method Incorrect";
}
return(result);
}
internal static void LogResponse(this ILogger logger, DeliveryResponse response)
{
logger?.LogDebug(Messages.LogTargetServiceResponse, response.ToJson());
}
private async Task <DeliveryResponse> DeliverAsync(PushTaskInfo taskInfo, DateTime now)
{
DeliveryRequest deliveryRequest = null;
DeliveryResponse deliveryResponse = new DeliveryResponse(RequestOutcome.UNKNOWN);
Exception exception = null;
try
{
deliveryRequest = new DeliveryRequest(taskInfo.OutputMessage, now + PostExpirationTimeSpan);
MessageDispatcherEventSource.Current.Info(taskInfo.OutputMessage.MessageInfo.TrackingId, this, nameof(this.DeliverAsync), OperationStates.Starting, $"msgId={taskInfo.OutputMessage.MessageInfo.MessageId}, batchId={taskInfo.OutputMessage.Id}, delivered={taskInfo.OutputMessage.Delivered}, requestExpiration={taskInfo.OutputMessage.RequestExpiration}");
var pushConnector = PushConnector.Create(taskInfo.OutputMessage.ConnectorCredential);
deliveryResponse = await pushConnector.DeliverAsync(deliveryRequest, this.CancelToken).ConfigureAwait(false);
}
catch (SocketException ex)
{
exception = ex;
deliveryResponse.DeliveryOutcome = RequestOutcome.FAILED_OPERATOR;
deliveryResponse.DeliveryDetail = ex.Message;
}
catch (OperationCanceledException ex)
{
exception = ex;
deliveryResponse.DeliveryOutcome = RequestOutcome.CANCELLED;
deliveryResponse.DeliveryDetail = ex.Message;
}
catch (Exception ex)
{
exception = ex;
deliveryResponse.DeliveryOutcome = RequestOutcome.FAILED_UNKNOWN;
deliveryResponse.DeliveryDetail = ex.Message;
}
if (deliveryResponse.DeliveryOutcome == RequestOutcome.SUCCESS)
{
deliveryRequest.Succeed();
MessageDispatcherEventSource.Current.Info(taskInfo.OutputMessage.MessageInfo.TrackingId, this, nameof(this.DeliverAsync), OperationStates.Succeeded, $"msgId={taskInfo.OutputMessage.MessageInfo.MessageId}, batchId={taskInfo.OutputMessage.Id}, E2ELantency={DateTime.UtcNow - taskInfo.OutputMessage.MessageInfo.SendTime}, PushLatency={DateTime.UtcNow - deliveryRequest.DeliverRequestTimestamp}, delivered={taskInfo.OutputMessage.Delivered}, requestExpiration={taskInfo.OutputMessage.RequestExpiration}, deliveryResponse={deliveryResponse}");
}
else
{
if (deliveryRequest != null)
{
deliveryRequest.Failed();
if (deliveryResponse.DeliveryOutcome == RequestOutcome.FAILED_UNAUTHORIZED)
{
// Need to refilter if authentication failed
taskInfo.OutputMessage.State = OutputMessageState.Nonfiltered;
}
else
{
taskInfo.OutputMessage.State = OutputMessageState.FilteredFailingDelivery;
}
MessageDispatcherEventSource.Current.Error(taskInfo.OutputMessage.MessageInfo.TrackingId, this, nameof(this.DeliverAsync), OperationStates.Failed, $"msgId={taskInfo.OutputMessage.MessageInfo.MessageId}, batchId={taskInfo.OutputMessage.Id}, outcome={deliveryResponse.DeliveryOutcome}, latency={DateTime.UtcNow - deliveryRequest.DeliverRequestTimestamp}, delivered={taskInfo.OutputMessage.Delivered}, requestExpiration={taskInfo.OutputMessage.RequestExpiration}, deliveryResponse={deliveryResponse}, exception={exception}");
}
else
{
MessageDispatcherEventSource.Current.Error(taskInfo.OutputMessage.MessageInfo.TrackingId, this, nameof(this.DeliverAsync), OperationStates.Failed, $"msgId={taskInfo.OutputMessage.MessageInfo.MessageId}, batchId={taskInfo.OutputMessage.Id}, outcome={deliveryResponse.DeliveryOutcome}, timestamp={DateTime.UtcNow}, delivered={taskInfo.OutputMessage.Delivered}, requestExpiration={taskInfo.OutputMessage.RequestExpiration}, deliveryResponse={deliveryResponse}, exception={exception}");
}
}
return(deliveryResponse);
}
private async Task StartDeliveryTask(PushTaskInfo taskInfo)
{
var operation = nameof(this.StartDeliveryTask);
try
{
var response = new DeliveryResponse(RequestOutcome.UNKNOWN);
var outputMessage = taskInfo.OutputMessage;
var now = DateTime.UtcNow;
var expiration = outputMessage.MessageInfo.SendTime + this.setting.PartitionSetting.ServiceConfigureSetting.EventTimeToLive;
var expired = expiration < now;
if (expired)
{
MessageDispatcherEventSource.Current.Info(taskInfo.OutputMessage.MessageInfo.TrackingId, this, operation + ".Deliver", OperationStates.Dropped, $"msgId={outputMessage.MessageInfo.MessageId}, batchId={outputMessage.Id}, state={outputMessage.State}, deliveryCount={outputMessage.DeliveryCount}, delivered={outputMessage.Delivered}, requestExpiration={outputMessage.RequestExpiration}, SendTime={outputMessage.MessageInfo.SendTime}, expired={expired}, expiration={expiration}, timeLived={now - outputMessage.MessageInfo.SendTime}");
return;
}
if (outputMessage.State == OutputMessageState.Filtered || outputMessage.State == OutputMessageState.FilteredFailingDelivery)
{
if (outputMessage.RequestExpiration > now)
{
response.DeliveryOutcome = RequestOutcome.DELIVERING;
}
else
{
var deliverTask = this.DeliverAsync(taskInfo, now);
if (await Task.WhenAny(deliverTask, Task.Delay(PostTimeout)) == deliverTask)
{
response = deliverTask.Result;
}
else
{
response.DeliveryOutcome = RequestOutcome.TIMEOUT;
MessageDispatcherEventSource.Current.Warning(taskInfo.OutputMessage.MessageInfo.TrackingId, this, operation + ".Deliver", OperationStates.TimedOut, $"msgId={outputMessage.MessageInfo.MessageId}, batchId={outputMessage.Id}, outcome={response.DeliveryOutcome}, delivered={outputMessage.Delivered}");
}
}
}
if (response.DeliveryOutcome != RequestOutcome.FAILED_UNKNOWN)
{
this.resultReporter.ReporAndForgetAsync(outputMessage.ReportingServiceUri, new List <OutputResult> {
new OutputResult(outputMessage, response)
}.AsReadOnly());
}
// Only retry for unknown failure
else
{
if (outputMessage.DeliveryCount < this.setting.PartitionSetting.MaximumDeliveryCount)
{
outputMessage.DeliveryCount++;
}
else
{
MessageDispatcherEventSource.Current.Info(taskInfo.OutputMessage.MessageInfo.TrackingId, this, operation + ".Postpone", OperationStates.Dropped, $"msgId={outputMessage.MessageInfo.MessageId}, batchId={outputMessage.Id}, state={outputMessage.State}, deliveryCount={outputMessage.DeliveryCount}, outcome={response.DeliveryOutcome}, delivered={outputMessage.Delivered}, requestExpiration={outputMessage.RequestExpiration}, SendTime={outputMessage.MessageInfo.SendTime}, expired={expired}, expiration={expiration}, timeLived={now - outputMessage.MessageInfo.SendTime}");
this.resultReporter.ReporAndForgetAsync(outputMessage.ReportingServiceUri, new List <OutputResult> {
new OutputResult(outputMessage, response)
}.AsReadOnly());
return;
}
outputMessage.DeliveryTime = DateTime.UtcNow.Add(this.outputMessageQueue.Setting.RetryDelay);
TaskHelper.FireAndForget(() => this.messageDispatcher.PostponedAsync(new List <PushTaskInfo> {
taskInfo
}), ex => UnhandledException(ex, nameof(this.StartDeliveryTask)));
}
}
catch (Exception ex)
{
MessageDispatcherEventSource.Current.Warning(taskInfo.OutputMessage.MessageInfo.TrackingId, this, operation, OperationStates.Failed, ex.ToString());
taskInfo.Tcs.TrySetException(ex);
}
finally
{
taskInfo.Tcs.TrySetResult(true);
}
}
private TargetDeliveryResponse GetTargetDeliveryResponse(TargetDeliveryRequest request, DeliveryResponse response)
{
this.UpdateStickyLocationHint(response);
this.logger.LogResponse(response);
return(new TargetDeliveryResponse(request, response, (HttpStatusCode)response.Status));
}
private TargetDeliveryResponse GetTargetDeliveryResponse(TargetDeliveryRequest request, DeliveryResponse response)
{
if (response == null)
{
return(new TargetDeliveryResponse(request, null, HttpStatusCode.ServiceUnavailable));
}
this.UpdateStickyLocationHint(response);
this.logger.LogResponse(response);
return(new TargetDeliveryResponse(request, ConvertResponseOptions(response), (HttpStatusCode)response.Status));
}
public async void PublishDeliveryResponse(DeliveryResponse deliveryResponse)
{
await _bus.PublishAsync(deliveryResponse);
}
