internal static void ProcessResponseCallbackWebExceptionHandler <T> (WebException webEx, RequestState <T> asynchRequestState,
PubnubErrorFilter.Level errorLevel)
{
#if (ENABLE_PUBNUB_LOGGING)
if (webEx.ToString().Contains("Aborted"))
{
LoggingMethod.WriteToLog(string.Format("DateTime {0}, ProcessResponseCallbackWebExceptionHandler WebException: {1}", DateTime.Now.ToString(), webEx.ToString()), LoggingMethod.LevelInfo);
}
else
{
LoggingMethod.WriteToLog(string.Format("DateTime {0}, ProcessResponseCallbackWebExceptionHandler WebException: {1}", DateTime.Now.ToString(), webEx.ToString()), LoggingMethod.LevelError);
}
#endif
UrlRequestCommonExceptionHandler <T> (webEx.Message, asynchRequestState, asynchRequestState.Timeout,
false, errorLevel);
}
internal static void ResponseCallbackExceptionHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState,
Exception ex, PubnubErrorFilter.Level errorLevel)
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, Process Response Exception: = {1}", DateTime.Now.ToString(), ex.ToString()), LoggingMethod.LevelError);
#endif
if (requestState.ChannelEntities != null)
{
if (requestState.RespType.Equals(ResponseType.SubscribeV2) ||
requestState.RespType.Equals(ResponseType.PresenceV2)
)
{
PubnubCallbacks.FireErrorCallbacksForAllChannels(ex, requestState,
PubnubErrorSeverity.Warn, PubnubErrorCode.None, errorLevel);
}
else
{
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (ex, requestState,
PubnubErrorSeverity.Critical, PubnubErrorCode.None, errorLevel);
}
}
ProcessResponseCallbackExceptionHandler <T> (ex, requestState, errorLevel);
}
internal static void ProcessResponseCallbackExceptionHandler <T> (Exception ex, RequestState <T> asynchRequestState,
PubnubErrorFilter.Level errorLevel)
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, ProcessResponseCallbackExceptionHandler Exception= {1} for URL: {2}",
DateTime.Now.ToString(), ex.ToString(),
(asynchRequestState.Request != null)?asynchRequestState.Request.RequestUri.ToString(): "asynchRequestState.Request null"),
LoggingMethod.LevelInfo);
#endif
UrlRequestCommonExceptionHandler <T> (ex.Message, asynchRequestState, asynchRequestState.Timeout,
false, errorLevel);
}
internal static void ResponseCallbackWebExceptionHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState,
WebException webEx, string channel, SafeDictionary <PubnubChannelCallbackKey, object> channelCallbacks,
PubnubErrorFilter.Level errorLevel)
{
if (requestState.Channels != null || requestState.RespType == ResponseType.Time)
{
if (requestState.RespType == ResponseType.Subscribe ||
requestState.RespType == ResponseType.Presence)
{
if (webEx.Message.IndexOf("The request was aborted: The request was canceled") == -1 ||
webEx.Message.IndexOf("Machine suspend mode enabled. No request will be processed.") == -1)
{
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (webEx, requestState,
PubnubErrorSeverity.Warn, channelCallbacks,
true, errorLevel);
}
}
else
{
PubnubCallbacks.CallErrorCallback <T> (webEx, requestState, channel,
PubnubErrorSeverity.Warn, requestState.ErrorCallback, errorLevel);
}
}
ProcessResponseCallbackWebExceptionHandler <T> (webEx, requestState, channel, errorLevel);
}
internal static void ResponseCallbackWebExceptionHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState,
WebException webEx,
PubnubErrorFilter.Level errorLevel)
{
if ((requestState != null) && (requestState.ChannelEntities != null || requestState.RespType != ResponseType.Time))
{
if (requestState.RespType.Equals(ResponseType.SubscribeV2) ||
requestState.RespType.Equals(ResponseType.PresenceV2)
)
{
if (webEx.Message.IndexOf("The request was aborted: The request was canceled") == -1 ||
webEx.Message.IndexOf("Machine suspend mode enabled. No request will be processed.") == -1)
{
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (webEx, requestState,
PubnubErrorSeverity.Warn, errorLevel);
}
}
else
{
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (webEx, requestState,
PubnubErrorSeverity.Warn, errorLevel);
}
}
ProcessResponseCallbackWebExceptionHandler <T> (webEx, requestState, errorLevel);
}
private void StartCoroutinesByName <T> (string url, RequestState <T> pubnubRequestState, int timeout, int pause, CurrentRequestType crt)
{
CoroutineParams <T> cp = new CoroutineParams <T> (url, timeout, pause, crt, typeof(T), pubnubRequestState);
if (crt == CurrentRequestType.Subscribe)
{
if ((SubTimeoutCoroutine != null) && (!isSubscribeComplete))
{
StopCoroutine(SubTimeoutCoroutine);
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, Stopped existing timeout coroutine {1}", DateTime.Now.ToString(), cp.crt.ToString()), LoggingMethod.LevelInfo);
#endif
}
SubTimeoutCoroutine = CheckTimeoutSub <T> (cp);
SubCoroutine = SendRequestSub <T> (cp);
StartCoroutine(SubTimeoutCoroutine);
StartCoroutine(SubCoroutine);
}
else if (crt == CurrentRequestType.NonSubscribe)
{
if ((NonSubTimeoutCoroutine != null) && (!isNonSubscribeComplete))
{
StopCoroutine(NonSubTimeoutCoroutine);
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, Stopped existing timeout coroutine {1}", DateTime.Now.ToString(), cp.crt.ToString()), LoggingMethod.LevelInfo);
#endif
}
NonSubTimeoutCoroutine = CheckTimeoutNonSub <T> (cp);
NonSubCoroutine = SendRequestNonSub <T> (cp);
StartCoroutine(NonSubTimeoutCoroutine);
StartCoroutine(NonSubCoroutine);
}
else if (crt == CurrentRequestType.PresenceHeartbeat)
{
if ((PresenceHeartbeatTimeoutCoroutine != null) && (!isPresenceHeartbeatComplete))
{
StopCoroutine(PresenceHeartbeatTimeoutCoroutine);
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, Stopped existing timeout coroutine {1}", DateTime.Now.ToString(), cp.crt.ToString()), LoggingMethod.LevelInfo);
#endif
}
PresenceHeartbeatTimeoutCoroutine = CheckTimeoutPresenceHeartbeat <T> (cp);
PresenceHeartbeatCoroutine = SendRequestPresenceHeartbeat <T> (cp);
StartCoroutine(PresenceHeartbeatTimeoutCoroutine);
StartCoroutine(PresenceHeartbeatCoroutine);
}
else if (crt == CurrentRequestType.Heartbeat)
{
if ((HeartbeatTimeoutCoroutine != null) && (!isHearbeatComplete))
{
StopCoroutine(HeartbeatTimeoutCoroutine);
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, Stopped existing timeout coroutine {1}", DateTime.Now.ToString(), cp.crt.ToString()), LoggingMethod.LevelInfo);
#endif
}
HeartbeatTimeoutCoroutine = CheckTimeoutHeartbeat <T> (cp);
HeartbeatCoroutine = SendRequestHeartbeat <T> (cp);
StartCoroutine(HeartbeatTimeoutCoroutine);
StartCoroutine(HeartbeatCoroutine);
}
}
internal static void ResponseCallbackErrorOrTimeoutHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState, string channel,
PubnubErrorFilter.Level errorLevel, IJsonPluggableLibrary jsonPluggableLibrary)
{
WebException webEx = new WebException(cea.Message);
if ((cea.Message.Contains("NameResolutionFailure") ||
cea.Message.Contains("ConnectFailure") ||
cea.Message.Contains("ServerProtocolViolation") ||
cea.Message.Contains("ProtocolError")
))
{
webEx = new WebException("Network connnect error", WebExceptionStatus.ConnectFailure);
PubnubCallbacks.CallErrorCallback <T> (cea.Message, null, channel,
PubnubErrorCode.NoInternetRetryConnect, PubnubErrorSeverity.Warn, requestState.ErrorCallback, errorLevel);
}
else if (cea.IsTimeout || Utility.CheckRequestTimeoutMessageInError(cea))
{
}
else if ((cea.Message.Contains("403")) ||
(cea.Message.Contains("java.io.FileNotFoundException")) ||
((PubnubUnity.Version.Contains("UnityWeb")) && (cea.Message.Contains("Failed downloading"))))
{
PubnubClientError error = new PubnubClientError(403, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("500"))
{
PubnubClientError error = new PubnubClientError(500, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("502"))
{
PubnubClientError error = new PubnubClientError(503, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("503"))
{
PubnubClientError error = new PubnubClientError(503, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("504"))
{
PubnubClientError error = new PubnubClientError(504, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else if (cea.Message.Contains("414"))
{
PubnubClientError error = new PubnubClientError(414, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
else
{
PubnubClientError error = new PubnubClientError(400, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server, requestState.Request, requestState.Response, cea.Message, channel);
PubnubCallbacks.GoToCallback(error, requestState.ErrorCallback, jsonPluggableLibrary);
}
ProcessResponseCallbackWebExceptionHandler <T> (webEx, requestState, channel, errorLevel);
}
internal static void FireErrorCallbacksForAllChannels <T> (WebException webEx, RequestState <T> requestState,
PubnubErrorSeverity severity, PubnubErrorFilter.Level errorLevel)
{
foreach (ChannelEntity channelEntity in requestState.ChannelEntities)
{
PubnubClientError error = Helpers.CreatePubnubClientError <T> (webEx, requestState, channelEntity.ChannelID.ChannelOrChannelGroupName,
severity);
FireErrorCallback <T> (channelEntity,
errorLevel, error);
}
}
internal static void FireErrorCallbacksForAllChannelsCommon <T>(Exception ex, string message, RequestState <T> requestState,
List <ChannelEntity> channelEntities,
PubnubErrorSeverity severity, PubnubErrorCode errorType,
ResponseType responseType, PubnubErrorFilter.Level errorLevel)
{
if ((channelEntities != null) && (channelEntities.Count > 0))
{
foreach (ChannelEntity channelEntity in channelEntities)
{
string channel = "";
string channelGroup = "";
if (channelEntity.ChannelID.IsChannelGroup)
{
channelGroup = channelEntity.ChannelID.ChannelOrChannelGroupName;
}
else
{
channel = channelEntity.ChannelID.ChannelOrChannelGroupName;
}
PubnubClientError error = null;
if (ex != null)
{
error = Helpers.CreatePubnubClientError <T> (ex, requestState, errorType,
severity, channel, channelGroup);
}
else
{
error = Helpers.CreatePubnubClientError <T> (message, requestState, errorType,
severity, channel, channelGroup);
}
FireErrorCallback <T> (channelEntity,
errorLevel, error);
}
}
else
{
if ((requestState != null) && (requestState.ErrorCallback != null))
{
PubnubClientError error = null;
if (ex != null)
{
error = Helpers.CreatePubnubClientError <T> (ex, requestState, errorType,
severity, "", "");
}
else
{
error = Helpers.CreatePubnubClientError <T> (message, requestState, errorType,
severity, "", "");
}
GoToCallback(error, requestState.ErrorCallback, errorLevel);
}
#if (ENABLE_PUBNUB_LOGGING)
else
{
LoggingMethod.WriteToLog(string.Format("DateTime {0}, FireErrorCallbacksForAllChannelsCommon: {1}",
DateTime.Now.ToString(),
(requestState != null)?"ErrorCallback null":"requestState null"
), LoggingMethod.LevelInfo);
}
LoggingMethod.WriteToLog(string.Format("DateTime {0}, FireErrorCallbacksForAllChannelsCommon: channelEntities count: {1}",
DateTime.Now.ToString(),
(channelEntities != null)?channelEntities.Count.ToString():"channelEntities null"
), LoggingMethod.LevelInfo);
#endif
}
}
protected override PubnubWebRequest SetTimeout <T> (RequestState <T> pubnubRequestState, PubnubWebRequest request)
{
request.Timeout = GetTimeoutInSecondsForResponseType(pubnubRequestState.Type) * 1000;
return(request);
}
void ConnectToHostAndSendRequest <T> (bool sslEnabled, TcpClient tcpClient, RequestState <T> pubnubRequestState, string requestString)
{
NetworkStream stream = tcpClient.GetStream();
string proxyAuth = string.Format("{0}:{1}", Proxy.ProxyUserName, Proxy.ProxyPassword);
byte[] proxyAuthBytes = Encoding.UTF8.GetBytes(proxyAuth);
//Proxy-Authenticate: authentication mode Basic, Digest and NTLM
string connectRequest = "";
if (sslEnabled)
{
connectRequest = string.Format("CONNECT {0}:443 HTTP/1.1\r\nProxy-Authorization: Basic {1}\r\nHost: {0}\r\n\r\n", this._domainName, Convert.ToBase64String(proxyAuthBytes));
}
else
{
connectRequest = string.Format("CONNECT {0}:80 HTTP/1.1\r\nProxy-Authorization: Basic {1}\r\nHost: {0}\r\n\r\n", this._domainName, Convert.ToBase64String(proxyAuthBytes));
}
byte[] tunnelRequest = Encoding.UTF8.GetBytes(connectRequest);
stream.Write(tunnelRequest, 0, tunnelRequest.Length);
stream.Flush();
stream.ReadTimeout = pubnubRequestState.Request.Timeout * 5;
StateObject <T> state = new StateObject <T> ();
state.tcpClient = tcpClient;
state.RequestState = pubnubRequestState;
state.requestString = requestString;
state.netStream = stream;
//stream.BeginRead(state.buffer, 0, state.buffer.Length, new AsyncCallback(ConnectToHostAndSendRequestCallback<T>), state);
StringBuilder response = new StringBuilder();
var responseStream = new StreamReader(stream);
char[] buffer = new char[2048];
int charsRead = responseStream.Read(buffer, 0, buffer.Length);
bool connEstablished = false;
while (charsRead > 0)
{
response.Append(buffer);
if ((response.ToString().IndexOf("200 Connection established") > 0) || (response.ToString().IndexOf("200 OK") > 0))
{
connEstablished = true;
break;
}
charsRead = responseStream.Read(buffer, 0, buffer.Length);
}
if (connEstablished)
{
if (sslEnabled)
{
SendSslRequest <T> (stream, tcpClient, pubnubRequestState, requestString);
}
else
{
SendRequest <T> (tcpClient, pubnubRequestState, requestString);
}
}
else if (response.ToString().IndexOf("407 Proxy Authentication Required") > 0)
{
int pos = response.ToString().IndexOf("Proxy-Authenticate");
string desc = "";
if (pos > 0)
{
desc = response.ToString().Substring(pos, response.ToString().IndexOf("\r\n", pos) - pos);
}
throw new WebException(string.Format("Proxy Authentication Required. Desc: {0}", desc));
}
else
{
throw new WebException("Couldn't connect to the server");
}
}
internal static void FireErrorCallbacksForAllChannels <T> (WebException webEx, RequestState <T> requestState,
PubnubErrorSeverity severity, SafeDictionary <PubnubChannelCallbackKey,
object> channelCallbacks, bool callbackObjectType, PubnubErrorFilter.Level errorLevel)
{
for (int index = 0; index < requestState.Channels.Length; index++)
{
string activeChannel = requestState.Channels [index].ToString();
PubnubClientError error = Helpers.CreatePubnubClientError <T> (webEx, requestState, activeChannel,
severity);
FireErrorCallback <T> (activeChannel, channelCallbacks,
callbackObjectType, requestState.RespType, errorLevel, error);
}
}
public CoroutineParams(string url, int timeout, int pause, CurrentRequestType crt, Type typeParameterType, RequestState <T> requestState)
{
this.url = url;
this.timeout = timeout;
this.pause = pause;
this.crt = crt;
this.typeParameterType = typeParameterType;
this.requestState = requestState;
}
public IEnumerator DelayRequest <T> (string url, RequestState <T> pubnubRequestState, int timeout, int pause, CurrentRequestType crt)
{
yield return(new WaitForSeconds(pause));
StartCoroutinesByName <T> (url, pubnubRequestState, timeout, pause, crt);
}
internal static void CreateErrorCodeAndCallErrorCallback <T> (int statusCode, CustomEventArgs <T> cea, RequestState <T> requestState,
PubnubErrorFilter.Level errorLevel)
{
PubnubClientError error = new PubnubClientError(statusCode, PubnubErrorSeverity.Critical, cea.Message, PubnubMessageSource.Server,
requestState.Request, requestState.Response, cea.Message, requestState.ChannelEntities);
PubnubCallbacks.CallErrorCallback <T> (requestState.ErrorCallback, requestState.ChannelEntities,
error, errorLevel);
}
internal static void SendCallbacks <T>(IJsonPluggableLibrary jsonPluggableLibrary, RequestState <T> asynchRequestState,
List <object> itemMessage, CallbackType callbackType, bool checkType)
{
if (asynchRequestState.ChannelEntities != null)
{
SendCallbacks <T> (jsonPluggableLibrary, asynchRequestState.ChannelEntities, itemMessage, callbackType, checkType);
}
else
{
#if (ENABLE_PUBNUB_LOGGING)
LoggingMethod.WriteToLog(string.Format("DateTime {0}, SendCallbacks1: Callback type={1}", DateTime.Now.ToString(), callbackType.ToString()), LoggingMethod.LevelInfo);
#endif
if (callbackType.Equals(CallbackType.Success))
{
GoToCallback <T> (itemMessage, asynchRequestState.SuccessCallback, jsonPluggableLibrary);
}
}
}
internal static void ResponseCallbackErrorOrTimeoutHandler <T> (CustomEventArgs <T> cea, RequestState <T> requestState,
PubnubErrorFilter.Level errorLevel)
{
WebException webEx = new WebException(cea.Message);
if ((cea.Message.Contains("NameResolutionFailure") ||
cea.Message.Contains("ConnectFailure") ||
cea.Message.Contains("ServerProtocolViolation") ||
cea.Message.Contains("ProtocolError")
))
{
webEx = new WebException("Network connnect error", WebExceptionStatus.ConnectFailure);
PubnubCallbacks.FireErrorCallbacksForAllChannels <T> (cea.Message, requestState,
PubnubErrorSeverity.Warn, PubnubErrorCode.NoInternetRetryConnect, errorLevel);
}
else if (cea.IsTimeout || Utility.CheckRequestTimeoutMessageInError(cea))
{
}
else if ((cea.Message.Contains("403")) ||
(cea.Message.Contains("java.io.FileNotFoundException")) ||
((PubnubUnity.Version.Contains("UnityWeb")) && (cea.Message.Contains("Failed downloading"))))
{
CreateErrorCodeAndCallErrorCallback <T> (403, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("500"))
{
CreateErrorCodeAndCallErrorCallback <T> (500, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("502"))
{
CreateErrorCodeAndCallErrorCallback <T> (502, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("503"))
{
CreateErrorCodeAndCallErrorCallback <T> (503, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("504"))
{
CreateErrorCodeAndCallErrorCallback <T> (504, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("414"))
{
CreateErrorCodeAndCallErrorCallback <T> (414, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("451"))
{
CreateErrorCodeAndCallErrorCallback <T> (451, cea, requestState, errorLevel);
}
else if (cea.Message.Contains("481"))
{
CreateErrorCodeAndCallErrorCallback <T> (481, cea, requestState, errorLevel);
}
else
{
CreateErrorCodeAndCallErrorCallback <T> (400, cea, requestState, errorLevel);
}
ProcessResponseCallbackWebExceptionHandler <T> (webEx, requestState, errorLevel);
}
private void ConnectToHostAndSendRequestCallback <T>(IAsyncResult asynchronousResult)
{
StateObject <T> asynchStateObject = asynchronousResult.AsyncState as StateObject <T>;
RequestState <T> asynchRequestState = asynchStateObject.RequestState;
string channels = "";
if (asynchRequestState != null && asynchRequestState.Channels != null)
{
channels = string.Join(",", asynchRequestState.Channels);
}
try
{
string requestString = asynchStateObject.requestString;
TcpClient tcpClient = asynchStateObject.tcpClient;
NetworkStream netStream = asynchStateObject.netStream;
int bytesRead = netStream.EndRead(asynchronousResult);
if (bytesRead > 0)
{
asynchStateObject.sb.Append(Encoding.ASCII.GetString(asynchStateObject.buffer, 0, bytesRead));
netStream.BeginRead(asynchStateObject.buffer, 0, StateObject <T> .BufferSize,
new AsyncCallback(ConnectToHostAndSendRequestCallback <T>), asynchStateObject);
}
else
{
string resp = asynchStateObject.sb.ToString();
if (resp.IndexOf("200 Connection established") > 0)
{
SendSslRequest <T>(netStream, tcpClient, asynchRequestState, requestString);
}
else
{
throw new WebException("Couldn't connect to the server");
}
}
}
catch (WebException webEx)
{
if (asynchRequestState != null && asynchRequestState.ErrorCallback != null)
{
Action <PubnubClientError> errorCallback = asynchRequestState.ErrorCallback;
CallErrorCallback(PubnubErrorSeverity.Warn, PubnubMessageSource.Client,
channels, errorCallback, webEx, null, null);
}
ProcessResponseCallbackWebExceptionHandler <T>(webEx, asynchRequestState, channels);
}
catch (Exception ex)
{
if (asynchRequestState != null && asynchRequestState.ErrorCallback != null)
{
Action <PubnubClientError> errorCallback = asynchRequestState.ErrorCallback;
CallErrorCallback(PubnubErrorSeverity.Warn, PubnubMessageSource.Client,
channels, errorCallback, ex, null, null);
}
ProcessResponseCallbackExceptionHandler <T>(ex, asynchRequestState);
}
}