/// <summary>
/// Create a CloudException from a failed response.
/// </summary>
/// <param name="request">The HTTP request.</param>
/// <param name="requestContent">The HTTP request content.</param>
/// <param name="response">The HTTP response.</param>
/// <param name="responseContent">The HTTP response content.</param>
/// <param name="innerException">Optional inner exception.</param>
/// <returns>A CloudException representing the failure.</returns>
public static CloudException Create(
HttpRequestMessage request,
string requestContent,
HttpResponseMessage response,
string responseContent,
Exception innerException = null)
{
// Get the error code and message
CloudError cloudError = ParseXmlOrJsonError(responseContent);
string code = cloudError.Code;
string message = cloudError.Message;
// Get the most descriptive message that we can
string exceptionMessage =
(code != null && message != null) ? code + ": " + message :
(message != null) ? message :
(code != null) ? code :
!string.IsNullOrEmpty(responseContent) ? responseContent :
(response != null && response.ReasonPhrase != null) ? response.ReasonPhrase :
(response != null) ? response.StatusCode.ToString() :
new InvalidOperationException().Message;
// Create the exception
CloudException exception = new CloudException(exceptionMessage, innerException);
exception.ErrorCode = code;
exception.ErrorMessage = message;
exception.Request = CloudHttpRequestErrorInfo.Create(request, requestContent);
exception.Response = CloudHttpResponseErrorInfo.Create(response, responseContent);
return(exception);
}
/// <summary>
/// Initializes a new instance of the IndexBatchException class.
/// </summary>
/// <param name="httpRequest">The original HTTP index request.</param>
/// <param name="httpResponse">The original HTTP index response.</param>
/// <param name="indexResponse">The deserialized response from the index request.</param>
public IndexBatchException(
HttpRequestMessage httpRequest,
HttpResponseMessage httpResponse,
DocumentIndexResponse indexResponse) : base(CreateMessage(indexResponse))
{
// Null check in CreateMessage().
_indexResponse = indexResponse;
Error =
new CloudError()
{
Code = String.Empty,
Message = this.Message,
OriginalMessage = this.Message,
ResponseBody = String.Empty
};
Request = CloudHttpRequestErrorInfo.Create(httpRequest);
Response = CloudHttpResponseErrorInfo.Create(httpResponse);
}
public void HandlesExceptionError()
{
var runtime = new MockCommandRuntime();
var request = new HttpRequestMessage(HttpMethod.Get, new Uri("https://www.contoso.com/resource?api-version-1.0"));
request.Headers.Add("x-ms-request-id", "HyakRequestId");
var response = new HttpResponseMessage(HttpStatusCode.BadRequest);
var hyakException = new TestHyakException("exception message", CloudHttpRequestErrorInfo.Create(request), CloudHttpResponseErrorInfo.Create(response))
{
Error = new Hyak.Common.CloudError {
Code = "HyakCode", Message = "HyakError"
}
};
var autorestException = new Microsoft.Rest.Azure.CloudException("exception message")
{
Body = new Microsoft.Rest.Azure.CloudError {
Code = "AutorestCode", Message = "Autorest message"
},
Request = new Microsoft.Rest.HttpRequestMessageWrapper(request, ""),
Response = new Microsoft.Rest.HttpResponseMessageWrapper(response, ""),
RequestId = "AutoRestRequestId"
};
var cmdlet = new ResolveError
{
Error = new[]
{
new ErrorRecord(new Exception("exception message"), "errorCode", ErrorCategory.AuthenticationError, this),
new ErrorRecord(hyakException, "errorCode", ErrorCategory.ConnectionError, this),
new ErrorRecord(autorestException, "errorCode", ErrorCategory.InvalidOperation, this),
},
CommandRuntime = runtime
};
Assert.Throws <NotImplementedException>(() => cmdlet.ExecuteCmdlet());
Assert.NotNull(runtime.OutputPipeline);
Assert.Equal(3, runtime.OutputPipeline.Count);
var errorResult = runtime.OutputPipeline[0] as AzureExceptionRecord;
Assert.NotNull(errorResult);
Assert.Equal(ErrorCategory.AuthenticationError, errorResult.ErrorCategory.Category);
Assert.NotNull(errorResult.Exception);
Assert.Equal(typeof(Exception), errorResult.Exception.GetType());
Assert.Equal("exception message", errorResult.Exception.Message);
var hyakResult = runtime.OutputPipeline[1] as AzureRestExceptionRecord;
Assert.NotNull(hyakResult);
Assert.Equal(ErrorCategory.ConnectionError, hyakResult.ErrorCategory.Category);
Assert.NotNull(errorResult.Exception);
Assert.Equal(typeof(TestHyakException), hyakResult.Exception.GetType());
Assert.Equal("exception message", hyakResult.Exception.Message);
Assert.NotNull(hyakResult.RequestMessage);
Assert.Equal(HttpMethod.Get.ToString(), hyakResult.RequestMessage.Verb);
Assert.Equal(new Uri("https://www.contoso.com/resource?api-version-1.0"), hyakResult.RequestMessage.Uri);
Assert.NotNull(hyakResult.ServerResponse);
Assert.Equal(HttpStatusCode.BadRequest.ToString(), hyakResult.ServerResponse.ResponseStatusCode);
var autorestResult = runtime.OutputPipeline[2] as AzureRestExceptionRecord;
Assert.NotNull(autorestResult);
Assert.Equal(ErrorCategory.InvalidOperation, autorestResult.ErrorCategory.Category);
Assert.NotNull(autorestResult.Exception);
Assert.Equal(typeof(Microsoft.Rest.Azure.CloudException), autorestResult.Exception.GetType());
Assert.Equal("exception message", autorestResult.Exception.Message);
Assert.NotNull(autorestResult.RequestMessage);
Assert.Equal(HttpMethod.Get.ToString(), autorestResult.RequestMessage.Verb);
Assert.Equal(new Uri("https://www.contoso.com/resource?api-version-1.0"), autorestResult.RequestMessage.Uri);
Assert.NotNull(autorestResult.ServerResponse);
Assert.Equal(HttpStatusCode.BadRequest.ToString(), autorestResult.ServerResponse.ResponseStatusCode);
Assert.Equal("AutoRestRequestId", autorestResult.RequestId);
Assert.Contains("AutorestCode", autorestResult.ServerMessage);
Assert.Contains("Autorest message", autorestResult.ServerMessage);
}
/// <summary>
/// Create a CloudException from a failed response sending XML content.
/// </summary>
/// <param name="request">The HTTP request.</param>
/// <param name="requestContent">The HTTP request content.</param>
/// <param name="response">The HTTP response.</param>
/// <param name="responseContent">The HTTP response content.</param>
/// <param name="innerException">Optional inner exception.</param>
/// <returns>A CloudException representing the failure.</returns>
public static new CloudException CreateFromXml(
HttpRequestMessage request,
string requestContent,
HttpResponseMessage response,
string responseContent,
Exception innerException = null)
{
string code = null;
string message = null;
string extendedErrorCode = null;
string errorMessageFormat = null;
List <string> errorMessageArguments = null;
if (responseContent != null)
{
try
{
XElement root = XDocument.Parse(responseContent).Root;
XElement codeElement = root.Element(XName.Get("Code", "http://schemas.microsoft.com/windowsazure"));
if (codeElement != null)
{
code = codeElement.Value;
}
XElement messageElement = root.Element(XName.Get("Message", "http://schemas.microsoft.com/windowsazure"));
if (messageElement != null)
{
message = messageElement.Value;
}
XElement extendedCodeElement = root.Element(XName.Get("ExtendedCode", "http://schemas.microsoft.com/windowsazure"));
if (extendedCodeElement != null)
{
extendedErrorCode = extendedCodeElement.Value;
}
XElement messageTemplateElement = root.Element(XName.Get("MessageTemplate", "http://schemas.microsoft.com/windowsazure"));
if (messageTemplateElement != null)
{
errorMessageFormat = messageTemplateElement.Value;
}
XElement parametersElement = root.Element(XName.Get("Parameters", "http://schemas.microsoft.com/windowsazure"));
if (parametersElement != null)
{
errorMessageArguments =
parametersElement
.Elements(XName.Get("string", "http://schemas.microsoft.com/2003/10/Serialization/Arrays"))
.Select(e => e.Value)
.ToList();
}
}
catch
{
// Ignore any and all failures
}
}
// Get the exception message
string exceptionMessage = null;
if (code != null || message != null || extendedErrorCode != null)
{
StringBuilder text = new StringBuilder();
if (code != null)
{
text.Append(code);
}
if (extendedErrorCode != null)
{
text.AppendFormat(
code != null ? " ({0})" : "{0}",
extendedErrorCode);
}
if (code != null || extendedErrorCode != null && message != null)
{
text.Append(": ");
}
if (message != null)
{
text.Append(message);
}
exceptionMessage = text.ToString();
}
else
{
// Otherwise use the best default that we can come up with
exceptionMessage =
(responseContent != null) ? responseContent :
(response != null && response.ReasonPhrase != null) ? response.ReasonPhrase :
(response != null) ? response.StatusCode.ToString() :
new InvalidOperationException().Message;
}
// Create the exception
TrafficManagerCloudException exception = new TrafficManagerCloudException(exceptionMessage, innerException);
exception.Error.Code = code;
exception.Error.Message = message;
exception.Request = CloudHttpRequestErrorInfo.Create(request, requestContent);
exception.Response = CloudHttpResponseErrorInfo.Create(response, responseContent);
exception.ExtendedErrorCode = extendedErrorCode;
exception.ErrorMessageFormat = errorMessageFormat;
exception.ErrorMessageArguments = errorMessageArguments ?? new List <string>();
return(exception);
}
