/// <summary>
///
/// </summary>
/// <param name="urls"></param>
/// <param name="lookupURL"></param>
/// <param name="token"></param>
/// <param name="apiKey"></param>
/// <param name="backendId"></param>
/// <returns>todo: insert docstring</returns>
/// <exception cref="HfException" >if Could not perform lookup and silentFailure is false</exception>
public async Task <GenericLookupResult> RetrieveURLsWithUserToken(IList <Bo4eUri> urls, Uri lookupURL, string token, string apiKey, BOBackendId backendId)
{
GenericLookupQuery urlObject = new GenericLookupQuery()
{
Uris = urls
};
string requestBody = JsonConvert.SerializeObject(urlObject);
var request = new HttpRequestMessage()
{
Content = new StringContent(requestBody, System.Text.UTF8Encoding.UTF8, MIME_TYPE_JSON),
Method = HttpMethod.Post,
RequestUri = lookupURL
};
var responseMessage = await httpClient.SendAsync(request);
string responseContent = await responseMessage.Content.ReadAsStringAsync();
if (!responseMessage.IsSuccessStatusCode)
{
_logger.LogCritical($"Could not perform lookup: {responseMessage.ReasonPhrase} / {responseContent}; The original request was: {requestBody} POSTed to {lookupURL}");
_logger.LogDebug($"Returning null from lookup helper because of negative response code '{responseMessage.StatusCode}'");
if (_silentFailure)
{
return(null);
}
else
{
throw new HfException(responseMessage);
}
}
GenericLookupResult resultObject = DeserializeObjectAndLog <GenericLookupResult>(responseContent);
return(resultObject);
}
public GenericDictionaryLookup ComputeGenericLookup(MethodDesc contextMethod, ReadyToRunHelperId lookupKind, object targetOfLookup)
{
GenericContextSource contextSource;
if (contextMethod.RequiresInstMethodDescArg())
{
contextSource = GenericContextSource.MethodParameter;
}
else if (contextMethod.RequiresInstMethodTableArg())
{
contextSource = GenericContextSource.TypeParameter;
}
else
{
Debug.Assert(contextMethod.AcquiresInstMethodTableFromThis());
contextSource = GenericContextSource.ThisObject;
}
// Can we do a fixed lookup? Start by checking if we can get to the dictionary.
// Context source having a vtable with fixed slots is a prerequisite.
if (contextSource == GenericContextSource.MethodParameter ||
HasFixedSlotVTable(contextMethod.OwningType))
{
DictionaryLayoutNode dictionaryLayout;
if (contextSource == GenericContextSource.MethodParameter)
{
dictionaryLayout = _nodeFactory.GenericDictionaryLayout(contextMethod);
}
else
{
dictionaryLayout = _nodeFactory.GenericDictionaryLayout(contextMethod.OwningType);
}
// If the dictionary layout has fixed slots, we can compute the lookup now. Otherwise defer to helper.
if (dictionaryLayout.HasFixedSlots)
{
int pointerSize = _nodeFactory.Target.PointerSize;
GenericLookupResult lookup = ReadyToRunGenericHelperNode.GetLookupSignature(_nodeFactory, lookupKind, targetOfLookup);
int dictionarySlot = dictionaryLayout.GetSlotForEntry(lookup);
int dictionaryOffset = dictionarySlot * pointerSize;
if (contextSource == GenericContextSource.MethodParameter)
{
return(GenericDictionaryLookup.CreateFixedLookup(contextSource, dictionaryOffset));
}
else
{
int vtableSlot = VirtualMethodSlotHelper.GetGenericDictionarySlot(_nodeFactory, contextMethod.OwningType);
int vtableOffset = EETypeNode.GetVTableOffset(pointerSize) + vtableSlot * pointerSize;
return(GenericDictionaryLookup.CreateFixedLookup(contextSource, vtableOffset, dictionaryOffset));
}
}
}
// Fixed lookup not possible - use helper.
return(GenericDictionaryLookup.CreateHelperLookup(contextSource));
}
public async Task GetTypeByIdIsSuccessfulAndLogsInformation()
{
GenericLookupResult type = await _pokedexAPILogic.GetTypeById(0);
Assert.AreEqual(0, type.Id);
Assert.AreEqual("Name0", type.Name);
_pokedexRepositoryMock.Verify(prm => prm.GetTypeById(0), Times.Once);
_loggerAPIMock.Verify(lm => lm.LogInformation("Mapping Type Results."), Times.Once);
}
public async Task <IActionResult> GetCategoryById(int id)
{
GenericLookupResult category = await _pokedexAPILogic.GetCategoryById(id);
if (category == null)
{
_logger.LogInformation(Constants.InvalidRequest + " for " + Constants.Category + Constants.WithId + id);
return(BadRequest());
}
return(Ok(category));
}
public async Task <IActionResult> GetPokeballById(int id)
{
GenericLookupResult pokeball = await _pokedexAPILogic.GetPokeballById(id);
if (pokeball == null)
{
_logger.LogInformation(Constants.InvalidRequest + " for " + Constants.Pokeball + Constants.WithId + id);
return(BadRequest());
}
return(Ok(pokeball));
}
public GenericDictionaryLookup ComputeGenericLookup(MethodDesc contextMethod, ReadyToRunHelperId lookupKind, object targetOfLookup)
{
if (targetOfLookup is TypeSystemEntity typeSystemEntity)
{
_nodeFactory.TypeSystemContext.DetectGenericCycles(contextMethod, typeSystemEntity);
}
GenericContextSource contextSource;
if (contextMethod.RequiresInstMethodDescArg())
{
contextSource = GenericContextSource.MethodParameter;
}
else if (contextMethod.RequiresInstMethodTableArg())
{
contextSource = GenericContextSource.TypeParameter;
}
else
{
Debug.Assert(contextMethod.AcquiresInstMethodTableFromThis());
contextSource = GenericContextSource.ThisObject;
}
//
// Some helpers represent logical concepts that might not be something that can be looked up in a dictionary
//
// Downgrade type handle for casting to a normal type handle if possible
if (lookupKind == ReadyToRunHelperId.TypeHandleForCasting)
{
var type = (TypeDesc)targetOfLookup;
if (!type.IsRuntimeDeterminedType ||
(!((RuntimeDeterminedType)type).CanonicalType.IsCanonicalDefinitionType(CanonicalFormKind.Universal) &&
!((RuntimeDeterminedType)type).CanonicalType.IsNullable))
{
if (type.IsNullable)
{
targetOfLookup = type.Instantiation[0];
}
lookupKind = ReadyToRunHelperId.NecessaryTypeHandle;
}
}
// We don't have separate entries for necessary type handles to avoid possible duplication
if (lookupKind == ReadyToRunHelperId.NecessaryTypeHandle)
{
lookupKind = ReadyToRunHelperId.TypeHandle;
}
// Can we do a fixed lookup? Start by checking if we can get to the dictionary.
// Context source having a vtable with fixed slots is a prerequisite.
if (contextSource == GenericContextSource.MethodParameter ||
HasFixedSlotVTable(contextMethod.OwningType))
{
DictionaryLayoutNode dictionaryLayout;
if (contextSource == GenericContextSource.MethodParameter)
{
dictionaryLayout = _nodeFactory.GenericDictionaryLayout(contextMethod);
}
else
{
dictionaryLayout = _nodeFactory.GenericDictionaryLayout(contextMethod.OwningType);
}
// If the dictionary layout has fixed slots, we can compute the lookup now. Otherwise defer to helper.
if (dictionaryLayout.HasFixedSlots)
{
int pointerSize = _nodeFactory.Target.PointerSize;
GenericLookupResult lookup = ReadyToRunGenericHelperNode.GetLookupSignature(_nodeFactory, lookupKind, targetOfLookup);
int dictionarySlot = dictionaryLayout.GetSlotForFixedEntry(lookup);
if (dictionarySlot != -1)
{
int dictionaryOffset = dictionarySlot * pointerSize;
bool indirectLastOffset = lookup.LookupResultReferenceType(_nodeFactory) == GenericLookupResultReferenceType.Indirect;
if (contextSource == GenericContextSource.MethodParameter)
{
return(GenericDictionaryLookup.CreateFixedLookup(contextSource, dictionaryOffset, indirectLastOffset: indirectLastOffset));
}
else
{
int vtableSlot = VirtualMethodSlotHelper.GetGenericDictionarySlot(_nodeFactory, contextMethod.OwningType);
int vtableOffset = EETypeNode.GetVTableOffset(pointerSize) + vtableSlot * pointerSize;
return(GenericDictionaryLookup.CreateFixedLookup(contextSource, vtableOffset, dictionaryOffset, indirectLastOffset: indirectLastOffset));
}
}
}
}
// Fixed lookup not possible - use helper.
return(GenericDictionaryLookup.CreateHelperLookup(contextSource, lookupKind, targetOfLookup));
}
/// <summary>
///
/// </summary>
/// <param name="urls"></param>
/// <param name="lookupURL"></param>
/// <param name="clientCertString"></param>
/// <param name="apiKey"></param>
/// <param name="backendId"></param>
/// <returns></returns>
/// <exception cref="HfException" >if Could not perform lookup and silentFailure is false</exception>
public async Task <GenericLookupResult> RetrieveURLs(IList <Bo4eUri> urls, Uri lookupURL, string clientCertString, string apiKey, BOBackendId backendId, string correlationId = null)
{
if (string.IsNullOrWhiteSpace(clientCertString))
{
_logger.LogWarning($"{nameof(clientCertString)} is initial: '{clientCertString}'");
}
if (lookupURL == null)
{
_logger.LogCritical($"{nameof(lookupURL)} is null!");
}
GenericLookupQuery urlObject = new GenericLookupQuery()
{
Uris = urls
};
string requestBody = JsonConvert.SerializeObject(urlObject, new StringEnumConverter());
var request = new HttpRequestMessage()
{
Content = new StringContent(requestBody, System.Text.UTF8Encoding.UTF8, MIME_TYPE_JSON),
RequestUri = lookupURL,
Method = HttpMethod.Post
};
if (request.Headers.Contains(HeaderNames.Auth.XArrClientCert))
{
_logger.LogDebug($"Removing header '{HeaderNames.Auth.XArrClientCert}'");
request.Headers.Remove(HeaderNames.Auth.XArrClientCert);
}
request.Headers.Add(HeaderNames.Auth.XArrClientCert, clientCertString);
if (request.Headers.Contains(HeaderNames.Azure.SUBSCRIPTION_KEY))
{
_logger.LogDebug($"Removing header '{HeaderNames.Azure.SUBSCRIPTION_KEY}'");
request.Headers.Remove(HeaderNames.Azure.SUBSCRIPTION_KEY);
}
if (!string.IsNullOrEmpty(apiKey))
{
_logger.LogDebug($"Adding {HeaderNames.Azure.SUBSCRIPTION_KEY} header");
request.Headers.Add(HeaderNames.Azure.SUBSCRIPTION_KEY, apiKey);
}
else
{
_logger.LogWarning($"{nameof(apiKey)} is initial: '{apiKey}'");
}
if (request.Headers.Contains(HeaderNames.BACKEND_ID))
{
_logger.LogDebug($"Removing {HeaderNames.BACKEND_ID} header");
request.Headers.Remove(HeaderNames.BACKEND_ID);
}
request.Headers.Add(HeaderNames.BACKEND_ID, backendId.ToString());
if (request.Headers.Contains("x-correlation-id"))
{
_logger.LogDebug($"Removing header 'x-correlation-id'");
request.Headers.Remove("x-correlation-id");
}
if (!string.IsNullOrEmpty(correlationId))
{
_logger.LogDebug($"Adding x-correlation-id header");
request.Headers.Add("x-correlation-id", correlationId);
}
var responseMessage = await httpClient.SendAsync(request);
if (!responseMessage.IsSuccessStatusCode)
{
string responseContentPost = await responseMessage.Content.ReadAsStringAsync();
_logger.LogCritical($"Could not perform lookup: {responseMessage.ReasonPhrase} / {responseContentPost}; The original request was: {requestBody} POSTed to {lookupURL}");
if (_silentFailure)
{
return(null);
}
else
{
throw new HfException(responseMessage);
}
}
string responseContent = await responseMessage.Content.ReadAsStringAsync();
GenericLookupResult resultObject = DeserializeObjectAndLog <GenericLookupResult>(responseContent);
return(resultObject);
}
