protected override bool HandleReceiveComplete(IAsyncResult result)
{
RequestContext context;
if (!base.Binder.EndTryReceive(result, out context))
{
return true;
}
if (context == null)
{
bool flag2 = false;
lock (base.ThisLock)
{
flag2 = base.Connection.Terminate();
}
if (!flag2 && (base.Binder.State == CommunicationState.Opened))
{
Exception e = new CommunicationException(System.ServiceModel.SR.GetString("EarlySecurityClose"));
base.ReliableSession.OnLocalFault(e, (Message) null, null);
}
return false;
}
WsrmMessageInfo info = WsrmMessageInfo.Get(base.Listener.MessageVersion, base.Listener.ReliableMessagingVersion, base.Binder.Channel, base.Binder.GetInnerSession(), context.RequestMessage);
base.StartReceiving(false);
this.ProcessRequest(context, info);
return false;
}
/// <summary>
/// is not found communication exception
/// </summary>
/// <param name="exception">Communication Exception</param>
/// <returns>true if exception caused by resource not found, otherwise, false</returns>
public static bool IsNotFoundCommunicationException(CommunicationException exception)
{
ServiceManagementError error = null;
string operationId = string.Empty;
ErrorHelper.TryGetExceptionDetails(exception, out error, out operationId);
return error != null && error.Code == HttpStatusCode.NotFound.ToString();
}
/// <summary>
/// Get current storage account from azure subscription
/// </summary>
/// <returns>A storage account</returns>
private CloudStorageAccount GetStorageAccountFromSubscription()
{
string CurrentStorageAccountName = CurrentSubscription.CurrentStorageAccountName;
if (string.IsNullOrEmpty(CurrentStorageAccountName))
{
throw new ArgumentException(Resources.DefaultStorageCredentialsNotFound);
}
else
{
WriteDebugLog(String.Format(Resources.UseCurrentStorageAccountFromSubscription, CurrentStorageAccountName, CurrentSubscription.SubscriptionName));
try
{
//The service channel initialized by subscription
return(CurrentSubscription.GetCloudStorageAccount());
}
catch (ServiceModel.CommunicationException e)
{
WriteVerboseWithTimestamp(Resources.CannotGetSotrageAccountFromSubscription);
if (e.IsNotFoundException())
{
//Repack the 404 error
string errorMessage = String.Format(Resources.CurrentStorageAccountNotFoundOnAzure, CurrentStorageAccountName, CurrentSubscription.SubscriptionName);
ServiceModel.CommunicationException exception = new ServiceModel.CommunicationException(errorMessage, e);
throw exception;
}
else
{
throw;
}
}
}
}
private void Handle(CommunicationException cEx, string additionalInformation = null)
{
base.StopWorker();
_service = null;
OpenServiceCommunicationAsync();
Log($"{$"{additionalInformation}: " ?? ""}{cEx}", LogLevel.WARNING);
}
public static bool TryGetExceptionDetails(CommunicationException exception, out ServiceManagementError errorDetails, out HttpStatusCode httpStatusCode, out string operationId)
{
errorDetails = null;
httpStatusCode = 0;
operationId = null;
if (exception == null)
{
return false;
}
if (exception.Message == "Internal Server Error")
{
httpStatusCode = HttpStatusCode.InternalServerError;
return true;
}
var wex = exception.InnerException as WebException;
if (wex == null)
{
return false;
}
var response = wex.Response as HttpWebResponse;
if (response == null)
{
return false;
}
if (response.Headers != null)
{
operationId = response.Headers[Constants.OperationTrackingIdHeader];
}
using (var s = response.GetResponseStream())
{
try
{
if (s == null || s.Length == 0)
{
return false;
}
var reader = XmlDictionaryReader.CreateTextReader(s, new XmlDictionaryReaderQuotas());
var ser = new DataContractSerializer(typeof(ServiceManagementError));
errorDetails = (ServiceManagementError)ser.ReadObject(reader, true);
}
catch (Exception)
{
return false;
}
}
return true;
}
/// <summary>
/// Shows <see cref="MessageBox"/> dialog with information about <paramref name="communicationException"/>.
/// </summary>
/// <param name="caption">The caption.</param>
/// <param name="communicationException">The <see cref="CommunicationException"/> which information will be display on <see cref="MessageBox"/>.</param>
protected void ShowError(string caption, CommunicationException communicationException)
{
if (communicationException != null)
{
ModalDialogService.ShowMessageBox(ModalDialogService, ServiceFactory, MessageBoxImage.Error, caption,
communicationException.Message,
MessageBoxButton.OK,
(communicationException.InnerException != null)
? communicationException.InnerException.Message
: string.Empty);
}
}
private static bool IsStatusResourceNotFound(CommunicationException ex)
{
WebException innerException = ex.InnerException as WebException;
if (innerException != null)
{
HttpWebResponse response = innerException.Response as HttpWebResponse;
if (response != null && response.StatusCode == HttpStatusCode.NotFound)
{
return true;
}
}
return false;
}
/// <summary>
/// Handles the exception and updates the parameters accodingly
/// </summary>
/// <param name="ex">The base exception</param>
public void HandleException(CommunicationException ex)
{
// Checking if the exception came from the code
if (ex is FaultException)
{
// Checking if a log is reqired
if (_logErrors)
{
_logger.LogTechnicalError(LOG_CATEGORY, _businessErrorMessage + ACTUAL_ERROR_MESSAGE_DELIMITER + ExtractMultiLevelErrorMessage(ex));
NeedToRetry = false;
}
// Has to be done after the log, because it ends the execution
if (_throwErrors)
{
// Indicating a business exception
throw new Exception(_businessErrorMessage + ACTUAL_ERROR_MESSAGE_DELIMITER + ex.Message, ex);
}
}
else
{
// The exception occured in the communication
// Indicating a failed attempt
_retriesLeft--;
// Checking if there are any retries left
if (AnyRetriesLeft)
{
// Waiting for the cooldown to expire
Thread.Sleep(_retryCooldown);
}
else
{
// Checking if a log is reqired
if (_logErrors)
{
_logger.LogTechnicalError(LOG_CATEGORY, _connectionErrorMessage + ACTUAL_ERROR_MESSAGE_DELIMITER + ExtractMultiLevelErrorMessage(ex));
NeedToRetry = false;
}
// Has to be done after the log, because it ends the execution
if (_throwErrors)
{
// Indicating a connection exception
throw new Exception(_connectionErrorMessage + ACTUAL_ERROR_MESSAGE_DELIMITER + ex.Message, ex);
}
}
}
}
private static string GetDetailedMessage(CommunicationException inner)
{
ServiceManagementError error = null;
ServiceManagementHelper.TryGetExceptionDetails(inner, out error);
if (error == null)
{
return inner.Message;
}
else
{
string errorDetails = string.Format(
CultureInfo.InvariantCulture,
"HTTP Status Code: {0} - HTTP Error Message: {1}",
error.Code,
error.Message);
return errorDetails;
}
}
public void IsNotFoundExceptionTest()
{
string message = "CommunicationExceptionUtilTest";
CommunicationException exception = new CommunicationException(message);
Assert.IsFalse(exception.IsNotFoundException());
}
static Exception ConvertTransferException(SocketException socketException, TimeSpan timeout, Exception originalException,
TransferOperation transferOperation, bool aborted, string timeoutErrorString, TransferOperation timeoutErrorTransferOperation,
SocketConnection socketConnection, TimeSpan remainingTime)
{
if (socketException.ErrorCode == UnsafeNativeMethods.ERROR_INVALID_HANDLE)
{
return new CommunicationObjectAbortedException(socketException.Message, socketException);
}
if (timeoutErrorString != null)
{
return ConvertTimeoutErrorException(originalException, transferOperation, timeoutErrorString, timeoutErrorTransferOperation);
}
TraceEventType exceptionEventType = socketConnection == null ? TraceEventType.Error : socketConnection.ExceptionEventType;
// 10053 can occur due to our timeout sockopt firing, so map to TimeoutException in that case
if (socketException.ErrorCode == UnsafeNativeMethods.WSAECONNABORTED &&
remainingTime <= TimeSpan.Zero)
{
TimeoutException timeoutException = new TimeoutException(SR.GetString(SR.TcpConnectionTimedOut, timeout), originalException);
if (TD.TcpConnectionTimedOutIsEnabled())
{
if (socketConnection != null)
{
int socketid = (socketConnection != null && socketConnection.socket != null) ? socketConnection.socket.GetHashCode() : -1;
TD.TcpConnectionTimedOut(socketid, socketConnection.RemoteEndpointAddress);
}
}
if (DiagnosticUtility.ShouldTrace(exceptionEventType))
{
TraceUtility.TraceEvent(exceptionEventType, TraceCode.TcpConnectionTimedOut, GetEndpointString(SR.TcpConnectionTimedOut, timeout, null, socketConnection), timeoutException, null);
}
return timeoutException;
}
if (socketException.ErrorCode == UnsafeNativeMethods.WSAENETRESET ||
socketException.ErrorCode == UnsafeNativeMethods.WSAECONNABORTED ||
socketException.ErrorCode == UnsafeNativeMethods.WSAECONNRESET)
{
if (aborted)
{
return new CommunicationObjectAbortedException(SR.GetString(SR.TcpLocalConnectionAborted), originalException);
}
else
{
CommunicationException communicationException = new CommunicationException(SR.GetString(SR.TcpConnectionResetError, timeout), originalException);
if (TD.TcpConnectionResetErrorIsEnabled())
{
if (socketConnection != null)
{
int socketId = (socketConnection.socket != null) ? socketConnection.socket.GetHashCode() : -1;
TD.TcpConnectionResetError(socketId, socketConnection.RemoteEndpointAddress);
}
}
if (DiagnosticUtility.ShouldTrace(exceptionEventType))
{
TraceUtility.TraceEvent(exceptionEventType, TraceCode.TcpConnectionResetError, GetEndpointString(SR.TcpConnectionResetError, timeout, null, socketConnection), communicationException, null);
}
return communicationException;
}
}
else if (socketException.ErrorCode == UnsafeNativeMethods.WSAETIMEDOUT)
{
TimeoutException timeoutException = new TimeoutException(SR.GetString(SR.TcpConnectionTimedOut, timeout), originalException);
if (DiagnosticUtility.ShouldTrace(exceptionEventType))
{
TraceUtility.TraceEvent(exceptionEventType, TraceCode.TcpConnectionTimedOut, GetEndpointString(SR.TcpConnectionTimedOut, timeout, null, socketConnection), timeoutException, null);
}
return timeoutException;
}
else
{
if (aborted)
{
return new CommunicationObjectAbortedException(SR.GetString(SR.TcpTransferError, socketException.ErrorCode, socketException.Message), originalException);
}
else
{
CommunicationException communicationException = new CommunicationException(SR.GetString(SR.TcpTransferError, socketException.ErrorCode, socketException.Message), originalException);
if (DiagnosticUtility.ShouldTrace(exceptionEventType))
{
TraceUtility.TraceEvent(exceptionEventType, TraceCode.TcpTransferError, GetEndpointString(SR.TcpTransferError, TimeSpan.MinValue, socketException, socketConnection), communicationException, null);
}
return communicationException;
}
}
}
protected void OnMessageException(Microsoft.Transactions.Wsat.Messaging.RequestAsyncResult result, Message message, CommunicationException exception, Fault fault)
{
DebugTrace.Trace(TraceLevel.Warning, "{0} - {1} reading request with action {2}: {3}", base.GetType().Name, exception.GetType().Name, message.Headers.Action, exception.Message);
this.SendFaultReply(result, fault);
DebugTrace.Trace(TraceLevel.Warning, "Replied with {0} fault", fault.Code.Name);
}
/// <summary>
/// Handles communication exceptions
/// </summary>
void ThrowCommunicationException(CommunicationException ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message + "\n" + ex.StackTrace);
string message = "There was a problem communicating with the service.";
throw new SockeyeChannelException(message);
}
public static bool TryGetExceptionDetails(CommunicationException exception, out ServiceManagementError errorDetails, out HttpStatusCode httpStatusCode, out string operationId)
{
bool flag;
errorDetails = null;
httpStatusCode = 0;
operationId = null;
if (exception != null)
{
if (exception.Message != "Internal Server Error")
{
WebException innerException = exception.InnerException as WebException;
if (innerException != null)
{
HttpWebResponse response = innerException.Response as HttpWebResponse;
if (response != null)
{
httpStatusCode = response.StatusCode;
if ((int)httpStatusCode != 0x193)
{
if (response.Headers != null)
{
operationId = response.Headers["x-ms-request-id"];
}
Stream responseStream = response.GetResponseStream();
using (responseStream)
{
if (responseStream.Length != (long)0)
{
try
{
XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateTextReader(responseStream, new XmlDictionaryReaderQuotas());
using (xmlDictionaryReader)
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(ServiceManagementError));
errorDetails = (ServiceManagementError)dataContractSerializer.ReadObject(xmlDictionaryReader, true);
}
}
catch (SerializationException serializationException)
{
flag = false;
return flag;
}
return true;
}
else
{
flag = false;
}
}
return flag;
}
else
{
try
{
Stream stream = response.GetResponseStream();
using (stream)
{
XmlDictionaryReader xmlDictionaryReader1 = XmlDictionaryReader.CreateTextReader(stream, new XmlDictionaryReaderQuotas());
using (xmlDictionaryReader1)
{
DataContractSerializer dataContractSerializer1 = new DataContractSerializer(typeof(ServiceManagementError));
errorDetails = (ServiceManagementError)dataContractSerializer1.ReadObject(xmlDictionaryReader1, true);
}
}
}
catch
{
}
return true;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
httpStatusCode = HttpStatusCode.InternalServerError;
return true;
}
}
else
{
return false;
}
}
/// <summary>
/// Handles a communication exception during publishing
/// </summary>
/// <param name="CommunicationException"></param>
private void FinishWithCommunicationException(CommunicationException ce)
{
boolError = true;
string statusMessage = "A Communication error occurred while trying to publish the survey.";
AddStatusMessage(statusMessage);
txtStatusSummary.Text = statusMessage;
txtStatus.AppendText(ce.ToString());
btnShowLog.Enabled = true;
btnDetails.Visible = true;
this.progressBar.Visible = false;
this.Cursor = Cursors.Default;
panel2.Visible = false;
lblSuccessNotice.Text = "A Communication error occurred while trying to publish the survey.";
lblSuccessNotice.BackColor = Color.FromArgb(243, 217, 217);
panel3.Visible = true;
lblSuccessNotice2.Visible = false;
btnPublishForm.Enabled = false;
}
private IMethodReturn HandleCookieExpirationExceptionForIntegration(CommunicationException exception, IMethodInvocation input, GetNextHandlerDelegate getNext)
{
//Application crashes when launched while Active Directory credentials are expired (often due to not logging off overnight)
//string ADExpired = "Your credentials have expired";
string ADExpired = WebSealSettings.GetADAccountExpiredExceptionKeySetting();
if (exception.Message.Contains(ADExpired))
{
//It will immediately quit
return input.CreateExceptionMethodReturn(new ADCredentialsExpiredException());
}
WebException webException = exception.InnerException as WebException;
if (webException == null)
{
//Even if it is sessionRenewException, also will come to here.
return input.CreateExceptionMethodReturn(exception);
}
if ((!webException.Message.Contains("403")) && (!webException.Message.Contains("401")))
{
return input.CreateExceptionMethodReturn(exception);
}
if (HiiP.Framework.Security.AccessControl.Authentication.AuthenticationManager.AuthenticationMode == AuthenticationMode.Integration)
{
HiiP.Framework.Security.AccessControl.Authentication.AuthenticationManager.Login();
return this.Invoke(input, getNext);
}
return input.CreateExceptionMethodReturn(exception);
}
private void OnReceiveCompleted(IAsyncResult result)
{
RequestContext context;
if (base.Binder.EndTryReceive(result, out context))
{
if (context != null)
{
using (context)
{
Message requestMessage = context.RequestMessage;
base.ProcessMessage(requestMessage);
context.Close(this.DefaultCloseTimeout);
}
base.Binder.BeginTryReceive(TimeSpan.MaxValue, onReceiveCompleted, this);
}
else if (!base.Connection.Closed && (base.Binder.State == CommunicationState.Opened))
{
Exception e = new CommunicationException(System.ServiceModel.SR.GetString("EarlySecurityClose"));
base.ReliableSession.OnLocalFault(e, (Message) null, null);
}
}
else
{
base.Binder.BeginTryReceive(TimeSpan.MaxValue, onReceiveCompleted, this);
}
}
public static bool TryGetExceptionDetails(CommunicationException exception, out ServiceManagementError errorDetails, out HttpStatusCode httpStatusCode, out string operationId)
{
bool flag;
errorDetails = null;
httpStatusCode = 0;
operationId = null;
if (exception != null)
{
if (exception.Message != "Internal Server Error")
{
WebException innerException = exception.InnerException as WebException;
if (innerException != null)
{
HttpWebResponse response = innerException.Response as HttpWebResponse;
if (response != null)
{
if (response.Headers != null)
{
operationId = response.Headers["x-ms-request-id"];
}
if (response.StatusCode != HttpStatusCode.NotFound)
{
Stream responseStream = response.GetResponseStream();
using (responseStream)
{
if (responseStream.Length != (long)0)
{
try
{
errorDetails = new ServiceManagementError();
responseStream.Seek((long)0, SeekOrigin.Begin);
StreamReader streamReader = new StreamReader(responseStream);
using (StringReader stringReader = new StringReader(streamReader.ReadToEnd()))
{
XmlReader xmlReader = XmlReader.Create(stringReader);
while (xmlReader.Read())
{
XmlNodeType nodeType = xmlReader.NodeType;
if (nodeType != XmlNodeType.Element)
{
continue;
}
if (xmlReader.Name != "Code")
{
if (xmlReader.Name != "Message")
{
continue;
}
xmlReader.Read();
errorDetails.Message = xmlReader.Value;
}
else
{
xmlReader.Read();
errorDetails.Code = xmlReader.Value;
}
}
}
}
catch (SerializationException serializationException)
{
flag = false;
return flag;
}
return true;
}
else
{
flag = false;
}
}
return flag;
}
else
{
errorDetails = new ServiceManagementError();
errorDetails.Message = string.Concat(response.ResponseUri.AbsoluteUri, " does not exist.");
errorDetails.Code = response.StatusCode.ToString();
return false;
}
}
else
{
return false;
}
}
else
{
return false;
}
}
else
{
httpStatusCode = HttpStatusCode.InternalServerError;
return true;
}
}
else
{
return false;
}
}
private bool shouldRetry(CommunicationException ce)
{
for (Exception e = ce; e != null; e = e.InnerException)
{
// there was a temporary communication error
System.Net.Sockets.SocketException se = e as System.Net.Sockets.SocketException;
if (se != null)
{
return true;
}
// continue to inner exception
}
// do not retry
return false;
}
public static bool TryGetExceptionDetails(CommunicationException exception, out ServiceManagementError errorDetails)
{
HttpStatusCode httpStatusCode = 0;
string str = null;
return ServiceManagementHelper.TryGetExceptionDetails(exception, out errorDetails, out httpStatusCode, out str);
}
public static bool TryGetExceptionDetails(CommunicationException exception, out ServiceManagementError errorDetails, out HttpStatusCode httpStatusCode, out string operationId)
{
errorDetails = null;
httpStatusCode = 0;
operationId = null;
if (exception == null)
{
return false;
}
if (exception.Message == "Internal Server Error")
{
httpStatusCode = HttpStatusCode.InternalServerError;
return true;
}
WebException wex = exception.InnerException as WebException;
if (wex == null)
{
return false;
}
HttpWebResponse response = wex.Response as HttpWebResponse;
if (response == null)
{
return false;
}
//httpStatusCode = response.StatusCode;
//if (httpStatusCode == HttpStatusCode.Forbidden)
//{
// return true;
//}
if (response.Headers != null)
{
operationId = response.Headers[Constants.OperationTrackingIdHeader];
}
// Don't wrap responseStream in a using statement to prevent it
// from being disposed twice (as it's disposed by reader if it is
// successfully disposed).
Stream responseStream = null;
try
{
responseStream = response.GetResponseStream();
if (responseStream.Length == 0)
{
return false;
}
try
{
using (XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(responseStream, new XmlDictionaryReaderQuotas()))
{
// Release the reference to responseStream since it
// will be closed when the reader is diposed
responseStream = null;
DataContractSerializer ser = new DataContractSerializer(typeof(ServiceManagementError));
errorDetails = (ServiceManagementError)ser.ReadObject(reader, true);
}
}
catch (SerializationException)
{
return false;
}
}
finally
{
if (responseStream != null)
{
responseStream.Dispose();
}
}
return true;
}
void OnInactivityElapsed(object state)
{
WsrmFault fault;
Exception e;
string exceptionMessage = SR.GetString(SR.SequenceTerminatedInactivityTimeoutExceeded, this.settings.InactivityTimeout);
if (TD.InactivityTimeoutIsEnabled())
{
TD.InactivityTimeout(exceptionMessage);
}
if (this.SequenceID != null)
{
string faultReason = SR.GetString(SR.SequenceTerminatedInactivityTimeoutExceeded, this.settings.InactivityTimeout);
fault = SequenceTerminatedFault.CreateCommunicationFault(this.SequenceID, faultReason, exceptionMessage);
e = fault.CreateException();
}
else
{
fault = null;
e = new CommunicationException(exceptionMessage);
}
OnLocalFault(e, fault, null);
}
internal void ProcessMessage11(ref MessageRpc rpc)
{
rpc.NextProcessor = this.processMessage2;
if (rpc.Operation.IsOneWay)
{
rpc.RequestContext.Reply(null);
rpc.OperationContext.RequestContext = null;
}
else
{
if (!rpc.Channel.IsReplyChannel &&
((object)rpc.RequestID == null) &&
(rpc.Operation.Action != MessageHeaders.WildcardAction))
{
CommunicationException error = new CommunicationException(SR.GetString(SR.SFxOneWayMessageToTwoWayMethod0));
throw TraceUtility.ThrowHelperError(error, rpc.Request);
}
if (!this.manualAddressing)
{
EndpointAddress replyTo = rpc.ReplyToInfo.ReplyTo;
if (replyTo != null && replyTo.IsNone && rpc.Channel.IsReplyChannel)
{
CommunicationException error = new CommunicationException(SR.GetString(SR.SFxRequestReplyNone));
throw TraceUtility.ThrowHelperError(error, rpc.Request);
}
if (this.isOnServer)
{
EndpointAddress remoteAddress = rpc.Channel.RemoteAddress;
if ((remoteAddress != null) && !remoteAddress.IsAnonymous)
{
MessageHeaders headers = rpc.Request.Headers;
Uri remoteUri = remoteAddress.Uri;
if ((replyTo != null) && !replyTo.IsAnonymous && (remoteUri != replyTo.Uri))
{
string text = SR.GetString(SR.SFxRequestHasInvalidReplyToOnServer, replyTo.Uri, remoteUri);
Exception error = new InvalidOperationException(text);
throw TraceUtility.ThrowHelperError(error, rpc.Request);
}
EndpointAddress faultTo = headers.FaultTo;
if ((faultTo != null) && !faultTo.IsAnonymous && (remoteUri != faultTo.Uri))
{
string text = SR.GetString(SR.SFxRequestHasInvalidFaultToOnServer, faultTo.Uri, remoteUri);
Exception error = new InvalidOperationException(text);
throw TraceUtility.ThrowHelperError(error, rpc.Request);
}
if (rpc.RequestVersion.Addressing == AddressingVersion.WSAddressingAugust2004)
{
EndpointAddress from = headers.From;
if ((from != null) && !from.IsAnonymous && (remoteUri != from.Uri))
{
string text = SR.GetString(SR.SFxRequestHasInvalidFromOnServer, from.Uri, remoteUri);
Exception error = new InvalidOperationException(text);
throw TraceUtility.ThrowHelperError(error, rpc.Request);
}
}
}
}
}
}
if (this.concurrency.IsConcurrent(ref rpc))
{
rpc.Channel.IncrementActivity();
rpc.SuccessfullyIncrementedActivity = true;
}
if (this.authenticationBehavior != null)
{
this.authenticationBehavior.Authenticate(ref rpc);
}
if (this.authorizationBehavior != null)
{
this.authorizationBehavior.Authorize(ref rpc);
}
this.instance.EnsureInstanceContext(ref rpc);
this.TransferChannelFromPendingList(ref rpc);
this.AcquireDynamicInstanceContext(ref rpc);
if (!rpc.IsPaused)
{
this.ProcessMessage2(ref rpc);
}
}
public void IsNotFoundExceptionTest()
{
string message = "CommunicationExceptionUtilTest";
CommunicationException exception = new CommunicationException(message);
}
/// <summary>
/// Validate the communicationException to see whether the HttpStatusCode matches the expectation
/// </summary>
/// <param name="communicationException"></param>
/// <param name="httpStatusCode"></param>
private static void ValidateHttpStatusResponse(CommunicationException communicationException, HttpStatusCode httpStatusCode)
{
HttpStatusResponse httpStatusResponse = DetermineHttpStatusResponse(communicationException);
Assert.AreEqual(httpStatusCode, httpStatusResponse.HttpStatusCode, string.Format("Unexpected HttpStatusCode received : {0}", httpStatusResponse.HttpStatusDescription));
}
public static bool TryGetExceptionDetails(CommunicationException exception, out ServiceManagementError errorDetails, out string operationId)
{
HttpStatusCode httpStatusCode;
return TryGetExceptionDetails(exception, out errorDetails, out httpStatusCode, out operationId);
}
protected void RethrowCommunicationError(CommunicationException ce, ServiceManagementError error)
{
String message = ce.Message;
if (error != null)
{
message = error.Message + " (" + error.Code + ")";
}
else if (ce is MessageSecurityException)
{
message =
ce.Message + ". Check SubscriptionId is correct: " + SubscriptionId + " " +
"Check certificate with the thumbrint " + CertificateThumbprint + " " +
"is configured as management certificate in azure portal.";
}
throw new CSManageException(message, ce);
}
/// <summary>
/// Determine the HttpStatusResponse from the protocol exception.
/// When this fails the Assert.Fail method will be called to prevent further execution.
/// </summary>
/// <param name="communicationException">The protocol exception which might the HttpStatusCode</param>
/// <returns>The HttpStatusResponse enumeration</returns>
private static HttpStatusResponse DetermineHttpStatusResponse(CommunicationException communicationException)
{
if (communicationException != null && communicationException.InnerException != null)
{
var webException = communicationException.InnerException as WebException;
if (webException != null && webException.Response != null)
{
var response = webException.Response as HttpWebResponse;
if (response != null)
{
return new HttpStatusResponse(response.StatusCode, response.StatusDescription);
}
}
}
Assert.Fail("Failed to determine HttpStatusCode from CommunicationException.");
return new HttpStatusResponse(HttpStatusCode.InternalServerError, "Failed to determine HttpStatusCode from CommunicationException.");
}
public CommunicationExceptionEx(CommunicationException inner)
: base(GetDetailedMessage(inner),inner)
{
}
public static bool TryGetExceptionDetails(CommunicationException exception, out ServiceManagementError errorDetails, out HttpStatusCode httpStatusCode, out string operationId)
{
errorDetails = null;
httpStatusCode = 0;
operationId = null;
if (exception == null)
{
return false;
}
if (exception.Message == "Internal Server Error")
{
httpStatusCode = HttpStatusCode.InternalServerError;
return false;
}
WebException wex = exception.InnerException as WebException;
if (wex == null)
{
return false;
}
HttpWebResponse response = wex.Response as HttpWebResponse;
if (response == null)
{
return false;
}
if (response.Headers != null)
{
operationId = response.Headers[Constants.OperationTrackingIdHeader];
}
if (response.StatusCode == HttpStatusCode.NotFound)
{
errorDetails = new ServiceManagementError();
errorDetails.Message = response.ResponseUri.AbsoluteUri + " does not exist.";
errorDetails.Code = response.StatusCode.ToString();
return false;
}
using (var s = response.GetResponseStream())
{
if (s.Length == 0)
{
return false;
}
try
{
errorDetails = new ServiceManagementError();
s.Seek(0, SeekOrigin.Begin);
var sr = new StreamReader(s);
using (var err = new StringReader(sr.ReadToEnd()))
{
var reader = XmlReader.Create(err);
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
if (reader.Name == "Code")
{
reader.Read();
errorDetails.Code = reader.Value;
}
else if (reader.Name == "Message")
{
reader.Read();
errorDetails.Message = reader.Value;
}
break;
}
}
}
}
}
catch
{
errorDetails = null;
return false;
}
}
return true;
}
private static void SetCommunicationStatusFlags(ref Message reply, IRuntime runtime)
{
if (!reply.IsFault) return;
try
{
var buffer = reply.CreateBufferedCopy(int.MaxValue);
var copy = buffer.CreateMessage();
if (!copy.IsFault) return;
var fault = MessageFault.CreateFault(copy, int.MaxValue);
var error = fault.Reason.GetMatchingTranslation().Text;
reply = buffer.CreateMessage();
var exception = new CommunicationException(error);
SetConnectivityErrorFlag(exception, runtime);
}
catch (Exception ex)
{
SetConnectivityErrorFlag(ex, runtime);
}
}
