void CacheData(RestRequestWithCache request, IRestClient restClient, object data)
{
if (data != null)
{
cache.Set(CacheKey(restClient, request, data.GetType()), data, new CacheItemPolicy());
}
}
public IEnumerable <StoredMessage> GetConversationById(string conversationId)
{
var request = new RestRequestWithCache(String.Format(ConversationEndpoint, conversationId), RestRequestWithCache.CacheStyle.IfNotModified);
var messages = GetModel <List <StoredMessage> >(request) ?? new List <StoredMessage>();
return(messages);
}
public async Task <IEnumerable <StoredMessage> > GetConversationById(string conversationId)
{
var request = new RestRequestWithCache(string.Format(ConversationEndpoint, conversationId), RestRequestWithCache.CacheStyle.IfNotModified);
var messages = await GetModel <List <StoredMessage> >(request).ConfigureAwait(false) ?? new List <StoredMessage>();
return(messages);
}
public void RetryMessage(string messageId)
{
var url = string.Format(RetryEndpoint, messageId);
var request = new RestRequestWithCache(url, Method.POST);
Execute(request, _ => true);
}
public IEnumerable <Endpoint> GetEndpoints()
{
var request = new RestRequestWithCache(EndpointsEndpoint, RestRequestWithCache.CacheStyle.IfNotModified);
var messages = GetModel <List <Endpoint> >(request);
return(messages ?? new List <Endpoint>());
}
public async Task LoadBody(StoredMessage message)
{
var request = new RestRequestWithCache(message.BodyUrl, RestRequestWithCache.CacheStyle.Immutable);
var baseUrl = message.BodyUrl;
if (!baseUrl.StartsWith("http"))
{
baseUrl = null; // We use the default
}
message.Body = await Execute(request, response =>
{
var presentationBody = new PresentationBody();
switch (response.StatusCode)
{
case HttpStatusCode.OK:
presentationBody.Text = response.Content;
break;
case HttpStatusCode.NoContent:
presentationBody.Hint = PresentationHint.NoContent;
presentationBody.Text = "Body was too large and not stored. Edit ServiceControl/MaxBodySizeToStore to be larger in the ServiceControl configuration.";
break;
}
return(presentationBody);
}, baseUrl).ConfigureAwait(false);
}
public async Task <string> GetVersion()
{
var request = new RestRequestWithCache(RestRequestWithCache.CacheStyle.Immutable);
var header = await Execute(request, restResponse => restResponse.Headers.SingleOrDefault(x => x.Name == ServiceControlHeaders.ParticularVersion)).ConfigureAwait(false);
return(header == null ? null : header.Value.ToString());
}
Task <PagedResult <T> > GetPagedResult <T>(RestRequestWithCache request, string url = null) where T : class, new()
{
var result = Execute <PagedResult <T>, List <T> >(request, response =>
{
string first = null, prev = null, next = null, last = null;
var links = (string)response.Headers.FirstOrDefault(header => header.Name == ServiceControlHeaders.Link)?.Value;
if (links != null)
{
var linksByRel = linkExpression.Matches(links)
.Cast <Match>()
.ToDictionary(match => match.Groups[2].Value, match => match.Groups[1].Value);
linksByRel.TryGetValue("first", out first);
linksByRel.TryGetValue("prev", out prev);
linksByRel.TryGetValue("next", out next);
linksByRel.TryGetValue("last", out last);
}
var requestQueryParameters = HttpUtility.ParseQueryString(url ?? request.Resource);
var pageSize = DefaultPageSize;
var perPage = requestQueryParameters["per_page"];
if (perPage != null)
{
pageSize = int.Parse(perPage);
}
var pageSizeText = (string)response.Headers.FirstOrDefault(header => header.Name == ServiceControlHeaders.PageSize)?.Value;
if (pageSizeText != null)
{
pageSize = int.Parse(pageSizeText);
}
var currentPage = 1;
var page = requestQueryParameters["page"];
if (page != null)
{
currentPage = int.Parse(page);
}
return(new PagedResult <T>
{
CurrentPage = currentPage,
Result = response.Data,
NextLink = next,
PrevLink = prev,
LastLink = last,
FirstLink = first,
TotalCount = int.Parse(response.Headers.First(x => x.Name == ServiceControlHeaders.TotalCount).Value.ToString()),
PageSize = pageSize
});
},
url);
return(result);
}
PagedResult <T> GetPagedResult <T>(RestRequestWithCache request) where T : class, new()
{
var result = Execute <PagedResult <T>, List <T> >(request, response => new PagedResult <T>
{
Result = response.Data,
TotalCount = int.Parse(response.Headers.First(x => x.Name == ServiceControlHeaders.TotalCount).Value.ToString())
});
return(result);
}
public Task RetryMessage(string messageId, string instanceId)
{
var url = instanceId != null?
string.Format(RetryEndpoint + "?instance_id={1}", messageId, instanceId) :
string.Format(RetryEndpoint, messageId);
var request = new RestRequestWithCache(url, Method.POST);
return(Execute(request, _ => true));
}
public Task <PagedResult <StoredMessage> > GetAuditMessages(string link)
{
if (IsAbsoluteUrl(link))
{
var request = new RestRequestWithCache("", RestRequestWithCache.CacheStyle.IfNotModified);
return(GetPagedResult <StoredMessage>(request, link));
}
else
{
var request = new RestRequestWithCache(link, RestRequestWithCache.CacheStyle.IfNotModified);
return(GetPagedResult <StoredMessage>(request));
}
}
public async Task <IEnumerable <KeyValuePair <string, string> > > GetMessageData(SagaMessage message)
{
var request = new RestRequestWithCache(string.Format(MessageBodyEndpoint, message.MessageId), message.Status == MessageStatus.Successful ? RestRequestWithCache.CacheStyle.Immutable : RestRequestWithCache.CacheStyle.IfNotModified);
var body = await Execute(request, response => response.Content).ConfigureAwait(false);
if (body == null)
{
return(Enumerable.Empty <KeyValuePair <string, string> >());
}
return(body.StartsWith("<?xml") ? GetXmlData(body) : JsonPropertiesHelper.ProcessValues(body));
}
void LogRequest(RestRequestWithCache request)
{
var resource = request.Resource != null?request.Resource.TrimStart('/') : string.Empty;
var url = connection.Url != null?connection.Url.TrimEnd('/') : string.Empty;
LogTo.Information("HTTP {Method} {url:l}/{resource:l} ({CacheSyle})", request.Method, url, resource, request.CacheSyle);
foreach (var parameter in request.Parameters)
{
LogTo.Debug("Request Parameter: {Name} : {Value}",
parameter.Name,
parameter.Value);
}
}
public async Task <IEnumerable <Endpoint> > GetEndpoints()
{
var rootUrls = await GetRootUrls().ConfigureAwait(false);
var endpointsUrl = rootUrls?.KnownEndpointsUrl ?? rootUrls?.EndpointsUrl ?? DefaultEndpointsEndpoint;
if (Uri.TryCreate(endpointsUrl, UriKind.Absolute, out var endpointsUri) &&
Uri.TryCreate(connection.Url, UriKind.Absolute, out var connectionUri))
{
endpointsUrl = endpointsUri.PathAndQuery.Replace(connectionUri.PathAndQuery, string.Empty);
}
var request = new RestRequestWithCache(endpointsUrl, RestRequestWithCache.CacheStyle.IfNotModified);
var endpoints = await GetModel <List <Endpoint> >(request).ConfigureAwait(false);
return(endpoints ?? new List <Endpoint>());
}
Task <T> GetModel <T>(RestRequestWithCache request, bool truncateLargeLists = false)
where T : class, new() => Execute <T, T>(request, response => response.Data, truncateLargeLists : truncateLargeLists);
Task <ServiceControlRootUrls> GetRootUrls()
{
var request = new RestRequestWithCache("/", RestRequestWithCache.CacheStyle.Immutable);
return(GetModel <ServiceControlRootUrls>(request));
}
T GetModel <T>(RestRequestWithCache request)
where T : class, new()
{
return(Execute <T, T>(request, response => response.Data));
}
T Execute <T>(RestRequestWithCache request, Func <IRestResponse, T> selector, string baseUrl = null)
{
var cacheStyle = request.CacheSyle;
var restClient = CreateClient(baseUrl);
switch (cacheStyle)
{
case RestRequestWithCache.CacheStyle.None:
break;
case RestRequestWithCache.CacheStyle.Immutable:
var item = cache.Get(CacheKey <T>(restClient, request));
if (item != null)
{
return((T)item);
}
break;
case RestRequestWithCache.CacheStyle.IfNotModified:
var obj = cache.Get(CacheKey <T>(restClient, request));
if (obj != null)
{
var tuple = (Tuple <string, T>)obj;
request.AddHeader("If-None-Match", tuple.Item1);
}
break;
}
LogRequest(request);
var response = restClient.Execute(request);
var data = default(T);
switch (cacheStyle)
{
case RestRequestWithCache.CacheStyle.Immutable:
if (response.StatusCode == HttpStatusCode.OK)
{
data = ProcessResponse(selector, response);
CacheData(request, restClient, data);
}
// https://github.com/Particular/FeatureDevelopment/issues/296
else if (response.StatusCode == HttpStatusCode.NoContent)
{
data = ProcessResponse(selector, response);
CacheData(request, restClient, data);
}
break;
case RestRequestWithCache.CacheStyle.IfNotModified:
switch (response.StatusCode)
{
case HttpStatusCode.OK:
data = ProcessResponse(selector, response);
var etag = response.Headers.FirstOrDefault(h => h.Name == "ETag");
if (etag != null)
{
CacheData(request, restClient, Tuple.Create(etag.Value.ToString(), data));
}
break;
case HttpStatusCode.NotModified:
LogResponse(response);
var obj = cache.Get(CacheKey <T>(restClient, request));
if (obj != null)
{
var tuple = (Tuple <string, T>)obj;
data = tuple.Item2;
}
break;
}
break;
default:
data = ProcessResponse(selector, response);
break;
}
return(data);
}
async Task <T> Execute <T, T2>(RestRequestWithCache request, Func <IRestResponse <T2>, T> selector, string url = null)
where T : class, new()
where T2 : class, new()
{
var cacheStyle = request.CacheSyle;
var restClient = CreateClient(url);
switch (cacheStyle)
{
case RestRequestWithCache.CacheStyle.None:
break;
case RestRequestWithCache.CacheStyle.Immutable:
var item = cache.Get(CacheKey <T>(restClient, request));
if (item != null)
{
return((T)item);
}
break;
case RestRequestWithCache.CacheStyle.IfNotModified:
var obj = cache.Get(CacheKey <T>(restClient, request));
if (obj != null)
{
var tuple = (Tuple <string, T>)obj;
request.AddHeader("If-None-Match", tuple.Item1);
}
break;
}
LogRequest(request);
var response = await restClient.ExecuteTaskAsync <T2>(request).ConfigureAwait(false);
CleanResponse(response);
var data = default(T);
switch (cacheStyle)
{
case RestRequestWithCache.CacheStyle.Immutable:
if (response.StatusCode == HttpStatusCode.OK)
{
data = ProcessResponse(selector, response);
CacheData(request, restClient, data);
}
break;
case RestRequestWithCache.CacheStyle.IfNotModified:
switch (response.StatusCode)
{
case HttpStatusCode.OK:
data = ProcessResponse(selector, response);
var etag = response.Headers.FirstOrDefault(h => h.Name == "ETag");
if (etag != null)
{
CacheData(request, restClient, Tuple.Create(etag.Value.ToString(), data));
}
break;
case HttpStatusCode.NotModified:
LogResponse(response);
var obj = cache.Get(CacheKey <T>(restClient, request));
if (obj != null)
{
var tuple = (Tuple <string, T>)obj;
data = tuple.Item2;
}
break;
}
break;
default:
data = ProcessResponse(selector, response);
break;
}
return(data);
}
Task <T> GetModel <T>(RestRequestWithCache request)
where T : class, new() => Execute <T, T>(request, response => response.Data);