protected virtual void CreateGatewayTimeoutMap(Error error, GatewayTimeoutException exception)
{
error.Title = Defaults.GatewayTimeoutException.Title;
error.Code = exception.Code;
error.Status = (int)HttpStatusCode.GatewayTimeout;
error.ExtraParameters = exception.Messages.ToDictionary(ms => ms.Key, ms => ms.Value);
}
private void EmptyMessagesCollectionIsNotAddedToMessagesCollection()
{
var ex = new GatewayTimeoutException();
ex.AddMessages(new string[0]);
Assert.Equal(0, ex.Messages.Count);
}
private void MessageIsSet()
{
var ex = new GatewayTimeoutException("gateway timeout");
Assert.Equal("gateway timeout", ex.Message);
Assert.NotNull(ex.Messages);
}
private void NullMessageWithValidKeyIsNotAddedToMessagesCollection()
{
var ex = new GatewayTimeoutException();
ex.AddMessage("aKey", null);
Assert.Empty(ex.Messages);
}
private void NullMessagesCollectionIsNotAddedToMessagesCollection()
{
var ex = new GatewayTimeoutException();
ex.AddMessages(null);
Assert.Empty(ex.Messages);
}
private void NullMessagesCollectionIsNotAddedToMessagesCollection()
{
var ex = new GatewayTimeoutException();
ex.AddMessages(null);
Assert.Equal(0, ex.Messages.Count);
}
private void EmptyMessagesCollectionWithKeyIsNotAddedToMessagesCollection()
{
var ex = new GatewayTimeoutException();
ex.AddMessages("Key1", new string[0]);
Assert.Empty(ex.Messages);
}
private void PropertiesAreDefaulted()
{
var ex = new GatewayTimeoutException();
Assert.Equal(Defaults.GatewayTimeoutException.Title, ex.Message);
Assert.NotNull(ex.Messages);
}
private void NullKeyThrowsArgumentNullException()
{
var ex = new GatewayTimeoutException();
var result = Assert.Throws <ArgumentNullException>(() => ex.AddMessage(null, "aMessage"));
Assert.Equal("key", result.ParamName);
}
private void CodeIsSet()
{
string code = "GTWYTO";
var ex = new GatewayTimeoutException("gateway timeout", code);
Assert.Same(code, ex.Code);
}
private void MessageAndInnerExceptionAreSetInProperties()
{
var innerEx = new Exception("innerMessage");
var ex = new GatewayTimeoutException("gateway timeout", "GTWYTO", innerEx);
Assert.Equal("gateway timeout", ex.Message);
Assert.Same(innerEx, ex.InnerException);
}
internal byte[] Send(IDeviceMessage message)
{
byte[] buffer = message.GetSendBuffer();
bool timedOut = false;
Connect(PrimaryEndpoint, PrimaryPort);
try {
for (int i = 0; i < 2; i++)
{
DateTime requestSent = DateTime.UtcNow;
if (client != null && client.Connected && sslStream.IsAuthenticated)
{
sslStream.Write(buffer, 0, buffer.Length);
sslStream.Flush();
}
byte[] rvalue = GetGatewayResponse();
if (rvalue != null && !ForceGatewayTimeout)
{
return(rvalue);
}
// did not get a response, switch endpoints and try again
timedOut = true;
if (!currentEndpoint.Equals("secondary") && !string.IsNullOrEmpty(SecondaryEndpoint) && i < 1)
{
Disconnect();
Connect(SecondaryEndpoint, SecondaryPort);
}
}
throw new GatewayTimeoutException();
}
catch (GatewayTimeoutException exc) {
exc.GatewayEvents = events;
throw exc;
}
catch (Exception exc) {
if (timedOut)
{
GatewayTimeoutException gatewayException = new GatewayTimeoutException(exc)
{
GatewayEvents = events
};
throw gatewayException;
}
else
{
GatewayException gatewayException = new GatewayException("Failed to connect to primary or secondary processing endpoints.", exc);
throw gatewayException;
}
}
finally {
Disconnect();
// remove the force timeout
if (ForceGatewayTimeout)
{
ForceGatewayTimeout = false;
}
}
}
private void DefaultEmptyKeyAddsToCollection()
{
var ex = new GatewayTimeoutException();
ex.AddMessage(Defaults.ErrorMessage.Key, "aMessage");
Assert.Single(ex.Messages);
Assert.Contains("aMessage", ex.Messages.First().Value);
}
/// <summary>
/// Creates an exception for a failed API request.
/// </summary>
/// <param name="res">The HttpResonseMessage.</param>
/// <returns></returns>
protected async Task CreateExceptionForFailedRequest(HttpResponseMessage res)
{
var responseContent = await res.Content.ReadAsStringAsync().ConfigureAwait(false);
var jsonError = string.IsNullOrEmpty(responseContent) ? null : JObject.Parse(responseContent);
var sys = jsonError?.SelectToken("$.sys").ToObject <SystemProperties>();
var errorDetails = jsonError?.SelectToken("$.details")?.ToObject <ErrorDetails>();
var message = jsonError?.SelectToken("$.message")?.ToString();
var statusCode = (int)res.StatusCode;
if (string.IsNullOrEmpty(message))
{
message = GetGenericErrorMessageForStatusCode(statusCode, sys?.Id);
}
if (errorDetails != null)
{
message += errorDetails.Errors?.ToString();
}
IEnumerable <string> headers = new List <string>();
if (statusCode == 429 && res.Headers.TryGetValues("X-Contentful-RateLimit-Reset", out headers))
{
var rateLimitException = new ContentfulRateLimitException(message)
{
RequestId = jsonError.SelectToken("$.requestId")?.ToString(),
ErrorDetails = errorDetails,
SystemProperties = sys,
SecondsUntilNextRequest = headers.FirstOrDefault() == null ? 0 : int.Parse(headers.FirstOrDefault())
};
throw rateLimitException;
}
if (statusCode == 504)
{
var gatewayTimeoutException = new GatewayTimeoutException()
{
RequestId = jsonError?.SelectToken("$.requestId")?.ToString(),
ErrorDetails = errorDetails,
SystemProperties = sys
};
throw gatewayTimeoutException;
}
var ex = new ContentfulException(statusCode, message)
{
RequestId = jsonError.SelectToken("$.requestId")?.ToString(),
ErrorDetails = errorDetails,
SystemProperties = sys
};
throw ex;
}
private void MessageIsAddedToMessagesCollectionWithDefaultKey()
{
var ex = new GatewayTimeoutException();
ex.AddMessage("aMessage");
Assert.Single(ex.Messages);
Assert.Contains("aMessage", ex.Messages.First().Value);
Assert.Equal(Defaults.ErrorMessage.Key, ex.Messages.First().Key);
}
private void KeyAndMessageAreAddedToMessagesCollection()
{
var ex = new GatewayTimeoutException();
ex.AddMessage("aKey", "aMessage");
Assert.Single(ex.Messages);
Assert.Equal("aKey", ex.Messages.First().Key);
Assert.Contains("aMessage", ex.Messages.First().Value);
}
private void NonDefaultEmptyKeyMessagesCollectionThrowsException()
{
var message1 = "message1";
var message2 = "messages2";
var messages = new string[] { message1, message2 };
var ex = new GatewayTimeoutException();
var result = Assert.Throws <ArgumentNullException>(() => ex.AddMessages(" ", messages));
Assert.Equal("key", result.ParamName);
}
private void MessageAndInnerExceptionAndExtraInfoAreSetInProperties()
{
var messages = new Dictionary <string, IEnumerable <string> >();
var message = new[] { "message1", "message2" };
messages.Add("key1", message);
var innerEx = new Exception("innerMessage");
var ex = new GatewayTimeoutException("gateway timeout", "GTWYTO", innerEx, messages);
Assert.Equal("gateway timeout", ex.Message);
Assert.Same(innerEx, ex.InnerException);
Assert.Same(messages, ex.Messages);
}
private void MessagesAreAddedToMessagesCollection()
{
var message1 = "message1";
var message2 = "messages2";
var messages = new string[] { message1, message2 };
var error = new GatewayTimeoutException();
error.AddMessages(messages);
var message = error.Messages.First();
Assert.Single(error.Messages);
Assert.Contains(message1, message.Value);
Assert.Contains(message2, message.Value);
Assert.Equal(message.Key, Defaults.ErrorMessage.Key);
}
private void MessagesAreAddedToMessagesCollectionUnderDifferentKey()
{
var message1 = "message1";
var message2 = "messages2";
var messages1 = new string[] { message1 };
var messages2 = new string[] { message2 };
var ex = new GatewayTimeoutException();
ex.AddMessages("key1", messages1);
ex.AddMessages("key2", messages2);
Assert.Equal(2, ex.Messages.Count);
Assert.True(ex.Messages.ContainsKey("key1"));
Assert.True(ex.Messages.ContainsKey("key2"));
Assert.Contains(message1, ex.Messages["key1"]);
Assert.Contains(message2, ex.Messages["key2"]);
}
private void MessagesAreAddedToMessagesCollectionUnderSameKey()
{
var message1 = "message1";
var message2 = "messages2";
var messages1 = new string[] { message1 };
var messages2 = new string[] { message2 };
var ex = new GatewayTimeoutException();
ex.AddMessages(messages1);
ex.AddMessages(messages2);
Assert.Single(ex.Messages);
var values = ex.Messages.SelectMany(m => m.Value);
var keys = ex.Messages.Select(m => m.Key);
Assert.Contains(message1, values);
Assert.Contains(message2, values);
Assert.All(keys, k => Assert.Equal(Defaults.ErrorMessage.Key, k));
}
